using System.Collections.Generic;

namespace GFGGame
{
    public class DecomposeDataManager : SingletonBase<DecomposeDataManager>
    {
        Dictionary<int, List<int>> _decomposeData = new Dictionary<int, List<int>>();//所有可分解的换装部件数据
        Dictionary<int, List<int>> _decomposeMaterialData = new Dictionary<int, List<int>>();//所有可分解的材料数据
        Dictionary<int, List<int>> _suitSyntheticMaterials = new Dictionary<int, List<int>>();//materiasId,Lsit<suitId>
        List<int> _rewardList = new List<int>();

        public const int MaxCount = 999;
        public void Clear()
        {
            _decomposeData.Clear();
            _decomposeMaterialData.Clear();
            _suitSyntheticMaterials.Clear();
        }
        public void Add(int itemId)
        {
            //初始化时禁止使用物品配置，会造成卡顿!!!
            int rarity = ItemDataManager.GetItemRarity(itemId);
            if (!_decomposeData.ContainsKey(rarity))
            {
                _decomposeData.Add(rarity, new List<int>());
            }

            long count = ItemCanDecomposeCount(itemId);
            if (_decomposeData[rarity].IndexOf(itemId) < 0 && count > 0)
            {
                _decomposeData[rarity].Add(itemId);
            }

            //套装拥有的时候需要让材料重新加进列表
            int[][] syntheticMateriarsArr = ItemDataManager.GetItemSyntheticSuitArr(itemId);
            if (syntheticMateriarsArr.Length > 0) {
                foreach (int[] materiars in syntheticMateriarsArr)
                {
                    int materialId = materiars[0];
                    int materialItemType = ItemDataManager.GetItemType(materialId);
                    if (materialItemType == ConstItemType.DRESS_UP) { 
                        long materiarsCount = ItemCanDecomposeCount(materialId);
                        if (materiarsCount> 0 && (materiarsCount + materiars[1] - DeductSynthesisNeedNum(materialId)) > 0)
                        {
                            rarity = ItemDataManager.GetItemRarity(materialId);
                            if (!_decomposeData.ContainsKey(rarity))
                            {
                                _decomposeData.Add(rarity, new List<int>());
                            }

                            if (_decomposeData[rarity].IndexOf(materialId) < 0)
                            {
                                _decomposeData[rarity].Add(materialId);
                            }
                        }
                    }
                }
            }
        }

        public void AddMaterial(int itemId)
        {
            //初始化时禁止使用物品配置，会造成卡顿!!!
            int rarity = ItemDataManager.GetItemRarity(itemId);
            if (!_decomposeMaterialData.ContainsKey(rarity))
            {
                _decomposeMaterialData.Add(rarity, new List<int>());
            }
            if (_decomposeMaterialData[rarity].IndexOf(itemId) < 0)
            {
                _decomposeMaterialData[rarity].Add(itemId);
            }
        }

        public void Remove(int itemId)
        {
            int rarity = ItemCfgArray.Instance.GetCfg(itemId).rarity;
            long count = ItemCanDecomposeCount(itemId);

            if (_decomposeData.ContainsKey(rarity) && _decomposeData[rarity].IndexOf(itemId) >= 0 && count <= 0)
            {
                _decomposeData[rarity].Remove(itemId);
            }
        }

        public void RemoveMaterial(int itemId)
        {
            int rarity = ItemCfgArray.Instance.GetCfg(itemId).rarity;
            long count = ItemCanDecomposeMaterialCount(itemId);

            if (_decomposeMaterialData.ContainsKey(rarity) && _decomposeMaterialData[rarity].IndexOf(itemId) >= 0 && count <= 0)
            {
                _decomposeMaterialData[rarity].Remove(itemId);
            }
        }

        //分解需要扣去合成需要的数量
        public int DeductSynthesisNeedNum(int itemId)
        {
            ItemCfg itemCfg = ItemCfgArray.Instance.GetCfg(itemId);
            if (itemCfg == null)
                return 0;

            int sum = 0;
            foreach (int syntheticId in itemCfg.syntheticSuitArr)
            {
                if (ItemDataManager.GetItemNum(syntheticId) <= 0) { 
                    ItemCfg syntheticItemCfg = ItemCfgArray.Instance.GetCfg(syntheticId);
                    foreach (int[] MateriarsInfo in syntheticItemCfg.syntheticMateriarsArr)
                    {
                        if(MateriarsInfo[0] == itemId)
                            sum += MateriarsInfo[1];
                    }  
                }
            }
            return sum;
        }

        public List<int> GetRewardList()
        {
            if (_rewardList.Count == 0)
            {
                DecomposeCfg[] cfgs = DecomposeCfgArray.Instance.dataArray;
                for (int i = 0; i < cfgs.Length; i++)
                {
                    for (int j = 0; j < cfgs[i].itemsArr.Length; j++)
                    {
                        if (_rewardList.IndexOf(cfgs[i].itemsArr[j][0]) < 0)
                        {
                            _rewardList.Add(cfgs[i].itemsArr[j][0]);
                        }
                    }
                }
            }
            return _rewardList;
        }

        //物品可分解的数量
        public long CanDecomposeCount(int decomposeType, int itemId)
        {
            if (decomposeType == 0) {
                return ItemCanDecomposeCount(itemId);
            }
            else
            {
                return ItemCanDecomposeMaterialCount(itemId);
            }
        }

