using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TableConfig;
using LitJson;

namespace Snxxz.UI
{
    public enum SuitType
    {
        None = 0,   //没有套装
        LowSuit = 1,  //普通套装
        HighSuit = 2, //强化套装
    }

    public class PlayerSuitModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
    {
        public List<int> suitPartlist { get; private set; }
        private Dictionary<int, Dictionary<int, int>> suitMaxLvDict = new Dictionary<int, Dictionary<int, int>>();
        private Dictionary<int, List<int>> suitConditionsDict = new Dictionary<int, List<int>>();
        private Dictionary<int, List<int>> suitGroupDict = new Dictionary<int, List<int>>();

        PlayerPackModel _playerPack;
        PlayerPackModel playerPack
        {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
        }

        public override void Init()
        {
            FuncConfigConfig conditionConfig = Config.Instance.Get<FuncConfigConfig>("EquipSuitColorStar");
            JsonData conditionJson = JsonMapper.ToObject(conditionConfig.Numerical1);
            suitConditionsDict.Clear();
            foreach (var suitType in conditionJson.Keys)
            {
                List<int> conditonlist = new List<int>();
                suitConditionsDict.Add(int.Parse(suitType), conditonlist);
                if (conditionJson[suitType].IsArray)
                {
                    for (int i = 0; i < conditionJson[suitType].Count; i++)
                    {
                        int con = int.Parse(conditionJson[suitType][i].ToString());
                        conditonlist.Add(con);
                    }
                }
            }
            FuncConfigConfig funcDisPlayModel = Config.Instance.Get<FuncConfigConfig>("StrengthenDisplay");
            int[] suitOrder = ConfigParse.GetMultipleStr<int>(funcDisPlayModel.Numerical1);
            suitPartlist = new List<int>();
            for (int i = 0; i < suitOrder.Length; i++)
            {
                if ((RoleEquipType)suitOrder[i] != RoleEquipType.retWeapon && (RoleEquipType)suitOrder[i] != RoleEquipType.retWeapon2)
                {
                    suitPartlist.Add(suitOrder[i]);
                }
            }

            FuncConfigConfig suitGroupConfig = Config.Instance.Get<FuncConfigConfig>("EquipSuitType");
            JsonData groupJson = JsonMapper.ToObject(suitGroupConfig.Numerical1);
            suitGroupDict.Clear();
            foreach (var groupType in groupJson.Keys)
            {
                List<int> partlist = new List<int>();
                suitGroupDict.Add(int.Parse(groupType), partlist);
                if (groupJson[groupType].IsArray)
                {
                    for (int i = 0; i < groupJson[groupType].Count; i++)
                    {
                        partlist.Add(int.Parse(groupJson[groupType][i].ToString()));
                    }
                }
            }

            FuncConfigConfig maxLvConfig = Config.Instance.Get<FuncConfigConfig>("EquipSuitMaxLv");
            JsonData maxjsonData = JsonMapper.ToObject(maxLvConfig.Numerical1);
            suitMaxLvDict.Clear();
            foreach (var part in maxjsonData.Keys)
            {
                Dictionary<int, int> suitTypeDict = new Dictionary<int, int>();
                suitMaxLvDict.Add(int.Parse(part), suitTypeDict);
                foreach (var type in maxjsonData[part].Keys)
                {
                    int maxLv = int.Parse(maxjsonData[part][type].ToString());
                    suitTypeDict.Add(int.Parse(type), maxLv);
                }
            }

            SetSuitCellRedPointlist();
        }

        public void OnBeforePlayerDataInitialize()
        {
            suitModelDict.Clear();
            FuncOpen.Instance.OnFuncStateChangeEvent -= RefreshFuncOpenState;
            playerPack.RefreshItemCountAct -= RefreshMat;
        }

        public void OnAfterPlayerDataInitialize()
        {
            playerPack.RefreshItemCountAct += RefreshMat;
            FuncOpen.Instance.OnFuncStateChangeEvent += RefreshFuncOpenState;
        }

        public void OnPlayerLoginOk()
        {
            GetEquipOrderlist(EquipSuitTips.E_SuitType);
            int equipPlace = 0;
            CheckRedPointCondition(out equipPlace);
            CheckTypeBtnRedPointCondition();
        }

        private void RefreshFuncOpenState(int funcId)
        {
            if (funcId != (int)FuncOpenEnum.Suit)
                return;
            int equipPlace = 0;
            CheckRedPointCondition(out equipPlace);
            CheckTypeBtnRedPointCondition();
        }

        private void RefreshMat(PackType type, int index, int id)
        {
            if (type != PackType.rptItem)
                return;

            int equipPlace = 0;
            CheckRedPointCondition(out equipPlace);
            CheckTypeBtnRedPointCondition();
        }

