using NPOI.SS.Formula.Functions;
using Prism.Commands;
using Prism.Common;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using TeamAAS_VP.Core;
using TeamAAS_VP.Data;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.Views.User;

namespace TeamAAS_VP.ViewModels.User
{
    public class LoginViewModel : BindableBase
    {
        private readonly IRegionManager _regionManager;
        private readonly IEventAggregator _eventAggregator;
        private readonly IContainerProvider _container;
        private readonly ISystemDatabaseService _systemDatabaseService;

		private List<TeamAAS_VP.Models.User> Users;
        #region 属性
        private ObservableCollection<string> _UserNameList;

        /// <summary>
        /// 用户列表
        /// </summary>
        public ObservableCollection<string> UserNameList
        {
            get { return _UserNameList; }
            set { _UserNameList = value; }
        }

        private string _SelectedUserName;

        /// <summary>
        /// 当前在登录界面选择的用户名。
        /// 加载登录页时会清空；切换用户名时会同步清空密码。
        /// </summary>
        public string SelectedUserName
        {
            get { return _SelectedUserName; }
            set
            {
                if (SetProperty(ref _SelectedUserName, value))
                {
                    UserPassword = string.Empty;
                }
            }
        }

        private string _UserPassword;

        /// <summary>
        /// 当前输入的登录密码。
        /// 登录成功或失败后都会清空，避免界面保留密码记录。
        /// </summary>
        public string UserPassword
        {
            get { return _UserPassword; }
            set { SetProperty(ref _UserPassword, value); }
        }

        private bool _IsRemember;

        /// <summary>
        /// 是否记住用户的界面状态。
        /// 当前登录策略不允许记住用户，加载和登录时会强制置为 false。
        /// </summary>
        public bool IsRemember
        {
            get { return _IsRemember; }
            set { SetProperty(ref _IsRemember, value); }
        }

        #endregion

        #region 命令
        /// <summary>
        /// 注册命令
        /// </summary>
        public DelegateCommand SignUpCommand { get; set; }
        /// <summary>
        /// 登录命令
        /// </summary>
        public DelegateCommand LoginCommand { get; set; }

        /// <summary>
        /// 登录页加载命令。
        /// 用于清除记住用户和密码输入。
        /// </summary>
        public DelegateCommand LoadedCommand { get; set; }

        private DelegateCommand _CardLoginCommand;

        /// <summary>
        /// 打开刷卡登录窗口命令。
        /// </summary>
        public DelegateCommand CardLoginCommand =>
            _CardLoginCommand ?? (_CardLoginCommand = new DelegateCommand(ExecuteCardLoginCommand));

        
        #endregion

        #region 事件

        #endregion

        public LoginViewModel(IRegionManager regionManager, IEventAggregator ea, IContainerProvider container, ISystemDatabaseService systemDatabaseService)
        {
            _regionManager = regionManager;
            _eventAggregator = ea;
            _container = container;
            _systemDatabaseService = systemDatabaseService;

			LoadedCommand = new DelegateCommand(async () => await OnLoadAsync());
            SignUpCommand = new DelegateCommand(new Action(SignUp));
            LoginCommand = new DelegateCommand(async () => await LoginAsync());

            UserNameList = new ObservableCollection<string>();

            // load users from system database (sync-block safe call)
            try
            {
                Users = _systemDatabaseService.GetAllUsersAsync().GetAwaiter().GetResult()?.ToList();
            }
            catch
            {
                Users = new List<TeamAAS_VP.Models.User>();
            }

            if (Users != null)
            {
                foreach (var user in Users)
                {
                    UserNameList.Add(user.UserName);
                }
            }
        }

        #region 方法

        /// <summary>
        /// 执行账号登录。
        /// 操作员账号允许免密码登录；工程师和管理员仍需要通过密码认证。
        /// 登录完成后清除记住用户标记、清空密码，并发布用户切换事件交由主窗口跳转主页。
        /// </summary>
        private async Task LoginAsync()
        {
            if (Users == null || string.IsNullOrEmpty(SelectedUserName))
                return;

            var selectedUser = Users.FirstOrDefault(u => u.UserName == SelectedUserName);
            if (selectedUser == null)
                return;

            var currentUser = _systemDatabaseService.GetCurrentUser();
            if (currentUser != null)
            {
                if (currentUser.UserName == SelectedUserName)
                {
                    UserPassword = string.Empty;
                    _eventAggregator.GetEvent<UserLoginNotification>().Publish(currentUser);
                    return;
                }
            }

            try
            {
                var user = selectedUser.userPart == UserPart.Operator
                    ? selectedUser
                    : await _systemDatabaseService.AuthenticateUserAsync(SelectedUserName, UserPassword);

                if (user != null)
                {
                    try
                    {
                        await _systemDatabaseService.ClearRememberUserAsync();
                    }
                    catch
                    {
                        
                    }
                    IsRemember = false;

                    // mark current user in system DB and record login
                    await _systemDatabaseService.SetCurrentUserAsync(user.Id);
                    //await _systemDatabaseService.RecordUserLoginAsync(new UserLoginRecord { UserId = user.Id, Success = true, Time = DateTime.Now, Message = "Login success" });

                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.登录成功}！", Duration = 1 });
                    UserPassword = string.Empty;
                    _eventAggregator.GetEvent<CurrentStatusNotification>().Publish();
                    _eventAggregator.GetEvent<UserLoginNotification>().Publish(_systemDatabaseService.GetCurrentUser());
                }
            }
            catch (Exception ex)
            {
                // authentication failed or error
                await _systemDatabaseService.RecordUserLoginAsync(new UserLoginRecord { UserId = 0, Success = false, Time = DateTime.Now, Message = $"Login failed for {SelectedUserName}: {ex.Message}" });
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.密码错误, Duration = 1 });
                UserPassword = string.Empty;
            }
        }

        /// <summary>
        /// 进入注册页。
        /// 只有当前用户为管理员时允许注册新用户。
        /// </summary>
        private void SignUp()
        {
            var management = _container.Resolve<Management>();
            if (_systemDatabaseService.GetCurrentUser().userPart != Enums.UserPart.Administrator)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.当前用户权限不足, Duration = 1 });
                return;
            }

            _regionManager.RequestNavigate("UserRegionContext", "SignUpView");
        }

        /// <summary>
        /// 登录页加载时执行安全清理。
        /// 清除数据库中的记住用户标记，并清空用户名选择和密码输入。
        /// </summary>
        private async Task OnLoadAsync()
        {
            try
            {
                await _systemDatabaseService.ClearRememberUserAsync();
            }
            catch
            {
            }
            IsRemember = false;
            SelectedUserName = null;
            UserPassword = string.Empty;
        }

        /// <summary>
        /// 更新用户列表。
        /// 只刷新可选用户名，不读取或回填任何记住用户和密码信息。
        /// </summary>
        public void UpdateUserList()
        {
            UserNameList.Clear();
            //获取所有用户
            try
            {
                Users = _systemDatabaseService.GetAllUsersAsync().GetAwaiter().GetResult()?.ToList();
            }
            catch
            {
                Users = new List<TeamAAS_VP.Models.User>();
            }

            if (Users != null)
            {
                foreach (var user in Users)
                {
                    UserNameList.Add(user.UserName);
                }
            }
        }

        /// <summary>
        /// 刷卡登录命令
        /// </summary>
        void ExecuteCardLoginCommand()
        {
            var cardLogin = _container.Resolve<CardLoginWindow>();
            var result = cardLogin.ShowDialog();
            if (result is bool st1 && !st1)
            {
                
            }
        }
        #endregion
    }
}