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_ISystemRepository;
using WIDESEAWCS_Core.BaseRepository;
using System.Net;
using WIDESEAWCS_Core.Caches;
using WIDESEA_ISerialPortRepository;
using Microsoft.AspNetCore.Http;
using SqlSugar;
using ICacheService = WIDESEAWCS_Core.Caches.ICacheService;
using Microsoft.AspNetCore.Builder;
using WIDESEAWCS_DTO.SerialPort;
using WIDESEAWCS_DTO.Telescopic;
using WIDESEAWCS_Common;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;

namespace WIDESEAWCS_SystemServices
{
    public class Sys_UserService : ServiceBase<Sys_User, ISys_UserRepository>, ISys_UserService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly ICacheService _cacheService;
        private readonly ISys_MenuService _menuService;
        private readonly ISys_RoleRepository _RoleRepository;
        private readonly ILoginHistoryRepository _loginHistoryRepository;
        private readonly IPutakeRepository _putakeRepository;
        private readonly IFaceRecognitionRepository _faceRecognitionRepository;



        public Sys_UserService(IFaceRecognitionRepository faceRecognitionRepository, ISys_UserRepository repository, IUnitOfWorkManage unitOfWorkManage,
            ICacheService cacheService, ISys_MenuService menuService, ISys_RoleRepository roleRepository, ILoginHistoryRepository loginHistoryRepository, IPutakeRepository putakeRepository) : base(repository)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _cacheService = cacheService;
            _menuService = menuService;
            _RoleRepository = roleRepository;
            _RoleRepository = roleRepository;
            _loginHistoryRepository = loginHistoryRepository;
            _putakeRepository = putakeRepository;
            _faceRecognitionRepository = faceRecognitionRepository;

        }

        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
                if (!string.IsNullOrEmpty(loginInfo.path))
                {
                    var faceResult = BaiDuFaceHelper.FaceSearch(loginInfo.path);

                    if (faceResult != null && faceResult.error_code == 0)
                    {
                        // 获取最高匹配度的用户
                        var bestMatch = faceResult.result.user_list.OrderByDescending(u => u.score).FirstOrDefault();//拿第一个最高的

                        if (bestMatch != null && double.TryParse(bestMatch.score, out double score) && score > 80) // 设定80分为可信度阈值
                        {
                            return new WebResponseContent { Data = true };
                        }
                    }

                    return WebResponseContent.Instance.Error("人脸识别失败，请重试");
                }
                else
                {
                    UserInfo user = BaseDal.GetUserInfo(loginInfo.UserName, loginInfo.Password);
                    var disbled = BaseDal.QueryFirst(x => x.UserName == loginInfo.UserName);//根据这个用户名来查看用户
                    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("无登录权限");
                        }
                        if (disbled.Enable != 1)
                        {
                            return WebResponseContent.Instance.Error("你的账号已被禁用，请联系管理员");
                        }

                        string token = JwtHelper.IssueJwt(new TokenModelJwt()
                        {
                            UserId = user.UserId,
                            RoleId = user.RoleId,
                            UserName = user.UserName,
                            TenantId = user.TenantId,
                        });
                        var loghis = new Dt_LoginHistory
                        {
                            Account = user.UserName,
                            TrurName = user.UserTrueName,
                            CreateDate = DateTime.Now

                        };


                        _cacheService.AddOrUpdate(user.UserId.ToString(), token);
                        _loginHistoryRepository.AddData(loghis);

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

            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }

            return content;
        }

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

        }

        public WebResponseContent GetUerType()
        {
            try
            {
                var role = _RoleRepository.QueryData();
                var user = BaseDal.QueryData();

                var result = user.Join(
                    role,
                    u => u.Role_Id,
                    r => r.RoleId,
                    (u, r) => new
                    {
                        u.User_Id,
                        u.UserName,
                        r.RoleId,
                        u.RoleName,
                        u.UserTrueName,
                    }).ToList();

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


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


        public WebResponseContent PermissionView(int userId, string group)
        {
            try
            {
                // 1. 获取用户信息
                var user = BaseDal.QueryData(x => x.User_Id == userId).FirstOrDefault();
                var allTasks = _putakeRepository.QueryData();

                if (user == null)
                {
                    return new WebResponseContent { Status = false, Message = "用户不存在" };
                }

                string roleName = user.RoleName;

                // 2. 判断是否是超级管理员
                if (roleName.Contains("超级管理员"))
                {
                    // 超级管理员仍然要筛选指定 group
                    var adminTasks = allTasks.Where(x => x.Grouptype == group).ToList();
                    return new WebResponseContent { Status = true, Data = adminTasks, Message = "获取成功" };
                }

                // 3. 确定普通用户角色匹配的任务类型
                List<string> allowedGroups = new List<string>();

                if (roleName.Contains("地沟")) allowedGroups.Add("地沟");//如果添加进数组中
                if (roleName.Contains("电气")) allowedGroups.Add("电气");
                if (roleName.Contains("机械")) allowedGroups.Add("机械");

                if (allowedGroups.Count == 0)
                {
                    return new WebResponseContent { Status = false, Message = "您无权限查看任务" };
                }

                // 4. 普通用户只能看自己权限范围内的任务
                if (!allowedGroups.Contains(group))
                {
                    return new WebResponseContent { Status = false, Message = "您无权限查看该任务类别" };
                }

                var tasks = allTasks.Where(t => t.Grouptype == group).ToList();

                return new WebResponseContent { Status = true, Data = tasks, Message = "获取成功" };
            }
            catch (Exception ex)
            {
                return new WebResponseContent { Status = false, Message = "错误: " + ex.Message };
            }
        }


        /// <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="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="paginationDTO"></param>
        /// <returns></returns>
        public WebResponseContent GetUserFace(PaginationDTO paginationDTO)
        {
            try
            {
                int totalCount = 0;
                var sys = Db.Queryable<Sys_User>();
                var face = _faceRecognitionRepository.Db.Queryable<Dt_FaceRecognition>();

                if (face == null)
                {
                    return new WebResponseContent { Status = false, Message = "数据为空" };
                }

                var query = sys.LeftJoin<Dt_FaceRecognition>((a, b) => a.Log_id == b.GroupID);
                if (!string.IsNullOrEmpty(paginationDTO.searchKeyword))
                {
                    query = query.Where((a, b) =>
                        a.UserName.Contains(paginationDTO.searchKeyword) ||
                        a.UserTrueName.Contains(paginationDTO.searchKeyword) ||
                        a.PhoneNo.Contains(paginationDTO.searchKeyword) ||
                        a.RoleName.Contains(paginationDTO.searchKeyword) ||
                        a.Role_Id.ToString().Contains(paginationDTO.searchKeyword)
                    );
                }
                if (paginationDTO.startDate.HasValue && paginationDTO.endDate.HasValue)
                {
                    query = query.Where((a, b) => a.CreateDate >= paginationDTO.startDate && a.CreateDate <= paginationDTO.endDate);
                }

                var result = query.Select((a, b) => new
                {
                    a.UserPwd,
                    a.Log_id,
                    a.User_Id,
                    a.UserName,
                    a.UserTrueName,
                    a.PhoneNo,
                    a.Role_Id,
                    a.RoleName,
                    a.HeadImageUrl,
                    a.Enable,
                    a.CreateDate,
                    a.Face_token,
                    b.GroupID,
                }).ToPageList(paginationDTO.pageIndex, paginationDTO.pageSize, ref totalCount);
                return new WebResponseContent
                {
                    Status = true,
                    Data = new
                    {
                        TotalCount = totalCount,//总数
                        PageIndex = paginationDTO.pageIndex,//页数
                        PaseSize = paginationDTO.pageSize,//一页多少数据
                        Items = result//返回字段
                    }

                };

            }
            catch (Exception)
            {

                throw;
            }
        }

        /// <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 face = _faceRecognitionRepository.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 = face,
                    Face_token = baiduResult.result.face_token,
                    PhoneNo = addUserDTO.phoneno,
                    Role_Id = addUserDTO.roleid,
                    RoleName = addUserDTO.rolename,
                    Enable = addUserDTO.enable,
                    UserPwd= "j79rYYvCz4vdhcboB1Ausg==",
                    CreateDate=DateTime.Now
                };
                BaseDal.AddData(sys);
                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
            {
                var sys = BaseDal.QueryData(x => x.User_Id == addUserDTO.id).FirstOrDefault();
                
                if (sys == null)
                {
                    return new WebResponseContent { Status = false, Message = "没找到该用户" };
                }
                var face = _faceRecognitionRepository.QueryData().Select(x => x.GroupID).FirstOrDefault();
                // 判断是否需要更新人脸图片
                string faceToken = null;
                if (!string.IsNullOrEmpty(addUserDTO.path)) // 如果传了图片路径，才更新人脸信息
                {
                    var baiduResult = BaiDuFaceHelper.AddUser(new BDUserInfo
                    {
                        ImgPath = addUserDTO.path,
                        user_id = addUserDTO.username,
                        group_id = face // 这里应该填百度人脸库分组
                    });

                    // 判断百度返回是否成功
                    if (baiduResult == null || baiduResult.error_code != 0)
                    {
                        return new WebResponseContent { Status = false, Data = "人脸以存在，不要重复上传：" + baiduResult.error_msg };
                    }
                    // 获取更新后的 Face_token
                    faceToken = baiduResult.result.face_token;
                }

                // 查询现有用户
               

                // 更新查询到的用户数据
                sys.UserName = addUserDTO.username;
                sys.UserTrueName = addUserDTO.usertruename;
                sys.HeadImageUrl = addUserDTO.path; // 更新头像路径（如果有新路径）
                sys.Log_id = face;
                //sys.Face_token = faceToken ?? addUserDTO.face_token; // 如果没有更新图片，保持原有 Face_token
                sys.Face_token = faceToken; // 如果没有更新图片，保持原有 Face_token
                sys.PhoneNo = addUserDTO.phoneno;
                sys.Role_Id = addUserDTO.roleid;
                sys.RoleName = addUserDTO.rolename;
                sys.Enable = addUserDTO.enable;

                // 更新数据库
                BaseDal.UpdateData(sys);

                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(DeleteUserImg deleteUserDTO)
        {
            try
            {
                
                string apiResult = BaiDuFaceHelper.DeleteUser(deleteUserDTO);//只要给token和log_id

                // 2. 解析返回结果，判断删除是否成功
                dynamic resultObj = JsonConvert.DeserializeObject(apiResult);
                if (resultObj.error_code == 0)
                {
                   // 百度删除成功后，删除数据库中的用户
                    var user = BaseDal.QueryData(deleteUserDTO.user_id);
                    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);
            }
        }


       
    }
}