using Snxxz.UI;
using System;
using System.Collections.Generic;
using System.Linq;

using LitJson;

namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
    public class PackModelInterface : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        private ItemConfig tagChinModel;
        private FuncConfigConfig _equipGSFormula;
        private FuncConfigConfig _itemPush;
        private FuncConfigConfig _drugIDFunc;
        private FuncConfigConfig _oneKeySellFunc;

        public int[] preciousItemType { get; private set; }
        private int[] drugIDs;
        public Dictionary<int, List<int>> betterEquipExceptDungeonDict { get; private set; }

        private int[] onekeySellTypes;
        PlayerPackModel _playerPack;
        PlayerPackModel playerPack {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
        }

        ItemTipsModel _itemTipsModel;
        ItemTipsModel itemTipsModel {
            get {
                return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>());
            }
        }

        PlayerBuffDatas buffDatas { get { return ModelCenter.Instance.GetModel<PlayerBuffDatas>(); } }
        PlayerMountDatas mountDatas { get { return ModelCenter.Instance.GetModel<PlayerMountDatas>(); } }
        PlayerPetDatas petDatas { get { return ModelCenter.Instance.GetModel<PlayerPetDatas>(); } }
        PlayerStrengthengDatas strengthDatas { get { return ModelCenter.Instance.GetModel<PlayerStrengthengDatas>(); } }
        MagicianModel magicianModel { get { return ModelCenter.Instance.GetModel<MagicianModel>(); } }
        TrialDungeonModel trialModel { get { return ModelCenter.Instance.GetModel<TrialDungeonModel>(); } }
        ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }

        private int[] pushItemIds;
        public int[] pushBuffTypeIds;
        private List<int> equipBaseAttrlist = new List<int>();
        public Dictionary<int, int> promptUseLimitDict { get; private set; }

        public override void Init()
        {
            _equipGSFormula = FuncConfigConfig.Get("EquipGSFormula");
            equipBaseAttrlist.Clear();
            JsonData baseAttr = JsonMapper.ToObject(_equipGSFormula.Numerical2);
            if (baseAttr.IsArray)
            {
                for (int i = 0; i < baseAttr.Count; i++)
                {
                    equipBaseAttrlist.Add(int.Parse(baseAttr[i].ToString()));
                }
            }

            _itemPush = FuncConfigConfig.Get("ItemPush");
            preciousItemType = ConfigParse.GetMultipleStr<int>(_itemPush.Numerical1);

            FuncConfigConfig noPromptUsetItem = FuncConfigConfig.Get("NoPromptUsetItem");
            promptUseLimitDict = ConfigParse.GetDic<int, int>(noPromptUsetItem.Numerical1);

            _drugIDFunc = FuncConfigConfig.Get("LifePotionlist");
            drugIDs = ConfigParse.GetMultipleStr<int>(_drugIDFunc.Numerical1);
            _oneKeySellFunc = FuncConfigConfig.Get("OneKeySellItemType");
            onekeySellTypes = ConfigParse.GetMultipleStr<int>(_oneKeySellFunc.Numerical1);
            FuncConfigConfig funcConfig = FuncConfigConfig.Get("IntroductionItem");
            pushItemIds = ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1);
            pushBuffTypeIds = ConfigParse.GetMultipleStr<int>(funcConfig.Numerical2);
            FuncConfigConfig betterEquipExcConfig = FuncConfigConfig.Get("GoodItemDungeon");
            betterEquipExceptDungeonDict = new Dictionary<int, List<int>>();
            JsonData excEquipData = JsonMapper.ToObject(betterEquipExcConfig.Numerical1);
            foreach (var dungeonId in excEquipData.Keys)
            {
                List<int> idlist = new List<int>();
                betterEquipExceptDungeonDict.Add(int.Parse(dungeonId), idlist);
                for (int i = 0; i < excEquipData[dungeonId].Count; i++)
                {
                    int itemId = int.Parse(excEquipData[dungeonId][i].ToString());
                    idlist.Add(itemId);
                }
            }
        }

        public void OnBeforePlayerDataInitialize()
        {
            isPackResetOk = true;
            itemModelDict.Clear();
            itemEffectCDDict.Clear();
            itemEffectTimelist.Clear();
        }

        public void OnPlayerLoginOk()
        {

        }


        public override void UnInit()
        {

        }

        #region 计算装备评分
        /// <summary>
        /// 得到特殊属性的字典
        /// </summary>
        private Dictionary<AttrEnum, int> specAttrDic = new Dictionary<AttrEnum, int>();
        public int SetEquipScore(PackType type, int itemId, Dictionary<int, List<int>> useDataDic = null, bool isPreview = false)
        {
            specAttrDic.Clear();
            int id = itemId;
            ItemConfig itemConfig = ItemConfig.Get(itemId);
            if (CheckIsCustomItem(itemConfig))
            {
                AppointItemConfig appointItemConfig = AppointItemConfig.Get(itemId);
                SetCustomAttrData(appointItemConfig);
                id = itemConfig.EffectValueA1;
            }
            else
            {
                if (isPreview)
                {
                    List<int> legendIdlist = new List<int>();
                    List<int> legendValuelist = new List<int>();
                    switch (itemConfig.EquipPlace)
                    {
                        case 11:
                            CalculateWingsLegendAttr(itemConfig, out legendIdlist, out legendValuelist);
                            break;
                        case 1:
                        case 2:
                        case 3:
                        case 4:
                        case 5:
                        case 6:
                        case 7:
                        case 8:
                        case 9:
                        case 10:
                        case 12:
                            CalculateEquipLegendAttr(itemConfig, out legendIdlist, out legendValuelist);
                            break;
                    }

                    var packType = GeneralDefine.GetPackTypeByItemType(itemConfig.Type);
                    switch (packType)
                    {
                        case PackType.JadeDynastyItem:
                            CalculateJadeDynastyLegendAttr(itemConfig,out legendIdlist, out legendValuelist);
                            break;
                    }

                    if (legendIdlist.Count == legendValuelist.Count)
                    {
                        SetLegendData(legendIdlist, legendValuelist);
                    }
                }
                else
                {
                    if (useDataDic != null)
                    {
                        if (useDataDic.ContainsKey((int)ItemUseDataKey.legendAttrID))
                        {
                            SetLegendData(useDataDic[(int)ItemUseDataKey.legendAttrID], useDataDic[(int)ItemUseDataKey.legendAttrValue]);
                        }

                        if (useDataDic.ContainsKey((int)ItemUseDataKey.outOfPrintAttrID))
                        {
                            SetExhaustedData(useDataDic[(int)ItemUseDataKey.outOfPrintAttrID], useDataDic[(int)ItemUseDataKey.outOfPrintAttrValue]);
                        }

                    }
                }
            }
            return GetEquipScore(type, id, specAttrDic);

        }

        private void CalculateEquipLegendAttr(ItemConfig itemConfig, out List<int> legendIdlist, out List<int> legendValuelist)
        {
            legendIdlist = new List<int>();
            legendValuelist = new List<int>();
            string attrCntKey = StringUtility.Contact(itemConfig.ItemColor, itemConfig.StarLevel);
            var attrIDDict = itemTipsModel.legendAttrIDPreviewDict;
            var attrCntDict = itemTipsModel.legendAttrCntPreviewDict;
            if (attrIDDict.ContainsKey(itemConfig.EquipPlace))
            {
                var attrTypeDict = itemTipsModel.legendAttrIDPreviewDict[itemConfig.EquipPlace];

                foreach (var attrType in attrTypeDict.Keys)
                {
                    var attrIds = attrTypeDict[attrType];
                    int attrCnt = 0;
                    if (attrCntDict.ContainsKey(attrCntKey))
                    {
                        attrCnt = attrCntDict[attrCntKey][attrType];
                    }
                    for (int i = 0; i < attrIds.Count; i++)
                    {
                        if (attrCnt > i)
                        {
                            legendIdlist.Add(attrIds[i]);
                        }
                    }
                }
            }
            for (int i = 0; i < legendIdlist.Count; i++)
            {
                if (itemTipsModel.legendAttrColorValuePreviewDict.ContainsKey(legendIdlist[i]))
                {
                    if (itemTipsModel.legendAttrColorValuePreviewDict[legendIdlist[i]].ContainsKey(itemConfig.ItemColor))
                    {
                        legendValuelist.Add(itemTipsModel.legendAttrColorValuePreviewDict[legendIdlist[i]][itemConfig.ItemColor]);
                    }
                }
                else if (itemTipsModel.legendAttrLvValuePreviewDict.ContainsKey(legendIdlist[i]))
                {
                    if (itemTipsModel.legendAttrLvValuePreviewDict[legendIdlist[i]].ContainsKey(itemConfig.LV))
                    {
                        legendValuelist.Add(itemTipsModel.legendAttrLvValuePreviewDict[legendIdlist[i]][itemConfig.LV]);
                    }
                }
            }
        }

        private void CalculateWingsLegendAttr(ItemConfig itemConfig, out List<int> legendIdlist, out List<int> legendValuelist)
        {
            legendIdlist = new List<int>();
            legendValuelist = new List<int>();
            var attrCntDict = itemTipsModel.wingsLegendAttrCntPreviewDict;
            var attrValueDict = itemTipsModel.wingsLegendAttrValuePreviewDict;
            int attrCnt = 0;
            if (attrCntDict.ContainsKey(itemConfig.LV))
            {
                attrCnt = attrCntDict[itemConfig.LV];
            }
            if (attrValueDict.ContainsKey(itemConfig.LV))
            {
                var attrIdDict = attrValueDict[itemConfig.LV];
                foreach (var attrId in attrIdDict.Keys)
                {
                    if (legendIdlist.Count < attrCnt)
                    {
                        legendIdlist.Add(attrId);
                        legendValuelist.Add(attrIdDict[attrId][0]);
                    }
                }

            }
        }

        private void CalculateJadeDynastyLegendAttr(ItemConfig itemConfig, out List<int> legendIdlist, out List<int> legendValuelist)
        {
            Dictionary<int, int> attrDict = null;
            itemTipsModel.TryGetJadeDynastyLegendAttr(itemConfig.ID,out attrDict);
            legendIdlist = attrDict.Keys.ToList();
            legendValuelist = attrDict.Values.ToList();
        }

        #region 预览定制属性逻辑处理
        public bool CheckIsCustomItem(ItemConfig itemConfig)
        {
            if (itemConfig == null) return false;

            if (itemConfig.Effect1 == 220)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 设置定制属性的数据
        /// </summary>   
        private void SetCustomAttrData(AppointItemConfig appointItemConfig)
        {
            if (appointItemConfig == null)
                return;

            List<int> legendIdlist = null;
            List<int> legendValuelist = null;
            List<int> exhaustedIdlist = null;
            List<int> exhaustedValuelist = null;
            int i = 0;
            if (appointItemConfig.LegendAttrID.Length > 0)
            {
                legendIdlist = new List<int>();
                legendValuelist = new List<int>();
                for (i = 0; i < appointItemConfig.LegendAttrID.Length; i++)
                {
                    legendIdlist.Add(appointItemConfig.LegendAttrID[i]);
                    legendValuelist.Add(appointItemConfig.LegendAttrValue[i]);
                }
            }

            if (appointItemConfig.OutOfPrintAttr.Length > 0)
            {
                exhaustedIdlist = new List<int>();
                exhaustedValuelist = new List<int>();
                for (i = 0; i < appointItemConfig.OutOfPrintAttr.Length; i++)
                {
                    exhaustedIdlist.Add(appointItemConfig.OutOfPrintAttr[i]);
                    exhaustedValuelist.Add(appointItemConfig.OutOfPrintAttrValue[i]);
                }
            }
            SetLegendData(legendIdlist, legendValuelist);
            SetExhaustedData(exhaustedIdlist, exhaustedValuelist);
        }
        #endregion
        /// <summary>
        /// 设置传奇属性数据
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="values"></param>
        private void SetLegendData(List<int> ids, List<int> values)
        {
            if (ids == null || ids.Count < 1) return;
            int i = 0;
            for (i = 0; i < ids.Count; i++)
            {
                SetSpecAttrlist(ids[i], values[i]);
            }
        }

        /// <summary>
        /// 设置绝版属性数据
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="values"></param>
        private void SetExhaustedData(List<int> ids, List<int> values)
        {
            if (ids == null || ids.Count < 1) return;
            int i = 0;
            for (i = 0; i < ids.Count; i++)
            {
                SetSpecAttrlist(ids[i], values[i]);
            }

        }

        private void SetSpecAttrlist(int attrId, int attrValue)
        {
            AttrEnum attrEnum = (AttrEnum)attrId;
            if (!specAttrDic.ContainsKey(attrEnum))
            {
                specAttrDic.Add(attrEnum, attrValue);
            }
            else
            {
                specAttrDic[attrEnum] = attrValue;
            }
        }

        /// <summary>
        /// 得到装备的评分
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        private Dictionary<int, int> itemEffectDict = new Dictionary<int, int>();
        private Dictionary<AttrEnum, float> curEquipAttrDict = new Dictionary<AttrEnum, float>(); //存储当前装备属性对应的数值 key 属性 value 属性值
        private Dictionary<AttrEnum, int> _tagGsProValueDict;
        private Dictionary<string, string> _equipGSFormulaDict = new Dictionary<string, string>(); //key 公式参数 value 参数数值
        private float curProValue = 0;
        private int GetEquipScore(PackType type, int itemId, Dictionary<AttrEnum, int> specAttrDict)
        {
            tagChinModel = ItemConfig.Get(itemId);
            if (tagChinModel == null || !GeneralDefine.CompareEquipPlaces.Contains(tagChinModel.EquipPlace)) return 0;

            Equation.Instance.Clear();
            _tagGsProValueDict = EquipGSParamConfig.GetTagGsProValueDict(tagChinModel.LV, tagChinModel.ItemColor, tagChinModel.StarLevel);
            curEquipAttrDict.Clear();
            itemEffectDict.Clear();
            _equipGSFormulaDict.Clear();
            try
            {
                if (tagChinModel.Effect1 != 0)
                {
                    ConvertAttrId(tagChinModel.Effect1, tagChinModel.EffectValueA1, itemEffectDict);
                }
                if (tagChinModel.Effect2 != 0)
                {
                    ConvertAttrId(tagChinModel.Effect2, tagChinModel.EffectValueA2, itemEffectDict);
                }

                if (tagChinModel.Effect3 != 0)
                {
                    ConvertAttrId(tagChinModel.Effect3, tagChinModel.EffectValueA3, itemEffectDict);
                }

                if (tagChinModel.Effect4 != 0)
                {
                    ConvertAttrId(tagChinModel.Effect4, tagChinModel.EffectValueA4, itemEffectDict);
                }

                if (tagChinModel.Effect5 != 0)
                {
                    ConvertAttrId(tagChinModel.Effect5, tagChinModel.EffectValueA5, itemEffectDict);
                }

            }
            catch (Exception ex)
            {
                DebugEx.Log(ex.ToString());
            }


            foreach (var key in itemEffectDict.Keys)
            {
                if (equipBaseAttrlist.Contains(key))
                {
                    switch ((AttrEnum)key)
                    {
                        case AttrEnum.ATKSPEED:
                        case AttrEnum.OnlyFinalHurt:
                        case AttrEnum.PVPAtkBackHP:
                            curEquipAttrDict.Add((AttrEnum)key, itemEffectDict[key]);
                            break;
                        default:
                            if (_tagGsProValueDict != null && _tagGsProValueDict.ContainsKey((AttrEnum)key))
                            {
                                curProValue = itemEffectDict[key] * _tagGsProValueDict[(AttrEnum)key];
                                curEquipAttrDict.Add((AttrEnum)key, curProValue);
                            }
                            else
                            {
                                curEquipAttrDict.Add((AttrEnum)key, itemEffectDict[key]);
                            }
                            break;
                    }
                }
            }

            foreach (AttrEnum attrType in specAttrDict.Keys)
            {
                switch (attrType)
                {
                    case AttrEnum.ATKSPEED:
                    case AttrEnum.OnlyFinalHurt:
                    case AttrEnum.PVPAtkBackHP:
                        curEquipAttrDict.Add(attrType, specAttrDict[attrType]);
                        break;
                    default:
                        if (_tagGsProValueDict != null && _tagGsProValueDict.ContainsKey(attrType))
                        {
                            curProValue = specAttrDict[attrType] * _tagGsProValueDict[attrType];
                            curEquipAttrDict.Add(attrType, curProValue);
                        }
                        else
                        {
                            curEquipAttrDict.Add(attrType, specAttrDict[attrType]);
                        }
                        break;
                }
            }

            if (_equipGSFormula != null)
            {
                foreach (var key in curEquipAttrDict.Keys)
                {
                    PlayerPropertyConfig propertyConfig = PlayerPropertyConfig.Get((int)key);
                    if (propertyConfig != null)
                    {
                        Equation.Instance.AddKeyValue(propertyConfig.Parameter, curEquipAttrDict[key]);
                    }
                }

                EquipGSParamConfig gSParamModel = EquipGSParamConfig.GetTagGSModel(tagChinModel.LV, tagChinModel.ItemColor, tagChinModel.StarLevel);
                if (gSParamModel != null)
                {
                    Equation.Instance.AddKeyValue("AtkSpeedC", gSParamModel.AtkSpeedC);
                }
                else
                {
                    Equation.Instance.AddKeyValue("AtkSpeedC", 0);
                }
                DebugEx.Log("评分：" + Equation.Instance.Eval<double>(_equipGSFormula.Numerical1));

                if(type == PackType.Deleted)
                {
                    type = GeneralDefine.GetPackTypeByItemType(tagChinModel.Type);
                }
                switch(type)
                {
                    case PackType.DogzEquip:
                    case PackType.DogzItem:
                         return Equation.Instance.Eval<int>(_equipGSFormula.Numerical3);
                    case PackType.JadeDynastyItem:
                    case PackType.JadeDynastyEquip:
                        return Equation.Instance.Eval<int>(_equipGSFormula.Numerical4);
                    default:
                        return Equation.Instance.Eval<int>(_equipGSFormula.Numerical1);
                }
            }
            return 0;
        }

        private void ConvertAttrId(int attrId, int attrValue, Dictionary<int, int> keyValues)
        {
            switch ((AttrEnum)attrId)
            {
                case AttrEnum.ATK:
                    if (!keyValues.ContainsKey((int)AttrEnum.MinAtk))
                    {
                        keyValues.Add(((int)AttrEnum.MinAtk), attrValue);
                    }
                    else
                    {
                        keyValues[(int)AttrEnum.MinAtk] += attrValue;
                    }

                    if (!keyValues.ContainsKey((int)AttrEnum.MaxAtk))
                    {
                        keyValues.Add(((int)AttrEnum.MaxAtk), attrValue);
                    }
                    else
                    {
                        keyValues[(int)AttrEnum.MaxAtk] += attrValue;
                    }
                    break;
                default:
                    if (!keyValues.ContainsKey(attrId))
                    {
                        keyValues.Add(attrId, attrValue);
                    }
                    else
                    {
                        keyValues[attrId] += attrValue;
                    }
                    break;
            }
        }
        #endregion

        #region 主界面物品弹框展示
        public event Action<PackType, string> GetPreciousItemEvent; //得到珍品  value 物品的实例ID

        public void GetPreciousItem(ItemModel itemModel)
        {
            if (itemModel.packType != PackType.Item) return;

            if (itemModel.config.UseLV > PlayerDatas.Instance.baseData.LV) return;

            bool isOverdue = IsOverdue(itemModel.guid, itemModel.itemId, itemModel.useDataDict);
            if (isOverdue)
            {
                return;
            }

            if (preciousItemType != null)
            {
                int i = 0;
                for (i = 0; i < preciousItemType.Length; i++)
                {
                    if (itemModel.config.Type == preciousItemType[i] && CheckPreciousCondition(itemModel))
                    {
                        if (GetPreciousItemEvent != null)
                        {
                            GetPreciousItemEvent(itemModel.packType, itemModel.guid);
                        }
                    }
                }
            }
        }

        public bool CheckPreciousCondition(ItemModel itemModel)
        {
            bool isReach = true;
            WindowSearchConfig windowSearch = WindowSearchConfig.Get((int)itemModel.config.Jump);
            if (windowSearch != null)
            {
                if (!FuncOpen.Instance.IsFuncOpen(windowSearch.Lv) && windowSearch.Lv != 0)
                {
                    isReach = false;
                    return isReach;
                }
            }
            if (pushItemIds.Contains(itemModel.itemId))
            {
                int itemCnt = playerPack.GetItemCountByID(PackType.Item, itemModel.itemId) - itemModel.count;
                if (itemCnt > 0)
                {
                    isReach = false;
                    return isReach;
                }
                else
                {
                    if (itemModel.preItemCount > 0)
                    {
                        isReach = false;
                        return isReach;
                    }
                }

            }

            if (promptUseLimitDict.ContainsKey(itemModel.itemId))
            {
                int playerLv = PlayerDatas.Instance.baseData.LV;
                if (playerLv < promptUseLimitDict[itemModel.itemId])
                {
                    isReach = false;
                    return isReach;
                }
            }

            ulong canUseCnt = 0;
            if (playerPack.IsReachUseLimit(itemModel.guid, out canUseCnt))
            {
                isReach = false;
                return isReach;
            }

            bool isBox = false;
            bool isCanOpen = ModelCenter.Instance.GetModel<BoxGetItemModel>().CheckOpenBoxCondition(itemModel.itemId, out isBox);
            if (isBox)
            {
                if (!isCanOpen)
                {
                    isReach = false;
                    return isReach;
                }
            }

            if (trialModel.trialTokens.Contains(itemModel.itemId))
            {
                if (!trialModel.IsAnySatisfyExchangeBetter(itemModel.itemId))
                {
                    isReach = false;
                    return isReach;
                }
            }

            if (playerPack.CheckIsDrugById(itemModel.itemId))
            {
                if (itemModel.config.RealmLimit > PlayerDatas.Instance.baseData.realmLevel)
                {
                    isReach = false;
                    return isReach;
                }
            }

            switch (itemModel.config.Type)
            {
                case 8:
                    if (buffDatas.BastBuff(itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 20:
                    if (magicianModel.IsGodWeaponMaxLevelByItem(itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 21:
                    if (!mountDatas.IsHint(HorseEnum.HorseDan, itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 22:
                    if (!mountDatas.IsHint(HorseEnum.HorseStone, itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 41:
                    if (!mountDatas.IsHint(HorseEnum.HorseDebris, itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 26:
                    if (!petDatas.IsHint(PetEnum.PetDebris, itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 27:
                    if (!petDatas.IsHint(PetEnum.PetDan, itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 28:
                    if (!petDatas.IsHint(PetEnum.PetStone, itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 25:
                    if (!ModelCenter.Instance.GetModel<GemModel>().SatisfyBetter(itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 39:
                    if (!CheckIsBetterWings(itemModel))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 52:
                    if (!strengthDatas.IsHint(itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 127:
                    var error = 0;
                    bool isHaveMakeNum = ItemOperateUtility.Instance.CanUseItem(itemModel.itemPlace ,1,out error);
                    int remainNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
                    if (!CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch
                        || remainNum > 0
                        || !isHaveMakeNum)
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                default:
                    break;
            }

            switch (itemModel.itemId)
            {
                case 951:
                    if (!CheckIsExtendGrid(itemModel.itemId))
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;
                case 952:
                    int willTime = HangUpSetModel.Instance.offlinePluginTime + itemModel.config.EffectValueA1;
                    if (HangUpSetModel.Instance.offlinePluginTime >= HangUpSetModel.Instance.maxOfflinePluginTime)
                    {
                        isReach = false;
                        return isReach;
                    }
                    break;

            }

            return isReach;
        }

        private bool CheckIsBetterWings(ItemModel itemModel)
        {
            if (itemModel == null) return false;

            ItemModel putModel = playerPack.GetItemModelByIndex(PackType.Equip, (int)RoleEquipType.Wing);
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Item);
            List<ItemModel> itemModels = null;
            if (singlePack != null)
            {
                singlePack.GetItemCountByType((int)ItemType.Wings, out itemModels);
            }
            int[] composeTypes = itemModel.config.JumpComposeCondi;
            bool isOpenCompose = false;
            if (composeTypes != null && composeTypes.Length >= 3)
            {
                int first = composeTypes[0];
                int second = composeTypes[1];
                int third = composeTypes[2];
                ComposeWinModel.ComposeThirdTypeData thirdTypeData = null;
                composeModel.TryGetThirdTypeData(first, second, third, out thirdTypeData);
                if (thirdTypeData != null)
                {
                    var itemCompound = thirdTypeData.itemCompound;
                    if (itemCompound.levelNeed <= PlayerDatas.Instance.baseData.LV)
                    {
                        isOpenCompose = true;
                    }
                }
            }

            if (!isOpenCompose)
            {
                return false;
            }

            if (putModel != null && putModel.config.LV >= itemModel.config.LV)
            {
                return false;
            }

            if (itemModels != null)
            {
                for (int i = 0; i < itemModels.Count; i++)
                {
                    if (itemModels[i].config.JobLimit / 100 == PlayerDatas.Instance.baseData.Job)
                    {
                        if (itemModels[i].config.LV >= itemModel.config.LV)
                        {
                            return false;
                        }
                    }
                }
            }

            return true;
        }

        private bool CheckIsExtendGrid(int itemId)
        {
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Item);
            if (singlePack == null) return false;

            int startLockIndex = singlePack.openGridCount - playerPack.InitBagGridCnt;
            FuncConfigConfig _tagFuncModel = FuncConfigConfig.Get("OpenBagItem");
            int haveCount = playerPack.GetItemCountByID(PackType.Item, itemId);
            Equation.Instance.Clear();
            Equation.Instance.AddKeyValue("index", startLockIndex + 1);
            int needTool = Equation.Instance.Eval<int>(_tagFuncModel.Numerical2);
            if (haveCount >= needTool)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public event Action<string> RefreshGetBetterEquipEvent; //得到更好的装备 value 物品的实例ID

        public bool IsSameJob(int jobLimit)
        {
            return jobLimit == 0 || jobLimit / 100 == PlayerDatas.Instance.baseData.Job;
        }

        public void OnGetEquip(ItemModel model)
        {
            if (model == null) return;
            if (model.packType != PackType.Item && model.packType != PackType.JadeDynastyItem) return;
            if (!IsSameJob(model.config.JobLimit)) return;

            int equipPlace = model.config.EquipPlace;
            switch ((RoleEquipType)equipPlace)
            {
                case RoleEquipType.Weapon:
                case RoleEquipType.Weapon2:
                case RoleEquipType.Hat:
                case RoleEquipType.Clothes:
                case RoleEquipType.Belt:
                case RoleEquipType.Trousers:
                case RoleEquipType.Shoes:
                case RoleEquipType.Neck:
                case RoleEquipType.FairyCan:
                case RoleEquipType.FairyCan2:
                case RoleEquipType.Wing:
                case RoleEquipType.SpiritAnimal:
                case RoleEquipType.JadeDynasty_Cloak:
                case RoleEquipType.JadeDynasty_FaceMask:
                case RoleEquipType.JadeDynasty_Glove1:
                case RoleEquipType.JadeDynasty_Glove2:
                case RoleEquipType.JadeDynasty_Ruyi:
                case RoleEquipType.JadeDynasty_Pendant:
                case RoleEquipType.JadeDynasty_Ring1:
                case RoleEquipType.JadeDynasty_Ring2:
                case RoleEquipType.JadeDynasty_Sword1:
                case RoleEquipType.JadeDynasty_Sword2:
                case RoleEquipType.JadeDynasty_Sword3:
                case RoleEquipType.JadeDynasty_Sword4:
                    if (betterEquipExceptDungeonDict.ContainsKey(PlayerDatas.Instance.baseData.MapID))
                    {
                        if (betterEquipExceptDungeonDict[PlayerDatas.Instance.baseData.MapID].Contains(model.itemId))
                        {
                            return;
                        }
                    }
                    SetGetBetterEquipEvent(model);
                    break;
            }
        }

        private void SetGetBetterEquipEvent(ItemModel model)
        {
            List<int> itemEffectTime = model.GetUseDataModel((int)ItemUseDataKey.createTime);
            if (itemEffectTime != null)
            {
                if (itemEffectTime[0] != 0)
                {
                    ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(model.guid);
                    double remainTime = 0;
                    if (cool != null)
                    {
                        remainTime = cool.GetRemainTime();
                    }

                    if (remainTime >= 0 && remainTime < 120 && model.config.ExpireTime > 0)
                    {
                        return;
                    }
                }
            }

            int isFightUp = IsFightUp(model.itemId,model.equipScore);
            int equipPlace = model.config.EquipPlace;
            if (isFightUp == 1)
            {
               switch(equipPlace)
                {
                    case 9:
                        break;
                    default:
                        if(model.packType == PackType.Item)
                        {
                            var equipItemModel = playerPack.GetItemModelByIndex(PackType.Equip, model.config.EquipPlace);
                            if (PlayerDatas.Instance.baseData.LV >= 200)
                            {
                                if (model.equipPlace > (int)RoleEquipType.Weapon2 && model.equipPlace < (int)RoleEquipType.Neck)
                                {
                                    if (equipItemModel != null && equipItemModel.config.ItemColor > model.config.ItemColor)
                                    {
                                        return;
                                    }
                                }
                            }
                        }
                        break;
                }
                if (RefreshGetBetterEquipEvent != null)
                {
                    RefreshGetBetterEquipEvent(model.guid);
                }
            }
        }

        private bool CheckIsBetterEquip(int curScore, int putOnScore = 0)
        {

            if (putOnScore <= 0)
            {
                return true;
            }

            if (curScore > putOnScore)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public event Action<PackType, string> RefreshPickItemEvent; //捡起的物品

        public void RefreshPickItem(PackType type, string guid)
        {
            if (type != PackType.Item) return;

            if (RefreshPickItemEvent != null)
            {
                RefreshPickItemEvent(type, guid);
            }
        }

        Dictionary<int, ItemModel> RealmBetterDict = new Dictionary<int, ItemModel>();
        public Dictionary<int, ItemModel> CheckBetterEquipByRealm()
        {
            RealmBetterDict.Clear();
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Item);
            if (singlePack == null) return RealmBetterDict;

            int realmLv = PlayerDatas.Instance.baseData.realmLevel;
            Dictionary<int, ItemModel> pairs = singlePack.GetAllItems();
            foreach (var model in pairs.Values)
            {
                if (model.config.EquipPlace > 0
                    && model.config.EquipPlace != (int)RoleEquipType.SpiritAnimal
                    && model.config.RealmLimit <= realmLv
                    && !IsOverdue(model.guid, model.itemId, model.useDataDict)
                    && IsFightUp(model.itemId, model.equipScore) == 1)
                {
                    if (!RealmBetterDict.ContainsKey(model.equipPlace))
                    {
                        RealmBetterDict.Add(model.equipPlace, model);
                    }
                    else
                    {
                        if (model.equipScore > RealmBetterDict[model.equipPlace].equipScore)
                        {
                            RealmBetterDict[model.equipPlace] = model;
                        }
                    }
                }
            }
            return RealmBetterDict;
        }

        List<ItemModel> RealmDruglist = new List<ItemModel>();
        public List<ItemModel> GetDruglistByRealm()
        {
            RealmDruglist.Clear();
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Item);
            if (singlePack == null) return RealmDruglist;

            int realmLv = PlayerDatas.Instance.baseData.realmLevel;
            Dictionary<int, ItemModel> pairs = singlePack.GetAllItems();
            foreach (var model in pairs.Values)
            {
                if (playerPack.CheckIsDrugById(model.itemId))
                {
                    AttrFruitConfig fruitConfig = AttrFruitConfig.Get(model.itemId);
                    if (!playerPack.IsReachMaxUseDrug(fruitConfig)
                        && model.config.RealmLimit <= realmLv)
                    {
                        RealmDruglist.Add(model);
                    }
                }
            }
            return RealmDruglist;
        }
        #endregion

        #region 解锁格子

        public void OpenGrid(int chooseGridCount, PackType type)
        {
            SinglePackModel singlePack = playerPack.GetSinglePackModel(type);
            int openCount = chooseGridCount - singlePack.openGridCount;
            int index = 0;
            switch (type)
            {
                case PackType.Item:
                    index = chooseGridCount - playerPack.InitBagGridCnt;
                    break;
                case PackType.Warehouse:
                    index = chooseGridCount - playerPack.InitDepotGridCnt;
                    break;
            }
            itemTipsModel.SetExtendGirdModel(openCount, index, type);
            WindowCenter.Instance.Open<ExtendWin>();
        }

        #endregion

        #region 物品处于CD中的逻辑处理

        private Dictionary<string, double> itemEffectCDDict = new Dictionary<string, double>(); //key 物品实例ID
        private List<string> itemEffectTimelist = new List<string>(); //key 物品实例ID
        /// <summary>
        /// 物品使用时间限制
        /// </summary>
        public void SetItemEffectCDTime(string guid, int itemID, int getTime, int serverSurplusTime)
        {
            double time = GetTimeOffest(TimeUtility.GetTime((uint)getTime));
            if (time < 0)
            {
                time = 0;
            }
            itemEffectTimelist.Add(guid);
            ItemConfig itemConfig = ItemConfig.Get(itemID);
            if (time >= itemConfig.ExpireTime)
            {
                KnapsackTimeCDMgr.Instance.UnRegister(guid);
                return;
            }
            double remainTime = (serverSurplusTime > 0 ? serverSurplusTime : itemConfig.ExpireTime) - time;
            KnapsackTimeCDMgr.Instance.Register(guid, itemID, remainTime);
        }

        public double GetTimeOffest(DateTime getTime)
        {
            DebugEx.Log("现在时间：" + TimeUtility.ServerNow + "获得时间:" + getTime);
            //TimeUtility.SyncServerTime();
            TimeSpan t = TimeUtility.ServerNow - getTime;
            DebugEx.Log("时间差：" + t.TotalSeconds);
            return t.TotalSeconds;
        }

        public List<string> GetItemEffectTimelist()
        {
            return itemEffectTimelist;
        }

        #endregion

        #region 设置可以一键出售的物品数据

        private int playerLv;
        private Dictionary<int, List<ItemModel>> _lifePotionDict = new Dictionary<int, List<ItemModel>>(); //key 药水等级
        private List<int> _sellItemScorelist = new List<int>();
        private Dictionary<int, Dictionary<int, List<ItemModel>>> _sameIndexEquipDict = new Dictionary<int, Dictionary<int, List<ItemModel>>>();  //存储相同装备位的装备
                                                                                                                                                  // private  _sameEquipScoreDict = new Dictionary<int, List<ItemModel>>(); //存储相同ID中相同装备评分的装备
        private Dictionary<int, ItemModel> _packModelDict;
        private List<ItemModel> _sellItemlist = new List<ItemModel>();

        public List<ItemModel> GetSellItemList()
        {
            GetOneKeySellModel();
            _sellItemlist.Sort(SetSellItemOrder);
            return _sellItemlist;
        }

        public int SetSellItemOrder(ItemModel startModel, ItemModel endModel)
        {
            bool startIsEquip = IsEquip(startModel);
            bool endIsEquip = IsEquip(endModel);
            if (startIsEquip.CompareTo(endIsEquip) != 0) return -startIsEquip.CompareTo(endIsEquip);
            int order1 = startModel.config.Type;
            int order2 = endModel.config.Type;
            if (order1.CompareTo(order2) != 0) return order1.CompareTo(order2);
            int color1 = startModel.config.ItemColor;
            int color2 = endModel.config.ItemColor;
            if (color1.CompareTo(color2) != 0) return -color1.CompareTo(color2);
            int code1 = startModel.itemId;
            int code2 = endModel.itemId;
            if (code1.CompareTo(code2) != 0) return -code1.CompareTo(code2);
            return 0;
        }

        public bool IsEquip(ItemModel model)
        {
            if (model.config.EquipPlace != 0)
                return true;
            else
                return false;
        }

        public void GetOneKeySellModel()
        {
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Item);
            if (singlePack == null)
                return;

            _sellItemlist.Clear();
            _lifePotionDict.Clear();
            _sameIndexEquipDict.Clear();
            _sellItemScorelist.Clear();
            playerLv = PlayerDatas.Instance.baseData.LV;
            _packModelDict = singlePack.GetAllItems();
            foreach (var key in _packModelDict.Keys)
            {
                GetCanSellEquipList(_packModelDict[key]);
                ItemModel itemModel = _packModelDict[key];
                if (drugIDs.Contains(itemModel.itemId))
                {
                    if (!_lifePotionDict.ContainsKey(itemModel.config.LV))
                    {
                        List<ItemModel> modellist = new List<ItemModel>();
                        modellist.Add(itemModel);
                        _lifePotionDict.Add(itemModel.config.LV, modellist);
                    }
                    else
                    {
                        _lifePotionDict[itemModel.config.LV].Add(itemModel);
                    }
                }
            }

            #region 得到可以出售的装备
            foreach (var key in _sameIndexEquipDict.Keys)
            {
                _sellItemScorelist = _sameIndexEquipDict[key].Keys.ToList();
                _sellItemScorelist.Sort();
                if (_sellItemScorelist.Count > 0)
                {
                    int score = 0;
                    int curJob = PlayerDatas.Instance.baseData.Job;
                    for (score = _sellItemScorelist.Count - 1; score > -1; score--)
                    {
                        SinglePackModel equipPack = playerPack.GetSinglePackModel(PackType.Equip);
                        ItemModel model = null;
                        if (equipPack != null)
                        {
                            model = equipPack.GetItemByIndex(key);
                        }

                        List<ItemModel> modellist = _sameIndexEquipDict[key][_sellItemScorelist[score]];
                        int i = 0;
                        bool remainBetter = true;
                        for (i = 0; i < modellist.Count; i++)
                        {
                            double joblimit = Math.Floor((double)modellist[i].config.JobLimit / 100);
                            if (model != null)
                            {
                                if (remainBetter)
                                {
                                    if (model.equipScore < _sellItemScorelist[score] && curJob == joblimit)
                                    {
                                        _sameIndexEquipDict[key].Remove(_sellItemScorelist[score]);
                                        remainBetter = false;
                                        break;
                                    }
                                }

                            }
                            else
                            {
                                if (curJob == joblimit)
                                {
                                    if (remainBetter)
                                    {
                                        _sameIndexEquipDict[key].Remove(_sellItemScorelist[score]);
                                        remainBetter = false;
                                        break;
                                    }
                                }
                            }
                        }

                        if (!remainBetter)
                        {
                            break;
                        }

                    }
                    int j = 0;
                    for (j = 0; j < _sellItemScorelist.Count; j++)
                    {

                        if (_sameIndexEquipDict[key].ContainsKey(_sellItemScorelist[j]))
                        {
                            int k = 0;
                            List<ItemModel> sellModlelist = _sameIndexEquipDict[key][_sellItemScorelist[j]];
                            for (k = 0; k < sellModlelist.Count; k++)
                            {
                                _sellItemlist.Add(sellModlelist[k]);
                            }
                        }
                    }

                }

            }
            #endregion

            List<int> drugLvlist = new List<int>();
            drugLvlist.AddRange(_lifePotionDict.Keys.ToList());
            drugLvlist.Sort();
            for (int i = drugLvlist.Count - 1; i > -1; i--)
            {
                if (drugLvlist[i] > playerLv)
                {
                    _lifePotionDict.Remove(drugLvlist[i]);
                }
                else
                {
                    _lifePotionDict.Remove(drugLvlist[i]);
                    break;
                }
            }

            foreach (var list in _lifePotionDict.Values)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    _sellItemlist.Add(list[i]);
                }

            }
        }


        //得到满足出售条件的装备列表
        public void GetCanSellEquipList(ItemModel model)
        {

            if (model.config.EquipPlace == 0 || !onekeySellTypes.Contains(model.config.Type))
                return;

            Dictionary<int, List<ItemModel>> sameScoreDict;
            List<ItemModel> sameScorelist;

            if (model.config.ItemColor < 3)
            {
                if (!_sameIndexEquipDict.ContainsKey(model.config.EquipPlace))
                {
                    sameScoreDict = new Dictionary<int, List<ItemModel>>();
                    sameScorelist = new List<ItemModel>();
                    sameScorelist.Add(model);
                    sameScoreDict.Add(model.equipScore, sameScorelist);
                    _sameIndexEquipDict.Add(model.config.EquipPlace, sameScoreDict);

                }
                else
                {
                    if (_sameIndexEquipDict[model.config.EquipPlace].ContainsKey(model.equipScore))
                    {
                        _sameIndexEquipDict[model.config.EquipPlace][model.equipScore].Add(model);
                    }
                    else
                    {
                        sameScorelist = new List<ItemModel>();
                        sameScorelist.Add(model);
                        _sameIndexEquipDict[model.config.EquipPlace].Add(model.equipScore, sameScorelist);
                    }

                }
            }


        }

        #endregion

        #region 发送请求
        /// <summary>
        /// 一键出售物品的请求
        /// </summary>
        /// <param name="_oneKeySelllist"></param>
        public void SendOneKeySellQuest(List<ItemModel> _oneKeySelllist)
        {
            if (!isPackResetOk || SettingEffectMgr.Instance.isStartOneKeySell) return;

            SettingEffectMgr.Instance.isStartOneKeySell = true;
            byte[] itemIndexs = new byte[_oneKeySelllist.Count];
            int i = 0;
            for (i = 0; i < _oneKeySelllist.Count; i++)
            {
                itemIndexs[i] = (byte)_oneKeySelllist[i].itemPlace;
            }
            CA311_tagCMSellItem sellItem = new CA311_tagCMSellItem();
            sellItem.PackType = (int)PackType.Item;
            sellItem.Count = (byte)_oneKeySelllist.Count;
            sellItem.ItemIndex = itemIndexs;
            GameNetSystem.Instance.SendInfo(sellItem);
        }

        /// <summary>
        /// 整理包裹物品
        /// </summary>
        /// <param name="type"></param>
        public bool isPackResetOk { get; set; }
        public void SendPackResetQuest(PackType type)
        {
            if (lookLineIndex > -1)
            {
                SetLookIndex(null);
            }

            if (KnapSackWin.titleType == KnapsackFuncTitle.bag)
            {
                playerPack.isPlayBetterEquipEffect = true;
            }

            SinglePackModel singlePack = playerPack.GetSinglePackModel(type);
            if (singlePack != null)
            {
                C070F_tagCItemPackReset packReset = new C070F_tagCItemPackReset();
                packReset.Type = (byte)type;
                packReset.ItemBeginIndex = 0;
                packReset.ItemEndIndex = (ushort)(singlePack.openGridCount - 1);
                GameNetSystem.Instance.SendInfo(packReset); //整理物品
                if (type == PackType.Item)
                {
                    isPackResetOk = false;
                }
            }
        }
        #endregion

        #region 查看某个位置的物品
        public event Action lookEquipEvent;
        private int _lookLineIndex = -1;
        public int lookLineIndex { get { return _lookLineIndex; } private set { _lookLineIndex = value; } }

        public string lookItemGUID { get; private set; }

        public void SetLookIndex(string guid, int singleRowCount = 5)
        {

            if (string.IsNullOrEmpty(guid) || guid == "")
            {
                lookLineIndex = -1;
            }
            else
            {
                int index = playerPack.GetItemModelByGUID(guid).itemPlace;
                lookLineIndex = index / singleRowCount;
                lookItemGUID = guid;
            }

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

        }
        #endregion

        #region 判断是否有更好的装备替换
        /// <summary>
        /// 过滤装备位判断
        /// </summary>
        /// <param name="ignoreType"></param>
        /// <returns></returns>
        public bool CheckBetterEquip(RoleEquipType ignoreType)
        {
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Equip);
            if (singlePack != null)
            {
                Dictionary<int, ItemModel> putOnDic = singlePack.GetAllItems();
                foreach (var key in putOnDic.Keys)
                {
                    if ((RoleEquipType)key == ignoreType)
                    {
                        continue;
                    }
                    if (key < 13)
                    {
                        List<ItemModel> itemlist = GetSameEquipPlacelist(key);
                        int i = 0;
                        for (i = 0; i < itemlist.Count; i++)
                        {
                            bool isOverdue = IsOverdue(itemlist[i].guid, itemlist[i].itemId, itemlist[i].useDataDict);
                            bool isRealm = PlayerDatas.Instance.baseData.realmLevel >= itemlist[i].config.RealmLimit ? true : false;
                            if (itemlist[i].equipScore > putOnDic[key].equipScore && !isOverdue && isRealm)
                            {
                                return true;
                            }
                        }
                    }
                }
            }
            else
            {
                int i = 1;
                for (i = 1; i < 13; i++)
                {
                    List<ItemModel> itemlist = GetSameEquipPlacelist(i);
                    if (itemlist.Count > 0)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private List<ItemModel> GetSameEquipPlacelist(int equipPlace)
        {
            List<ItemModel> modellist = new List<ItemModel>();
            Dictionary<int, ItemModel> dic = null;
            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Item);
            if (singlePack != null)
            {
                dic = singlePack.GetAllItems();
                foreach (var model in dic.Values)
                {
                    if (model.config.EquipPlace == equipPlace)
                    {
                        double equipJob = Math.Floor((double)model.config.JobLimit / 100);
                        if (equipJob == 0 || equipJob == PlayerDatas.Instance.baseData.Job)
                        {
                            modellist.Add(model);
                        }
                    }
                }
            }
            return modellist;
        }

        /// <summary>
        /// 获取装备评分最高可提升战力的装备
        /// </summary>
        /// <param name="_places"></param>
        /// <returns></returns>
        public string GetHighestScoreEquipByPlace(int equipPlace)
        {
            var itemPackage = playerPack.GetSinglePackModel(PackType.Item);
            var allItems = itemPackage.GetAllItems();
            ItemModel putModel = playerPack.GetItemModelByIndex(PackType.Equip, equipPlace);
            equipPlace = (equipPlace == 9 || equipPlace == 10) ? 9 : equipPlace;
            var guid = string.Empty;
            var equips = new List<string>();
            var score = putModel == null ? 0 : putModel.equipScore;
            var job = PlayerDatas.Instance.baseData.Job;
            foreach (var item in allItems.Values)
            {
                if (item.config.EquipPlace == equipPlace)
                {
                    if (!IsOverdue(item.guid, item.itemId, item.useDataDict)
                       && (item.config.JobLimit == 0 || (item.config.JobLimit / 100) == job) && item.equipScore > score)
                    {
                        guid = item.guid;
                        score = item.equipScore;
                    }
                }
            }

            return guid;
        }
        #endregion

        #region 背包整理后好的同类型最好的装备
        public Dictionary<int, Dictionary<int, ItemModel>> itemModelDict = new Dictionary<int, Dictionary<int, ItemModel>>();  // key1 装备位置索引 key2 背包位置索引
        public void SetBagSortBetterEquipList(ItemModel itemModel)
        {
            if (itemModel == null || itemModel.packType != PackType.Item) return;

            if (!IsCanPutOn(itemModel)) return;

            int equipPlace = itemModel.config.EquipPlace;
            if (!itemModelDict.ContainsKey(equipPlace))
            {
                Dictionary<int, ItemModel> dict = new Dictionary<int, ItemModel>();
                if (IsFightUp(itemModel.itemId, itemModel.equipScore) == 1)
                {
                    dict.Add(itemModel.itemPlace, itemModel);
                    itemModelDict.Add(equipPlace, dict);
                }
            }
            else
            {
                if (IsFightUp(itemModel.itemId, itemModel.equipScore) == 1)
                {
                    itemModelDict[equipPlace].Add(itemModel.itemPlace, itemModel);
                }
            }

        }

        public ItemModel GetBagSortBetterEquip(int equipPlace, int index)
        {
            ItemModel itemModel = null;
            if (itemModelDict.ContainsKey(equipPlace))
            {
                itemModelDict[equipPlace].TryGetValue(index, out itemModel);
            }
            return itemModel;
        }

        public bool IsCanPutOn(ItemModel itemModel)
        {
            double equipJob = Math.Floor((double)itemModel.config.JobLimit / 100);
            int playerJob = PlayerDatas.Instance.baseData.Job;
            int equipPlace = itemModel.config.EquipPlace;
            if (equipPlace == 0 || equipPlace > 12) return false;
            if (equipJob != 0 && equipJob != playerJob) return false;

            List<int> putOnlimitList = itemModel.GetUseDataModel((int)ItemUseDataKey.cancelUseLimit);
            if (putOnlimitList != null)
            {
                if (putOnlimitList[0] == 1)
                {
                    return true;
                }
            }

            return CheckPutOnRealm(itemModel.config);
        }

        private bool CheckPutOnRealm(ItemConfig config)
        {
            var _realmLv = config.RealmLimit;
            if (PlayerDatas.Instance.baseData.realmLevel < _realmLv)
            {
                return false;
            }
            return true;
        }
        #endregion

        #region 得到物品的品质颜色
        private Dictionary<int, int> wingRefineQualityDict;
        private int[] wingsQualitys;
        private int[] wingsRefineExps;
        public int GetItemQuality(int itemId, Dictionary<int, List<int>> useDataDic = null)
        {
            wingsQualitys = null;
            wingsRefineExps = null;
            ItemConfig itemConfig = ItemConfig.Get(itemId);
            wingRefineQualityDict = WingRefineAttrConfig.GetWingsQualityModel(itemConfig.LV);
            if (useDataDic != null)
            {
                if (useDataDic.ContainsKey(42) && wingRefineQualityDict != null)
                {
                    wingsQualitys = wingRefineQualityDict.Keys.ToArray();
                    wingsRefineExps = wingRefineQualityDict.Values.ToArray();
                    int i = 0;
                    for (i = wingsRefineExps.Length - 1; i > -1; i--)
                    {
                        if (useDataDic[42][0] >= wingsRefineExps[i])
                        {
                            return wingsQualitys[i];
                        }
                    }
                }
            }
            return itemConfig.ItemColor;
        }
        #endregion


        //设置玩家货币显示
        public string OnChangeCoinsUnit(ulong value)
        {

            string strCoins = value.ToString();
            if (strCoins.Length > 4 && strCoins.Length < 9)
            {
                double coins = Math.Floor((double)value / 10000);
                strCoins = coins + Language.Get("KnapS114");
            }
            else if (strCoins.Length >= 9 && strCoins.Length < 13)
            {
                double coins = Math.Floor((double)value / 100000000);
                strCoins = coins + Language.Get("KnapS115");
            }
            else if (strCoins.Length >= 13 && strCoins.Length < 19)
            {
                double coins = Math.Floor((double)value / 1000000000000);
                strCoins = coins + Language.Get("KnapS126");
            }
            else if (strCoins.Length >= 19)
            {
                ServerTipDetails.DisplayNormalTip(Language.Get("KnapS127"));
            }
            return strCoins;
        }

        /// <summary>
        /// 装备是否可以提升战力
        /// </summary>
        /// <param name="_itemID"></param>
        /// <param name="_score"></param>
        /// <returns></returns>
        public int IsFightUp(int _itemID, int _score)//-1低级，0不是本职业，1更好
        {
            ItemConfig chinItemModel = ItemConfig.Get(_itemID);
            if (chinItemModel != null)
            {
                ItemModel putOnModel = null;
                switch((RoleEquipType)chinItemModel.EquipPlace)
                {
                    case RoleEquipType.Clothes:
                    case RoleEquipType.FairyCan:
                    case RoleEquipType.Belt:
                    case RoleEquipType.Hat:
                    case RoleEquipType.Neck:
                    case RoleEquipType.Shoes:
                    case RoleEquipType.SpiritAnimal:
                    case RoleEquipType.Trousers:
                    case RoleEquipType.Weapon:
                    case RoleEquipType.Weapon2:
                    case RoleEquipType.Wing:
                        putOnModel = playerPack.GetItemModelByIndex(PackType.Equip, chinItemModel.EquipPlace);
                        break;
                    case RoleEquipType.JadeDynasty_Cloak:
                    case RoleEquipType.JadeDynasty_FaceMask:
                    case RoleEquipType.JadeDynasty_Glove1:
                    case RoleEquipType.JadeDynasty_Pendant:
                    case RoleEquipType.JadeDynasty_Ring1:
                    case RoleEquipType.JadeDynasty_Ruyi:
                    case RoleEquipType.JadeDynasty_Sword1:
                    case RoleEquipType.JadeDynasty_Sword2:
                    case RoleEquipType.JadeDynasty_Sword3:
                    case RoleEquipType.JadeDynasty_Sword4:
                        putOnModel = playerPack.GetItemModelByIndex(PackType.JadeDynastyEquip, chinItemModel.EquipPlace);
                        break;
                    default:
                        return 0;
                }

                ItemModel putOnModel2 = null;
                switch((RoleEquipType)chinItemModel.EquipPlace)
                {
                    case RoleEquipType.FairyCan:
                        putOnModel2 = playerPack.GetItemModelByIndex(PackType.Equip, (int)RoleEquipType.FairyCan2);
                        break;
                    case RoleEquipType.JadeDynasty_Glove1:
                        putOnModel2 = playerPack.GetItemModelByIndex(PackType.JadeDynastyEquip, (int)RoleEquipType.JadeDynasty_Glove2);
                        break;
                    case RoleEquipType.JadeDynasty_Ring1:
                        putOnModel2 = playerPack.GetItemModelByIndex(PackType.JadeDynastyEquip, (int)RoleEquipType.JadeDynasty_Ring2);
                        break;
                }

                switch ((RoleEquipType)chinItemModel.EquipPlace)
                {
                    case RoleEquipType.FairyCan:
                    case RoleEquipType.JadeDynasty_Glove1:
                    case RoleEquipType.JadeDynasty_Ring1:
                        if (putOnModel2 != null)
                        {
                            if (putOnModel != null)
                            {
                                if (putOnModel2.equipScore < putOnModel.equipScore)
                                {
                                    putOnModel = putOnModel2;
                                }
                            }
                        }
                        else
                        {
                            putOnModel = putOnModel2;
                        }
                        break;
                }

                int equipScore1 = 0;
                if (putOnModel != null)
                {
                    equipScore1 = (int)putOnModel.equipScore;
                }

                int playerJob = PlayerDatas.Instance.baseData.Job;

                if (playerJob == Math.Floor((double)chinItemModel.JobLimit / 100) || chinItemModel.JobLimit == 0)
                {
                    if (equipScore1 > _score)
                        return -1;
                    else if (equipScore1 < _score)
                        return 1;
                    else
                        return 0;
                }
                else
                {
                    return 0;
                }
            }
            return 0;
        }

        #region 物品是否过期
        public bool IsOverdue(string guid, int itemId, Dictionary<int, List<int>> useDataDict = null)
        {
            ItemConfig itemConfig = ItemConfig.Get(itemId);
            if (itemConfig == null) return false;

            if (itemConfig.ExpireTime > 0)
            {
                ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(guid);
                switch ((EquipReduceType)itemConfig.EndureReduceType)
                {
                    case EquipReduceType.Def_EquipReduceType_Time:
                        if (guid != "")
                        {
                            List<int> itemEffectTime = null;
                            if (useDataDict != null)
                            {
                                if (useDataDict.ContainsKey((int)ItemUseDataKey.createTime))
                                {
                                    itemEffectTime = useDataDict[(int)ItemUseDataKey.createTime];
                                }
                            }

                            if (itemEffectTime != null && itemEffectTime[0] != 0)
                            {
                                if (cool == null || cool.GetRemainTime() <= 0)
                                {
                                    return true;
                                }
                            }
                        }
                        break;

                    case EquipReduceType.Def_EquipReduceType_RTimeItem:
                        if (guid != "")
                        {
                            if (cool == null || cool.GetRemainTime() <= 0)
                            {
                                return true;
                            }
                        }
                        break;

                }
            }

            return false;
        }
        #endregion
    }
}