        public override void UnInit()
        {

        }

        /// <summary>
        /// 获取排序后的装备位顺序
        /// </summary>
        Dictionary<int, ItemModel> equipDict;
        public List<int> GetEquipOrderlist(SuitType type)
        {
            List<int> orderlist = new List<int>();
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptEquip);
            if (singlePack == null)
            {
                orderlist.AddRange(suitPartlist);
                return orderlist;
            }

            equipDict = singlePack.GetPackModelIndexDict();
            for(int i = 0; i < suitPartlist.Count; i++)
            {
                if(equipDict.ContainsKey(suitPartlist[i]))
                {
                    ItemModel itemModel = equipDict[suitPartlist[i]];
                    if(IsMakerSuit(type, itemModel.chinItemModel.ItemColor,itemModel.chinItemModel.StarLevel))
                    {
                        orderlist.Add(suitPartlist[i]);
                    }
                }
            }

            for (int i = 0; i < suitPartlist.Count; i++)
            {
                if (equipDict.ContainsKey(suitPartlist[i]))
                {
                    ItemModel itemModel = equipDict[suitPartlist[i]];
                    if (!IsMakerSuit(type, itemModel.chinItemModel.ItemColor, itemModel.chinItemModel.StarLevel))
                    {
                        orderlist.Add(suitPartlist[i]);
                    }
                }
            }

            for (int i = 0; i < suitPartlist.Count; i++)
            {
                if (!equipDict.ContainsKey(suitPartlist[i]))
                {
                    orderlist.Add(suitPartlist[i]);
                }
            }

            return orderlist;
        }

        #region 接收服务端数据
        public Dictionary<int, Dictionary<int, int>> suitModelDict = new Dictionary<int, Dictionary<int, int>>();
        public event Action RefreshSuitModelAct;
        public void GetServerSuitModel(HA309_tagMCEquipPartSuiteLVInfo info)
        {
            for (int i = 0; i < info.Count; i++)
            {
                int equipPlace = info.InfoList[i].EquipIndex;
                string suitLvInfo = info.InfoList[i].SuiteLVInfo;
                JsonData suitTypeJson = JsonMapper.ToObject(suitLvInfo);
                if (!suitModelDict.ContainsKey(equipPlace))
                {
                    Dictionary<int, int> suitTypeDict = new Dictionary<int, int>();
                    suitModelDict.Add(equipPlace, suitTypeDict);
                    foreach (var type in suitTypeJson.Keys)
                    {
                        suitTypeDict.Add(int.Parse(type), int.Parse(suitTypeJson[type].ToString()));
                    }
                }
                else
                {
                    suitModelDict[equipPlace].Clear();

                    foreach (var type in suitTypeJson.Keys)
                    {
                        if (!suitModelDict[equipPlace].ContainsKey(int.Parse(type)))
                        {
                            suitModelDict[equipPlace].Add(int.Parse(type), int.Parse(suitTypeJson[type].ToString()));
                        }
                        else
                        {
                            suitModelDict[equipPlace][int.Parse(type)] = int.Parse(suitTypeJson[type].ToString());
                        }
                    }
                }
            }

            if (RefreshSuitModelAct != null)
            {
                RefreshSuitModelAct();
            }

            int place = 0;
            CheckRedPointCondition(out place);
        }

        #endregion

        #region 发送请求
        public void SendMakeSuit(int suitType, int equipPlace)
        {
            CA317_tagCMSuitCompose suitMaker = new CA317_tagCMSuitCompose();
            suitMaker.SuiteType = (byte)suitType;
            suitMaker.EquipPlace = (byte)equipPlace;
            GameNetSystem.Instance.SendInfo(suitMaker);
        }

        public void SendSplitSuit(int equipPlace, SuitType suitType)
        {
            CA308_tagCMSuiteDecompose decompose = new CA308_tagCMSuiteDecompose();
            decompose.EquipPlace = (byte)equipPlace;
            switch (suitType)
            {
                case SuitType.None:
                case SuitType.LowSuit:
                    decompose.SuiteType = (byte)SuitType.None;
                    break;
                case SuitType.HighSuit:
                    decompose.SuiteType = (byte)SuitType.HighSuit;
                    break;
            }
            GameNetSystem.Instance.SendInfo(decompose);
        }
        #endregion

