using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System;

public class ArenaManager : GameSystemManager<ArenaManager>
{
    public readonly int rankType = 1;    // 榜单类型
    public readonly int funcId = 27;    // 功能Id
    public readonly int recType = 308;  // 演武场玩家挑战记录类型 308
    public readonly int ChallengeMoneyType = 53;
    public readonly int NeedChallengeMoneyCnt = 1;
    public readonly int RecordType = 308;   // 演武场玩家挑战记录
    public int initialPoints;   // 玩家初始积分
    public int challengeRecordCount;    // 被挑战记录条数（不超过50）
    public int challengeTicketLimit;    // 挑战券基础存储上限
    public int[][] fixedChallengeRewards;   // 固定挑战奖励 [[物品ID,个数], ...]
    public int[][] matchVictoryPoints;  // 匹配位置挑战胜利对应增减积分 [[挑战方增加积分, 防守方扣除积分], ...]，长度即为匹配的人数，从最高分开始配置
    public int lowerRankStart;  // 从比自己低几个段的名次开始匹配
    public int rankStep;    // 每个匹配段跨x名，如配置 2|10，即代表从自己名次向后20名开始匹配，每跨10名匹配1人
    public Dictionary<int, int[]> robotMatchCounts; // 玩家所在小于等于该名次对应匹配机器人数 {名次:[匹配机器人数下限, 上限], ...}
    public int currencyType;    // 刷新匹配固定消耗货币类型
    public int currencyValue;   // 刷新匹配固定消耗货币值
    public Dictionary<int, int[][]> dailyRankRewards; // 每日排行奖励 {"名次":[[物品ID, 个数,是否拍品], ...], ...} 配置的名次key，自动按小于等于对应名次给奖励
    public Dictionary<int, int[][]> seasonRankRewards;  // 赛季排行奖励 {"名次":[[物品ID, 个数,是否拍品], ...], ...}

    public uint score;    // 当前积分

