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;

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;

        public Sys_UserService(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;
        }

        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.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 });
                }
                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 };
            }
        }



        public WebResponseContent UploaDavatar(List<IFormFile> files, int userId)
        {
            if (files == null || files.Count == 0)
                return new WebResponseContent { Status = false, Message = "请上传文件" };

            //  1. 指定固定的存储目录
            //string baseDirectory = @"E:\美型\NiuJuKongZhi\项目代码\WIDESEAWCS_Server 正式\WIDESEAWCS_Server\wwwroot\image\";
            string baseDirectory = @"wwwroot\image\";

            // 2. 生成子目录，避免文件冲突
            string subDirectory = $"{DateTime.Now:yyMMddHHmmss}_{new Random().Next(1000, 9999)}";
            string filePath = Path.Combine(baseDirectory, subDirectory);

            //3. 确保目录存在
            if (!Directory.Exists(filePath))
                Directory.CreateDirectory(filePath);

            try
            {
                string uploadedFilePath = "";
                for (int i = 0; i < files.Count; i++)
                {
                    // 4. 生成唯一文件名（防止重名覆盖）
                    string fileName = $"{Guid.NewGuid()}{Path.GetExtension(files[i].FileName)}";
                    string fullFilePath = Path.Combine(filePath, fileName);

                    // 5. 保存文件到指定路径
                    using (var stream = new FileStream(fullFilePath, FileMode.Create))
                    {
                        files[i].CopyTo(stream);
                    }

                    // 6. 记录文件路径（存入数据库的相对路径）
                    uploadedFilePath = Path.Combine("/image", subDirectory, fileName).Replace("\\", "/");
                    break; // 只处理第一个文件
                }

                //7. 更新用户头像路径到数据库
                var user = BaseDal.QueryData(u => u.User_Id == userId).FirstOrDefault();
                if (user != null)
                {
                    user.HeadImageUrl = uploadedFilePath;
                    UpdateData(user);
                }
                else
                {
                    return new WebResponseContent { Status = false, Message = "用户不存在" };
                }

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