        //物品可分解的数量
        public long ItemCanDecomposeCount(int itemId)
        {
            //合成需要的数量
            int synthesisNum = DeductSynthesisNeedNum(itemId);
            return ItemDataManager.GetItemNum(itemId) - 1 - synthesisNum;
        }

        //材料可分解的数量
        public long ItemCanDecomposeMaterialCount(int itemId)
        {
            //合成需要的数量
            int synthesisNum = DeductSynthesisMaterialNeedNum(itemId);
            return ItemDataManager.GetItemNum(itemId) - synthesisNum;
        }

        //整理分解物品数据
        public void TidyDecomposeData()
        {
            foreach (var itemId in DressUpMenuItemDataManager.GetDressUpItemDatas())
            {
                if (!DressUpMenuItemCfg1Array.Instance.CheckIsBackGroundType(itemId))
                {
                    Add(itemId);
                }
            }

            foreach (var info in BagDataManager.Instance.GetBagData())
            {
                if (info.Value.itemType == ConstItemType.ITEM && info.Value.subType == ConstItemSubType.MATERIAL_SKILL_BOOK)
                {
                    AddMaterial(info.Value.id);
                }
            }
        }

        //获得分解服装数据
        public List<int> GetDecomposeDataByRarity(int rarity)
        {
            if (!_decomposeData.ContainsKey(rarity)) return null;
            return _decomposeData[rarity];
        }

        //获得分解技能书数据
        public List<int> GetDecomposeMaterialByRarity(int rarity)
        {
            if (!_decomposeMaterialData.ContainsKey(rarity)) return null;
            Dictionary<int, int> LeagueSkillLvDatas = SkillDataManager.Instance.LeagueSkillLvDatas;
            List<int> materialDataKey = new List<int>();
            foreach (var key in _decomposeMaterialData.Keys)
            {
                materialDataKey.Add(key);
            }

            for (int i = 0; i < materialDataKey.Count; i++)
            {
                for (int k = _decomposeMaterialData[materialDataKey[i]].Count-1; k >= 0; k--)
                {
                    int itemId = _decomposeMaterialData[materialDataKey[i]][k];
                    if (ItemCanDecomposeMaterialCount(itemId) <= 0) {
                        _decomposeMaterialData[materialDataKey[i]].RemoveAt(k);
                    }
                }
            }

            return _decomposeMaterialData[rarity];
        }

        //分解需要扣去合成材料需要的数量
        public int DeductSynthesisMaterialNeedNum(int itemId)
        {
            int sum = 0;
            int skillId = ItemDataManager.GetItemSkillId(itemId);
            if(skillId == 0)
            {
                return 0;
            }
            Dictionary<int, int> leagueSkillLvDatas = SkillDataManager.Instance.GetLeagueSkillLvDatas();
            if (!leagueSkillLvDatas.ContainsKey(skillId))
                return 0;

            int skillLv = leagueSkillLvDatas[skillId];
            PassivitySkillLvlCfg skillLvlCfg = PassivitySkillLvlCfgArray.Instance.GetCfgByskilllvlAndskillId(skillLv, skillId);
            int skillLvIndex = skillLv;

            while (skillLvlCfg != null && skillLvlCfg.materiarsArr != null && skillLvlCfg.materiarsArr.Length > 0)
            {
                sum += skillLvlCfg.materiarsArr[0][1];
                skillLvIndex += 1;
                skillLvlCfg = PassivitySkillLvlCfgArray.Instance.GetCfgByskilllvlAndskillId(skillLvIndex, skillId);
            }
            return sum;
        }

        public void InitSuitSyntheticMaterias()
        {
            List<SuitCfg> suitCfgs = new List<SuitCfg>();
            suitCfgs.AddRange(new List<SuitCfg>(SuitCfgArray.Instance.GetCfgsBysyntheticType(1)));
            suitCfgs.AddRange(new List<SuitCfg>(SuitCfgArray.Instance.GetCfgsBysyntheticType(2)));
            suitCfgs.AddRange(new List<SuitCfg>(SuitCfgArray.Instance.GetCfgsBysyntheticType(3)));

            for (int i = 0; i < suitCfgs.Count; i++)
            {
                int suitId = suitCfgs[i].id;
                for (int j = 0; j < suitCfgs[i].partsArr.Length; j++)
                {
                    ItemCfg itemCfg = ItemCfgArray.Instance.GetCfg(suitCfgs[i].partsArr[j]);

                    for (int k = 0; k < itemCfg.syntheticMateriarsArr.Length; k++)
                    {
                        int materialId = itemCfg.syntheticMateriarsArr[k][0];
                        if (!_suitSyntheticMaterials.ContainsKey(materialId))
                        {
                            _suitSyntheticMaterials[materialId] = new List<int>();
                        }
                        if (_suitSyntheticMaterials[materialId].IndexOf(suitId) < 0) _suitSyntheticMaterials[materialId].Add(suitId);
                    }
                }
            }
        }
        /// <summary>
        /// 检测物品对应的套装是否全部合成
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public bool CheckIsItemForSuitSynthetic(int itemId)
        {
            if (!_suitSyntheticMaterials.ContainsKey(itemId)) return true;
            for (int i = 0; i < _suitSyntheticMaterials[itemId].Count; i++)
            {
                if (!DressUpMenuSuitDataManager.CheckHaveSuit(_suitSyntheticMaterials[itemId][i])) return false;
            }
            return true;
        }
    }
}