    public List<ArenaMatchInfo> matchInfoList = new List<ArenaMatchInfo>();
    //用于用来拿战斗胜利失败的头像信息
    public Dictionary<uint, ArenaMatchInfo> allFaceInfoDict = new Dictionary<uint, ArenaMatchInfo>();
    public Dictionary<uint, List<ArenaGameRec>> gameRecDict = new Dictionary<uint, List<ArenaGameRec>>(); // <RecID,ArenaGameRec>
    public uint atkPlayerId;
    public Redpoint parentRedpoint = new Redpoint(MainRedDot.MainChallengeRedpoint, MainRedDot.ArenaRepoint);
    public Redpoint challengeButtonRedpoint;
    public int nowAwardTabIndex = 0;
    public event Action OnArenaMatchListEvent;
    public event Action OnUpdateArenaPlayerInfo;
    public event Action OnUpdateGameRecInfo;
    public override void Init()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitializeEvent;
        PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefresh;
        InitTable();
        InitRedpoint();
    }

    public override void Release()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitializeEvent;
        PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefresh;
    }

    public void OnBeforePlayerDataInitializeEvent()
    {
        matchInfoList.Clear();
        gameRecDict.Clear();
        allFaceInfoDict.Clear();
    }

    void InitRedpoint()
    {
        challengeButtonRedpoint = new Redpoint(MainRedDot.ArenaRepoint, GetRedPonitId(1));
    }

    void InitTable()
    {
        FuncConfigConfig config = FuncConfigConfig.Get("ArenaSet");
        initialPoints = int.Parse(config.Numerical1);
        challengeRecordCount = int.Parse(config.Numerical2);
        challengeTicketLimit = int.Parse(config.Numerical3);
        fixedChallengeRewards = JsonMapper.ToObject<int[][]>(config.Numerical4);

        config = FuncConfigConfig.Get("ArenaMatch");
        matchVictoryPoints = JsonMapper.ToObject<int[][]>(config.Numerical1);
        string[] matchParams = config.Numerical2.Split('|');
        lowerRankStart = int.Parse(matchParams[0]);
        rankStep = int.Parse(matchParams[1]);
        robotMatchCounts = ConfigParse.GetDic<int, int[]>(config.Numerical3);
        string[] costParams = config.Numerical4.Split('|');
        currencyType = int.Parse(costParams[0]);
        currencyValue = int.Parse(costParams[1]);

        config = FuncConfigConfig.Get("ArenaBillboradAward");
        dailyRankRewards = ConfigParse.ParseIntArray2Dict(config.Numerical1);
        seasonRankRewards = ConfigParse.ParseIntArray2Dict(config.Numerical2);
    }
    public void UpdateRedPonit()
    {
        parentRedpoint.state = RedPointState.None;
        challengeButtonRedpoint.state = RedPointState.None;

        if (!FuncOpen.Instance.IsFuncOpen(funcId))
            return;

        if (UIHelper.GetMoneyCnt(ChallengeMoneyType) > 0)
        {
            challengeButtonRedpoint.state = RedPointState.Simple;
        }
    }

    public bool TryGetPlayerInfo(uint playerID, out ArenaMatchInfo info)
    {
        return allFaceInfoDict.TryGetValue(playerID, out info);
    }

    // 1 挑战按钮
    public int GetRedPonitId(int num)
    {
        return MainRedDot.ArenaRepoint * 10 + num;
    }

    private void PlayerDataRefresh(PlayerDataType type)
    {
        if (type != PlayerDataType.ChallengeVoucher)
            return;
        UpdateRedPonit();
    }

    public int GetMaxChallengeCount()
    {
        return challengeTicketLimit;
    }

    public void OnArenaMatchList(HA922_tagSCArenaMatchList vNetData)
    {
        if (vNetData == null || vNetData.MatchList.IsNullOrEmpty())
            return;

        matchInfoList.Clear();

        foreach (var item in vNetData.MatchList)
        {
            var matchInfo = new ArenaMatchInfo
            {
                PlayerID = item.PlayerID,
                PlayerName = item.PlayerName,
                Lv = item.LV,
                RealmLV = item.RealmLV,
                FightPower = (ulong)item.FightPowerEx * 100000000 + (ulong)item.FightPower,
                Face = item.Face,
                FacePic = item.FacePic
            };
            matchInfoList.Add(matchInfo);
            allFaceInfoDict[item.PlayerID] = matchInfo;
        }
        matchInfoList.Reverse();
        OnArenaMatchListEvent?.Invoke();
    }


    public void UpdateArenaPlayerInfo(HA923_tagSCArenaPlayerInfo vNetData)
    {
        if (vNetData == null)
            return;
        this.score = vNetData.Score;
        OnUpdateArenaPlayerInfo?.Invoke();
    }
    public void UpdateGameRecInfo(HA009_tagSCGameRecInfo vNetData)
    {
        if (vNetData == null || vNetData.RecType != recType)
            return;
        gameRecDict.Clear();
        uint recID = vNetData.RecID;
        if (!gameRecDict.ContainsKey(recID))
            gameRecDict[recID] = new List<ArenaGameRec>();
        foreach (var rec in vNetData.RecList)
        {
            try
            {
                var userData = JsonMapper.ToObject(rec.UserData);
                string name = userData["Name"].ToString();
                int addScore = int.Parse(userData["AddScore"].ToString());
                ulong fightPower = ulong.Parse(userData["FightPower"].ToString());

                var arenaGameRec = new ArenaGameRec
                {
                    Time = rec.Time,
                    Value1 = rec.Value1,
                    Value2 = rec.Value2,
                    Value3 = rec.Value3,
                    Value4 = rec.Value4,
                    Value5 = rec.Value5,
                    Value6 = rec.Value6,
                    Value7 = rec.Value7,
                    Value8 = rec.Value8,
                    Name = name,
                    AddScore = addScore,
                    FightPower = fightPower
                };

                gameRecDict[recID].Add(arenaGameRec);

                if (recID == PlayerDatas.Instance.baseData.PlayerID)
                {
                    allFaceInfoDict[rec.Value3] = new ArenaMatchInfo
                    {
                        Face = rec.Value5,
                        FacePic = rec.Value6,
                        RealmLV = (ushort)rec.Value7,
                        Lv = (ushort)rec.Value8,
                        PlayerName = name,
                        FightPower = fightPower,
                    };
                }

            }
            catch (Exception ex)
            {
                Debug.LogError($"JSON解析错误: {ex.Message}, UserData: {rec.UserData}");
                continue;
            }
        }
        OnUpdateGameRecInfo?.Invoke();
    }


    public Dictionary<int, int[][]> GetArenaAwardDict(int functionOrder)
    {
        return functionOrder == 0 ? dailyRankRewards : seasonRankRewards;
    }

    public void SendViewGameRecPack()
    {
        CA008_tagCSViewGameRec pack = new CA008_tagCSViewGameRec();
        pack.RecType = (ushort)RecordType;
        GameNetSystem.Instance.SendInfo(pack);
    }

    public void SendArenaMatch(bool isRefresh = false)
    {
        CB209_tagCSArenaMatch pack = new CB209_tagCSArenaMatch();
        pack.IsRefresh = isRefresh ? (byte)1 : (byte)0;
        GameNetSystem.Instance.SendInfo(pack);
    }

    public void SendTurnFight(uint playerID)
    {
        CB410_tagCMTurnFight pack = new CB410_tagCMTurnFight();
        pack.MapID = 3;
        pack.TagType = 1;
        pack.TagID = playerID;
        GameNetSystem.Instance.SendInfo(pack);
    }

    public bool IsTimeInvalid(uint time)
    {
        DateTime dateTime = TimeUtility.GetTime(time);
        GetCurrentSeasonDates(out DateTime seasonStartDate, out DateTime seasonEndDate);
        return dateTime < seasonStartDate || dateTime > seasonEndDate;
    }

    /// <summary>
    /// 根据索引和排序方向获取积分
    /// </summary>
    /// <param name="index">索引位置（从0开始）</param>
    /// <param name="isAscending">true-正序，false-倒序</param>
    /// <param name="isChallenger">true-挑战方增加积分，false-防守方扣除积分</param>
    /// <returns>对应的积分值</returns>
    public int GetChallengePoints(int index, bool isAscending = false, bool isChallenger = true)
    {
        // 检查索引是否在有效范围内
        if (matchVictoryPoints.IsNullOrEmpty() || index < 0 || index >= matchVictoryPoints.Length)
            return 0;
        int targetIndex = isAscending ? index : matchVictoryPoints.Length - 1 - index;
        return matchVictoryPoints[targetIndex][isChallenger ? 0 : 1];
    }

    /// <summary>
    /// 获得当前赛季的起止日期。赛季从周一 00:00:00 开始，到周日 23:59:59 结束。
    /// 服务端定义周一为每周的第一天。
    /// </summary>
    /// <param name="seasonStartDate">输出参数：赛季的起始日期（本周一 00:00:00）</param>
    /// <param name="seasonEndDate">输出参数：赛季的结束日期（本周日 23:59:59）</param>
    public void GetCurrentSeasonDates(out DateTime seasonStartDate, out DateTime seasonEndDate)
    {
        DateTime now = TimeUtility.ServerNow;
        // 在 .NET 中，DayOfWeek 枚举 Sunday = 0, Monday = 1, ..., Saturday = 6。
        // 为了符合周一是一周第一天的计算标准，我们将周日视为一周的第7天。
        int currentDayOfWeek = (int)now.DayOfWeek;
        if (currentDayOfWeek == 0) // 如果是周日 (Sunday = 0)
        {
            currentDayOfWeek = 7;
        }

        // 从当前日期减去相应的天数，得到周一的日期。
        // 例如，如果是周三(3)，则需要减去 3-1=2 天。
        // 如果是周日(7)，则需要减去 7-1=6 天。
        DateTime monday = now.AddDays(-(currentDayOfWeek - 1));
        // 设置赛季的起始时间为周一的 0点0分0秒
        seasonStartDate = new DateTime(monday.Year, monday.Month, monday.Day, 0, 0, 0);
        // 赛季的结束日期是开始日期（周一）加上6天，即周日
        DateTime sunday = seasonStartDate.AddDays(6);
        // 设置赛季的结束时间为周日的 23点59分59秒
        seasonEndDate = new DateTime(sunday.Year, sunday.Month, sunday.Day, 23, 59, 59);
    }

    /// <summary>
    /// 根据recID获取按时间从大到小排序的List<ArenaGameRec>
    /// </summary>
    /// <param name="recID">记录ID</param>
    /// <param name="sortedList">输出参数：按时间从大到小排序的ArenaGameRec列表</param>
    /// <returns>如果recID存在且成功获取列表返回true，否则返回false</returns>
    public bool TryGetSortedArenaGameRecList(uint recID, out List<ArenaGameRec> sortedList)
    {
        sortedList = null;
        if (!gameRecDict.ContainsKey(recID))
            return false;
        sortedList = new List<ArenaGameRec>(gameRecDict[recID]);
        sortedList.Sort((a, b) => b.Time.CompareTo(a.Time)); // 按时间从大到小排序
        return true;
    }
}




public class ArenaMatchInfo
{
    public uint PlayerID;        //目标玩家ID
    public string PlayerName;
    public ushort Lv;             //等级
    public ushort RealmLV;        //境界，机器人读境界表取等级对应境界
    public uint TitleID;
    public ulong FightPower;        //战力
    public uint Face;        //基本脸型
    public uint FacePic;        //头像框

}

public class ArenaGameRec
{
    public uint Time;        //战斗时间戳
    public uint Value1;        //更新积分，战斗后的最终积分
    public uint Value2;        //攻击类型 1-发起攻击的，2-被攻击的
    public uint Value3;        //相对攻击类型的目标玩家ID
    public uint Value4;        //是否获胜 1-获胜；2-失败
    public uint Value5;        //目标头像
    public uint Value6;        //目标头像框
    public uint Value7;        //目标官职
    public uint Value8;        //目标等级
    public string Name;         //目标名称
    public int AddScore;        //本次自己变更的积分，有正负
    public ulong FightPower;    //目标战力
    public int TitileId; //未来接入

}