using System.Linq.Expressions;
using BCrypt.Net;
using Microsoft.Extensions.Logging;
using QYZH.InteractiveMagazine.IService;
using QYZH.InteractiveMagazine.IService.Dto;
using QYZH.InteractiveMagazine.Models.Common;
using QYZH.InteractiveMagazine.Models.Dto;
using QYZH.InteractiveMagazine.Models.Entity;
using QYZH.InteractiveMagazine.Repository;
using SqlSugar;

namespace QYZH.InteractiveMagazine.Service;

/// <summary>
/// 管理员用户服务实现
/// </summary>
public class AdminUserService(BaseRepository<AdminUser> adminUserRepository, ILogger<AdminUserService> logger) : BaseRepository<AdminUser>, IAdminUserService
{

    /// <summary>
    /// 创建管理员
    /// </summary>
    public async Task<AdminUserOutput> CreateAsync(AdminUserInput input)
    {
        logger.LogInformation("正在创建管理员，用户名: {UserName}", input.UserName);

        if (string.IsNullOrWhiteSpace(input.UserName))
        {
            throw new BusinessException("用户名不能为空", 400);
        }

        if (string.IsNullOrWhiteSpace(input.Password))
        {
            throw new BusinessException("密码不能为空", 400);
        }

        // 检查用户名是否已存在
        var existingUser = await adminUserRepository.GetFirstAsync(a => a.UserName == input.UserName);
        if (existingUser != null)
        {
            logger.LogWarning("创建管理员失败，用户名已存在: {UserName}", input.UserName);
            throw new BusinessException("用户名已存在", 400);
        }

        var adminUser = new AdminUser
        {
            UserName = input.UserName.Trim(),
            PasswordHash = BCrypt.Net.BCrypt.HashPassword(input.Password),
            Type = input.Type,
            Status = input.Status,
            CreatedBy = "System",
            UpdatedBy = "System",
            CreatedAt = DateTime.Now,
            UpdatedAt = DateTime.Now,
            IsDeleted = false
        };

        var result = await adminUserRepository.InsertAsync(adminUser);
        if (!result)
        {
            logger.LogError("管理员创建失败，用户名: {UserName}", input.UserName);
            throw new BusinessException("创建管理员失败", 500);
        }

        logger.LogInformation("管理员创建成功，用户名: {UserName}, ID: {Id}", input.UserName, adminUser.Id);

        return MapToOutput(adminUser);
    }

    /// <summary>
    /// 更新管理员
    /// </summary>
    public async Task<AdminUserOutput> UpdateAsync(long id, AdminUserInput input)
    {
        logger.LogInformation("正在更新管理员，ID: {Id}", id);

        var adminUser = await adminUserRepository.GetByIdAsync(id);
        if (adminUser == null)
        {
            logger.LogWarning("未找到要更新的管理员，ID: {Id}", id);
            throw new BusinessException("管理员不存在", 404);
        }

        // 如果用户名有变更，检查是否与其他用户重复
        if (!string.IsNullOrWhiteSpace(input.UserName) && input.UserName != adminUser.UserName)
        {
            var existingUser = await adminUserRepository.GetFirstAsync(a => a.UserName == input.UserName.Trim());
            if (existingUser != null && existingUser.Id != id)
            {
                logger.LogWarning("更新管理员失败，用户名已存在: {UserName}", input.UserName);
                throw new BusinessException("用户名已存在", 400);
            }

            adminUser.UserName = input.UserName.Trim();
        }

        // 如果提供了密码，则更新密码
        if (!string.IsNullOrWhiteSpace(input.Password))
        {
            adminUser.PasswordHash = BCrypt.Net.BCrypt.HashPassword(input.Password);
        }

        if (!string.IsNullOrWhiteSpace(input.Type))
        {
            adminUser.Type = input.Type;
        }

        if (!string.IsNullOrWhiteSpace(input.Status))
        {
            adminUser.Status = input.Status;
        }

        adminUser.UpdatedBy = "System";
        adminUser.UpdatedAt = DateTime.Now;

        var result = await adminUserRepository.UpdateAsync(adminUser);
        if (!result)
        {
            logger.LogError("管理员更新失败，ID: {Id}", id);
            throw new BusinessException("更新管理员失败", 500);
        }

        logger.LogInformation("管理员更新成功，ID: {Id}", id);

        return MapToOutput(adminUser);
    }

    /// <summary>
    /// 删除管理员（软删除）
    /// </summary>
    public async Task DeleteAsync(long id)
    {
        logger.LogInformation("正在删除管理员，ID: {Id}", id);

        var adminUser = await adminUserRepository.GetByIdAsync(id);
        if (adminUser == null)
        {
            logger.LogWarning("未找到要删除的管理员，ID: {Id}", id);
            throw new BusinessException("管理员不存在", 404);
        }

        var result = await adminUserRepository.DeleteByIdAsync(id);
        if (!result)
        {
            logger.LogError("管理员删除失败，ID: {Id}", id);
            throw new BusinessException("删除管理员失败", 500);
        }

        logger.LogInformation("管理员删除成功，ID: {Id}", id);
    }

    /// <summary>
    /// 根据ID获取管理员
    /// </summary>
    public async Task<AdminUserOutput> GetByIdAsync(long id)
    {
        logger.LogInformation("正在获取管理员信息，ID: {Id}", id);

        var adminUser = await adminUserRepository.GetByIdAsync(id);
        if (adminUser == null)
        {
            logger.LogWarning("未找到管理员，ID: {Id}", id);
            throw new BusinessException("管理员不存在", 404);
        }

        return MapToOutput(adminUser);
    }

    /// <summary>
    /// 分页查询管理员列表
    /// </summary>
    public async Task<PageListModel<AdminUserOutput>> GetListAsync(AdminUserQueryInput input)
    {
        logger.LogInformation("正在查询管理员列表，页码: {PageIndex}, 每页条数: {PageSize}", input.PageIndex, input.PageSize);

        if (input.PageIndex <= 0)
        {
            throw new BusinessException("页码必须大于0", 400);
        }

        if (input.PageSize <= 0 || input.PageSize > 100)
        {
            throw new BusinessException("每页条数必须在1-100之间", 400);
        }
        RefAsync<int> totalNumber = 0;
        var pageResult = await adminUserRepository.Queryable()
               .WhereIF(!string.IsNullOrWhiteSpace(input.UserName), a => a.UserName == input.UserName)
                .OrderByDescending(a => a.CreatedAt)
                 .Select(a => MapToOutput(a), true)
                  .ToPageListAsync(input.PageIndex, input.PageSize, totalNumber);
        return new PageListModel<AdminUserOutput>(pageResult, input.PageIndex, input.PageSize, totalNumber);
    }

    /// <summary>
    /// 将实体映射为输出DTO
    /// </summary>
    private static AdminUserOutput MapToOutput(AdminUser adminUser)
    {
        return new AdminUserOutput
        {
            Id = adminUser.Id,
            UserName = adminUser.UserName,
            Type = adminUser.Type,
            Status = adminUser.Status,
            CreatedBy = adminUser.CreatedBy,
            CreatedAt = adminUser.CreatedAt,
            UpdatedBy = adminUser.UpdatedBy,
            UpdatedAt = adminUser.UpdatedAt
        };
    }
}