using System.ComponentModel;
using System.Runtime.CompilerServices;
using Microsoft.Extensions.Logging;
using OrpaonVision.Core.Results;
using OrpaonVision.Model.Security;
using OrpaonVision.ConfigApp.Infrastructure.Services;

namespace OrpaonVision.ConfigApp.Infrastructure.Services;

/// <summary>
/// 当前用户上下文服务。
/// </summary>
public sealed class CurrentUserContext : INotifyPropertyChanged
{
    private readonly ILogger<CurrentUserContext> _logger;
    private readonly IAuthorizationService _authorizationService;
    private UserModel? _currentUser;
    private List<PermissionModel> _userPermissions = new();
    private List<RoleModel> _userRoles = new();

    /// <summary>
    /// 构造函数。
    /// </summary>
    public CurrentUserContext(
        ILogger<CurrentUserContext> logger,
        IAuthorizationService authorizationService)
    {
        _logger = logger;
        _authorizationService = authorizationService;
    }

    /// <summary>
    /// 当前登录用户。
    /// </summary>
    public UserModel? CurrentUser
    {
        get => _currentUser;
        private set
        {
            if (_currentUser != value)
            {
                _currentUser = value;
                OnPropertyChanged();
                OnPropertyChanged(nameof(IsAuthenticated));
                OnPropertyChanged(nameof(CurrentUserId));
                OnPropertyChanged(nameof(CurrentUserName));
                
                // 用户变更时重新加载权限
                _ = Task.Run(LoadUserPermissions);
            }
        }
    }

    /// <summary>
    /// 是否已认证。
    /// </summary>
    public bool IsAuthenticated => CurrentUser != null;

    /// <summary>
    /// 当前用户ID。
    /// </summary>
    public Guid CurrentUserId => CurrentUser?.Id ?? Guid.Empty;

    /// <summary>
    /// 当前用户名。
    /// </summary>
    public string CurrentUserName => CurrentUser?.Username ?? string.Empty;

    /// <summary>
    /// 用户权限列表。
    /// </summary>
    public IReadOnlyList<PermissionModel> UserPermissions => _userPermissions.AsReadOnly();

    /// <summary>
    /// 用户角色列表。
    /// </summary>
    public IReadOnlyList<RoleModel> UserRoles => _userRoles.AsReadOnly();

    /// <summary>
    /// 设置当前用户。
    /// </summary>
    public async Task<Result> SetCurrentUserAsync(UserModel user)
    {
        try
        {
            _logger.LogInformation("设置当前用户: {Username}", user.Username);
            
            CurrentUser = user;
            
            // 等待权限加载完成
            await LoadUserPermissions();
            
            return Result.Success();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设置当前用户失败: {Username}", user.Username);
            return Result.Fail("SET_USER_FAILED", $"设置当前用户失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 清除当前用户。
    /// </summary>
    public void ClearCurrentUser()
    {
        _logger.LogInformation("清除当前用户");
        CurrentUser = null;
        _userPermissions.Clear();
        _userRoles.Clear();
    }

    /// <summary>
    /// 检查用户是否拥有指定权限。
    /// </summary>
    public bool HasPermission(string permissionCode)
    {
        if (!IsAuthenticated || string.IsNullOrEmpty(permissionCode))
            return false;

        return _userPermissions.Any(p => p.Code.Equals(permissionCode, StringComparison.OrdinalIgnoreCase));
    }

    /// <summary>
    /// 检查用户是否拥有指定角色。
    /// </summary>
    public bool HasRole(string roleName)
    {
        if (!IsAuthenticated || string.IsNullOrEmpty(roleName))
            return false;

        return _userRoles.Any(r => r.Name.Equals(roleName, StringComparison.OrdinalIgnoreCase));
    }

    /// <summary>
    /// 批量检查权限。
    /// </summary>
    public Dictionary<string, bool> CheckPermissions(IEnumerable<string> permissionCodes)
    {
        var result = new Dictionary<string, bool>();
        foreach (var code in permissionCodes)
        {
            result[code] = HasPermission(code);
        }
        return result;
    }

    /// <summary>
    /// 刷新用户权限。
    /// </summary>
    public async Task<Result> RefreshPermissionsAsync()
    {
        try
        {
            if (!IsAuthenticated)
                return Result.Success();

            _logger.LogInformation("刷新用户权限: {Username}", CurrentUser!.Username);
            await LoadUserPermissions();
            return Result.Success();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "刷新用户权限失败: {Username}", CurrentUser?.Username);
            return Result.Fail("REFRESH_PERMISSIONS_FAILED", $"刷新用户权限失败: {ex.Message}");
        }
    }

    private async Task LoadUserPermissions()
    {
        try
        {
            if (!IsAuthenticated)
            {
                _userPermissions.Clear();
                _userRoles.Clear();
                return;
            }

            // 获取用户权限
            var permissionsResult = _authorizationService.GetUserPermissions(CurrentUserId);
            if (permissionsResult.Succeeded)
            {
                _userPermissions = permissionsResult.Data?.ToList() ?? new List<PermissionModel>();
            }
            else
            {
                _logger.LogWarning("获取用户权限失败: {Code} - {Message}", permissionsResult.Code, permissionsResult.Message);
                _userPermissions = new List<PermissionModel>();
            }

            // 获取用户角色
            var rolesResult = _authorizationService.GetUserRoles(CurrentUserId);
            if (rolesResult.Succeeded)
            {
                _userRoles = rolesResult.Data?.ToList() ?? new List<RoleModel>();
            }
            else
            {
                _logger.LogWarning("获取用户角色失败: {Code} - {Message}", rolesResult.Code, rolesResult.Message);
                _userRoles = new List<RoleModel>();
            }

            // 通知权限变更
            OnPropertyChanged(nameof(UserPermissions));
            OnPropertyChanged(nameof(UserRoles));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "加载用户权限失败: {Username}", CurrentUser?.Username);
            _userPermissions = new List<PermissionModel>();
            _userRoles = new List<RoleModel>();
        }
    }

    /// <inheritdoc />
    public event PropertyChangedEventHandler? PropertyChanged;

    private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}