using Microsoft.Extensions.Logging;
using SqlSugar;
using Volo.Abp.Domain.Services;
using Yi.Framework.AiHub.Domain.Entities;
using Yi.Framework.SqlSugarCore.Abstractions;

namespace Yi.Framework.AiHub.Domain.Managers;

/// <summary>
/// 邀请码管理器 - 负责邀请码核心业务逻辑
/// </summary>
public class InviteCodeManager : DomainService
{
    private readonly ISqlSugarRepository<InviteCodeAggregateRoot> _inviteCodeRepository;
    private readonly ISqlSugarRepository<InvitationRecordAggregateRoot> _invitationRecordRepository;
    private readonly ILogger<InviteCodeManager> _logger;

    public InviteCodeManager(
        ISqlSugarRepository<InviteCodeAggregateRoot> inviteCodeRepository,
        ISqlSugarRepository<InvitationRecordAggregateRoot> invitationRecordRepository,
        ILogger<InviteCodeManager> logger)
    {
        _inviteCodeRepository = inviteCodeRepository;
        _invitationRecordRepository = invitationRecordRepository;
        _logger = logger;
    }

    /// <summary>
    /// 生成用户的邀请码
    /// </summary>
    /// <param name="userId">用户ID</param>
    /// <returns>邀请码</returns>
    public async Task<string> GenerateInviteCodeForUserAsync(Guid userId)
    {
        // 检查是否已有邀请码
        var existingCode = await _inviteCodeRepository._DbQueryable
            .Where(x => x.UserId == userId)
            .FirstAsync();

        if (existingCode != null)
        {
            return existingCode.Code;
        }

        // 生成新邀请码
        var code = GenerateUniqueInviteCode();
        var inviteCode = new InviteCodeAggregateRoot(userId, code);
        await _inviteCodeRepository.InsertAsync(inviteCode);

        _logger.LogInformation($"用户 {userId} 生成邀请码 {code}");

        return code;
    }

    /// <summary>
    /// 获取用户的邀请码信息
    /// </summary>
    public async Task<InviteCodeAggregateRoot?> GetUserInviteCodeAsync(Guid userId)
    {
        return await _inviteCodeRepository._DbQueryable
            .Where(x => x.UserId == userId)
            .FirstAsync();
    }

    /// <summary>
    /// 统计用户本周邀请人数
    /// </summary>
    public async Task<int> GetWeeklyInvitationCountAsync(Guid userId, DateTime weekStart)
    {
        return await _invitationRecordRepository._DbQueryable
            .Where(x => x.InviterId == userId)
            .Where(x => x.InvitationTime >= weekStart)
            .CountAsync();
    }

    /// <summary>
    /// 获取邀请历史记录
    /// </summary>
    public async Task<List<InvitationHistoryDto>> GetInvitationHistoryAsync(Guid userId, int limit = 10)
    {
        return await _invitationRecordRepository._DbQueryable
            .Where(x => x.InviterId == userId)
            .OrderBy(x => x.InvitationTime, OrderByType.Desc)
            .Take(limit)
            .Select(x => new InvitationHistoryDto
            {
                InvitedUserName = "用户***", // 脱敏处理
                InvitationTime = x.InvitationTime
            })
            .ToListAsync();
    }

    /// <summary>
    /// 使用邀请码
    /// </summary>
    /// <param name="userId">使用者ID</param>
    /// <param name="inviteCode">邀请码</param>
    /// <returns>邀请人ID</returns>
    public async Task<Guid> UseInviteCodeAsync(Guid userId, string inviteCode)
    {
        if (string.IsNullOrWhiteSpace(inviteCode))
        {
            throw new UserFriendlyException("邀请码不能为空");
        }

        // 查找邀请码
        var inviteCodeEntity = await _inviteCodeRepository._DbQueryable
            .Where(x => x.Code == inviteCode)
            .FirstAsync();

        if (inviteCodeEntity == null)
        {
            throw new UserFriendlyException("邀请码不存在");
        }

        // 验证不能使用自己的邀请码
        if (inviteCodeEntity.UserId == userId)
        {
            throw new UserFriendlyException("不能使用自己的邀请码");
        }

        // 验证邀请码是否已被使用
        if (inviteCodeEntity.IsUsed)
        {
            throw new UserFriendlyException("该邀请码已被使用");
        }

        // 验证邀请码拥有者是否已被邀请
        if (inviteCodeEntity.IsUserInvited)
        {
            throw new UserFriendlyException("该用户已被邀请,邀请码无效");
        }

        // 验证本周邀请码使用次数
        var weekStart = CardFlipManager.GetWeekStartDate(DateTime.Now);
        var weeklyUseCount = await _invitationRecordRepository._DbQueryable
            .Where(x => x.InvitedUserId == userId)
            .Where(x => x.InvitationTime >= weekStart)
            .CountAsync();

        if (weeklyUseCount >= CardFlipManager.MAX_INVITE_FLIPS)
        {
            throw new UserFriendlyException($"本周邀请码使用次数已达上限({CardFlipManager.MAX_INVITE_FLIPS}次),请下周再来");
        }

        // 检查当前用户的邀请码信息
        var myInviteCode = await _inviteCodeRepository._DbQueryable
            .Where(x => x.UserId == userId)
            .FirstAsync();

        // 标记邀请码为已使用
        inviteCodeEntity.MarkAsUsed(userId);
        await _inviteCodeRepository.UpdateAsync(inviteCodeEntity);

        // 标记当前用户已被邀请(仅第一次使用邀请码时标记)
        if (myInviteCode == null)
        {
            myInviteCode = new InviteCodeAggregateRoot(userId, GenerateUniqueInviteCode());
            myInviteCode.MarkUserAsInvited();
            await _inviteCodeRepository.InsertAsync(myInviteCode);
        }
        else if (!myInviteCode.IsUserInvited)
        {
            myInviteCode.MarkUserAsInvited();
            await _inviteCodeRepository.UpdateAsync(myInviteCode);
        }

        // 创建邀请记录
        var invitationRecord = new InvitationRecordAggregateRoot(
            inviteCodeEntity.UserId,
            userId,
            inviteCode);
        await _invitationRecordRepository.InsertAsync(invitationRecord);

        _logger.LogInformation($"用户 {userId} 使用邀请码 {inviteCode} 成功");

        return inviteCodeEntity.UserId;
    }

    /// <summary>
    /// 检查用户是否已被邀请
    /// </summary>
    public async Task<bool> IsUserInvitedAsync(Guid userId)
    {
        var inviteCode = await _inviteCodeRepository._DbQueryable
            .Where(x => x.UserId == userId)
            .FirstAsync();

        return inviteCode?.IsUserInvited ?? false;
    }

    /// <summary>
    /// 生成唯一邀请码
    /// </summary>
    private string GenerateUniqueInviteCode()
    {
        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        var random = new Random();
        var code = new char[8];

        for (int i = 0; i < code.Length; i++)
        {
            code[i] = chars[random.Next(chars.Length)];
        }

        return new string(code);
    }
}

/// <summary>
/// 邀请历史记录DTO
/// </summary>
public class InvitationHistoryDto
{
    /// <summary>
    /// 被邀请人名称(脱敏)
    /// </summary>
    public string InvitedUserName { get; set; } = string.Empty;

    /// <summary>
    /// 邀请时间
    /// </summary>
    public DateTime InvitationTime { get; set; }
}