using WIDESEAWCS_Core.Authorization;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Core.Const;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.HttpContextUser;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_Model;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_Core.BaseRepository;
using System.Net;
using WIDESEAWCS_Core.Caches;
using WIDESEAWCS_DTO.SerialPort;
using Microsoft.AspNetCore.Http;
using Newtonsoft.Json;
using WIDESEAWCS_Common;
using FaceAI;
using System.Runtime.InteropServices;
using System.IO;
using WIDESEAWCS_DTO.Telescopic;

namespace WIDESEAWCS_SystemServices
{
    public class Sys_UserService : ServiceBase<Sys_User, IRepository<Sys_User>>, ISys_UserService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly ICacheService _cacheService;
        private readonly ISys_MenuService _menuService;
        private readonly IRepository<Dt_FaceRecognition> _faceServer;
        private readonly IRepository<Dt_Loginhsy> _LoginhsyServer;
        private readonly IRepository<Dt_Maintenance> _MainServer;
        private readonly IRepository<Sys_Role> _RoleServer;
        private readonly IRepository<Dt_AuthorizationRecord> _AuthorizatRecServer;

        public Sys_UserService(IRepository<Dt_AuthorizationRecord> AuthorizatRecServer,IRepository<Sys_Role> RoleServer,IRepository<Dt_Loginhsy> LoginhsyServer,IRepository<Dt_FaceRecognition> faceServer, IRepository<Sys_User> repository, IUnitOfWorkManage unitOfWorkManage, ICacheService cacheService, ISys_MenuService menuService, IRepository<Dt_Maintenance> MainServer) : base(repository)
        {
            _faceServer = faceServer;
            _LoginhsyServer = LoginhsyServer;
            _unitOfWorkManage = unitOfWorkManage;
            _cacheService = cacheService;
            _menuService = menuService;
            _MainServer = MainServer;
            _RoleServer = RoleServer;
            _AuthorizatRecServer = AuthorizatRecServer;
        }


