using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVisionCommon
{
    public class UserManager
    {
        private Dictionary<string, RecordUserData> _users;
        private readonly string _dataFilePath;
        private RecordUserData _currentUser;
        private static UserManager _instance;
        /// <summary>
        /// 线程锁
        /// </summary>
        private static readonly object _lock = new object();
        private UserManager(string dataFilePath = "users.json")
        {
            _dataFilePath = dataFilePath;
            _users = new Dictionary<string, RecordUserData>();
            _currentUser = null;
            LoadUsers();
        }

        public static UserManager Instance
        {
            get
            {
                // 双重检查锁定确保线程安全
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            _instance = new UserManager();
                        }
                    }
                }
                return _instance;
            }
        }

        /// <summary>
        /// 当前登录用户
        /// </summary>
        public RecordUserData CurrentUser => _currentUser;

        /// <summary>
        /// 用户列表（只读）
        /// </summary>
        public Dictionary<string, RecordUserData> Users
        {
            get { return _users; }
        }
        /// <summary>
        /// 用户数量
        /// </summary>
        public int UserCount => _users.Count;

        /// <summary>
        /// 用户登录
        /// </summary>
        /// <param name="account">账户</param>
        /// <param name="password">密码</param>
        /// <returns></returns>
        public bool Login(string account, string password)
        {
            var user = _users.FirstOrDefault(u =>
                u.Value.EmployeeAccount == account && AESHelper.Decrypt(u.Value.EmployeePassword) == password);

            if (user.Value != null && user.Value != null)
            {
                _currentUser = user.Value;
                return true;
            }
            return false;
        }

        /// <summary>
        /// 用户登出
        /// </summary>
        public void Logout()
        {
            _currentUser = null;
        }

        /// <summary>
        /// 检查当前用户权限
        /// </summary>
        /// <param name="requireAdmin">是否是管理员？</param>
        /// <returns>返回权限</returns>
        private bool CheckPermission(bool requireAdmin = false)
        {
            if (_currentUser == null) return false;

            if (requireAdmin)
                return _currentUser.EmployeePermission == UserPermission.Administrator;

            return true;
        }

        /// <summary>
        /// 添加用户（需要管理员权限）
        /// </summary>
        /// <param name="user">RecordUserData user</param>
        /// <returns>是否添加成功！</returns>
        public bool AddUser(RecordUserData user)
        {
            if (_currentUser == null)
            {
                _currentUser = user;
            }
            //if (!CheckPermission(true))
            //{
            //    MessageBox.Show("需要管理员权限才能添加用户！", "权限不足", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            //    return false;
            //}

            if (_users.Any(u => u.Value.EmployeeNumber == user.EmployeeNumber ||
                               u.Value.EmployeeAccount == user.EmployeeAccount))
            {
                MessageBox.Show("员工号或账号已存在！", "添加失败", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }

            RecordUserData recordUserData = new RecordUserData();
            recordUserData.EmployeeNumber = user.EmployeeNumber;
            recordUserData.EmployeeAccount = user.EmployeeAccount;
            recordUserData.EmployeePassword = AESHelper.Encrypt(user.EmployeePassword);
            recordUserData.EmployeeName = user.EmployeeName;
            recordUserData.EmployeePermission = user.EmployeePermission;
            _users.Add(recordUserData.EmployeeNumber, recordUserData);
            SaveUsers();
            return true;
        }

        /// <summary>
        /// 删除用户（需要管理员权限）
        /// </summary>
        /// <param name="employeeNumber">string employeeNumber</param>
        /// <returns>是否删除成功</returns>
        public bool DeleteUser(string employeeNumber)
        {
            //if (!CheckPermission(true))
            //{
            //    MessageBox.Show("需要管理员权限才能删除用户！", "权限不足", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            //    return false;
            //}

            //// 管理员不能删除自己
            //if (_currentUser.EmployeeNumber == employeeNumber)
            //{
            //    MessageBox.Show("不能删除当前登录的用户！", "删除失败", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            //    return false;
            //}

            var user = _users.FirstOrDefault(u => u.Value.EmployeeNumber == employeeNumber);
            if (user.Value != null)
            {
                _users.Remove(user.Key);
                SaveUsers();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 更新用户信息
        /// </summary>
        /// <param name="updatedUser">RecordUserData updatedUser</param>
        /// <returns>是否更新成功</returns>
        public bool UpdateUser(RecordUserData updatedUser)
        {
            // 普通用户只能修改自己的信息，管理员可以修改所有用户信息
            bool canModify = _currentUser.EmployeePermission == UserPermission.Administrator ||
                            _currentUser.EmployeeNumber == updatedUser.EmployeeNumber;

            if (!canModify)
            {
                MessageBox.Show("没有权限修改此用户信息！", "权限不足", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }

            var existingUser = _users.FirstOrDefault(u => u.Value.EmployeeNumber == updatedUser.EmployeeNumber);
            if (existingUser.Value != null)
            {
                // 检查账号是否重复（排除自己）
                if (_users.Any(u => u.Value.EmployeeAccount == updatedUser.EmployeeAccount &&
                                   u.Value.EmployeeNumber != updatedUser.EmployeeNumber))
                {
                    MessageBox.Show("账号已存在！", "更新失败", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return false;
                }

                // 更新用户信息
                existingUser.Value.EmployeeName = updatedUser.EmployeeName;
                existingUser.Value.EmployeeAccount = updatedUser.EmployeeAccount;
                existingUser.Value.EmployeePassword = AESHelper.Encrypt(updatedUser.EmployeePassword);

                // 只有管理员可以修改权限
                if (_currentUser.EmployeePermission == UserPermission.Administrator)
                {
                    existingUser.Value.EmployeePermission = updatedUser.EmployeePermission;
                }
                SaveUsers();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 根据员工号查询用户
        /// </summary>
        /// <param name="employeeNumber">string employeeNumber</param>
        /// <returns>RecordUserData</returns>
        public RecordUserData GetUserByNumber(string employeeNumber)
        {
            return _users.FirstOrDefault(u => u.Value.EmployeeNumber == employeeNumber).Value.Clone();
        }

        /// <summary>
        /// 根据账号查询用户
        /// </summary>
        /// <param name="account">string account</param>
        /// <returns>RecordUserData</returns>
        public RecordUserData GetUserByAccount(string account)
        {
            return _users.FirstOrDefault(u => u.Value.EmployeeAccount == account).Value.Clone();
        }

        /// <summary>
        /// 获取所有用户列表
        /// </summary>
        /// <returns>List<RecordUserData></returns>
        public List<RecordUserData> GetAllUsers()
        {
            return _users.Select(u => u.Value.Clone()).ToList();
        }

        /// <summary>
        /// 根据权限筛选用户
        /// </summary>
        /// <param name="permission">UserPermission permission</param>
        /// <returns>List<RecordUserData></returns>
        public List<RecordUserData> GetUsersByPermission(UserPermission permission)
        {
            return _users.Where(u => u.Value.EmployeePermission == permission)
                        .Select(u => u.Value.Clone()).ToList();
        }

        /// <summary>
        /// 保存用户数据到JSON文件
        /// </summary>
        private void SaveUsers()
        {
            try
            {
                ConfigManager<Dictionary<string, RecordUserData>>.SaveConfig<Dictionary<string, RecordUserData>>(_users, _dataFilePath);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"保存用户数据失败：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 从JSON文件加载用户数据
        /// </summary>
        private void LoadUsers()
        {
            try
            {
                if (File.Exists(_dataFilePath))
                {
                    _users = ConfigManager<Dictionary<string, RecordUserData>>.LoadConfig<Dictionary<string, RecordUserData>>(_dataFilePath) ?? new Dictionary<string, RecordUserData>();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"加载用户数据失败：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                _users = new Dictionary<string, RecordUserData>();
            }
        }

        /// <summary>
        /// 验证员工号是否唯一
        /// </summary>
        /// <param name="employeeNumber">string employeeNumber</param>
        /// <param name="excludeEmployeeNumber">string excludeEmployeeNumber = null</param>
        /// <returns>员工号是否唯一？</returns>
        public bool IsEmployeeNumberUnique(string employeeNumber, string excludeEmployeeNumber = null)
        {
            return !_users.Any(u => u.Value.EmployeeNumber == employeeNumber &&
                                   u.Value.EmployeeNumber != excludeEmployeeNumber);
        }

        /// <summary>
        /// 验证账号是否唯一
        /// </summary>
        /// <param name="account">string account</param>
        /// <param name="excludeEmployeeNumber">string excludeEmployeeNumber = null</param>
        /// <returns>账号是否唯一？</returns>
        public bool IsAccountUnique(string account, string excludeEmployeeNumber = null)
        {
            return !_users.Any(u => u.Value.EmployeeAccount == account &&
                                   u.Value.EmployeeNumber != excludeEmployeeNumber);
        }
    }
}