using System;
using System.Collections.Generic;
using FairyGUI;

namespace GFGGame
{
    public class ArenaDataManager : SingletonBase<ArenaDataManager>
    {
        public List<int> ThemeList = new List<int>();//本周主题列表
        public string Tag;//本周标签
        public int SeasonId = 1;// 赛季id
        public int Grade = 1;//本赛季段位
        public int Rank = 10000;//本赛季段位内排名
        public int HighestGrade = 1;//本赛季最高段位
        public int HighestRank = 10000; //本赛最高季段位内排名
        public List<FightRoleData> DressupList = new List<FightRoleData>();//我的搭配列表
        public List<ArenaTargetData> Targets = new List<ArenaTargetData>();//对手
        public ArenaTargetData SelfData = new ArenaTargetData();//自己的排行榜信息
        public Dictionary<int, List<ArenaTargetData>> rankDatasDic = new Dictionary<int, List<ArenaTargetData>>();//排行榜数据
        public List<ArenaHistoryData> historyDatas = new List<ArenaHistoryData>();//获取竞技场历史记录

        public int SelectThemeIndex = 0;//当前选中换装主题（ThemeList）的下标
        public int SelectTargetIndex = 0;//当前选中挑战对象的下标
        public int CurFightIndex = 0;//当前挑战的为第几场

        /// <summary>
        /// 是否快速挑战
        /// </summary>
        /// <value></value>
        public bool QuickFight
        {
            get
            {
                return StorageDataManager.Instance.GetStorageValue(ConstStorageId.ARENA_QUICK_FIGHT) == 1 ? true : false;
            }
            set
            {
                StorageSProxy.ReqSetClientValue(ConstStorageId.ARENA_QUICK_FIGHT, value == true ? 1 : 0).Coroutine();
            }
        }
        public void Clear()
        {
            DressupList.Clear();
            Targets.Clear();
        }

        /// <summary>
        /// 试图更新最高段位、排行数据
        /// </summary>
        public void TryUpdateHighest()
        {
            HighestGrade = HighestGrade >= Grade ? HighestGrade : Grade;
            HighestRank = HighestRank >= Rank ? HighestRank : Rank;
        }

        //获取竞技场对手角色战斗数据
        public FightRoleData GetArenaRoleData(int index, ArenaTargetData arenaTarget)
        {
            return arenaTarget.RoleDressupList[index];
        }
        //获取竞技场机器人战斗数据
        public FightRobotData GetArenaRobotData(int index, ArenaTargetData arenaTarget)
        {
            return arenaTarget.RobotDressupList[index];
        }