        #region 处理套装预览数据
        public Dictionary<string, ActivateSuitData> activateAttrDict { get; private set; }
        public void GetActivateSuitModel()
        {
            Dictionary<string, EquipSuitAttrConfig> suitAttrDict = EquipSuitAttrConfig.GetSuitAttrDict();
            activateAttrDict = new Dictionary<string, ActivateSuitData>();
            foreach (var suitID in suitAttrDict.Keys)
            {
                EquipSuitAttrConfig attrConfig = suitAttrDict[suitID];
                List<int> equipPlacelist = null;
                int suitCnt = GetSameSuitCnt((SuitType)attrConfig.suiteType, GetEquipPlaceByGroupType(attrConfig.groupType)[0], attrConfig.suiteLV, out equipPlacelist, attrConfig.job);
                if (suitCnt >= attrConfig.count1)
                {
                    if (!activateAttrDict.ContainsKey(suitID))
                    {
                        ActivateSuitData suitData = new ActivateSuitData(suitCnt, suitAttrDict[suitID], equipPlacelist);
                        activateAttrDict.Add(suitID, suitData);
                    }
                }
            }
        }

        public ActivateSuitData GetSingleSuitAttr(string suitID)
        {
            ActivateSuitData suitData = default(ActivateSuitData);
            activateAttrDict.TryGetValue(suitID, out suitData);
            return suitData;
        }

        /// <summary>
        /// 获取所有激活套装的属性加成
        /// </summary>
        Dictionary<int, int> activateSuitAttrDict = new Dictionary<int, int>();
        public Dictionary<int,int> GetActiveSuitAttr()
        {
            activateSuitAttrDict.Clear();
            GetActivateSuitModel();
            foreach(var key in activateAttrDict.Keys)
            {
                ActivateSuitData suitData = activateAttrDict[key];
                int[] attrIds = null;
                int[] attrValues = null;
                if (suitData.suitCnt >= suitData.attrConfig.count1)
                {
                    attrIds = ConfigParse.GetMultipleStr<int>(suitData.attrConfig.propList1);
                    attrValues = ConfigParse.GetMultipleStr<int>(suitData.attrConfig.propValueList1);
                    SetActiveSuitAttr(attrIds,attrValues);
                }

                if(suitData.suitCnt >= suitData.attrConfig.count2)
                {
                    attrIds = ConfigParse.GetMultipleStr<int>(suitData.attrConfig.propList2);
                    attrValues = ConfigParse.GetMultipleStr<int>(suitData.attrConfig.propValueList2);
                    SetActiveSuitAttr(attrIds, attrValues);
                }

                if (suitData.suitCnt >= suitData.attrConfig.count3)
                {
                    attrIds = ConfigParse.GetMultipleStr<int>(suitData.attrConfig.propList3);
                    attrValues = ConfigParse.GetMultipleStr<int>(suitData.attrConfig.propValueList3);
                    SetActiveSuitAttr(attrIds, attrValues);
                }
            }
            return activateSuitAttrDict;
        }

        public void SetActiveSuitAttr(int[] attrIds,int[] attrValues)
        {
            for (int i = 0; i < attrIds.Length; i++)
            {
                if (!activateSuitAttrDict.ContainsKey(attrIds[i]))
                {
                    activateSuitAttrDict.Add(attrIds[i], attrValues[i]);
                }
                else
                {
                    activateSuitAttrDict[attrIds[i]] += attrValues[i];
                }
            }
        }
        #endregion

        public bool IsReachMax(int equipPlace, int suitType, int suitLv)
        {
            bool isReach = false;
            if (suitMaxLvDict.ContainsKey(equipPlace))
            {
                if (suitMaxLvDict[equipPlace].ContainsKey(suitType))
                {
                    int maxLv = suitMaxLvDict[equipPlace][suitType];
                    if (suitLv >= maxLv)
                    {
                        isReach = true;
                    }
                }
            }
            return isReach;
        }

        /// <summary>
        /// 判断当前装备是否需要升阶才可以进行锻造
        /// </summary>
        /// <returns></returns>
        public bool IsNeedUpgradEquipLv(int equipPlace,int suitType)
        {
            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip,equipPlace);
            if (itemModel == null) return false;