        #region
        //public WebResponseContent Login(LoginInfo loginInfo)
        //{
        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {
        //        //BaseDal.QueryFirst(x => x.UserName == loginInfo.UserName);

        //        string msg = string.Empty;

        //        #region 临时使用
        //        try
        //        {
        //            loginInfo.Password = loginInfo.Password.EncryptDES(AppSecret.User);
        //        }
        //        catch
        //        {

        //        }
        //        #endregion

        //        UserInfo user = BaseDal.QueryFirst(x => x.UserName == loginInfo.UserName && x.UserPwd == loginInfo.Password, x => new UserInfo { HeadImageUrl = x.HeadImageUrl, RoleId = x.Role_Id, TenantId = x.TenantId, UserId = x.User_Id, UserName = x.UserName, UserTrueName = x.UserTrueName });
        //        if (user != null)
        //        {
        //            object obj = _menuService.GetMenuActionList(user.RoleId);
        //            if (obj is not IEnumerable<object> list)
        //            {
        //                return WebResponseContent.Instance.Error("无登录权限");
        //            }
        //            if (!list.Any())
        //            {
        //                return WebResponseContent.Instance.Error("无登录权限");
        //            }

        //            string token = JwtHelper.IssueJwt(new TokenModelJwt()
        //            {
        //                UserId = user.UserId,
        //                RoleId = user.RoleId,
        //                UserName = user.UserName,
        //                TenantId = user.TenantId,
        //            });

                 // _cacheService.AddOrUpdate(user.UserId.ToString(), token);

        //            content = WebResponseContent.Instance.OK(data: new { token, userName = user.UserTrueName, img = user.HeadImageUrl,ID=user.UserId });
        //        }
        //        else
        //        {
        //            content = WebResponseContent.Instance.Error("账号或密码错误");
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        content = WebResponseContent.Instance.Error(ex.Message);
        //    }

        //    return content;
        //}
        #endregion

        /// <summary>
        /// 人脸识别登入接口
        /// </summary>
        /// <param name="loginInfo"></param>
        /// <returns></returns>
        public WebResponseContent Login(LoginInfo loginInfo)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                //string msg = string.Empty;

                #region 临时使用
                try
                {
                    loginInfo.Password = loginInfo.Password.EncryptDES(AppSecret.User);
                }
                catch
                {
                }
                #endregion
                // 先获取用户信息
                UserInfo user = null;
                if (!string.IsNullOrEmpty(loginInfo.path))
                {
                    // 人脸识别登录
                    var groupId = _faceServer.QueryData().Select(x => x.GroupID).FirstOrDefault();
                    if (groupId == null)
                    {
                        return WebResponseContent.Instance.Error("没找到该人脸识别分组");
                    }

                    var faceResult = BaiDuFaceHelper.FaceSearch(loginInfo.path, groupId);

                   

                    if (faceResult != null && faceResult.error_code == 0)
                    {
                        var bestMatch = faceResult.result.user_list.OrderByDescending(u => u.score).FirstOrDefault();
                        string usercount = bestMatch.user_id;
                        if (bestMatch != null && double.TryParse(bestMatch.score, out double score) && score > 80)
                        {
                            //用识别到的 user_id 来获取用户信息
                            var faceuser = BaseDal.QueryData(x => x.UserName == usercount).FirstOrDefault(); // 获取匹配的第一个用户
                            if (faceuser != null)
                            {
                                // 手动将 Sys_User 映射到 UserInfo
                                user = new UserInfo
                                {
                                    UserId = faceuser.User_Id,
                                    UserName = faceuser.UserName,
                                    UserTrueName = faceuser.UserTrueName,
                                    HeadImageUrl = faceuser.HeadImageUrl,
                                    RoleId = faceuser.Role_Id,
                                    TenantId = faceuser.TenantId,
                                };
                            }
                        }

                        if (user == null)
                        {
                            return WebResponseContent.Instance.Error("人脸识别失败，请重试");
                        }
                        loginInfo.UserName = user.UserName;
                    }
                }
                else
                {
                    // 密码登录
                    user = GetUserInfo(loginInfo.UserName, loginInfo.Password);
                }

                // 如果找到用户
                if (user != null)
                {

                    var disbled = BaseDal.QueryFirst(x => x.UserName == loginInfo.UserName);
                    if (disbled.Enable != 1)
                    {
                        return WebResponseContent.Instance.Error("你的账号已被禁用，请联系管理员");
                    }

                    // 获取角色权限
                    object obj = _menuService.GetMenuActionList(user.RoleId);
                    if (obj is not IEnumerable<object> list || !list.Any())
                    {
                        return WebResponseContent.Instance.Error("无登录权限");
                    }

                    // 生成 JWT Token
                    string token = JwtHelper.IssueJwt(new TokenModelJwt()
                    {
                        UserId = user.UserId,
                        RoleId = user.RoleId,
                        UserName = user.UserName,
                        TenantId = user.TenantId,
                    });

                    // 记录登录历史
                    var loghis = new Dt_Loginhsy
                    {
                        UserName = user.UserName,
                        LoginTiem =DateTime.Now,
                        CreateDate = DateTime.Now
                    };
                   

                    // 保存用户登录信息
                    _cacheService.AddOrUpdate(user.UserId.ToString(), token);
                     _LoginhsyServer.AddData(loghis);
                  // var id=   _LoginhsyServer.Db.Insertable(loghis).ExecuteReturnIdentity();
                   

                    // 返回响应
                    content = WebResponseContent.Instance.OK(data: new
                    {
                        token,
                        userName = user.UserName,
                        img = user.HeadImageUrl,
                        ID = user.UserId,
                        RoleId = user.RoleId,
                        depid = disbled.Dept_Id,
                    });
                }
                else
                {
                    content = WebResponseContent.Instance.Error("账号或密码错误");
                }
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error("登录异常: " + ex.ToString());
            }