        /// <summary>
        /// 获取推荐列表
        /// </summary>
        /// <param name="scoreType"></param>
        /// <param name="tags"></param>
        /// <returns></returns>
        public List<int> GetRecommentItemList(int scoreType, string[] tags)
        {
            Dictionary<int, List<int>> itemListDic = new Dictionary<int, List<int>>();
            Dictionary<int, List<int>> itemDatasDic = DressUpMenuItemDataManager.ItemDatasBySubTypeDic;

            foreach (int subType in itemDatasDic.Keys)
            {
                if (itemDatasDic.Count == 0) continue;
                List<int> dressList = SortDressList(itemDatasDic[subType], scoreType, tags);
                int max = subType == (int)ConstDressUpItemType.TE_SHU ? 3 : 1;
                max = Math.Min(max, dressList.Count);
                itemListDic[subType] = dressList.GetRange(0, max);
            }

            if (itemListDic.ContainsKey(ConstDressUpItemType.LIAN_YI_QUN) && itemListDic.ContainsKey(ConstDressUpItemType.SHANG_YI) && itemListDic.ContainsKey(ConstDressUpItemType.XIA_ZHUANG))
            {
                bool hasTagLYQ = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.LIAN_YI_QUN][0], tags);
                bool hasTagSY = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.SHANG_YI][0], tags);
                bool hasTagXZ = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.XIA_ZHUANG][0], tags);
                if (hasTagLYQ && !hasTagSY && !hasTagXZ)
                {
                    itemListDic.Remove(ConstDressUpItemType.SHANG_YI);
                    itemListDic.Remove(ConstDressUpItemType.XIA_ZHUANG);
                }
                else if (!hasTagLYQ && (hasTagSY || hasTagXZ))
                {
                    itemListDic.Remove(ConstDressUpItemType.LIAN_YI_QUN);
                }
                else
                {
                    int scoreLYQ = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.LIAN_YI_QUN][0], scoreType, tags);
                    int scoreSY = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.SHANG_YI][0], scoreType, tags);
                    int scoreXZ = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.XIA_ZHUANG][0], scoreType, tags);
                    if (scoreLYQ > scoreSY + scoreXZ)
                    {
                        itemListDic.Remove(ConstDressUpItemType.SHANG_YI);
                        itemListDic.Remove(ConstDressUpItemType.XIA_ZHUANG);
                    }
                    else
                    {
                        itemListDic.Remove(ConstDressUpItemType.LIAN_YI_QUN);
                    }
                }
            }
            List<int> itemList = new List<int>();
            foreach (int subType in itemListDic.Keys)
            {
                itemList.AddRange(itemListDic[subType]);
            }
            return itemList;
        }
        private List<int> SortDressList(List<int> dressList, int scoreType, string[] tags)
        {
            dressList.Sort((int a, int b) =>
            {
                ItemCfg cfgA = ItemCfgArray.Instance.GetCfg(a);
                ItemCfg cfgB = ItemCfgArray.Instance.GetCfg(b);
                if (ItemDataManager.CheckItemTagsRight(a, tags) && !ItemDataManager.CheckItemTagsRight(b, tags)) return -1;
                if (ItemDataManager.CheckItemTagsRight(b, tags) && !ItemDataManager.CheckItemTagsRight(a, tags)) return 1;
                int scoreA = ItemDataManager.GetItemAdditionScore(a, scoreType, tags);
                int scoreB = ItemDataManager.GetItemAdditionScore(b, scoreType, tags);
                return scoreB - scoreA;
            });
            return dressList;
        }




        /*********************************************************************************************************************/
        /// <summary>
        /// 获取三套服装总战力
        /// </summary>
        /// <param name="roleType"></param>
        /// <param name="roleDatas"></param>
        /// <param name="robotDatas"></param>
        /// <returns></returns>
        public int GetAllFightScore(int roleType, List<FightRoleData> roleDatas, List<FightRobotData> robotDatas)
        {
            int fightScore = 0;
            for (int i = 0; i < ThemeList.Count; i++)
            {
                if (roleType == ArenaFightTargetType.PLAYER)
                {
                    fightScore += GetArenaRoleFightScore(roleDatas[i]);
                }
                else
                {
                    fightScore += GetArenaRobotFightScore(robotDatas[i]);
                }
            }
            return fightScore;
        }
        /// <summary>
        /// 获取玩家竞技场战力
        /// </summary>
        /// <returns></returns>
        public int GetArenaRoleFightScore(FightRoleData roleDatas)
        {
            //竞技场战力=搭配战力+卓越点击战力+卡牌战力
            //搭配战力=第1套搭配所有部件主属性和+第2套搭配所有部件主属性和+第3套搭配所有部件主属性和
            //卓越点击战力=卓越点击评分和/2.33
            //技能战力=（第1套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能1当前等级对应的战力系数+（第1套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能2当前等级对应的战力系数+（第1套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能3当前等级对应的战力系数+（第2套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能1当前等级对应的战力系数+（第2套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能2当前等级对应的战力系数+（第2套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能3当前等级对应的战力系数+（第3套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能1当前等级对应的战力系数+（第3套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能2当前等级对应的战力系数+（第3套搭配所有部件主属性和+卡牌主属性+人物基础分）*技能3当前等级对应的战力系数
            double fightScore = 0;

            FightRoleData roleData = FightDataManager.Instance.roleData;
            double itemSum = GetItemScoreSum(roleDatas.itemScoreList);
            double clickScore = GetPerfectClickScore(roleDatas) / ConstScoreSystem.PART_SCORE;
            double skillScore = FightDataManager.Instance.GetSkillFightScore(itemSum, roleData.baseScore, roleData.cardId, roleData.cardScore, roleData.skillLvs);
            fightScore = itemSum + clickScore + skillScore;

            return (int)Math.Ceiling(fightScore);
        }
        /// <summary>
        /// 获取竞技场机器人战力
        /// </summary>
        /// <returns></returns>
        public int GetArenaRobotFightScore(FightRobotData robotData)
        {
            double fightScore = 0;

            double itemSum = GetItemScoreSum(robotData.itemScoreList);
            double clickScore = GetRobotPerfectClickScore(robotData) / ConstScoreSystem.PART_SCORE;
            double skillScore = FightDataManager.Instance.GetSkillFightScore(itemSum, robotData.baseScore, robotData.cardId, robotData.cardScore, robotData.skillLvs);
            fightScore = itemSum + clickScore + skillScore;

            return (int)Math.Ceiling(fightScore);
        }

        /// <summary>
        /// 所有部件主属性和
        /// </summary>
        /// <returns></returns>
        public double GetItemScoreSum(List<int> itemScoreList)
        {
            double scoreSum = 0;
            for (int i = 0; i < itemScoreList.Count; i++)
            {
                scoreSum += itemScoreList[i];
            }
            return scoreSum;

        }
        //玩家卓越点击战力
        private double GetPerfectClickScore(FightRoleData roleData)
        {
            double clickScore = 0;
            foreach (int key in roleData.pardScoreListDic.Keys)
            {
                clickScore += ScoreSystemData.Instance.GetPartScore(roleData, key, ClickType.PREFACT_CLICK, 0);
            }
            return clickScore;
        }
        //机器人卓越点击战力
        private double GetRobotPerfectClickScore(FightRobotData robotData)
        {
            double clickScore = 0;
            FightScoreCfg[] scoreCfg = FightScoreCfgArray.Instance.dataArray;
            for (int i = 0; i < scoreCfg.Length; i++)
            {
                clickScore += ScoreSystemData.Instance.GetRobotPartScore(robotData, i + 1, ClickType.PREFACT_CLICK, 0);
            }
            return clickScore;
        }


    }
}