using AmtScanner.Api.Data;
using AmtScanner.Api.Models;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace AmtScanner.Api.Controllers;

/// <summary>
/// 角色控制器
/// </summary>
[ApiController]
[Route("api/[controller]")]
[Authorize]
public class RoleController : ControllerBase
{
    private readonly AppDbContext _context;

    public RoleController(AppDbContext context)
    {
        _context = context;
    }

    /// <summary>
    /// 获取角色列表（分页）
    /// </summary>
    [HttpGet("list")]
    public async Task<ActionResult<ApiResponse<PaginatedResponse<RoleListItemDto>>>> GetRoleList(
        [FromQuery] int current = 1,
        [FromQuery] int size = 10,
        [FromQuery] string? roleName = null,
        [FromQuery] string? roleCode = null)
    {
        var query = _context.Roles.AsQueryable();

        if (!string.IsNullOrEmpty(roleName))
        {
            query = query.Where(r => r.RoleName.Contains(roleName));
        }

        if (!string.IsNullOrEmpty(roleCode))
        {
            query = query.Where(r => r.RoleCode.Contains(roleCode));
        }

        var total = await query.CountAsync();
        var roles = await query
            .OrderBy(r => r.Id)
            .Skip((current - 1) * size)
            .Take(size)
            .Select(r => new RoleListItemDto
            {
                RoleId = r.Id,
                RoleName = r.RoleName,
                RoleCode = r.RoleCode,
                Description = r.Description,
                Enabled = r.Enabled,
                CreateTime = r.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss")
            })
            .ToListAsync();

        return Ok(ApiResponse<PaginatedResponse<RoleListItemDto>>.Success(new PaginatedResponse<RoleListItemDto>
        {
            Records = roles,
            Current = current,
            Size = size,
            Total = total
        }));
    }

    /// <summary>
    /// 获取所有角色（下拉选择用）
    /// </summary>
    [HttpGet("all")]
    public async Task<ActionResult<ApiResponse<List<RoleSimpleDto>>>> GetAllRoles()
    {
        var roles = await _context.Roles
            .Where(r => r.Enabled)
            .OrderBy(r => r.Id)
            .Select(r => new RoleSimpleDto
            {
                RoleId = r.Id,
                RoleName = r.RoleName,
                RoleCode = r.RoleCode
            })
            .ToListAsync();

        return Ok(ApiResponse<List<RoleSimpleDto>>.Success(roles));
    }

    /// <summary>
    /// 获取角色详情
    /// </summary>
    [HttpGet("{id}")]
    public async Task<ActionResult<ApiResponse<RoleListItemDto>>> GetRole(int id)
    {
        var role = await _context.Roles.FindAsync(id);
        if (role == null)
        {
            return NotFound(ApiResponse<RoleListItemDto>.Fail(404, "角色不存在"));
        }

        return Ok(ApiResponse<RoleListItemDto>.Success(new RoleListItemDto
        {
            RoleId = role.Id,
            RoleName = role.RoleName,
            RoleCode = role.RoleCode,
            Description = role.Description,
            Enabled = role.Enabled,
            CreateTime = role.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss")
        }));
    }

    /// <summary>
    /// 创建角色
    /// </summary>
    [HttpPost]
    public async Task<ActionResult<ApiResponse<RoleListItemDto>>> CreateRole([FromBody] CreateRoleDto dto)
    {
        // 检查角色编码是否已存在
        if (await _context.Roles.AnyAsync(r => r.RoleCode == dto.RoleCode))
        {
            return BadRequest(ApiResponse<RoleListItemDto>.Fail(400, "角色编码已存在"));
        }

        // 检查角色名称是否已存在
        if (await _context.Roles.AnyAsync(r => r.RoleName == dto.RoleName))
        {
            return BadRequest(ApiResponse<RoleListItemDto>.Fail(400, "角色名称已存在"));
        }

        var role = new Role
        {
            RoleName = dto.RoleName,
            RoleCode = dto.RoleCode,
            Description = dto.Description,
            Enabled = dto.Enabled,
            CreatedAt = DateTime.UtcNow
        };

        _context.Roles.Add(role);
        await _context.SaveChangesAsync();

        return Ok(ApiResponse<RoleListItemDto>.Success(new RoleListItemDto
        {
            RoleId = role.Id,
            RoleName = role.RoleName,
            RoleCode = role.RoleCode,
            Description = role.Description,
            Enabled = role.Enabled,
            CreateTime = role.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss")
        }, "创建成功"));
    }

