using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace GFGGame
{

    public class CardDataManager
    {
        private static Dictionary<int, Dictionary<int, CardData>> _cardDicByType = new Dictionary<int, Dictionary<int, CardData>>();

        public static Dictionary<int, Dictionary<int, int>> _selectList = new Dictionary<int, Dictionary<int, int>>();

        public static void Clear()
        {
            _cardDicByType.Clear();
        }

        public static void InitServerData(List<RoleCard> roleCards)
        {
            if (roleCards.Count != 0)
            {
                for (int i = 0; i < roleCards.Count; i++)
                {
                    CardData cardData = _cardDicByType[0][roleCards[i].cardId];
                    cardData.lv = roleCards[i].lv;
                    cardData.exp = roleCards[i].exp;
                    cardData.star = roleCards[i].star;
                    cardData.res = roleCards[i].res;
                    cardData.scores[ConstDressUpScoreType.SCORE_FENG] = roleCards[i].score1;
                    cardData.scores[ConstDressUpScoreType.SCORE_HUA] = roleCards[i].score2;
                    cardData.scores[ConstDressUpScoreType.SCORE_XUE] = roleCards[i].score3;
                    cardData.scores[ConstDressUpScoreType.SCORE_YUE] = roleCards[i].score4;


                    CardData cardDataByScore = _cardDicByType[cardData.itemCfg.rarity][roleCards[i].cardId];

                    cardDataByScore.lv = roleCards[i].lv;
                    cardDataByScore.exp = roleCards[i].exp;
                    cardDataByScore.star = roleCards[i].star;
                    cardDataByScore.res = roleCards[i].res;
                    cardDataByScore.scores[ConstDressUpScoreType.SCORE_FENG] = roleCards[i].score1;
                    cardDataByScore.scores[ConstDressUpScoreType.SCORE_HUA] = roleCards[i].score2;
                    cardDataByScore.scores[ConstDressUpScoreType.SCORE_XUE] = roleCards[i].score3;
                    cardDataByScore.scores[ConstDressUpScoreType.SCORE_YUE] = roleCards[i].score4;

                }
            }
        }

        public static void Add(int itemId)
        {
            CardData card = new CardData();
            ItemCfg itemCfg = ItemCfgArray.Instance.GetCfg(itemId);
            card.id = itemId;
            card.lv = 1;

            card.exp = 0;
            card.star = 1;
            card.itemCfg = itemCfg;
            card.res = itemCfg.res;
            card.scores = new Dictionary<int, int>();
            card.scores.Add(ConstDressUpScoreType.SCORE_FENG, itemCfg.score1);
            card.scores.Add(ConstDressUpScoreType.SCORE_HUA, itemCfg.score2);
            card.scores.Add(ConstDressUpScoreType.SCORE_XUE, itemCfg.score3);
            card.scores.Add(ConstDressUpScoreType.SCORE_YUE, itemCfg.score4);
            card.mainScore = CardDataManager.GetMainScore(card.scores);
            card.resources = CardDataManager.GetCardResources(itemCfg);

            if (_cardDicByType.ContainsKey(0) == false)
            {
                _cardDicByType[0] = new Dictionary<int, CardData>();
            }
            if (_cardDicByType.ContainsKey(card.itemCfg.rarity) == false)
            {
                _cardDicByType[card.itemCfg.rarity] = new Dictionary<int, CardData>();
            }
            _cardDicByType[0].Add(card.id, card);
            _cardDicByType[card.itemCfg.rarity].Add(card.id, card);

        }
        private static int GetMainScore(Dictionary<int, int> scores)
        {
            //五个属性中最大的为主属性
            int mainScore = 1;
            int mainScoreValue = 0;
            ICollection keys = scores.Keys;
            foreach (int key in keys)
            {
                if (scores[key] > mainScoreValue)
                {
                    mainScore = key;
                }
            }
            return mainScore;
        }
        private static List<string> GetCardResources(ItemCfg itemCfg)
        {
            List<string> resources = new List<string>();
            resources.Add(itemCfg.res);
            resources.Add(itemCfg.cardRes);
            return resources;
        }
        private static void Refresh(CardData cardData)
        {
            _cardDicByType[0][cardData.id] = cardData;
            _cardDicByType[cardData.itemCfg.rarity][cardData.id] = cardData;
            GameProxy.ReqUpdateCardStatus(cardData);
        }

        private static void RefreshCardLvProperty(CardData lastCardData, int lv)
        {
            List<CardLvlCfg> cardLvCfgs = CardCfgManager.GetCardLvCfgsByRarity(lastCardData.itemCfg.rarity);

            for (int i = lastCardData.lv; i < lv; i++)
            {
                lastCardData.scores[ConstDressUpScoreType.SCORE_FENG] += cardLvCfgs[i - 1].score1;
                lastCardData.scores[ConstDressUpScoreType.SCORE_HUA] += cardLvCfgs[i - 1].score1;
                lastCardData.scores[ConstDressUpScoreType.SCORE_XUE] += cardLvCfgs[i - 1].score1;
                lastCardData.scores[ConstDressUpScoreType.SCORE_YUE] += cardLvCfgs[i - 1].score1;
            }
        }
        private static void RefreshCardStarProperty(CardData lastCardData, int star)
        {
            List<CardLvlCfg> cardLvCfgs = CardCfgManager.GetCardLvCfgsByRarity(lastCardData.itemCfg.rarity);

            for (int i = lastCardData.star; i < star; i++)
            {
                lastCardData.scores[ConstDressUpScoreType.SCORE_FENG] += cardLvCfgs[i - 1].score1;
                lastCardData.scores[ConstDressUpScoreType.SCORE_HUA] += cardLvCfgs[i - 1].score1;
                lastCardData.scores[ConstDressUpScoreType.SCORE_XUE] += cardLvCfgs[i - 1].score1;
                lastCardData.scores[ConstDressUpScoreType.SCORE_YUE] += cardLvCfgs[i - 1].score1;
            }
            // lastCardData.star = star + 1;
            // CardDataManager.Refresh(lastCardData);
        }
        private static List<CardData> SortItemList(List<CardData> arrayList)
        {

            arrayList.Sort((CardData a, CardData b) =>
            {

                int rarityA = a.itemCfg.rarity;
                int rarityB = b.itemCfg.rarity;
                if (rarityA < rarityB)
                {
                    return 1;
                }
                else if (rarityA > rarityB)
                {
                    return -1;
                }

                return string.Compare(a.itemCfg.res, b.itemCfg.res);
            });
            return arrayList;
        }



        /// <summary>
        /// 卡牌升级
        /// </summary>
        /// <param name="cardId"></param>
        public static void UpCardLv(int cardId, int lv, int exp)
        {
            CardData cardData = _cardDicByType[0][cardId];

            CardDataManager.RefreshCardLvProperty(cardData, lv);
            cardData.lv = lv;
            cardData.exp = exp;
            CardDataManager.Refresh(cardData);

        }
        /// <summary>
        /// 卡牌升星
        /// </summary>
        /// <param name="cardId"></param>
        public static void UpCardStar(int cardId)
        {
            CardData cardData = _cardDicByType[0][cardId];

            int star = cardData.star + 1;

            CardDataManager.RefreshCardStarProperty(cardData, star);
            cardData.star = star;
            CardDataManager.Refresh(cardData);
        }
        /// <summary>
        /// 替换卡面
        /// </summary>
        /// <param name="cardId"></param>
        /// <param name="res"></param>
        public static void SetShowCard(int cardId, string res)
        {
            _cardDicByType[0][cardId].res = res;
            CardDataManager.Refresh(_cardDicByType[0][cardId]);
        }


        /// <summary>
        /// 根据男主类型获取卡牌字典
        /// </summary>
        public static Dictionary<int, CardData> GetCardDicByRarity(int rarity)
        {
            if (rarity == 0)
            {
                return _cardDicByType.ContainsKey(0) ? _cardDicByType[0] : null;
            }
            else
            {
                return _cardDicByType.ContainsKey(rarity) ? _cardDicByType[rarity] : null;
            }
        }
        public static List<CardData> CardDicToList(Dictionary<int, CardData> cardDic)
        {
            CardData[] cardArray = new CardData[cardDic.Count];
            cardDic.Values.CopyTo(cardArray, 0);

            List<CardData> cardList = new List<CardData>(cardArray);
            cardList = CardDataManager.SortItemList(cardList);

            return cardList;
        }

        public static bool isFullLv(int cardId, int lv, bool showTips = true)
        {
            CardData cardData = _cardDicByType[0][cardId];
            if (lv > CardCfgManager.GetCardLvCfgsByRarity(cardData.itemCfg.rarity).Count)
            {
                if (showTips == true)
                {
                    PromptController.Instance.ShowFloatTextPrompt("已达到最大等级");
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        public static bool isFullStar(int cardId, int star, bool showTips = true)
        {
            CardData cardData = _cardDicByType[0][cardId];
            if (star >= CardCfgManager.GetCardStarCfgsByTypeAndRarity(cardData.itemCfg.subType, cardData.itemCfg.rarity).Count)
            {
                if (showTips == true)
                {
                    PromptController.Instance.ShowFloatTextPrompt("已达到最大星级");
                }
                return true;
            }
            else
            {
                return false;
            }
        }


        /// <summary>
        ///  根据物品id获取卡牌数据
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public static CardData GetCardDataById(int itemId)
        {
            return _cardDicByType[0][itemId];

        }



        public static void GetPreViewLvAndExp(int rarity, int curLv, int curExp, int hasExp, out int showLv, out int showExp)
        {
            List<CardLvlCfg> listCardLvCfgs = CardCfgManager.GetCardLvCfgsByRarity(rarity);
            showLv = curLv;
            showExp = curExp + hasExp;
            CardLvlCfg tCurCfg = CardLvlCfgArray.Instance.GetCfg(showLv, rarity);
            while (showExp >= tCurCfg.needExp && showLv <= listCardLvCfgs.Count)
            {
                showLv++;
                if (showLv == listCardLvCfgs.Count)
                {
                    //满级
                    showLv = listCardLvCfgs.Count - 1;
                    showExp = tCurCfg.needExp;
                    break;
                }
                tCurCfg = CardLvlCfgArray.Instance.GetCfg(showLv, rarity);
                showExp -= tCurCfg.needExp;
            }
        }

        public static List<CardData> FilterCardList(List<CardData> cardList, Dictionary<int, Dictionary<int, int>> selectList)
        {
            List<CardData> _cardList = new List<CardData>();
            if (selectList.ContainsKey((int)EnumCardFilterType.SubType) == true && selectList[(int)EnumCardFilterType.SubType].Keys.Count > 0)
            {
                for (int i = cardList.Count - 1; i >= 0; i--)
                {

                    if (selectList[(int)EnumCardFilterType.SubType].ContainsKey(cardList[i].itemCfg.subType) == false)
                    {

                        //稀有度
                        cardList.RemoveAt(i);

                        continue;
                    }
                }
            }
            if (selectList.ContainsKey((int)EnumCardFilterType.PROPERTY) == true && selectList[(int)EnumCardFilterType.PROPERTY].Keys.Count > 0)
            {
                for (int i = cardList.Count - 1; i >= 0; i--)
                {

                    if (selectList[(int)EnumCardFilterType.PROPERTY].ContainsKey(cardList[i].mainScore) == false)
                    {
                        cardList.RemoveAt(i);

                        continue;
                    }
                }
            }

            //属性
            if (selectList.ContainsKey((int)EnumCardFilterType.FOSTER) == true && selectList[(int)EnumCardFilterType.FOSTER].Keys.Count > 0)
            {
                for (int i = 0; i < cardList.Count; i++)
                {

                    //培养度
                    List<CardLvlCfg> cardLvCfgs = CardCfgManager.GetCardLvCfgsByRarity(cardList[i].itemCfg.rarity);
                    List<CardStarCfg> cardStarCfgs = CardCfgManager.GetCardStarCfgsByTypeAndRarity(cardList[i].itemCfg.subType, cardList[i].itemCfg.rarity);
                    ICollection keys = selectList[(int)EnumCardFilterType.FOSTER].Keys;
                    foreach (int key in keys)
                    {
                        if (key == ConstCardState.STATE_FULL_LV && cardList[i].lv == cardLvCfgs.Count - 1 ||
                            key == ConstCardState.STATE_LV && cardList[i].lv < cardLvCfgs.Count - 1 ||
                            key == ConstCardState.STATE_FULL_STAR && cardList[i].star == cardStarCfgs.Count ||
                            key == ConstCardState.STATE_STAR && cardList[i].star < cardStarCfgs.Count)
                        {
                            _cardList.Add(cardList[i]);

                            continue;
                        }


                        //if ()
                        //{
                        //技能相关留空
                        //}
                    }
                }
                return _cardList;
            }
            else
            {
                return cardList;
            }

        }


    }
}