using Microsoft.Extensions.Logging;
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 CardFlipManager : DomainService
{
    private readonly ISqlSugarRepository<CardFlipTaskAggregateRoot> _cardFlipTaskRepository;
    private readonly ILogger<CardFlipManager> _logger;

    // 翻牌规则配置
    public const int MAX_FREE_FLIPS = 5;        // 免费翻牌次数
    public const int MAX_BONUS_FLIPS = 3;       // 赠送翻牌次数
    public const int MAX_INVITE_FLIPS = 2;      // 邀请解锁翻牌次数
    public const int TOTAL_MAX_FLIPS = 10;      // 总最大翻牌次数

    private const int NINTH_FLIP = 9;            // 第9次翻牌
    private const int TENTH_FLIP = 10;           // 第10次翻牌

    private const long NINTH_MIN_REWARD = 3000000;   // 第9次最小奖励 300w
    private const long NINTH_MAX_REWARD = 7000000;   // 第9次最大奖励 700w
    private const long TENTH_MIN_REWARD = 8000000;   // 第10次最小奖励 800w
    private const long TENTH_MAX_REWARD = 12000000;  // 第10次最大奖励 1200w

    public CardFlipManager(
        ISqlSugarRepository<CardFlipTaskAggregateRoot> cardFlipTaskRepository,
        ILogger<CardFlipManager> logger)
    {
        _cardFlipTaskRepository = cardFlipTaskRepository;
        _logger = logger;
    }

    /// <summary>
    /// 获取或创建本周任务
    /// </summary>
    public async Task<CardFlipTaskAggregateRoot?> GetOrCreateWeeklyTaskAsync(
        Guid userId,
        DateTime weekStart,
        bool createIfNotExists)
    {
        var task = await _cardFlipTaskRepository._DbQueryable
            .Where(x => x.UserId == userId && x.WeekStartDate == weekStart)
            .FirstAsync();

        if (task == null && createIfNotExists)
        {
            task = new CardFlipTaskAggregateRoot(userId, weekStart);
            await _cardFlipTaskRepository.InsertAsync(task);
        }

        return task;
    }

    /// <summary>
    /// 获取已翻牌的顺序列表
    /// </summary>
    public List<int> GetFlippedOrder(CardFlipTaskAggregateRoot task)
    {
        return task.FlippedOrder ?? new List<int>();
    }

    /// <summary>
    /// 执行翻牌逻辑
    /// </summary>
    /// <param name="userId">用户ID</param>
    /// <param name="flipNumber">翻牌序号</param>
    /// <param name="weekStart">本周开始日期</param>
    /// <returns>翻牌结果</returns>
    public async Task<FlipResult> ExecuteFlipAsync(Guid userId, int flipNumber, DateTime weekStart)
    {
        // 验证翻牌序号
        if (flipNumber < 1 || flipNumber > TOTAL_MAX_FLIPS)
        {
            throw new UserFriendlyException($"翻牌序号必须在1-{TOTAL_MAX_FLIPS}之间");
        }

        // 获取或创建本周任务
        var task = await GetOrCreateWeeklyTaskAsync(userId, weekStart, createIfNotExists: true);

        // 验证翻牌次数
        if (task.TotalFlips >= TOTAL_MAX_FLIPS)
        {
            throw new UserFriendlyException("本周翻牌次数已用完,请下周再来!");
        }

        // 验证该牌是否已经翻过
        var flippedOrder = GetFlippedOrder(task);
        if (flippedOrder.Contains(flipNumber))
        {
            throw new UserFriendlyException($"第 {flipNumber} 号牌已经翻过了!");
        }

        // 判断翻牌类型
        var flipType = DetermineFlipType(task);

        // 验证是否有足够的次数
        if (!CanUseFlipType(task, flipType))
        {
            throw new UserFriendlyException(GetFlipTypeErrorMessage(flipType));
        }

        // 计算翻牌结果
        var result = CalculateFlipResult(flipNumber);

        // 记录奖励
        if (result.IsWin)
        {
            if (flipNumber == NINTH_FLIP)
            {
                task.SetNinthReward(result.RewardAmount);
            }
            else if (flipNumber == TENTH_FLIP)
            {
                task.SetTenthReward(result.RewardAmount);
            }
        }

        // 更新翻牌次数
        task.IncrementFlip(flipType);

        // 记录翻牌顺序
        if (task.FlippedOrder == null)
        {
            task.FlippedOrder = new List<int>();
        }
        task.FlippedOrder.Add(flipNumber);

        await _cardFlipTaskRepository.UpdateAsync(task);

        _logger.LogInformation($"用户 {userId} 完成第 {flipNumber} 次翻牌,中奖:{result.IsWin}");

        return result;
    }

    /// <summary>
    /// 判断是否可以翻牌
    /// </summary>
    public bool CanFlipCard(CardFlipTaskAggregateRoot? task)
    {
        if (task == null) return true; // 没有任务记录,可以开始翻牌

        return task.TotalFlips < TOTAL_MAX_FLIPS;
    }

    /// <summary>
    /// 判断翻牌类型
    /// </summary>
    public FlipType DetermineFlipType(CardFlipTaskAggregateRoot task)
    {
        if (task.FreeFlipsUsed < MAX_FREE_FLIPS)
        {
            return FlipType.Free;
        }
        else if (task.BonusFlipsUsed < MAX_BONUS_FLIPS)
        {
            return FlipType.Bonus;
        }
        else
        {
            return FlipType.Invite;
        }
    }

    /// <summary>
    /// 判断是否可以使用该翻牌类型
    /// </summary>
    public bool CanUseFlipType(CardFlipTaskAggregateRoot task, FlipType flipType)
    {
        return flipType switch
        {
            FlipType.Free => task.FreeFlipsUsed < MAX_FREE_FLIPS,
            FlipType.Bonus => task.BonusFlipsUsed < MAX_BONUS_FLIPS,
            FlipType.Invite => task.InviteFlipsUsed < MAX_INVITE_FLIPS,
            _ => false
        };
    }

    /// <summary>
    /// 计算翻牌结果
    /// </summary>
    private FlipResult CalculateFlipResult(int flipNumber)
    {
        var result = new FlipResult
        {
            FlipNumber = flipNumber,
            IsWin = false,
            ShowDoubleRewardTip = false
        };

        // 前8次固定失败
        if (flipNumber <= 8)
        {
            result.IsWin = false;
            result.RewardDesc = "很遗憾,未中奖";
        }
        // 第9次中奖
        else if (flipNumber == NINTH_FLIP)
        {
            var rewardAmount = GenerateRandomReward(NINTH_MIN_REWARD, NINTH_MAX_REWARD);
            result.IsWin = true;
            result.RewardAmount = rewardAmount;
            result.RewardDesc = $"恭喜获得尊享包 {rewardAmount / 10000}w tokens!";
            result.ShowDoubleRewardTip = true; // 显示翻倍包提示
        }
        // 第10次中奖(翻倍)
        else if (flipNumber == TENTH_FLIP)
        {
            var rewardAmount = GenerateRandomReward(TENTH_MIN_REWARD, TENTH_MAX_REWARD);
            result.IsWin = true;
            result.RewardAmount = rewardAmount;
            result.RewardDesc = $"恭喜获得尊享包 {rewardAmount / 10000}w tokens(翻倍奖励)!";
        }

        return result;
    }

    /// <summary>
    /// 获取翻牌类型错误提示
    /// </summary>
    private string GetFlipTypeErrorMessage(FlipType flipType)
    {
        return flipType switch
        {
            FlipType.Free => "免费翻牌次数已用完",
            FlipType.Bonus => "赠送翻牌次数已用完",
            FlipType.Invite => "需要使用邀请码解锁更多次数",
            _ => "无法翻牌"
        };
    }

    /// <summary>
    /// 生成随机奖励金额
    /// </summary>
    private long GenerateRandomReward(long min, long max)
    {
        var random = new Random();
        return (long)(random.NextDouble() * (max - min) + min);
    }

    /// <summary>
    /// 获取本周开始日期(周一)
    /// </summary>
    public static DateTime GetWeekStartDate(DateTime date)
    {
        var dayOfWeek = (int)date.DayOfWeek;
        // 将周日(0)转换为7
        if (dayOfWeek == 0) dayOfWeek = 7;

        // 计算本周一的日期
        var monday = date.Date.AddDays(-(dayOfWeek - 1));
        return monday;
    }

    /// <summary>
    /// 获取翻牌类型描述
    /// </summary>
    public static string GetFlipTypeDesc(int flipNumber)
    {
        if (flipNumber <= MAX_FREE_FLIPS)
        {
            return "免费";
        }
        else if (flipNumber <= MAX_FREE_FLIPS + MAX_BONUS_FLIPS)
        {
            return "赠送";
        }
        else
        {
            return "邀请解锁";
        }
    }
}

/// <summary>
/// 翻牌结果
/// </summary>
public class FlipResult
{
    /// <summary>
    /// 翻牌序号
    /// </summary>
    public int FlipNumber { get; set; }

    /// <summary>
    /// 是否中奖
    /// </summary>
    public bool IsWin { get; set; }

    /// <summary>
    /// 奖励金额
    /// </summary>
    public long RewardAmount { get; set; }

    /// <summary>
    /// 奖励描述
    /// </summary>
    public string RewardDesc { get; set; } = string.Empty;

    /// <summary>
    /// 是否显示翻倍奖励提示
    /// </summary>
    public bool ShowDoubleRewardTip { get; set; }
}