            return content;
        }

        /// <summary>
        /// 1:N 人脸搜索接口
        /// </summary>
        /// <param name="image">图片信息(**总数据大小应小于10M**)，图片上传方式根据image_type来判断</param>
        /// <param name="imageType">图片类型     <br> **BASE64**:图片的base64值，base64编码后的图片数据，编码后的图片大小不超过2M； <br>**URL**:图片的 URL地址( 可能由于网络等原因导致下载图片时间过长)； <br>**FACE_TOKEN**: 人脸图片的唯一标识，调用人脸检测接口时，会为每个人脸图片赋予一个唯一的FACE_TOKEN，同一张图片多次检测得到的FACE_TOKEN是同一个。</param>
        /// <param name="groupIdList">从指定的group中进行查找 用逗号分隔，**上限20个**</param>
        /// </param>
        /// <return>JObject</return>
        ///
        public string FaceSearch(string image, string imageType, string groupIdList, string userId)
        {
            string result = "";
            switch (imageType)
            {
                case "base64":
                    //result = FaceCompare.FaceIdentifyByBuffer(image, groupIdList, userId);
                    break;
                case "url":
                    //result = FaceCompare.FaceIdentify(image, groupIdList, userId);
                    break;
                case "token":
                    //result = FaceCompare.FaceIdentifyByFeature(image, groupIdList, userId);
                    break;
                default:
                    break;
            }
            return result;
        }

        /// <summary>
        /// 通过特征值比对（1:1） 对人脸特征值进行比较，可返回人脸特征相似分值（百分制）
        /// </summary>
        /// <param name="file1">传图片路径</param>
        /// <param name="file2">传图片路径</param>
        /// <returns></returns>
        public string FaceCompareFeature(string file1, string file2)
        {
            try
            {
                //var result = FaceCompare.match(file1, file2);
                //string buf = Marshal.PtrToStringAnsi(result);
                //return buf;

                return string.Empty; // 这里需要替换为实际的人脸比对逻辑
            }
            catch (Exception e)
            {
                return e.Message;
            }
        }
        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            UpdateIgnoreColOnExecute = x =>
            {
                return new List<string>
                {
                    nameof(Sys_User.UserPwd),
                    nameof(Sys_User.TenantId)
                };
            };
            return base.UpdateData(saveModel);
        }

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            string pwd = "123456";
            string uesrName = saveModel.MainData[nameof(Sys_User.UserName).FirstLetterToLower()].ToString();
            saveModel.MainData[nameof(Sys_User.UserPwd).FirstLetterToLower()] = pwd.EncryptDES(AppSecret.User);

            WebResponseContent content = base.AddData(saveModel);
            if (content.Status)
            {
                return WebResponseContent.Instance.OK($"用户新建成功.帐号{uesrName}密码{pwd}");
            }
            else
            {
                return content;
            }
        }

        /// <summary>
        /// 个人中心获取当前用户信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent GetCurrentUserInfo()
        {
            var data = BaseDal.QueryFirst(x => x.User_Id == App.User.UserId, s => new
            {
                s.UserName,
                s.UserTrueName,
                //s.Address,
                //s.PhoneNo,
                //s.Email,
                s.Remark,
                //s.Gender,
                s.RoleName,
                s.HeadImageUrl,
                s.CreateDate
            });
            return WebResponseContent.Instance.OK(null, data);
        }

        /// <summary>
        /// 修改密码
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public WebResponseContent ModifyPwd(string oldPwd, string newPwd)
        {
            WebResponseContent content = WebResponseContent.Instance;
            oldPwd = oldPwd?.Trim();
            newPwd = newPwd?.Trim();
            string message = "";
            try
            {
                if (string.IsNullOrEmpty(oldPwd)) return WebResponseContent.Instance.Error("旧密码不能为空");
                if (string.IsNullOrEmpty(newPwd)) return WebResponseContent.Instance.Error("新密码不能为空");
                if (newPwd.Length < 6) return WebResponseContent.Instance.Error("密码不能少于6位");

                int userId = App.User.UserId;
                string userCurrentPwd = BaseDal.QueryFirst(x => x.User_Id == userId, s => s.UserPwd);

                string _oldPwd = oldPwd.EncryptDES(AppSecret.User);
                if (_oldPwd != userCurrentPwd) return WebResponseContent.Instance.Error("旧密码不正确");

                string _newPwd = newPwd.EncryptDES(AppSecret.User);
                if (userCurrentPwd == _newPwd) return WebResponseContent.Instance.Error("新密码不能与旧密码相同");


                BaseDal.UpdateData(new Sys_User
                {
                    User_Id = userId,
                    UserPwd = _newPwd,
                    LastModifyPwdDate = DateTime.Now
                }, new List<string>
                {
                    nameof(Sys_User.LastModifyPwdDate),
                    nameof(Sys_User.UserPwd)
                });

                content = WebResponseContent.Instance.OK("密码修改成功");
            }
            catch (Exception ex)
            {
                message = ex.Message;
                content = WebResponseContent.Instance.Error("服务器了点问题,请稍后再试");
            }
            return content;
        }

        /// <summary>
        /// 更新密码
        /// </summary>
        /// <param name="id"></param>
        /// <param name="oldPwd"></param>
        /// <param name="newPwd"></param>
        /// <returns></returns>
        public WebResponseContent UpdatePwd(int id, string oldPwd, string newPwd)
        {
            WebResponseContent content = new WebResponseContent();
            oldPwd = oldPwd?.Trim();
            newPwd = newPwd?.Trim();

            try
            {
                if (string.IsNullOrEmpty(oldPwd)) return content.Error("旧密码不能为空");
                if (string.IsNullOrEmpty(newPwd)) return content.Error("新密码不能为空");
                if (newPwd.Length < 6) return content.Error("密码不能少于6位");

                // 获取用户当前密码
                string userCurrentPwd = BaseDal.QueryFirst(x => x.User_Id == id, s => s.UserPwd) ?? "";

                if (string.IsNullOrEmpty(userCurrentPwd)) return content.Error("用户不存在或密码未设置");

                //// 进行密码加密对比
                //string _oldPwd = oldPwd.EncryptDES(AppSecret.User);
                //if (_oldPwd != userCurrentPwd) return content.Error("旧密码不正确");

                // 生成新密码加密值
                string _newPwd = newPwd.EncryptDES(AppSecret.User);
                if (userCurrentPwd == _newPwd) return content.Error("新密码不能与旧密码相同");

                // 更新密码
                bool isUpdated = BaseDal.UpdateData(new Sys_User
                {
                    User_Id = id,
                    UserPwd = _newPwd,
                    LastModifyPwdDate = DateTime.Now
                }, new List<string>
        {
            nameof(Sys_User.LastModifyPwdDate),
            nameof(Sys_User.UserPwd)
        });

                if (!isUpdated)
                {
                    return content.Error("密码修改失败，请稍后重试");
                }

                return content.OK("密码修改成功", id);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"修改密码异常: {ex.Message}");
                return content.Error($"服务器错误: {ex.Message}");
            }
        }


        public WebResponseContent Upuserbase(UserDTO userDTO)
        {
            try
            {
                var user = BaseDal.QueryData(x => x.User_Id == userDTO.id).FirstOrDefault();
                if (user == null)
                {
                    return new WebResponseContent { Status = false, Message = "没找到该用户" };
                }
                user.UserTrueName = userDTO.usertruename;
                user.PhoneNo = userDTO.phone;
                user.HeadImageUrl = userDTO.files;
                BaseDal.UpdateData(user); // 确保更新到数据库
                return new WebResponseContent { Status = true, Data = user };
            }
            catch (Exception ex)
            {

                return new WebResponseContent { Status = false, Message = "失败：" + ex };
            }

        }

        /// <summary>
        /// 图片文件名
        /// </summary>
        /// <param name="files"></param>
        /// <returns></returns>
        public WebResponseContent SaveFiles(IFormCollection files)
        {
            if (files == null || files.Files.Count == 0)
                return new WebResponseContent { Status = false, Message = "请上传文件" };

            // 1. 确保存储目录存在
            string baseDirectory = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "image");
            if (!Directory.Exists(baseDirectory))
                Directory.CreateDirectory(baseDirectory);

            try
            {
                var file = files.Files[0]; // 只处理第一个文件
                string fileName = file.FileName; // 直接使用前端的文件名

                string fullFilePath = Path.Combine(baseDirectory, fileName);

                // 2. 保存文件（如果存在，则覆盖）
                using (var stream = new FileStream(fullFilePath, FileMode.Create))
                {
                    file.CopyTo(stream);
                }

                // 3. 返回文件名
                return new WebResponseContent { Status = true, Message = "文件上传成功", Data = fileName };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "上传文件失败：" + ex.Message };
            }
        }


        /// <summary>
        /// 添加用户
        /// </summary>
        /// <param name="addUserDTO"></param>
        /// <returns></returns>
        public WebResponseContent AdduserData(AddUserDTO addUserDTO)
        {
            try
            {
                if (addUserDTO == null)
                {
                    return new WebResponseContent { Status = false, Message = "请求数据为空，可能是 JSON 解析失败" };
                }

                var list = BaseDal.QueryData(a => a.UserName == addUserDTO.username).FirstOrDefault();
                if (list != null)
                {
                    return new WebResponseContent { Status = false, Message = "账号重复，请重新录入" };
                }

                //人脸识别先注释掉后期开启
                //var face = _faceServer.QueryData().Select(x => x.GroupID).FirstOrDefault();
                //var baiduResult = BaiDuFaceHelper.AddUser(new BDUserInfo
                //{
                //    ImgPath = addUserDTO.path,
                //    user_id = addUserDTO.username,
                //    group_id = face // 这里应该填百度人脸库分组
                //                    // group_id = baiduResult.result.log_id
                //});


                //// 判断百度返回是否成功
                //if (baiduResult == null || baiduResult.error_code != 0)
                //{
                //    return new WebResponseContent { Status = false, Data = "人脸注册失败：" + baiduResult.error_msg };


                //}

                // 创建用户数据
                var sys = new Sys_User
                {
                    UserName = addUserDTO.username,
                    UserTrueName = addUserDTO.usertruename,
                    HeadImageUrl = addUserDTO.path,
                    //Log_id = baiduResult.log_id,
                    //Face_token = baiduResult.result.face_token,
                    PhoneNo = addUserDTO.phoneno,
                    Role_Id = addUserDTO.roleid,
                    IsLeader=addUserDTO.IsLeader,
                    RoleName = addUserDTO.rolename,
                    Enable = addUserDTO.enable,
                    Unit=addUserDTO.userunit,
                    UserPwd = "j79rYYvCz4vdhcboB1Ausg==",
                    Userteam=addUserDTO.userteam,
                    Dept_Id=addUserDTO.dept_Id,
                    //CardNumber=addUserDTO.carnuber,
                    CreateDate = DateTime.Now
                };
                BaseDal.AddData(sys);

                //创建Dt_Maintenance表中的数据
                var Main = new Dt_Maintenance
                {
                    UserAccount = addUserDTO.username,
                    Roleid = addUserDTO.roleid,
                    IsLeader =addUserDTO.IsLeader,//是否是组长
                };
                _MainServer.AddData(Main);

                return new WebResponseContent { Status = true, Data = sys };
            }
            catch (Exception ex)
            {

                return new WebResponseContent { Status = false, Message = "失败" + ex };
            }

        }


        /// <summary>
        ///百度云 更新用户
        /// </summary>
        /// <param name="addUserDTO"></param>
        /// <returns></returns>
        public WebResponseContent UpuserData(AddUserDTO addUserDTO)
        {
            try
            {
                // 1. 查询用户
                var userList = BaseDal.QueryData();
                var sys = userList.FirstOrDefault(x => x.User_Id == addUserDTO.id);
                if (sys == null)
                {
                    return new WebResponseContent { Status = false, Message = "没找到该用户" };
                }
               
                //查找Dt_MaintenanceTeam中的数据
                var team = _MainServer.QueryData(x => x.UserAccount == sys.UserName).FirstOrDefault();
                if (team == null)
                {
                    return new WebResponseContent { Status = false, Message = "没找到该用户的维护组信息" };
                }

                // 2. 检查账号是否修改，并判断是否重复//StringComparison.OrdinalIgnoreCase：表示忽略大小写进行比较，比如 "admin" 和 "ADMIN" 也认为是相等的
                if (!string.Equals(sys.UserName ,addUserDTO.username))
                {
                    var existUser = userList.FirstOrDefault(a => a.UserName == addUserDTO.username);
                    if (existUser != null)
                    {
                        return new WebResponseContent { Status = false, Message = "账号重复，请重新录入" };
                    }
                    sys.UserName = addUserDTO.username; // 确认可以改时才修改
                }

                // 3. 更新其他用户信息
                sys.UserTrueName = addUserDTO.usertruename;
                sys.PhoneNo = addUserDTO.phoneno;
                sys.Role_Id = addUserDTO.roleid;
                sys.RoleName = addUserDTO.rolename;
                //sys.CardNumber = addUserDTO.carnuber;
                sys.Userteam = addUserDTO.userteam;
                sys.Unit = addUserDTO.userunit;
                sys.Dept_Id = addUserDTO.dept_Id;
                //sys.Enable = addUserDTO.enable;
                sys.IsLeader = addUserDTO.IsLeader;//更新用户表的是否是组长
                //如果人脸识别添加了这里就注释掉
                sys.HeadImageUrl = addUserDTO.path;

                // 4. 查询人脸库分组 ID
                var faceGroupID = _faceServer.QueryData().Select(x => x.GroupID).FirstOrDefault();

                // 5. 判断是否需要更新人脸信息
                //if (!string.Equals(sys.HeadImageUrl,addUserDTO.path)) // 有新图片才处理人脸注册
                //{
                //    var baiduResult = BaiDuFaceHelper.AddUser(new BDUserInfo
                //    {
                //        ImgPath = addUserDTO.path,
                //        user_id = sys.UserName,
                //        group_id = faceGroupID
                //    });

                //    // 6. 判断百度 API 是否成功
                //    if (baiduResult == null || baiduResult.error_code != 0)
                //    {
                //        return new WebResponseContent { Status = false, Message = "人脸更新失败：" + baiduResult.error_msg };
                //    }

                //    // 7. 更新人脸相关字段
                //    sys.Log_id = baiduResult.log_id;
                //    sys.HeadImageUrl = addUserDTO.path;
                //    sys.Face_token = baiduResult.result.face_token;
                //}

                // 8. 更新数据库
                
                //更新Dt_Maintenance表中的数据和user表中修改的一样
                team.UserAccount = addUserDTO.username;//账号
                team.Roleid = addUserDTO.roleid;//更新权限
                team.IsLeader = addUserDTO.IsLeader;

                var existAuthority = userList.FirstOrDefault(a => a.UserName == addUserDTO.username);
                // 先缓存旧的 enable 值
                var oldEnable = sys.Enable;

                // 修改 enable
                sys.Enable = addUserDTO.enable;

                // 然后比较旧值和新值
                if (oldEnable != addUserDTO.enable)
                {
                    var authority = new Dt_AuthorizationRecord
                    {
                        Account = addUserDTO.username,
                        UserName = addUserDTO.usertruename,
                        UerUnit = addUserDTO.userunit,
                        UserTeam = addUserDTO.userteam,
                        EnableTime = addUserDTO.enable == 1 ? DateTime.Now : (DateTime?)null, //启用
                        DisableTime = addUserDTO.enable == 0 ? DateTime.Now : (DateTime?)null,//不启用
                       
                    };


                    _AuthorizatRecServer.AddData(authority);
                }


                BaseDal.UpdateData(sys);
                _MainServer.UpdateData(team);

                return new WebResponseContent { Status = true, Data = sys };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "失败：" + ex.Message };
            }
        }





        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="deleteUserDTO"></param>
        /// <returns></returns>
        public WebResponseContent DeleteUserData(string account)
        {
            try
            {

                // 2. 查询人脸库分组 ID
                //var faceGroupID = _faceServer.QueryData().Select(x => x.GroupID).FirstOrDefault();

                //WIDESEAWCS_Common.DeleteUserImg deleteUserImg = new WIDESEAWCS_Common.DeleteUserImg();
                //deleteUserImg.group_id = faceGroupID;
                //deleteUserImg.user_id = account;

                //string apiResult = BaiDuFaceHelper.DeleteUser(deleteUserImg);//只要给token和log_id

                //// 2. 解析返回结果，判断删除是否成功
                //dynamic resultObj = JsonConvert.DeserializeObject(apiResult);
                //if (resultObj.error_code == 0)
                //{
                    // 百度删除成功后，删除数据库中的用户
                  var user = BaseDal.QueryData(x => x.UserName == account).FirstOrDefault();
                var main = _MainServer.QueryData(x => x.UserAccount == account).FirstOrDefault();
                if (user != null&&main!=null)
                    {
                        BaseDal.DeleteData(user);
                    _MainServer.DeleteData(main);
                }
                    return WebResponseContent.Instance.OK("用户删除成功");
                //}
                //else
                //{
                //    return WebResponseContent.Instance.Error("百度 API 删除失败：" + resultObj.error_msg);
                //}
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error("删除用户失败：" + ex.Message);
            }
        }


        public WebResponseContent SaveFaceFiles(IFormCollection files)
        {
            if (files == null || files.Files.Count == 0)
                return new WebResponseContent { Status = false, Message = "请上传文件" };

            // 1. 确保存储目录存在
            string baseDirectory = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "image");
            if (!Directory.Exists(baseDirectory))
                Directory.CreateDirectory(baseDirectory);

            try
            {
                var file = files.Files[0]; // 只处理第一个文件
                string fileName = file.FileName; // 直接使用前端的文件名

                string fullFilePath = Path.Combine(baseDirectory, fileName);

                // 2. 保存文件（如果存在，则覆盖）
                using (var stream = new FileStream(fullFilePath, FileMode.Create))
                {
                    file.CopyTo(stream);
                }

                // 3. 返回文件名
                return new WebResponseContent { Status = true, Message = "文件上传成功", Data = fileName };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "上传文件失败：" + ex.Message };
            }
        }


        /// <summary>
        /// 删除数据库中没有使用的图片
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent CleanUnusedImages()
        {
            try
            {
                // 获取文件的完整路径
                string pathimage = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "image");

                // 如果文件夹不存在，返回错误信息
                if (!Directory.Exists(pathimage))
                {
                    return new WebResponseContent { Status = false, Message = "图片文件夹不存在" };
                }

                // **使用 HashSet 提高查找效率**
                var userImageSet = BaseDal.QueryData(x => !string.IsNullOrEmpty(x.HeadImageUrl))
                                          .Select(x => x.HeadImageUrl)
                                          .ToHashSet(); // **提升查询速度**

                // 获取文件夹中的所有图片文件（文件名）
                var imageFiles = Directory.GetFiles(pathimage)
                                          .Select(Path.GetFileName)
                                          .ToList();

                int deletedCount = 0;
                foreach (var file in imageFiles)
                {
                    // **HashSet 查询 O(1)**
                    if (!userImageSet.Contains(file))
                    {
                        string filePath = Path.Combine(pathimage, file);
                        try
                        {
                            File.Delete(filePath);
                            deletedCount++;
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"无法删除文件 {file}: {ex.Message}");
                        }
                    }
                }

                return new WebResponseContent { Status = true, Message = $"清理完成，删除了 {deletedCount} 张未使用的图片" };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = $"清理失败: {ex.Message}" };
            }
    }

        /// <summary>
        /// GetUserInfo登入方法
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public UserInfo GetUserInfo(string userName, string password)
        {
            return BaseDal.QueryFirst(x => x.UserName == userName && x.UserPwd == password, x => new UserInfo { HeadImageUrl = x.HeadImageUrl, RoleId = x.Role_Id, TenantId = x.TenantId, UserId = x.User_Id, UserName = x.UserName, UserTrueName = x.UserTrueName });
        }

        /// <summary>
        /// 人脸删除（删除用户的某一张人脸，如果该用户只有一张人脸图片，则同时删除用户。）
        /// </summary>
        /// <param name="addUserDTO"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent DeleteUserIsface(string account)
        {
            try
            {

                // 1. 查询人脸库分组 ID
                var faceGroupID = _faceServer.QueryData().Select(x => x.GroupID).FirstOrDefault();
                //2.查询要删那个用户的
                var user = BaseDal.QueryData(x => x.UserName == account).FirstOrDefault();
                if (user == null)
                {
                    return new WebResponseContent { Status = false, Message = "用户不存在，请检查账号是否输入正确" };
                }

                WIDESEAWCS_Common.DeleteUserImg deleteUserImg = new WIDESEAWCS_Common.DeleteUserImg();
                deleteUserImg.group_id = faceGroupID;
                deleteUserImg.user_id = account;
                deleteUserImg.face_token = user.Face_token;
                deleteUserImg.log_id = user.Log_id;

                string apiResult = BaiDuFaceHelper.DeleteUserImg(deleteUserImg);//给用户账号/用户组id/Face_token/Log_id

                // 2. 解析返回结果，判断删除是否成功
                dynamic resultObj = JsonConvert.DeserializeObject(apiResult);
                if (resultObj.error_code == 0)
                {
                    if (user != null)
                    {
                        BaseDal.DeleteData(user);
                    }
                    return WebResponseContent.Instance.OK("删除成功");
                }
                else
                {
                    return WebResponseContent.Instance.Error("百度 API 删除失败：" + resultObj.error_msg);
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error("删除用户失败：" + ex.Message);
            }
        }

        public WebResponseContent ReturnDeptid(string account)
        {
            try
            {
                var loginer = BaseDal.QueryData(x => x.UserName == account).FirstOrDefault();
                if (loginer == null)
                    return new WebResponseContent { Status = false, Message = "用户不存在" };
                return new WebResponseContent { Status = true, Data = loginer.Dept_Id };

            }
            catch (Exception ex)
            {

                return new WebResponseContent { Status = false, Message="失败"};
            }
        }


        /// <summary>
        /// 表连接角色表，展示数据
        /// </summary>
        /// <returns></returns>
        public WebResponseContent YShowUserList(PaginationDTO pagination)
        {
            try
            {
                int totalCount = 0;
                var Role = _RoleServer.Db.Queryable<Sys_Role>();
                var query = Role.InnerJoin<Sys_User>((a, b) => a.RoleId == b.Role_Id);

                //搜索关键字
                if (!string.IsNullOrEmpty(pagination.searchKeyword))
                {
                    query = query.Where((a, b) =>
                    b.UserName.Contains(pagination.searchKeyword) ||
                    b.UserTrueName.Contains(pagination.searchKeyword) ||
                    b.PhoneNo.Contains(pagination.searchKeyword) ||
                    a.RoleName.Contains(pagination.searchKeyword));
                }
                //时间查询
                if (pagination.startDate.HasValue && pagination.endDate.HasValue)
                {
                    query = query.Where((a, b) => b.CreateDate >= pagination.startDate.Value && b.CreateDate <= pagination.endDate.Value);
                }
                //排序
                if (!string.IsNullOrEmpty(pagination.sortField))
                {
                    var isAcs = pagination.sortOrder?.ToLower() == "asc";
                    query = pagination.sortField.ToLower() switch
                    {


                        "CreateDate" => isAcs ? query.OrderBy((a, b) => b.CreateDate) : query.OrderByDescending((a, b) => b.CreateDate),

                        _ => query.OrderByDescending((a, b) => b.Creater) // 默认按创建时间降序
                    };

                }
                else
                {
                    query = query.OrderByDescending((a, b) => b.Creater);
                }
                var reslut = query.Select((a, b) => new
                { 
                  b.User_Id,
                  b.UserName,
                  b.UserTrueName,
                  b.Unit,
                  b.Userteam,
                  b.Role_Id,
                  b.IsLeader,
                  //b.RoleName,
                  b.CardNumber,
                  b.PhoneNo,
                  b.UserPwd,
                  b.DeptName,
                  b.Dept_Id,
                  b.Email,
                  b.Enable,
                  b.Gender,
                  b.HeadImageUrl,
                  b.Address,
                  b.CreateDate,
                  b.Creater,
                  a.RoleName,

                }).ToPageList(pagination.pageIndex, pagination.pageSize, ref totalCount);
                

                return new WebResponseContent
                {
                    Status = true,
                    Data = new
                    {
                        totalCount = totalCount,
                        PageIndex = pagination.pageIndex,
                        PageSize = pagination.pageSize,
                        Items = reslut
                    }
                };

            }
            catch (Exception ex)
            {

                return new WebResponseContent { Status = false, Message = ex.Message };
                }
            }
        

    }
}