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)
    {
        var inviterCount= await _invitationRecordRepository._DbQueryable
            .Where(x => x.InviterId == userId)
            .Where(x => x.InvitationTime >= weekStart)
            .CountAsync();
        var invitedUserIdCount= await _invitationRecordRepository._DbQueryable
            .Where(x => x.InvitedUserId == userId)
            .Where(x => x.InvitationTime >= weekStart)
            .CountAsync();
        return inviterCount + invitedUserIdCount;
    }

    /// <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("不能使用自己的邀请码");
        }
        
        // 检查当前用户是否已经填写过别人的邀请码（一辈子只能填写一次）
        var hasUsedOthersCode = await IsFilledInviteCodeAsync(userId);

        if (hasUsedOthersCode)
        {
            throw new UserFriendlyException("您已经填写过别人的邀请码了，每个账号只能填写一次");
        }
        
        // 增加邀请码被使用次数
        inviteCodeEntity.UsedCount++;
        await _inviteCodeRepository.UpdateAsync(inviteCodeEntity);
        
        // 创建邀请记录（双方都会因为这条记录增加一次翻牌机会）
        var invitationRecord = new InvitationRecordAggregateRoot(
            inviteCodeEntity.UserId,
            userId,
            inviteCode);
        await _invitationRecordRepository.InsertAsync(invitationRecord);

        _logger.LogInformation($"用户 {userId} 使用邀请码 {inviteCode} 成功，邀请人 {inviteCodeEntity.UserId} 和被邀请人 {userId} 都增加一次翻牌机会");

        return inviteCodeEntity.UserId;
    }

    /// <summary>
    /// 检查用户是否已填写过邀请码
    /// </summary>
    public async Task<bool> IsFilledInviteCodeAsync(Guid userId)
    {
        // 检查当前用户是否已经填写过别人的邀请码（一辈子只能填写一次）
        return await _invitationRecordRepository._DbQueryable
            .Where(x => x.InvitedUserId == userId)
            .AnyAsync();
    }

    /// <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; }
}