    /// <summary>
    /// 更新角色
    /// </summary>
    [HttpPut("{id}")]
    public async Task<ActionResult<ApiResponse<RoleListItemDto>>> UpdateRole(int id, [FromBody] UpdateRoleDto dto)
    {
        var role = await _context.Roles.FindAsync(id);
        if (role == null)
        {
            return NotFound(ApiResponse<RoleListItemDto>.Fail(404, "角色不存在"));
        }

        // 检查角色编码是否与其他角色重复
        if (!string.IsNullOrEmpty(dto.RoleCode) && dto.RoleCode != role.RoleCode)
        {
            if (await _context.Roles.AnyAsync(r => r.RoleCode == dto.RoleCode && r.Id != id))
            {
                return BadRequest(ApiResponse<RoleListItemDto>.Fail(400, "角色编码已存在"));
            }
            role.RoleCode = dto.RoleCode;
        }

        // 检查角色名称是否与其他角色重复
        if (!string.IsNullOrEmpty(dto.RoleName) && dto.RoleName != role.RoleName)
        {
            if (await _context.Roles.AnyAsync(r => r.RoleName == dto.RoleName && r.Id != id))
            {
                return BadRequest(ApiResponse<RoleListItemDto>.Fail(400, "角色名称已存在"));
            }
            role.RoleName = dto.RoleName;
        }

        if (dto.Description != null)
        {
            role.Description = dto.Description;
        }

        if (dto.Enabled.HasValue)
        {
            role.Enabled = dto.Enabled.Value;
        }

        await _context.SaveChangesAsync();

        return Ok(ApiResponse<RoleListItemDto>.Success(new RoleListItemDto
        {
            RoleId = role.Id,
            RoleName = role.RoleName,
            RoleCode = role.RoleCode,
            Description = role.Description,
            Enabled = role.Enabled,
            CreateTime = role.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss")
        }, "更新成功"));
    }

    /// <summary>
    /// 删除角色
    /// </summary>
    [HttpDelete("{id}")]
    public async Task<ActionResult<ApiResponse<object>>> DeleteRole(int id)
    {
        var role = await _context.Roles
            .Include(r => r.UserRoles)
            .Include(r => r.RoleMenus)
            .FirstOrDefaultAsync(r => r.Id == id);

        if (role == null)
        {
            return NotFound(ApiResponse<object>.Fail(404, "角色不存在"));
        }

        // 检查是否有用户使用该角色
        if (role.UserRoles.Any())
        {
            return BadRequest(ApiResponse<object>.Fail(400, "该角色下存在用户，无法删除"));
        }

        // 删除角色菜单关联
        _context.RoleMenus.RemoveRange(role.RoleMenus);
        
        // 删除角色
        _context.Roles.Remove(role);
        await _context.SaveChangesAsync();

        return Ok(ApiResponse<object>.Success(null, "删除成功"));
    }

    /// <summary>
    /// 获取角色的菜单权限
    /// </summary>
    [HttpGet("{id}/menus")]
    public async Task<ActionResult<ApiResponse<List<int>>>> GetRoleMenus(int id)
    {
        var role = await _context.Roles.FindAsync(id);
        if (role == null)
        {
            return NotFound(ApiResponse<List<int>>.Fail(404, "角色不存在"));
        }

        var menuIds = await _context.RoleMenus
            .Where(rm => rm.RoleId == id)
            .Select(rm => rm.MenuId)
            .ToListAsync();

        return Ok(ApiResponse<List<int>>.Success(menuIds));
    }

    /// <summary>
    /// 设置角色的菜单权限
    /// </summary>
    [HttpPut("{id}/menus")]
    public async Task<ActionResult<ApiResponse<object>>> SetRoleMenus(int id, [FromBody] SetRoleMenusDto dto)
    {
        var role = await _context.Roles.FindAsync(id);
        if (role == null)
        {
            return NotFound(ApiResponse<object>.Fail(404, "角色不存在"));
        }

        // 删除原有的菜单权限
        var existingMenus = await _context.RoleMenus
            .Where(rm => rm.RoleId == id)
            .ToListAsync();
        _context.RoleMenus.RemoveRange(existingMenus);

        // 添加新的菜单权限
        if (dto.MenuIds != null && dto.MenuIds.Any())
        {
            var newMenus = dto.MenuIds.Select(menuId => new RoleMenu
            {
                RoleId = id,
                MenuId = menuId
            });
            _context.RoleMenus.AddRange(newMenus);
        }

        await _context.SaveChangesAsync();

        return Ok(ApiResponse<object>.Success(null, "菜单权限设置成功"));
    }
}

/// <summary>
/// 角色列表项 DTO
/// </summary>
public class RoleListItemDto
{
    public int RoleId { get; set; }
    public string RoleName { get; set; } = string.Empty;
    public string RoleCode { get; set; } = string.Empty;
    public string? Description { get; set; }
    public bool Enabled { get; set; }
    public string CreateTime { get; set; } = string.Empty;
}

/// <summary>
/// 角色简单 DTO（下拉选择用）
/// </summary>
public class RoleSimpleDto
{
    public int RoleId { get; set; }
    public string RoleName { get; set; } = string.Empty;
    public string RoleCode { get; set; } = string.Empty;
}

/// <summary>
/// 创建角色 DTO
/// </summary>
public class CreateRoleDto
{
    public string RoleName { get; set; } = string.Empty;
    public string RoleCode { get; set; } = string.Empty;
    public string? Description { get; set; }
    public bool Enabled { get; set; } = true;
}

/// <summary>
/// 更新角色 DTO
/// </summary>
public class UpdateRoleDto
{
    public string? RoleName { get; set; }
    public string? RoleCode { get; set; }
    public string? Description { get; set; }
    public bool? Enabled { get; set; }
}

/// <summary>
/// 设置角色菜单 DTO
/// </summary>
public class SetRoleMenusDto
{
    public List<int>? MenuIds { get; set; }
}