using System.Collections.Generic;
using ET;

namespace GFGGame
{
    public class NoticeArebaRankChange : AMHandler<SC_RankChange>
    {
        protected override async ETTask Run(Session session, SC_RankChange message)
        {
            ArenaDataManager.Instance.Grade = message.Grade;
            ArenaDataManager.Instance.Rank = message.RankInGrade;
            ArenaDataManager.Instance.TryUpdateHighest();
            await ETTask.CompletedTask;
        }
    }
    public class NoticeArenaHistoryChange : AMHandler<SC_ArenaHistoryAdd>
    {
        protected override async ETTask Run(Session session, SC_ArenaHistoryAdd message)
        {
            ArenaHistoryData historyData = ArenaSproxy.GetArenaHistoryData(message.history);
            ArenaDataManager.Instance.historyDatas.Insert(0, historyData);
            ArenaDataManager.Instance.historyDatas.RemoveAt(ArenaDataManager.Instance.historyDatas.Count - 1);
            await ETTask.CompletedTask;
        }
    }
    public static class ArenaSproxy
    {
        //获取竞技场信息
        public static async ETTask GetArenaInfos()
        {
            S2C_GetArenaInfos response = null;
            response = (S2C_GetArenaInfos)await MessageHelper.SendToServer(new C2S_GetArenaInfos());
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.ThemeList = response.ThemeList;
                    ArenaDataManager.Instance.SeasonId = response.SeasonId;
                    ArenaDataManager.Instance.Grade = response.Grade;
                    ArenaDataManager.Instance.Rank = response.RankInGrade;
                    ArenaDataManager.Instance.HighestGrade = response.HighestGradeOfSeason;
                    ArenaDataManager.Instance.HighestRank = response.HighestRankInGradeOfSeason;

                    ArenaDataManager.Instance.Clear();
                    for (int i = 0; i < response.DressupList.Count; i++)
                    {
                        FightRoleData roleData = new FightRoleData();
                        roleData.cardId = response.DressupList[i].CardId;
                        roleData.itemList = response.DressupList[i].EquipIds;

                        ArenaDataManager.Instance.DressupDic[response.ThemeList[i]] = roleData;
                    }

                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }
                }
            }
        }
        //刷新竞争对手
        public static async ETTask ReqRefreshArenaTargets()
        {
            S2C_RefreshArenaTargets response = null;
            response = (S2C_RefreshArenaTargets)await MessageHelper.SendToServer(new C2S_RefreshArenaTargets());
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }
                }
            }
        }

        //更换搭配
        public static async ETTask ReqChangeArenaDressup(int theme, FightRoleData roleData)
        {
            ArenaDressupProto dressupInfo = new ArenaDressupProto();
            dressupInfo.CardId = roleData.cardId;
            dressupInfo.EquipIds = roleData.itemList;

            S2C_ChangeArenaDressup response = null;
            response = (S2C_ChangeArenaDressup)await MessageHelper.SendToServer(new C2S_ChangeArenaDressup() { Theme = theme, DressupInfo = dressupInfo });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.DressupDic[theme] = roleData;
                }
            }
        }

        //购买挑战次数
        public static async ETTask ReqBuyArenaFightTimes(int times)
        {

            S2C_BuyArenaFightTimes response = null;
            response = (S2C_BuyArenaFightTimes)await MessageHelper.SendToServer(new C2S_BuyArenaFightTimes());
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {

                }
            }
        }

        //挑战
        public static async ETTask ReqArenaFight(bool _isWin, int type, int roleId)
        {

            S2C_ArenaFight response = null;
            response = (S2C_ArenaFight)await MessageHelper.SendToServer(new C2S_ArenaFight() { Grade = ArenaDataManager.Instance.Grade, RankInGrade = ArenaDataManager.Instance.Rank, Type = type, RoleId = roleId, isWin = _isWin });
            if (response != null && response.targets != null)
            {
                if (response.Error != ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("该玩家排名已经发生变化，请重新选择");
                }
                if (response.Grade > ArenaDataManager.Instance.Grade)
                {
                    ViewManager.Show<ArenaDanUpView>(new object[] { ArenaDataManager.Instance.Grade, response.Grade, response.RewardId });
                }
                else if (response.RankInGrade > ArenaDataManager.Instance.Rank)
                {
                    ViewManager.Show<ArenaRankUpView>(new object[] { ArenaDataManager.Instance.Rank, response.RankInGrade });
                }

                ArenaDataManager.Instance.Grade = response.Grade;
                ArenaDataManager.Instance.Rank = response.RankInGrade;
                ArenaDataManager.Instance.TryUpdateHighest();

                ArenaDataManager.Instance.Targets.Clear();
                for (int i = 0; i < response.targets.Count; i++)
                {
                    ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                }
            }
        }

        //获取排行榜
        public static async ETTask ReqArenaRank(int rankType, int startIndex, int endIndex)
        {
            S2C_ArenaRank response = null;
            response = (S2C_ArenaRank)await MessageHelper.SendToServer(new C2S_ArenaRank() { RankType = rankType, StartIndex = startIndex, EndIndex = endIndex });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    if (startIndex == 0)
                    {
                        ArenaDataManager.Instance.rankDatas.Clear();
                    }
                    for (int i = 0; i < response.ranks.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.ranks[i]));
                    }
                    ArenaDataManager.Instance.selfData = GetArenaTargetData(response.self);
                }
            }
        }

        //获取竞技场历史记录
        public static async ETTask ReqArenaHistory(int rankType, int startIndex, int endIndex)
        {
            S2C_ArenaHistory response = null;
            response = (S2C_ArenaHistory)await MessageHelper.SendToServer(new C2S_ArenaHistory() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.historyDatas.Clear();
                    for (int i = 0; i < response.history.Count; i++)
                    {
                        ArenaDataManager.Instance.historyDatas.Add(GetArenaHistoryData(response.history[i]));
                    }
                }
            }
        }

        public static ArenaHistoryData GetArenaHistoryData(ArenaHistory arenaHistory)
        {
            ArenaHistoryData arenaTarget = new ArenaHistoryData();

            return arenaTarget;
        }

        private static ArenaTargetData GetArenaTargetData(ArenaTargetProto arenaTargetProto)
        {
            ArenaTargetData arenaTarget = new ArenaTargetData();
            arenaTarget.Grade = arenaTargetProto.Grade;
            arenaTarget.RankInGrade = arenaTargetProto.RankInGrade;
            arenaTarget.Type = arenaTargetProto.Type;
            arenaTarget.RoleInfo = DataChangeUtil.Instance.GetOtherRoleInfoData(arenaTargetProto.RoleInfo);

            arenaTarget.RoleDressupList.Clear();
            arenaTarget.RobotDressupList.Clear();

            for (int j = 0; j < ArenaDataManager.Instance.ThemeList.Count; j++)
            {
                if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
                {
                    FightRoleData roleData = new FightRoleData();
                    roleData.cardId = arenaTargetProto.PlayerDressupList[j].CardId;
                    roleData.itemList = arenaTargetProto.PlayerDressupList[j].EquipIds;

                    arenaTarget.RoleDressupList.Add(roleData);
                }
                else if (arenaTarget.Type == ArenaFightTargetType.ROBOT)
                {
                    ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(arenaTargetProto.RobotDressupInfo.RobotId);
                    FightRobotData robotData = new FightRobotData();
                    robotData.targetItemList = new List<int>(robotCfg.partsScoreArr);
                    robotData.targetBaseScore = robotCfg.baseScore;
                    robotData.targetCardId = robotCfg.cardIdsArr[j];
                    robotData.targetCardScore = robotCfg.cardScore * arenaTargetProto.RobotDressupInfo.Random;
                    robotData.skillLvs.Add(robotCfg.skillLvs);
                    robotData.targetCardScore = robotCfg.cardScore * arenaTargetProto.RobotDressupInfo.Random;
                    robotData.showSuit = robotCfg.suitIdsArr[j];

                    arenaTarget.RobotDressupList.Add(robotData);
                }
            }
            return arenaTarget;
        }
    }
}