            int suitLv = GetServerSuitLv(equipPlace, suitType);
            if(suitLv >= itemModel.chinItemModel.LV)
            {
               if(!IsReachMax(equipPlace,suitType,suitLv))
                {
                    return true;
                }
            }
            return false;
        }

        public bool IsFirstEquipMaker()
        {
            for(int i = 0; i < suitPartlist.Count; i++)
            {
               if(GetServerSuitLv(suitPartlist[i],(int)SuitType.LowSuit) > 0)
                {
                    return false;
                }
            }
            return true;
        }

        public List<int> GetNeedConditions(int suitType)
        {
            List<int> list = null;
            suitConditionsDict.TryGetValue(suitType, out list);
            return list;
        }

        public int GetServerSuitLv(int equipPlace, int suitType)
        {
            int suitLv = 0;
            if (suitModelDict.ContainsKey(equipPlace))
            {
                if (suitModelDict[equipPlace].ContainsKey(suitType))
                {
                    suitLv = suitModelDict[equipPlace][suitType];
                }
            }
            return suitLv;
        }

        public Dictionary<int, int> GetServerSuitModelByPlace(int equipPlace)
        {
            Dictionary<int, int> dictionary = null;
            suitModelDict.TryGetValue(equipPlace, out dictionary);
            return dictionary;
        }

        public Dictionary<SuitType, int> GetServerSuitCntByPlace(int equipPlace)
        {
            Dictionary<SuitType, int> dictionary = null;
            if (suitModelDict.ContainsKey(equipPlace))
            {
                dictionary = new Dictionary<SuitType, int>();

                foreach (var type in suitModelDict[equipPlace].Keys)
                {
                    SuitType suitType = (SuitType)type;
                    int suitLv = suitModelDict[equipPlace][type];
                    List<int> placelist;
                    int suitCnt = GetSameSuitCnt(suitType, equipPlace, suitLv, out placelist);
                    dictionary.Add(suitType, suitCnt);
                }
            }
            return dictionary;
        }

        public bool IsMakerSuit(SuitType suitType, int itemColor, int starLv)
        {
            bool isMaker = false;
            if (suitConditionsDict.ContainsKey((int)suitType))
            {
                List<int> list = suitConditionsDict[(int)suitType];
                if (itemColor >= list[0] && starLv >= list[1])
                {
                    isMaker = true;
                }
            }
            return isMaker;
        }

        public int GetSameSuitCnt(SuitType suitType, int equipPlace, int suitLv, out List<int> equipPlacelist, int job = 0)
        {
            equipPlacelist = new List<int>();
            int sumNumber = 0;
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptEquip);
            if (singlePack == null || suitLv <= 0)
                return sumNumber;

            if (PlayerDatas.Instance.baseData.Job != job && job != 0)
                return sumNumber;

            Dictionary<int, ItemModel> equipDict = singlePack.GetPackModelIndexDict();
            foreach (ItemModel model in equipDict.Values)
            {
                if (GetGroupType(model.itemInfo.ItemPlace) == GetGroupType(equipPlace))
                {
                    int serverSuitLv = GetServerSuitLv(model.itemInfo.ItemPlace, (int)suitType);

                    if (serverSuitLv != 0)
                    {
                        if (IsMakerSuit(suitType, model.chinItemModel.ItemColor, model.chinItemModel.StarLevel))
                        {
                            if (model.chinItemModel.LV < serverSuitLv)
                            {
                                serverSuitLv = model.chinItemModel.LV;
                            }
                        }
                        else
                        {
                            serverSuitLv = 0;
                        }

                        if (serverSuitLv == suitLv)
                        {
                            sumNumber++;
                            equipPlacelist.Add(model.itemInfo.ItemPlace);
                        }
                    }
                }
            }
            return sumNumber;
        }

        public int GetSameSuitCntByType(SuitType suitType)
        {
            int sumCnt = 0;
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptEquip);
            if (singlePack == null)
                return sumCnt;

            Dictionary<int, ItemModel> equipDict = singlePack.GetPackModelIndexDict();
            foreach (ItemModel model in equipDict.Values)
            {
                Dictionary<int, int> suitTypeDic = GetServerSuitModelByPlace(model.itemInfo.ItemPlace);
                if (suitTypeDic != null)
                {
                    if (suitTypeDic.ContainsKey((int)suitType))
                    {
                        if (suitTypeDic[(int)suitType] > 0)
                        {
                            sumCnt++;
                        }
                    }
                }
            }
            return sumCnt;
        }

        public int GetGroupType(int equipPlace)
        {
            foreach (var groupType in suitGroupDict.Keys)
            {
                if (suitGroupDict[groupType].Contains(equipPlace))
                {
                    return groupType;
                }
            }

            return 0;
        }

        public List<int> GetEquipPlaceByGroupType(int groupType)
        {
            if (suitGroupDict.ContainsKey(groupType))
            {
                return suitGroupDict[groupType];
            }

            return null;
        }

        public int GetEquipJob(int itemId)
        {
            ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(itemId);
            return (int)Math.Floor((double)itemConfig.JobLimit / 100);
        }

        public bool IsUpgradSuitLv(int equipPlace, int suitType, int suitlv)
        {
            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, equipPlace);
            if (itemModel == null)
            {
                return false;
            }
            else
            {
                bool isUpgrad = true;
                bool isMaker = IsMakerSuit((SuitType)suitType, itemModel.chinItemModel.ItemColor, itemModel.chinItemModel.StarLevel);
                if (isMaker)
                {
                    if (!IsReachMax(equipPlace, suitType, suitlv))
                    {
                        if (suitlv >= itemModel.chinItemModel.LV)
                        {
                            isUpgrad = false;
                        }
                        if (suitType == (int)SuitType.HighSuit)
                        {
                            int lowSuitLv = GetServerSuitLv(equipPlace, (int)SuitType.LowSuit);
                            if (suitlv >= lowSuitLv)
                            {
                                isUpgrad = false;
                            }
                        }
                    }
                    else
                    {
                        isUpgrad = false;
                    }
                }
                else
                {
                    isUpgrad = false;
                }
                return isUpgrad;
            }
        }

        public bool IsPerfectGetSuitLv(int itemId, int equipPlace)
        {
            ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(itemId);
            if (itemConfig == null)
                return false;

            bool isPerfect = true;
            if (IsMakerSuit(SuitType.LowSuit, itemConfig.ItemColor, itemConfig.StarLevel))
            {
                int suitLv = GetServerSuitLv(equipPlace, (int)SuitType.LowSuit);
                if (suitLv > 0)
                {
                    if (itemConfig.LV < suitLv)
                    {
                        isPerfect = false;
                    }
                }
                else
                {
                    isPerfect = false;
                }
            }
            else if (IsMakerSuit(SuitType.HighSuit, itemConfig.ItemColor, itemConfig.StarLevel))
            {
                int suitLv = GetServerSuitLv(equipPlace, (int)SuitType.HighSuit);
                if (suitLv > 0)
                {
                    if (itemConfig.LV < suitLv)
                    {
                        isPerfect = false;
                    }
                }
                else
                {
                    isPerfect = false;
                }
            }
            else
            {
                isPerfect = false;
            }

            return isPerfect;

        }

        public Dictionary<SuitType, ReplaceSuit> SetReplaceSuitModel(int itemId, int equipPlace)
        {
            ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(itemId);
            Dictionary<SuitType, ReplaceSuit> replaceDict = new Dictionary<SuitType, ReplaceSuit>();
            if (itemConfig == null)
                return replaceDict;

            ItemModel putOnModel = playerPack.GetItemModelByIndex(PackType.rptEquip, equipPlace);

            ReplaceSuit replaceLowSuit = new ReplaceSuit();
            replaceLowSuit.isNoEffect = false;
            replaceLowSuit.isPerfect = false;
            replaceLowSuit.effectLv = 0;

            ReplaceSuit replaceHighSuit = new ReplaceSuit();
            replaceHighSuit.isNoEffect = false;
            replaceHighSuit.isPerfect = false;
            replaceHighSuit.effectLv = 0;
            int suitLv = GetServerSuitLv(equipPlace, (int)SuitType.LowSuit);
            int realSuitLv = 0;
            if(putOnModel != null)
            {
                if(IsMakerSuit(SuitType.LowSuit, putOnModel.chinItemModel.ItemColor, putOnModel.chinItemModel.StarLevel))
                {
                   if(putOnModel.chinItemModel.LV < suitLv)
                    {
                        realSuitLv = putOnModel.chinItemModel.LV;
                    }
                   else
                    {
                        realSuitLv = suitLv;
                    }
                }
            }
            if (!IsMakerSuit(SuitType.LowSuit, itemConfig.ItemColor, itemConfig.StarLevel))
            {
                if (realSuitLv > 0)
                {
                    replaceLowSuit.isNoEffect = true;
                }
            }
            else
            {
                if (realSuitLv > 0)
                {
                    if (itemConfig.LV < realSuitLv)
                    {

                        replaceLowSuit.effectLv = itemConfig.LV;
                    }
                    else
                    {
                        replaceLowSuit.isPerfect = true;
                    }
                }
            }

            suitLv = GetServerSuitLv(equipPlace, (int)SuitType.HighSuit);
            realSuitLv = 0;
            if (putOnModel != null)
            {
                if (IsMakerSuit(SuitType.HighSuit, putOnModel.chinItemModel.ItemColor, putOnModel.chinItemModel.StarLevel))
                {
                    if (putOnModel.chinItemModel.LV < suitLv)
                    {
                        realSuitLv = putOnModel.chinItemModel.LV;
                    }
                    else
                    {
                        realSuitLv = suitLv;
                    }
                }
            }
            if (!IsMakerSuit(SuitType.HighSuit, itemConfig.ItemColor, itemConfig.StarLevel))
            {
                if (realSuitLv > 0)
                {
                    replaceHighSuit.isNoEffect = true;
                }
            }
            else
            {
                if (realSuitLv > 0)
                {
                    if (itemConfig.LV < realSuitLv)
                    {
                        replaceHighSuit.effectLv = itemConfig.LV;
                    }
                    else
                    {
                        replaceHighSuit.isPerfect = true;
                    }
                }
            }


            replaceDict.Add(SuitType.LowSuit, replaceLowSuit);
            replaceDict.Add(SuitType.HighSuit, replaceHighSuit);
            return replaceDict;
        }

        #region 红点逻辑处理
        public const int SUITTYPEBTNREDPOINT_KEY = 106041000;
        public Redpoint typeBtnRedPoint = new Redpoint(MainRedDot.RedPoint_SuitFuncKey, SUITTYPEBTNREDPOINT_KEY);
        public Dictionary<int, Redpoint> suitCellRedPointDict { get; private set; }
        SuitType redSuitType = SuitType.None;

        public void SetSuitCellRedPointlist()
        {
            if (suitPartlist == null)
                return;

            suitCellRedPointDict = new Dictionary<int, Redpoint>();
            int i = 0;
            for (i = 0; i < suitPartlist.Count; i++)
            {
                int id = MainRedDot.RedPoint_SuitFuncKey * 1000 + i;
                Redpoint suitRedPoint = new Redpoint(MainRedDot.RedPoint_SuitFuncKey, id);
                suitCellRedPointDict.Add(suitPartlist[i], suitRedPoint);
            }
        }

        public void CheckRedPointCondition(out int equipPlace)
        {
            equipPlace = 0;
            for (int i = 0; i < suitPartlist.Count; i++)
            {
                if (suitCellRedPointDict.ContainsKey(suitPartlist[i]))
                {
                    suitCellRedPointDict[suitPartlist[i]].state = RedPointState.None;
                }
            }

            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Suit))
                return;

            redSuitType = EquipSuitTips.E_SuitType;
            List<int> orderPlacelist = GetEquipOrderlist(redSuitType);
            orderPlacelist.Sort(CompareSuitLV);

            for (int i = 0; i < orderPlacelist.Count; i++)
            {
                if (IsShowRedPoint(orderPlacelist[i], redSuitType))
                {
                    suitCellRedPointDict[orderPlacelist[i]].state = RedPointState.Simple;
                    equipPlace = orderPlacelist[i];
                    return;
                }
            }
            if (IsReachSuitActive(redSuitType, orderPlacelist, out equipPlace))
            {
                suitCellRedPointDict[equipPlace].state = RedPointState.Simple;
                return;
            }
        }

        public void CheckTypeBtnRedPointCondition()
        {
            typeBtnRedPoint.state = RedPointState.None;
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Suit))
                return;

            redSuitType = SuitType.None;
            switch (EquipSuitTips.E_SuitType)
            {
                case SuitType.LowSuit:
                    redSuitType = SuitType.HighSuit;
                    break;
                case SuitType.HighSuit:
                    redSuitType = SuitType.LowSuit;
                    break;
            }

            List<int> orderPlacelist = GetEquipOrderlist(redSuitType);
            orderPlacelist.Sort(CompareSuitLV);

            for (int i = 0; i < orderPlacelist.Count; i++)
            {
                if (IsShowRedPoint(orderPlacelist[i], redSuitType))
                {
                    typeBtnRedPoint.state = RedPointState.Simple;
                    return;
                }

            }
            int equipPlace = 0;
            if (IsReachSuitActive(redSuitType, orderPlacelist, out equipPlace))
            {
                typeBtnRedPoint.state = RedPointState.Simple;
                return;
            }
        }

        public int CompareSuitLV(int startPlace, int endPlace)
        {
            int startSuitLv = GetServerSuitLv(startPlace, (int)redSuitType);
            int endSuitLv = GetServerSuitLv(endPlace, (int)redSuitType);
            if (startSuitLv.CompareTo(endSuitLv) != 0)
                return startSuitLv.CompareTo(endSuitLv);
            int startIndex = suitPartlist.IndexOf(startPlace);
            int endIndex = suitPartlist.IndexOf(endPlace);
            if (startIndex.CompareTo(endIndex) != 0)
                return startIndex.CompareTo(endIndex);

            return 0;
        }

        private bool IsShowRedPoint(int equipPlace, SuitType suitType)
        {
            int groupType = GetGroupType(equipPlace);
            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, equipPlace);
            if (groupType == 0 || itemModel == null)
                return false;

            bool isShow = false;
            int suitLv = GetServerSuitLv(equipPlace, (int)suitType);

            EquipSuitCompoundConfig matConfig = EquipSuitCompoundConfig.GetMakerEquipSuitMatModel((int)suitType,
                equipPlace, suitLv + 1, GetEquipJob(itemModel.itemId));

            EquipSuitAttrConfig attrConfig = EquipSuitAttrConfig.GetSuitAttrConfig(groupType
                  , (int)suitType, 1, GetEquipJob(itemModel.itemId));

            bool isUpgrad = IsUpgradSuitLv(equipPlace,(int)suitType,suitLv);
            if (isUpgrad)
            {
                bool isMatEnough = true;
                if (matConfig != null)
                {
                    int[] matIds = matConfig.CostItemID;
                    int[] matCnts = matConfig.CostItemCnt;
                    for (int i = 0; i < matIds.Length; i++)
                    {
                        int haveCnt = playerPack.GetItemCountByID(PackType.rptItem, matIds[i]);
                        if (haveCnt < matCnts[i])
                        {
                            isMatEnough = false;
                            break;
                        }
                    }
                }
                else
                {
                    isMatEnough = false;
                }

                if (isMatEnough)
                {
                    List<int> placelist = null;
                    int nowSuitCnt = GetSameSuitCnt(suitType, equipPlace, suitLv, out placelist);
                    int willSuitCnt = GetSameSuitCnt(suitType, equipPlace, suitLv + 1, out placelist) + 1;
                    DebugEx.Log("装备位置：" + equipPlace);
                    if (IsAdaptRules(groupType, nowSuitCnt, willSuitCnt, attrConfig))
                    {
                        isShow = true;
                    }
                }
            }

            return isShow;
        }

        private bool IsAdaptRules(int groupType, int nowSuitCnt, int willSuitCnt, EquipSuitAttrConfig attrConfig)
        {
            if (attrConfig == null)
                return false;

            bool isAdapt = true;
            if (willSuitCnt != attrConfig.count1 && willSuitCnt != attrConfig.count2 && willSuitCnt != attrConfig.count3)
            {
                isAdapt = false;
            }
            //DesignDebug.Log("groupType:" + groupType + "NowSuitCnt:" + nowSuitCnt + "willSuitCnt:" + willSuitCnt);
            //if (nowSuitCnt == attrConfig.count1 || nowSuitCnt == attrConfig.count2 || nowSuitCnt == attrConfig.count3)
            //{
            //    if (willSuitCnt != attrConfig.count1 && willSuitCnt != attrConfig.count2 && willSuitCnt != attrConfig.count3)
            //    {
            //        isAdapt = false;
            //    }
            //}
            return isAdapt;
        }

        public bool IsReachSuitActive(SuitType suitType, List<int> partlist, out int equipPlace)
        {
            equipPlace = 0;
            if (partlist == null)
                return false;

            Dictionary<int, Dictionary<int, int>> needMatCntDict = new Dictionary<int, Dictionary<int, int>>(); //群组 id 数量
            Dictionary<int, int> minActiveSuitCntDic = new Dictionary<int, int>();
            Dictionary<int, List<int>> upgradEquipPlaceDict = new Dictionary<int, List<int>>();
            for (int i = 0; i < partlist.Count; i++)
            {
                int groupType = GetGroupType(partlist[i]);
                int suitLv = GetServerSuitLv(partlist[i], (int)suitType);
                ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, partlist[i]);
                if (itemModel != null)
                {
                    bool isUpgrad = IsUpgradSuitLv(partlist[i], (int)suitType, suitLv);
                    EquipSuitAttrConfig attrConfig = EquipSuitAttrConfig.GetSuitAttrConfig(groupType
                      , (int)suitType, 1, GetEquipJob(itemModel.itemId));
                    EquipSuitCompoundConfig matConfig = EquipSuitCompoundConfig.GetMakerEquipSuitMatModel((int)suitType,
                      partlist[i], suitLv + 1, GetEquipJob(itemModel.itemId));

                    if (isUpgrad)
                    {
                        if (matConfig != null)
                        {
                            if (!needMatCntDict.ContainsKey(groupType))
                            {
                                Dictionary<int, int> matCntDict = new Dictionary<int, int>();
                                needMatCntDict.Add(groupType, matCntDict);
                                //minActiveSuitCntDic.Add(groupType, 1);
                                List<int> equipPlacelist = new List<int>();
                                upgradEquipPlaceDict.Add(groupType, equipPlacelist);
                            }

                            int[] matIds = matConfig.CostItemID;
                            int[] matCnts = matConfig.CostItemCnt;
                            for (int j = 0; j < matIds.Length; j++)
                            {
                                if (!needMatCntDict[groupType].ContainsKey(matIds[j]))
                                {
                                    needMatCntDict[groupType].Add(matIds[j], matCnts[j]);
                                }
                                else
                                {
                                    needMatCntDict[groupType][matIds[j]] += matCnts[j];
                                }
                            }

                            bool isReach = true;
                            foreach(var id in needMatCntDict[groupType].Keys)
                            {
                                int haveCnt = playerPack.GetItemCountByID(PackType.rptItem, id);
                                if (haveCnt < needMatCntDict[groupType][id])
                                {
                                    isReach = false;
                                    break;
                                }
                            }
                            if(isReach)
                            {
                                upgradEquipPlaceDict[groupType].Add(partlist[i]);
                            }
                        }
                    }
                }
            }

            foreach(var type in upgradEquipPlaceDict.Keys)
            {
                if(upgradEquipPlaceDict[type].Count > 0)
                {
                    ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, upgradEquipPlaceDict[type][0]);
                    EquipSuitAttrConfig attrConfig = EquipSuitAttrConfig.GetSuitAttrConfig(type
                        , (int)suitType, 1, GetEquipJob(itemModel.itemId));

                    if (upgradEquipPlaceDict[type].Count >= attrConfig.count1)
                    {
                        equipPlace = upgradEquipPlaceDict[type][0];
                        return true;
                    }
                }
            }
            return false;
        }
        #endregion


        public SuitType jumpToSuitType { get; private set;}
        public int jumpToGroupType { get; private set; }  //1.防具 2.仙器
        public int jumpToEquipPlace { get; private set; }
        /// <summary>
        /// 设置成就前往数据
        /// </summary>
        /// <param name="suitType"></param>
        /// <param name="groupType"></param>
        public void SetJumpToModel(SuitType suitType,int groupType)
        {
            jumpToSuitType = suitType;
            jumpToGroupType = groupType;
            //jumpToEquipPlace = GetMakerEquipPlace();
        }

        public void ClearJumpModel()
        {
            jumpToSuitType = SuitType.None;
            jumpToGroupType = 0;
            jumpToEquipPlace = 0;
        }

        public int GetMakerEquipPlace()
        {
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptEquip);
            if (singlePack == null) return 0;

            Dictionary<int, ItemModel> dic = singlePack.GetPackModelIndexDict();
            List<int> placelist = new List<int>();
            placelist.AddRange(suitPartlist);
            placelist.Sort(CompareBySuitLv);
            for(int i = 0; i <placelist.Count; i++)
            {
                int group = GetGroupType(placelist[i]);
                if(dic.ContainsKey(placelist[i]) && group == jumpToGroupType)
                {
                    int suitLv = GetServerSuitLv(placelist[i], (int)jumpToSuitType);
                    bool isMatEnough = IsEnoughSuitMat((int)jumpToSuitType,placelist[i], suitLv, dic[placelist[i]].itemId);
                    bool isMaker = IsMakerSuit(jumpToSuitType, dic[placelist[i]].chinItemModel.ItemColor, dic[placelist[i]].chinItemModel.StarLevel);
                    if(isMaker && dic[placelist[i]].chinItemModel.LV > suitLv && isMatEnough)
                    {
                        return placelist[i];
                    }
                }
            }

            return 0;
        }

        public bool IsEnoughSuitMat(int suitTye,int equipPlace,int suitLv,int itemId)
        {
            EquipSuitCompoundConfig matConfig = EquipSuitCompoundConfig.GetMakerEquipSuitMatModel((int)suitTye,
             equipPlace, suitLv + 1, GetEquipJob(itemId));

            bool isMatEnough = true;
            if (matConfig != null)
            {
                int[] matIds = matConfig.CostItemID;
                int[] matCnts = matConfig.CostItemCnt;
                for (int i = 0; i < matIds.Length; i++)
                {
                    int haveCnt = playerPack.GetItemCountByID(PackType.rptItem, matIds[i]);
                    if (haveCnt < matCnts[i])
                    {
                        isMatEnough = false;
                        break;
                    }
                }
            }
            else
            {
                isMatEnough = false;
            }

            return isMatEnough;
        }

        public int CompareBySuitLv(int starPlace,int endPlace)
        {
            int suitLv1 = GetServerSuitLv(starPlace,(int)jumpToSuitType);
            int suitLv2 = GetServerSuitLv(endPlace,(int)jumpToSuitType);
            if (suitLv1.CompareTo(suitLv2) != 0) return suitLv1.CompareTo(suitLv2);

            int starIndex = suitPartlist.IndexOf(starPlace);
            int endIndex = suitPartlist.IndexOf(endPlace);
            if (starIndex.CompareTo(endIndex) != 0) return starIndex.CompareTo(endIndex);

            return 0;
        }

    }

    public struct ActivateSuitData
    {
        public int suitCnt;
        public EquipSuitAttrConfig attrConfig;
        public List<int> equipPlacelist;
        public ActivateSuitData(int cnt, EquipSuitAttrConfig config, List<int> list)
        {
            suitCnt = cnt;
            attrConfig = config;
            equipPlacelist = list;
        }
    }

    public struct ReplaceSuit
    {
        public bool isNoEffect;
        public bool isPerfect;
        public int effectLv;
    }
}