using YD_Event.Application.Auth;
using YD_Event.Application.Role.Dtos;
using YD_Event.Core.Options;
using YD_Event.Core.Shared;
using Microsoft.Extensions.Options;

namespace YD_Event.Application.Role;

/// <summary>
/// 角色管理
/// </summary>
public class SysRoleService : BaseService<SysRole>, ITransient
{
    private readonly ISqlSugarRepository<SysRole> _sysRoleRepository;
    private readonly ISqlSugarRepository<SysRoleMenu> _sysRoleMenuRepository;
    private readonly ISqlSugarRepository<SysUserRole> _sysUserRoleRepository;
    private readonly IEasyCachingProvider _easyCachingProvider;
    private readonly IIdGenerator _idGenerator;
    private readonly AuthManager _authManager;
    private readonly IOptionsMonitor<RoleOptions> _roleOptionsMonitor;

    public SysRoleService(ISqlSugarRepository<SysRole> sysRoleRepository,
        ISqlSugarRepository<SysRoleMenu> sysRoleMenuRepository,
        ISqlSugarRepository<SysUserRole> sysUserRoleRepository,
        IEasyCachingProvider easyCachingProvider,
        IIdGenerator idGenerator,
        AuthManager authManager,
        IOptionsMonitor<RoleOptions> roleOptionsMonitor) : base(sysRoleRepository)
    {
        _sysRoleRepository = sysRoleRepository;
        _sysRoleMenuRepository = sysRoleMenuRepository;
        _sysUserRoleRepository = sysUserRoleRepository;
        _easyCachingProvider = easyCachingProvider;
        _idGenerator = idGenerator;
        _authManager = authManager;
        _roleOptionsMonitor = roleOptionsMonitor;
    }

    /// <summary>
    /// 角色分页查询
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [DisplayName("角色分页查询")]
    [HttpGet("page")]
    public async Task<PageResult<SysRolePageOutput>> Page([FromQuery] SysRoleQueryInput dto)
    {
        var isAdmin = await IsCurrentUserAdminAsync();
        var query = _sysRoleRepository.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(dto.Name), x => x.Name.Contains(dto.Name));

        if (!isAdmin)
        {
            // 非管理员用户，过滤掉管理员和单位用户角色
            query = query.Where(x => x.Id != _roleOptionsMonitor.CurrentValue.AdminRoleId && x.Id != _roleOptionsMonitor.CurrentValue.UnitUserRoleId);
        }

