using System;
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.Tag = response.Tag;
                    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.ThemeList.Count; i++)
                    {
                        FightRoleData roleData = new FightRoleData();
                        roleData.cardId = response.DressupList.Count > i ? response.DressupList[i].CardId : 0;
                        roleData.itemList = response.DressupList.Count > i ? response.DressupList[i].EquipIds : new List<int>();

                        ArenaDataManager.Instance.DressupList.Add(roleData);
                    }

                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }
                }
            }
        }
        //刷新竞争对手
        public static async ETTask<bool> 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]));
                    }
                    PromptController.Instance.ShowFloatTextPrompt("刷新成功");
                    return true;
                }
            }
            return false;
        }

        //更换搭配
        public static async ETTask<bool> ReqChangeArenaDressup(int index, int cardId, List<int> itemList)
        {
            ArenaDressupProto dressupInfo = new ArenaDressupProto();
            dressupInfo.CardId = cardId;
            dressupInfo.EquipIds = itemList;

            S2C_ChangeArenaDressup response = null;
            response = (S2C_ChangeArenaDressup)await MessageHelper.SendToServer(new C2S_ChangeArenaDressup() { Index = index, DressupInfo = dressupInfo });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.DressupList[index].cardId = cardId;
                    ArenaDataManager.Instance.DressupList[index].itemList = itemList;
                    PromptController.Instance.ShowFloatTextPrompt("保存成功");

                    return true;
                }
            }
            return false;
        }

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

            S2C_BuyArenaFightTimes response = null;
            response = (S2C_BuyArenaFightTimes)await MessageHelper.SendToServer(new C2S_BuyArenaFightTimes() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("购买成功");
                }
            }
        }

        //挑战
        public static async ETTask ReqArenaFight(bool isWin, int type, long targetRoleId, int selfFightPower, int targetFightPower, List<int> myScore, List<int> targetScore)
        {

            S2C_ArenaFight response = null;
            response = (S2C_ArenaFight)await MessageHelper.SendToServer(new C2S_ArenaFight()
            {
                RoleId = RoleDataManager.roleId,
                Grade = ArenaDataManager.Instance.Grade,
                RankInGrade = ArenaDataManager.Instance.Rank,
                Type = type,
                TargetRoleId = targetRoleId,
                IsWin = isWin,
                SelfFightPower = selfFightPower,
                TargetFightPower = targetFightPower
            });
            if (response != null && response.targets != null)
            {


                ArenaDataManager.Instance.Targets.Clear();
                for (int i = 0; i < response.targets.Count; i++)
                {
                    ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                }
                if (response.Error != ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("该玩家排名已经发生变化，请重新选择");
                    return;
                }
                ArenaDataManager.Instance.Grade = response.Grade;
                ArenaDataManager.Instance.Rank = response.RankInGrade;
                ArenaDataManager.Instance.TryUpdateHighest();

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

            }
        }

        //获取排行榜
        public static async ETTask<bool> 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 (!ArenaDataManager.Instance.rankDatasDic.ContainsKey(rankType))
                    {
                        ArenaDataManager.Instance.rankDatasDic[rankType] = new List<ArenaTargetData>();
                    }
                    List<ArenaTargetData> rankDatas = ArenaDataManager.Instance.rankDatasDic[rankType];
                    for (int i = 0; i < response.ranks.Count; i++)
                    {
                        rankDatas.Add(GetArenaTargetData(response.ranks[i]));
                    }
                    ArenaDataManager.Instance.SelfData = GetArenaTargetData(response.self);
                    return true;
                }
            }
            return false;
        }

        //获取竞技场历史记录
        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 async ETTask ReqArenaFightAttr(long roleId, List<FightRoleData> list)
        {
            S2C_ArenaFightAttr response = null;
            response = (S2C_ArenaFightAttr)await MessageHelper.SendToServer(new C2S_ArenaFightAttr() { TargetRoleId = roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    for (int i = 0; i < response.data.Count; i++)
                    {
                        list[i].cardScore = response.data[i].CardScore;
                        list[i].skillLvs = response.data[i].SkillLevel;
                        list[i].itemScoreList = response.data[i].SuitScore;
                    }
                }
            }
        }



        public static ArenaHistoryData GetArenaHistoryData(ArenaHistoryProto arenaHistory)
        {
            ArenaHistoryData arenaTarget = new ArenaHistoryData();
            arenaTarget.isWin = arenaHistory.IsWin;
            arenaTarget.IsChallenge = arenaHistory.IsChallenge;
            arenaTarget.FightTime = arenaHistory.FightTime;
            arenaTarget.Type = arenaHistory.Type;

            if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
            {
                arenaTarget.RoleInfo.roleId = arenaHistory.RoleInfo.RoleId;
                arenaTarget.RoleInfo.roleName = arenaHistory.RoleInfo.RoleName;
                arenaTarget.RoleInfo.roleLv = arenaHistory.RoleInfo.RoleLvl;
                arenaTarget.RoleInfo.roleHead = arenaHistory.RoleInfo.HeadItemId;
            }
            else
            {
                ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(arenaHistory.RobotDressupInfo.RobotId);

                arenaTarget.RoleInfo.roleId = 0;
                arenaTarget.RoleInfo.roleName = robotCfg.gradeName;
                arenaTarget.RoleInfo.roleLv = robotCfg.level;
                arenaTarget.RoleInfo.roleHeadRes = robotCfg.targetRes;
            }
            for (int i = 0; i < ArenaDataManager.Instance.ThemeList.Count; i++)
            {
                if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
                {
                    FightRoleData roleData = GetFightRoleData(arenaHistory.PlayerDressupList[i], arenaTarget.RoleInfo, i);
                    arenaTarget.RoleDressupList.Add(roleData);
                }
                else if (arenaTarget.Type == ArenaFightTargetType.ROBOT)
                {
                    FightRobotData robotData = GetFightRobotData(arenaHistory.RobotDressupInfo, i);
                    arenaTarget.RobotDressupList.Add(robotData);
                }
            }
            arenaTarget.GradeChangeType = arenaHistory.GradeChangeType;
            arenaTarget.SelfFightScore = arenaHistory.SelfFightScore;
            arenaTarget.OtherFightScore = arenaHistory.OtherFightScore;
            arenaTarget.Grade = arenaHistory.Grade;
            arenaTarget.Rank = arenaHistory.Rank;
            arenaTarget.SelfFightPower = arenaHistory.SelfFightPower;
            arenaTarget.TargetFightPower = arenaHistory.TargetFightPower;
            return arenaTarget;
        }

        private static ArenaTargetData GetArenaTargetData(ArenaTargetProto arenaTargetProto)
        {
            ArenaTargetData arenaTarget = new ArenaTargetData();
            arenaTarget.Grade = arenaTargetProto.Grade;
            arenaTarget.RankInGrade = arenaTargetProto.RankInGrade;
            arenaTarget.Type = arenaTargetProto.Type;
            if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
            {
                arenaTarget.RoleInfo.roleId = arenaTargetProto.RoleInfo.RoleId;
                arenaTarget.RoleInfo.roleName = arenaTargetProto.RoleInfo.RoleName;
                arenaTarget.RoleInfo.roleLv = arenaTargetProto.RoleInfo.RoleLvl;
                arenaTarget.RoleInfo.roleHead = arenaTargetProto.RoleInfo.HeadItemId;
            }
            else
            {
                ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(arenaTargetProto.RobotDressupInfo.RobotId);

                arenaTarget.RoleInfo.roleId = 0;
                arenaTarget.RoleInfo.roleName = robotCfg.gradeName;
                arenaTarget.RoleInfo.roleLv = robotCfg.level;
                arenaTarget.RoleInfo.roleHeadRes = robotCfg.targetRes;
            }
            arenaTarget.RoleDressupList.Clear();
            arenaTarget.RobotDressupList.Clear();

            for (int j = 0; j < ArenaDataManager.Instance.ThemeList.Count; j++)
            {
                if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
                {
                    FightRoleData roleData = GetFightRoleData(arenaTargetProto.PlayerDressupList[j], arenaTarget.RoleInfo, j);
                    arenaTarget.RoleDressupList.Add(roleData);
                }
                else if (arenaTarget.Type == ArenaFightTargetType.ROBOT)
                {
                    FightRobotData robotData = GetFightRobotData(arenaTargetProto.RobotDressupInfo, j);
                    arenaTarget.RobotDressupList.Add(robotData);
                }
            }
            return arenaTarget;
        }

        private static FightRoleData GetFightRoleData(ArenaDressupProto dressupProto, OtherRoleInfoData roleInfo, int index)
        {
            FightRoleData roleData = new FightRoleData();
            roleData.name = roleInfo.roleName;
            roleData.headId = roleInfo.roleHead;

            roleData.baseScore = RoleLevelCfgArray.Instance.GetCfg(roleInfo.roleLv).baseScore;
            roleData.cardId = dressupProto.CardId;
            roleData.itemList = dressupProto.EquipIds;
            if (index == 0) roleData.tags = new string[1] { ArenaDataManager.Instance.Tag };

            return roleData;
        }
        private static FightRobotData GetFightRobotData(ArenaRobotProto robotProto, int index)
        {
            ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(robotProto.RobotId);
            FightRobotData robotData = new FightRobotData();
            robotData.name = robotCfg.gradeName;
            robotData.res = robotCfg.targetRes;
            robotData.itemScoreList = new List<int>(robotCfg.partsScoreArr);
            robotData.baseScore = robotCfg.baseScore;
            robotData.cardId = robotProto.CardIdList[index];
            double cardScore = (double)robotCfg.cardScore * (double)robotProto.Random / 10000 * 100;
            robotData.cardScore = (int)Math.Ceiling(cardScore);
            robotData.skillLvs.Add(robotCfg.skillLvs);
            robotData.showSuitId = robotProto.SuitList[index];
            if (index == 0)//只有第一个主题才计算标签
            {
                robotData.tags = new string[1] { ArenaDataManager.Instance.Tag };
                robotData.tagAddition = robotCfg.tagAddition;
            }
            return robotData;
        }
    }
}