        return await query
            .OrderBy(x => x.Sort)
            .OrderByDescending(x => x.Id)
            .Select(x => new SysRolePageOutput
            {
                Id = x.Id,
                Name = x.Name,
                CreatedTime = x.CreatedTime,
                Status = x.Status,
                Code = x.Code,
                Sort = x.Sort,
                Remark = x.Remark
            }).ToPagedListAsync(dto);
    }

    /// <summary>
    /// 检查当前登录用户是否是管理员
    /// </summary>
    /// <returns></returns>
    private async Task<bool> IsCurrentUserAdminAsync()
    {
        var userId = _authManager.UserId;
        // 首先检查是否是超级管理员（用户ID为1000）
        if (_authManager.IsSuperAdmin)
        {
            return true;
        }
        // 检查用户是否拥有管理员角色
        return await _sysUserRoleRepository.IsAnyAsync(x => x.UserId == userId && x.RoleId == _roleOptionsMonitor.CurrentValue.AdminRoleId);
    }

    /// <summary>
    /// 添加角色
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [DisplayName("添加角色")]
    [HttpPost("add")]
    [UnitOfWork]
    public async Task AddRole(AddSysRoleInput dto)
    {
        var role = dto.Adapt<SysRole>();
        role.Id = _idGenerator.NewLong();
        // 自动生成Code，避免重复
        role.Code = $"Role_{role.Id}";
        
        if (await _sysRoleRepository.IsAnyAsync(x => x.Name == dto.Name))
        {
            throw new InvalidOperationException($"角色名称 {dto.Name} 已存在");
        }

        await _sysRoleRepository.InsertAsync(role);
        
        // 保存角色权限
        var menuIds = dto.MenuIds ?? dto.Menus;
        if (menuIds != null && menuIds.Any())
        {
            var roleMenus = menuIds.Select(x => new SysRoleMenu()
            {
                MenuId = x,
                RoleId = role.Id
            }).ToList();

            await _sysRoleMenuRepository.InsertRangeAsync(roleMenus);
        }
    }

    /// <summary>
    /// 更新角色
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [DisplayName("更新角色")]
    [HttpPut("edit")]
    [UnitOfWork]
    public async Task UpdateRole(UpdateSysRoleInput dto)
    {
        var sysRole = await _sysRoleRepository.GetByIdAsync(dto.Id);
        if (sysRole == null)
        {
            throw new InvalidOperationException("角色不存在");
        }
        
        if (await _sysRoleRepository.IsAnyAsync(x => x.Id != dto.Id && x.Name == dto.Name))
        {
            throw new InvalidOperationException($"角色名称 {dto.Name} 已存在");
        }

        dto.Adapt(sysRole);
        await _sysRoleRepository.UpdateAsync(sysRole);
        
        // 更新角色权限 - 软删旧权限
        await _sysRoleMenuRepository.SoftDeleteAsync(x => x.RoleId == dto.Id);
        var menuIds = dto.MenuIds ?? dto.Menus;
        if (menuIds != null && menuIds.Any())
        {
            var roleMenus = menuIds.Select(x => new SysRoleMenu()
            {
                MenuId = x,
                RoleId = dto.Id
            }).ToList();

            await _sysRoleMenuRepository.InsertRangeAsync(roleMenus);
        }
        await _easyCachingProvider.RemoveByPrefixAsync(CacheConst.PermissionKey);
    }

    /// <summary>
    /// 授权角色权限
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisplayName("授权角色权限")]
    [HttpPost("grantPermission")]
    [UnitOfWork]
    public async Task GrantPermission(GrantRolePermissionInput input)
    {
        var sysRole = await _sysRoleRepository.GetByIdAsync(input.Id);
        if (sysRole == null) throw new InvalidOperationException("角色不存在");

        var roleMenus = input.MenuIds.Select(x => new SysRoleMenu()
        {
            MenuId = x,
            RoleId = input.Id
        }).ToList();

        await _sysRoleMenuRepository.SoftDeleteAsync(x => x.RoleId == input.Id);
        if (roleMenus.Any())
        {
            await _sysRoleMenuRepository.InsertRangeAsync(roleMenus);
        }
        await _easyCachingProvider.RemoveByPrefixAsync(CacheConst.PermissionKey);
    }

    /// <summary>
    /// 获取角色可访问的菜单和按钮id
    /// </summary>
    /// <param name="id">角色id</param>
    /// <returns></returns>
    [DisplayName("获取角色可访问的菜单和按钮id")]
    [HttpGet("getRoleMenu")]
    public async Task<List<long>> GetRoleMenu([FromQuery] long id)
    {
        return await _sysRoleRepository.AsQueryable()
             .InnerJoin<SysRoleMenu>((role, roleMenu) => role.Id == roleMenu.RoleId)
             .InnerJoin<SysMenu>((role, roleMenu, menu) => roleMenu.MenuId == menu.Id)
             .Where((role, roleMenu, menu) => role.Id == id && menu.Status == AvailabilityStatus.Enable)
             .Select((role, roleMenu) => roleMenu.MenuId)
             .ToListAsync();
    }

    /// <summary>
    /// 修改角色状态
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [DisplayName("修改角色状态")]
    [HttpPut("setStatus")]
    public override async Task SetStatus(AvailabilityDto dto)
    {
        await base.SetStatus(dto);
        await _easyCachingProvider.RemoveByPrefixAsync(CacheConst.PermissionKey);
    }

    /// <summary>
    /// 删除角色
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [DisplayName("删除角色")]
    [HttpDelete("delete")]
    public override async Task Delete(KeyDto dto)
    {
        await base.Delete(dto);
        // 软删关联权限
        await _sysRoleMenuRepository.SoftDeleteAsync(x => x.RoleId == dto.Id);
        await _easyCachingProvider.RemoveByPrefixAsync(CacheConst.PermissionKey);
    }

    /// <summary>
    /// 角色下拉选项
    /// </summary>
    /// <returns></returns>
    [DisplayName("角色下拉选项")]
    [HttpGet("select")]
    public async Task<List<SelectOutput>> RoleSelect()
    {
        var isAdmin = await IsCurrentUserAdminAsync();
        var query = _sysRoleRepository.AsQueryable().Where(x => x.Status == AvailabilityStatus.Enable);

        if (!isAdmin)
        {
            // 非管理员用户，过滤掉管理员和单位用户角色
            query = query.Where(x => x.Id != _roleOptionsMonitor.CurrentValue.AdminRoleId && x.Id != _roleOptionsMonitor.CurrentValue.UnitUserRoleId);
        }

        return await query
            .OrderBy(x => x.Sort)
            .OrderBy(x => x.Id)
            .Select(x => new SelectOutput()
            {
                Value = x.Id,
                Label = x.Name
            }).ToListAsync();
    }

    /// <summary>
    /// 角色下拉选项(兼容接口)
    /// </summary>
    /// <returns></returns>
    [DisplayName("角色下拉选项(兼容接口)")]
    [HttpGet("roleselect")]
    public async Task<List<SelectOutput>> RoleSelectCompat()
    {
        return await RoleSelect();
    }
}