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

namespace Snxxz.UI
{
    public class RuneModel : Model, IBeforePlayerDataInitialize
    {
        RuneComposeModel m_RuneComposeModel;
        RuneComposeModel runeComposeModel {
            get {
                return m_RuneComposeModel ?? (m_RuneComposeModel = ModelCenter.Instance.GetModel<RuneComposeModel>());
            }
        }

        public override void Init()
        {
            ParseConfig();
            for (int i = 0; i < 8; i++)
            {
                Redpoint redpoint = new Redpoint(10801, 1080101 + i);
                runeHoleRedpoints.Add(redpoint);
                redpoint.state = RedPointState.None;
            }

            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
        }

        private void OnFuncStateChangeEvent(int func)
        {
            if (func == (int)FuncOpenEnum.Rune)
            {
                UpdateRedpoint();
                UpdateBreakRedpoint();
            }
        }

        public override void UnInit()
        {
        }

        public void OnBeforePlayerDataInitialize()
        {
            ClearRuneData();
        }

        #region 配置
        public const int RUNE_TYPE = 30;
        public const int RUNE_CREAMTYPE = 31;
        public Dictionary<int, Dictionary<int, float>> runeAttrDic = new Dictionary<int, Dictionary<int, float>>();
        public Dictionary<int, float> runeAttrAdditionDic = new Dictionary<int, float>();
        public Dictionary<int, float> runeExpDic = new Dictionary<int, float>();
        public Dictionary<int, float> runeEliteAdditonDic = new Dictionary<int, float>();
        Dictionary<int, int> runeQualityMaxLevel;
        public int[] runeUnlockArray { get; private set; }
        public float runeExpAddition { get; private set; }
        public string runeExpFormula { get; private set; }
        public int runePackMaxNum { get; private set; }
        public Dictionary<int, int> doublePropRuneInlayDict { get; private set; }

        private void ParseConfig()
        {

            System.Threading.ThreadPool.QueueUserWorkItem(
                (object aaa) =>
                {
                    foreach (var key in FuncConfigConfig.m_RuneAttrCfgs.Keys)
                    {
                        runeAttrDic.Add(key, ConfigParse.GetDic<int, float>(FuncConfigConfig.m_RuneAttrCfgs[key].Numerical2));
                        runeAttrAdditionDic.Add(key, float.Parse(FuncConfigConfig.m_RuneAttrCfgs[key].Numerical3));
                    }
                    runeExpDic = ConfigParse.GetDic<int, float>(FuncConfigConfig.GetRuneNeedExpFormula().Numerical2);
                    runeExpAddition = float.Parse(FuncConfigConfig.GetRuneNeedExpFormula().Numerical3);
                    runeEliteAdditonDic = ConfigParse.GetDic<int, float>(FuncConfigConfig.GetRuneNeedExpFormula().Numerical4);
                    runeExpFormula = FuncConfigConfig.GetRuneNeedExpFormula().Numerical1;
                    FuncConfigConfig cfg = Config.Instance.Get<FuncConfigConfig>("RuneUnlock");
                    if (cfg != null)
                    {
                        runeUnlockArray = ConfigParse.GetMultipleStr<int>(cfg.Numerical1);
                    }
                    cfg = Config.Instance.Get<FuncConfigConfig>("RunePackageNum");
                    runePackMaxNum = int.Parse(cfg.Numerical1);

                    var config = Config.Instance.Get<FuncConfigConfig>("RuneMaxLV");
                    runeQualityMaxLevel = ConfigParse.GetDic<int, int>(config.Numerical1);

                    var maxlevel = runeQualityMaxLevel != null ? runeQualityMaxLevel.Values.Last() : 0;

                    for (int i = 1; i < maxlevel; i++)
                    {
                        Equation.Instance.Clear();
                        Equation.Instance.AddKeyValue(replaceValStr, i + 1);
                        var _result = Equation.Instance.Eval<float>(runeExpFormula);
                        runeExpResultDict.Add(i + 1, _result);
                    }
                    doublePropertyRunes = new List<int>();
                    var _cfgs = Config.Instance.GetAllValues<RuneComposeConfig>();
                    foreach (var _cfg in _cfgs)
                    {
                        doublePropertyRunes.Add(_cfg.TagItemID);
                    }

                    cfg = Config.Instance.Get<FuncConfigConfig>("RuneDoubleInlayCnt");
                    doublePropRuneInlayDict = ConfigParse.GetDic<int, int>(cfg.Numerical1);
                }
                );

        }

        private static StringBuilder _textBuilder = new StringBuilder();
        static readonly string replaceValStr = "level";

        public int GetRuneMaxLevel(int _itemColor)
        {
            if (runeQualityMaxLevel != null && runeQualityMaxLevel.ContainsKey(_itemColor))
            {
                return runeQualityMaxLevel[_itemColor];
            }
            if (runeQualityMaxLevel != null)
            {
                return runeQualityMaxLevel.Values.Last();
            }
            return 0;
        }

        public int GetRuneMaxLevelByItem(int _itemId)
        {
            var config = Config.Instance.Get<ItemConfig>(_itemId);
            return config == null ? 0 : GetRuneMaxLevel(config.ItemColor);
        }

        public string GetRuneAttrStr(int id, int level)
        {
            _textBuilder.Length = 0;
            RuneConfig _tagRuneModel = Config.Instance.Get<RuneConfig>(id);
            int[] runeTypes = _tagRuneModel.AttrType;
            int i = 0;
            for (i = 0; i < runeTypes.Length; i++)
            {
                PlayerPropertyConfig playerPro = Config.Instance.Get<PlayerPropertyConfig>(runeTypes[i]);
                string _str = StringUtility.Contact(playerPro.Name, "  ", "+",
                    UIHelper.ReplacePercentage(GetRuneAttrVal(id, level, runeTypes[i]), playerPro.ISPercentage),
                    playerPro.ISPercentage == 1 ? "%" : string.Empty, i == runeTypes.Length - 1 ? string.Empty : "\n");
                _textBuilder.Append(_str);
            }
            return _textBuilder.ToString();
        }
        public Dictionary<int, Dictionary<int, float>> runeAttrResultDict = new Dictionary<int, Dictionary<int, float>>();
        public int GetRuneAttrVal(int id, int level, int type)
        {
            ItemConfig _tagChinModel = Config.Instance.Get<ItemConfig>(id);
            RuneConfig _tagRuneModel = Config.Instance.Get<RuneConfig>(id);
            float runeValue = 0;
            if (_tagChinModel != null && _tagRuneModel != null)
            {
                float params1 = 0;
                Dictionary<int, float> _dict = null;
                if (runeAttrResultDict.TryGetValue(type, out _dict))
                {
                    if (_dict.ContainsKey(level))
                    {
                        params1 = _dict[level];
                    }
                }
                else
                {
                    _dict = new Dictionary<int, float>();
                    runeAttrResultDict.Add(type, _dict);
                }
                if (params1 == 0)
                {
                    Equation.Instance.Clear();
                    Equation.Instance.AddKeyValue(replaceValStr, level);
                    FuncConfigConfig funcRune = FuncConfigConfig.GetRuneAttrFormula(type);
                    params1 = Equation.Instance.Eval<float>(funcRune.Numerical1);
                    _dict.Add(level, params1);
                }
                int[] runeTypes = _tagRuneModel.AttrType;
                float params2 = runeAttrDic[type][_tagChinModel.ItemColor];
                if (runeTypes.Length > 1)
                {
                    float coe = runeAttrAdditionDic[type];
                    coe = coe == 0 ? 1 : coe;
                    runeValue = params1 * params2 * coe;
                }
                else
                {
                    runeValue = params1 * params2;
                }
            }
            return Mathf.RoundToInt(runeValue);
        }
        private Dictionary<int, float> runeExpResultDict = new Dictionary<int, float>();
        public List<int> doublePropertyRunes { get; private set; }
        public int GetRuneNeedExp(int id, int level)
        {
            float _levelUpExp = 0;
            ItemConfig _tagChinModel = Config.Instance.Get<ItemConfig>(id);
            if (level < GetRuneMaxLevel(_tagChinModel.ItemColor))
            {
                float _result = 0;
                if (runeExpResultDict.ContainsKey(level + 1))
                {
                    _result = runeExpResultDict[level + 1];
                }
                else
                {
                    Equation.Instance.Clear();
                    Equation.Instance.AddKeyValue(replaceValStr, level + 1);
                    _result = Equation.Instance.Eval<float>(runeExpFormula);
                    runeExpResultDict.Add(level + 1, _result);
                }
                RuneConfig cfg = Config.Instance.Get<RuneConfig>(id);
                if (cfg.AttrType.Length > 1)
                {
                    _levelUpExp = _result * runeExpDic[_tagChinModel.ItemColor] * runeExpAddition;
                }
                else
                {
                    _levelUpExp = _result * runeExpDic[_tagChinModel.ItemColor];
                }
            }
            return Mathf.RoundToInt(_levelUpExp);
        }

        public float GetRuneSoulBreakExp(RuneData _rune)
        {
            ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
            var _treasureSoul = ModelCenter.Instance.GetModel<TreasureSoulModel>();
            var _upper = (float)_treasureSoul.GetTreasureSoulValue((int)TreasurePrivilege.RuneBreakExpAdd) / 10000;
            if (_itemCfg.Type == RUNE_CREAMTYPE)
            {
                return _itemCfg.EffectValueA1 * _upper;
            }
            else
            {
                return runeEliteAdditonDic[_itemCfg.ItemColor] * _upper;
            }
        }

        public float GetRuneBreakExp(RuneData _rune, bool _compose = false)
        {
            float _exp = 0;
            ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
            var _treasureSoul = ModelCenter.Instance.GetModel<TreasureSoulModel>();
            var _upper = (float)_treasureSoul.GetTreasureSoulValue((int)TreasurePrivilege.RuneBreakExpAdd) / 10000;
            if (_itemCfg.Type == RUNE_CREAMTYPE)
            {
                return _itemCfg.EffectValueA1 + _itemCfg.EffectValueA1 * _upper;
            }
            for (int i = 1; i <= _rune.lv; i++)
            {
                if (i == 1 && !_compose)
                {
                    _exp += runeEliteAdditonDic[_itemCfg.ItemColor] + runeEliteAdditonDic[_itemCfg.ItemColor] * _upper;
                }
                else
                {
                    _exp += GetRuneNeedExp(_rune.id, i - 1);
                }
            }
            return _exp;
        }

        public int GetRuneLevelByExp(int id, float _exp)
        {
            float _totalExp = 0;
            var maxlevel = runeQualityMaxLevel != null ? runeQualityMaxLevel.Values.Last() : 0;
            for (int i = 1; i < maxlevel; i++)
            {
                _totalExp += GetRuneNeedExp(id, i);
                if (_totalExp > _exp)
                {
                    return i;
                }
            }
            return maxlevel;
        }
        #endregion
        public const int RUNE_REDPOINT_INTERVAL = 100;
        private Redpoint runeRedpoint = new Redpoint(1, 108);
        private Redpoint m_RuneMosaicRedpoint = new Redpoint(108, 10801);
        public Redpoint runeLevelUpRedpoint = new Redpoint(1080120);
        public Redpoint runeReplaceRedpoint = new Redpoint(1080130);
        private List<Redpoint> runeHoleRedpoints = new List<Redpoint>();
        public Redpoint runeMosaicRedpoint { get { return m_RuneMosaicRedpoint; } }

        public Redpoint GetRedpoint(int _hole)
        {
            return runeHoleRedpoints[_hole];
        }

        //public void UpdateRedpoint()
        //{
        //    for (int i = 0; i < runeHoleRedpoints.Count; i++)
        //    {
        //        runeHoleRedpoints[i].state = RedPointState.None;
        //    }
        //    if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
        //    {
        //        return;
        //    }
        //    for (int i = 0; i < runeHoleRedpoints.Count; i++)
        //    {
        //        RuneData runeData = GetHoleRune(i);
        //        if (runeData != null)
        //        {
        //            if (RuneSplinters >= GetRuneNeedExp(runeData.id, runeData.lv)
        //                && runeData.lv < RuneMaxLevel)
        //            {
        //                runeHoleRedpoints[i].state = RedPointState.Simple;
        //            }
        //            else if (CanEquipBetterRune(i))
        //            {
        //                runeHoleRedpoints[i].state = RedPointState.Simple;
        //            }
        //        }
        //        else if (CanMosaicRune(i))
        //        {
        //            runeHoleRedpoints[i].state = RedPointState.Simple;
        //        }
        //    }
        //}
        /// <summary>
        /// 新版符印红点
        ///1.有可操作的时候仅按优先级显示1个红点
        ///2.优先级：可镶嵌>可替换>可升级
        ///3.同时有可镶嵌，可替换，可升级的符印孔时，默认只显示1个红点在镶嵌孔上
        ///4.镶嵌：同时存在2个或以上的孔可镶嵌时，优先显示在孔位低的孔上，当孔上镶嵌了符印后，红点在下一个可镶嵌孔位置上显示，直至没有新符印可镶嵌，才继续判断更好品质符印的替换逻辑
        ///5.替换：同上，有可替换更好品质的符印时，显示红点，同时多个时，从孔位低的开始显示，直到没有可替换的孔，再判断符印可升级的逻辑
        ///6.升级：仅一个符印满足升级条件时，红点在该孔上；同时存在多个符印孔可升级时，红点显示在符印等级最低的孔上；符印等级相同时，红点显示在消耗少的孔上；升级需要的精华相同时，按孔位低的优先显示红点
        ///7.右下角操作按钮：可镶嵌时镶嵌按钮红点显示；替换和升级同时满足时，仅替换按钮显示红点；无镶嵌和替换时，升级按钮红点显示
        ///8.选中有红点的符印孔时，符印孔上的红点隐藏不显示
        /// </summary>
        List<int> runelevelUpSorts = new List<int>();
        public void UpdateRedpoint()
        {
            for (int i = 0; i < runeHoleRedpoints.Count; i++)
            {
                runeHoleRedpoints[i].state = RedPointState.None;
            }
            runeLevelUpRedpoint.state = RedPointState.None;
            runeReplaceRedpoint.state = RedPointState.None;
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
            {
                return;
            }
            var _holeCount = runeHoleRedpoints.Count;
            for (int i = 0; i < _holeCount; i++)
            {
                var _data = GetHoleRune(i);
                if (_data == null && CanMosaicRune(i))
                {
                    runeHoleRedpoints[i].state = RedPointState.Simple;
                    if (sltRuneHole == i)
                    {
                        runeReplaceRedpoint.state = RedPointState.Simple;
                    }
                    return;
                }
            }
            for (int i = 0; i < _holeCount; i++)
            {
                var _data = GetHoleRune(i);
                if (_data != null && CanEquipBetterRune(i))
                {
                    runeHoleRedpoints[i].state = RedPointState.Simple;
                    if (sltRuneHole == i)
                    {
                        runeReplaceRedpoint.state = RedPointState.Simple;
                    }
                    return;
                }
            }
            runelevelUpSorts.Clear();
            for (int i = 0; i < _holeCount; i++)
            {
                var _data = GetHoleRune(i);
                if (_data != null && RuneSplinters >= GetRuneNeedExp(_data.id, _data.lv)
                       && _data.lv < GetRuneMaxLevelByItem(_data.id))
                {
                    runelevelUpSorts.Add(i);
                }
            }
            if (runelevelUpSorts.Count > 0)
            {
                runelevelUpSorts.Sort(CompareLevelUp);
                runeHoleRedpoints[runelevelUpSorts[0]].state = RedPointState.Simple;
                if (sltRuneHole == runelevelUpSorts[0])
                {
                    runeLevelUpRedpoint.state = RedPointState.Simple;
                }
            }
        }

        int CompareLevelUp(int x, int y)
        {
            var _data_x = GetHoleRune(x);
            var _data_y = GetHoleRune(y);
            if (_data_x.lv != _data_y.lv)
            {
                return _data_x.lv.CompareTo(_data_y.lv);
            }
            var _cost_x = GetRuneNeedExp(_data_x.id, _data_x.lv);
            var _cost_y = GetRuneNeedExp(_data_y.id, _data_y.lv);
            if (_cost_x != _cost_y)
            {
                return _cost_x.CompareTo(_cost_y);
            }
            return x.CompareTo(y);
        }

        private Redpoint m_ResolveRedpoint = new Redpoint(108, 10802);
        public void UpdateBreakRedpoint()
        {
            m_ResolveRedpoint.state = RedPointState.None;
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
            {
                return;
            }

            m_ResolveRedpoint.state = runePackData.Count >= runePackMaxNum && !IsEmptyHole() ? RedPointState.Simple : RedPointState.None;
        }

        public bool CanLevelUpRune(int _hole)
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
            {
                return false;
            }
            RuneData runeData = GetHoleRune(_hole);
            if (runeData != null)
            {
                if (RuneSplinters > GetRuneNeedExp(runeData.id, runeData.lv)
                    && runeData.lv < GetRuneMaxLevelByItem(runeData.id))
                {
                    return true;
                }
            }
            return false;
        }

        public bool CanLevelUpRune(out int _hole)
        {
            _hole = 0;
            for (int i = 0; i < 8; i++)
            {
                if (CanLevelUpRune(i))
                {
                    _hole = i;
                    return true;
                }
            }
            return false;
        }

        public bool CanMosaicRune(int _hole)
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
            {
                return false;
            }
            RuneData runeData = GetHoleRune(_hole);
            if (runeData == null && IsRuneHoleOpen(_hole))
            {
                foreach (var rune in runePackData.Values)
                {
                    ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(rune.id);
                    if (_itemCfg.Type == RUNE_CREAMTYPE)
                    {
                        continue;
                    }
                    if (!IsSameInHoleRune(_itemCfg.ID, _hole))
                    {
                        if (runeComposeModel.m_RuneBothPropertys.Contains(rune.id)
                        && GetDoublePropLimitCount() <= GetCurrentDoublePropCount())
                        {
                            return false;
                        }
                        return true;
                    }
                }
            }
            return false;
        }

        public int GetDoublePropLimitCount()
        {
            var _count = 0;
            foreach (var _key in doublePropRuneInlayDict.Keys)
            {
                if (RuneTowerOpenLV >= _key)
                {
                    _count = doublePropRuneInlayDict[_key];
                }
                else
                {
                    break;
                }
            }
            return _count;
        }

        public int GetCurrentDoublePropCount()
        {
            var _count = 0;
            foreach (var _rune in runeHoleData.Values)
            {
                if (runeComposeModel.m_RuneBothPropertys.Contains(_rune.id))
                {
                    _count += 1;
                }
            }
            return _count;
        }

        public int SurplusRunePackCnt {
            get {
                return runePackMaxNum - runePackData.Count;
            }
        }
        private Dictionary<int, RuneData> runePackData = new Dictionary<int, RuneData>();
        private Dictionary<int, RuneData> runeHoleData = new Dictionary<int, RuneData>();
        private uint runeTowerOpenLv = 0;
        public uint RuneTowerOpenLV {
            get { return runeTowerOpenLv; }
        }
        public event Action OnRefreshRuneHole;
        public event Action OnRefreshRunePack;
        public event Action OnRefreshRuneExp;
        public event Action OnRefreshRuneChip;
        public event Action OnRefreshRuneTowerLv;
        private uint holeState = 0;
        public int sltRuneHole = -1;
        private int runeSplinters = 0;
        public int RuneSplinters {
            get {
                return runeSplinters;
            }
        }
        private int runeChip = 0;
        public int RuneChip {
            get {
                return runeChip;
            }
        }
        public void SetRuneChip(int val)
        {
            runeChip = val;
            if (OnRefreshRuneChip != null)
                OnRefreshRuneChip();
        }
        public void SetRuneSplinters(int val)
        {
            runeSplinters = val;
            if (OnRefreshRuneExp != null)
            {
                OnRefreshRuneExp();
            }
            UpdateRedpoint();
        }
        public void OnRunePackRefresh(HA204_tagMCVPackRefresh vNetData)
        {
            for (ushort i = 0; i < vNetData.Count; i++)
            {
                HA204_tagMCVPackRefresh.tagMCVPackItem item = vNetData.VPacklItemList[i];
                string runeData = item.ItemData.ToString();
                int dlt = 10 - runeData.Length;
                _textBuilder.Length = 0;
                _textBuilder.Append('0', dlt);
                runeData = runeData.Insert(0, _textBuilder.ToString());
                int id = int.Parse(runeData.Substring(5, 5));
                int lv = int.Parse(runeData.Substring(2, 3)) + 1;
                int packType = vNetData.PackType;
                int index = item.ItemPlace;
                RuneData data = null;
                runePackData.TryGetValue(index, out data);
                if (data == null)
                {
                    data = new RuneData(index, id, lv, packType, 0);
                    runePackData.Add(index, data);
                }
                else
                {
                    data.SetRuneData(index, id, lv, packType, 0);
                }
            }
            if (OnRefreshRunePack != null)
            {
                OnRefreshRunePack();
            }
            UpdateRedpoint();
            UpdateBreakRedpoint();
        }
        public void OnRunePackClear(HA205_tagMCVPackClear vNetData)
        {
            for (ushort i = 0; i < vNetData.Count; i++)
            {
                int index = vNetData.ItemPlaceList[i];
                if (runePackData.ContainsKey(index))
                {
                    runePackData.Remove(index);
                }
            }
            if (OnRefreshRunePack != null)
            {
                OnRefreshRunePack();
            }
            UpdateRedpoint();
            UpdateBreakRedpoint();
        }
        public void OnRuneHoleRefresh(HA31F_tagMCRuneInfo vNetData)
        {
            holeState = vNetData.RuneHoleOpenState;
            for (byte i = 0; i < vNetData.Count; i++)
            {
                RuneData data = null;
                runeHoleData.TryGetValue(i, out data);
                if (IsRuneHoleOpen(i) && vNetData.RuneDataList[i] != 0)
                {
                    _textBuilder.Length = 0;
                    string runeData = vNetData.RuneDataList[i].ToString();
                    int dlt = 10 - runeData.Length;
                    _textBuilder.Length = 0;
                    _textBuilder.Append('0', dlt);
                    runeData = runeData.Insert(0, _textBuilder.ToString());
                    int id = int.Parse(runeData.Substring(5, 5));
                    if (id == 0)
                    {
                        continue;
                    }
                    int lv = int.Parse(runeData.Substring(2, 3)) + 1;
                    int placetype = 1;
                    if (data == null)
                    {
                        data = new RuneData(i, id, lv, (int)PackType.rptInterimPack, placetype);
                        runeHoleData.Add(i, data);
                    }
                    else
                    {
                        data.SetRuneData(i, id, lv, (int)PackType.rptInterimPack, placetype);
                    }
                }
                else
                {
                    if (data != null)
                    {
                        data = null;
                        runeHoleData.Remove(i);
                    }
                }
            }
            if (OnRefreshRuneHole != null)
            {
                OnRefreshRuneHole();
            }
            UpdateRedpoint();
            UpdateBreakRedpoint();
        }
        public bool IsRuneHoleOpen(int hole)
        {
            if (holeState < 1) return false;
            int k = 1 << hole;
            if ((holeState & k) == k)
            {
                return true;
            }
            return false;
        }
        public RuneData GetHoleRune(int hole)
        {
            RuneData data = null;
            runeHoleData.TryGetValue(hole, out data);
            return data;
        }
        public Dictionary<int, RuneData> GetAllRuneData()
        {
            return runeHoleData;
        }
        public int GetHoleRuneCnt()
        {
            return runeHoleData.Count;
        }

        public bool IsEmptyHole()
        {
            for (int i = 0; i < 8; i++)
            {
                if (IsRuneHoleOpen(i) && !runeHoleData.ContainsKey(i))
                {
                    return true;
                }
            }
            return false;
        }

        public Dictionary<int, RuneData> GetPackRune()
        {
            return runePackData;
        }

        public int RuneCount {
            get {
                var _count = 0;
                foreach (var _rune in runePackData.Values)
                {
                    if (!_rune.IsRuneCream)
                    {
                        _count++;
                    }
                }
                return _count;
            }
        }

        public int GetRuneCountById(int _itemId)
        {
            var count = 0;
            foreach (var _rune in runePackData.Values)
            {
                if (_rune.id == _itemId)
                {
                    count += 1;
                }
            }
            return count;
        }

        /// <summary>
        ///得到所有的解锁符印Id
        /// </summary>
        /// <returns></returns>
        public Dictionary<int, List<int>> GetAllUnlockRuneIdlist()
        {
            List<RuneConfig> runes = Config.Instance.GetAllValues<RuneConfig>();
            if (runes == null) return null;

            Dictionary<int, List<int>> unlockDict = new Dictionary<int, List<int>>();
            for (int i = 0; i < runes.Count; i++)
            {
                int offset = (int)RuneTowerOpenLV - runes[i].TowerID;
                if (offset >= 0 && runes[i].AttrType.Length < 2)
                {
                    if (!unlockDict.ContainsKey(runes[i].TowerID))
                    {
                        List<int> unlocklist = new List<int>();
                        unlocklist.Add(runes[i].ID);
                        unlockDict.Add(runes[i].TowerID, unlocklist);
                    }
                    else
                    {
                        unlockDict[runes[i].TowerID].Add(runes[i].ID);
                    }
                }
            }
            return unlockDict;
        }

        public bool CanEquipRune(int _color, out int _hole)
        {
            _hole = 0;
            foreach (var _rune in runePackData.Values)
            {
                var _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
                if (_itemCfg.Type == RUNE_CREAMTYPE)
                {
                    continue;
                }
                else
                {
                    if (_itemCfg.ItemColor >= _color)
                    {
                        if (CanEquipHoleRune(_itemCfg.ID, _itemCfg.ItemColor, out _hole))
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        public bool CanEquipBetterRune(int _hole)
        {
            var _runeHole = GetHoleRune(_hole);
            if (_runeHole == null)
            {
                return false;
            }
            var _runeCfg = Config.Instance.Get<RuneConfig>(_runeHole.id);
            var _itemCfg = Config.Instance.Get<ItemConfig>(_runeHole.id);
            var _propertyType = _runeCfg.AttrType[0];
            if (_runeCfg == null)
            {
                return false;
            }
            foreach (var _rune in runePackData.Values)
            {
                if (_rune.IsRuneCream)
                {
                    continue;
                }
                var _runeBetterCfg = Config.Instance.Get<RuneConfig>(_rune.id);
                if (_runeBetterCfg == null)
                {
                    continue;
                }
                bool _same = false;
                for (int i = 0; i < _runeBetterCfg.AttrType.Length; i++)
                {
                    if (_runeBetterCfg.AttrType[i] == _propertyType)
                    {
                        _same = true;
                        break;
                    }
                }
                if (!_same)
                {
                    continue;
                }
                var _itemBetterCfg = Config.Instance.Get<ItemConfig>(_rune.id);
                if (_itemBetterCfg.ItemColor > _itemCfg.ItemColor
                    || (_itemBetterCfg.ItemColor == _itemCfg.ItemColor && _runeCfg.AttrType.Length == 1 && _runeBetterCfg.AttrType.Length == 2))
                {
                    if (runeComposeModel.m_RuneBothPropertys.Contains(_rune.id)
                        && GetDoublePropLimitCount() <= GetCurrentDoublePropCount()
                        && !runeComposeModel.m_RuneBothPropertys.Contains(_runeHole.id))
                    {
                        return false;
                    }
                    return true;
                }
            }
            return false;
        }

        public bool IsBetterRune(RuneData _data, int _hole)
        {
            var _runeHole = GetHoleRune(_hole);
            if (_runeHole == null)
            {
                return false;
            }
            var _runeCfg = Config.Instance.Get<RuneConfig>(_runeHole.id);
            var _itemCfg = Config.Instance.Get<ItemConfig>(_runeHole.id);
            var _propertyType = _runeCfg.AttrType[0];
            if (_runeCfg == null)
            {
                return false;
            }
            if (_data.IsRuneCream)
            {
                return false;
            }
            var _runeBetterCfg = Config.Instance.Get<RuneConfig>(_data.id);
            bool _same = false;
            for (int i = 0; i < _runeBetterCfg.AttrType.Length; i++)
            {
                if (_runeBetterCfg.AttrType[i] == _propertyType)
                {
                    _same = true;
                    break;
                }
            }
            if (!_same)
            {
                return false;
            }
            var _itemBetterCfg = Config.Instance.Get<ItemConfig>(_data.id);
            if (_itemBetterCfg.ItemColor > _itemCfg.ItemColor
                || (_itemBetterCfg.ItemColor == _itemCfg.ItemColor && _runeCfg.AttrType.Length == 1 && _runeBetterCfg.AttrType.Length == 2))
            {
                if (runeComposeModel.m_RuneBothPropertys.Contains(_data.id)
                    && GetDoublePropLimitCount() <= GetCurrentDoublePropCount()
                    && !runeComposeModel.m_RuneBothPropertys.Contains(_runeHole.id))
                {
                    return false;
                }
                return true;
            }
            return false;
        }

        public bool CanEquipHoleRune(int id, int _color, out int _hole)
        {
            _hole = 0;
            for (int i = 0; i < 8; i++)
            {
                if (!IsRuneHoleOpen(i))
                {
                    return false;
                }
                var _rune = GetHoleRune(i);
                if (runeComposeModel.m_RuneBothPropertys.Contains(id))
                {
                    if (GetDoublePropLimitCount() <= GetCurrentDoublePropCount())
                    {
                        return false;
                    }
                }
                if (_rune == null)
                {
                    if (IsSameInHoleRune(id, i))
                    {
                        continue;
                    }
                    _hole = i;
                    return true;
                }
                else
                {
                    var _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
                    if (_itemCfg.ItemColor < _color && !IsSameInHoleRune(id, i))
                    {
                        _hole = i;
                        return true;
                    }
                }
            }
            return false;
        }

        public RuneData GetPackRune(int index)
        {
            RuneData data = null;
            runePackData.TryGetValue(index, out data);
            return data;
        }
        public List<RuneData> runePackList { get; set; }
        public void OnRuneTowerRefresh(HA3BA_tagMCTrialTowerInfo vNetData)
        {
            if (runeTowerOpenLv != vNetData.PassLV)
            {
                runeTowerOpenLv = vNetData.PassLV;
                if (OnRefreshRuneTowerLv != null)
                {
                    OnRefreshRuneTowerLv();
                }
            }
            UpdateRedpoint();
        }

        public bool IsSameInHoleRune(int id, int hole)
        {
            var _runeConfig = Config.Instance.Get<RuneConfig>(id);
            for (int i = 0; i < _runeConfig.AttrType.Length; i++)
            {
                if (IsSameRune(_runeConfig.AttrType[i], hole))
                {
                    return true;
                }
            }
            return false;
        }

        public bool IsSameRune(int type, int hole)
        {
            foreach (int key in runeHoleData.Keys)
            {
                if (key == hole)
                {
                    continue;
                }
                RuneConfig _runeCfg = Config.Instance.Get<RuneConfig>(runeHoleData[key].id);
                for (int i = 0; i < _runeCfg.AttrType.Length; i++)
                {
                    if (type == _runeCfg.AttrType[i])
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public int GetOpenTowerCnt()
        {
            int Cnt = 0;
            for (int i = 0; i < 8; i++)
            {
                if (IsRuneHoleOpen(i))
                {
                    Cnt++;
                }
                else break;
            }
            return Cnt;
        }

        public void ClearRuneData()
        {
            runePackData.Clear();
            runeHoleData.Clear();
        }

        public event Action JumpToComposeEvent;
        public void JumpToRuneCompose()
        {
            if (WindowCenter.Instance.CheckOpen<RunePanel>())
            {
                if (JumpToComposeEvent != null)
                {
                    JumpToComposeEvent();
                }
            }
        }

        #region 符印合成
        public int GetMaxLevelRuneCnt(int _id, out RuneData _runeData)
        {
            int _Cnt = 0;
            _runeData = null;
            foreach (var _rune in runePackData.Values)
            {
                if (_rune.id == _id)
                {
                    if (_runeData == null || _rune.lv >= _runeData.lv)
                    {
                        _runeData = _rune;
                    }
                    _Cnt++;
                }
            }
            foreach (var _rune in runeHoleData.Values)
            {
                if (_rune.id == _id)
                {
                    if (_runeData == null || _rune.lv >= _runeData.lv)
                    {
                        _runeData = _rune;
                    }
                    _Cnt++;
                    break;
                }
            }
            return _Cnt;
        }
        #endregion
        #region 符印分解
        public List<RuneData> runeBreakList { get; set; }
        private Dictionary<int, bool> m_RuneBreakEnableDict = new Dictionary<int, bool>();
        public Dictionary<int, bool> runeBreakEnableDict {
            get {
                return m_RuneBreakEnableDict;
            }
        }
        private List<Transform> m_RuneBreakRects = new List<Transform>();
        public List<Transform> runeBreakRects {
            get {
                return m_RuneBreakRects;
            }
        }
        public event Action OnRefreshBreakRune;
        public void UpdateBreakRune()
        {
            if (OnRefreshBreakRune != null)
            {
                OnRefreshBreakRune();
            }
        }
        #endregion
    }
    public class RuneData
    {
        /// <summary>
        /// 符印对应位置索引，若在孔上则对应孔id,若在背包，则对应背包位置索引
        /// </summary>
        private int _index = -1;
        public int index {
            get { return _index; }
        }
        /// <summary>
        /// 符印对应物品id
        /// </summary>
        private int _id = -1;
        public int id { get { return _id; } }
        /// <summary>
        /// 符印对应强化等级
        /// </summary>
        private int _lv = 0;
        public int lv {
            get { return _lv; }
        }
        /// <summary>
        /// 预留字段
        /// </summary>
        private int _locked = -1;
        public int locked { get { return _locked; } }
        /// <summary>
        /// 背包类型，符印背包255
        /// </summary>
        private int _packtype = -1;
        public int packtype { get { return _packtype; } }
        /// <summary>
        /// 符印放置位置，默认为符印背包
        /// </summary>
        private int _placetype = 0;
        public int placetype { get { return _placetype; } }

        public bool IsRuneCream { get; private set; }

        public RuneData(int index, int id, int lv, int packtype, int placetype = 0)
        {
            this._index = index;
            this._id = id;
            this._lv = lv;
            this._packtype = packtype;
            this._placetype = placetype;
            var _itemCfg = Config.Instance.Get<ItemConfig>(id);
            if (_itemCfg != null)
            {
                IsRuneCream = _itemCfg.Type == RuneModel.RUNE_CREAMTYPE;
            }
        }

        public void SetRuneData(int index, int id, int lv, int packtype, int placetype = 0)
        {
            this._index = index;
            this._id = id;
            this._lv = lv;
            this._packtype = packtype;
            this._placetype = placetype;
            var _itemCfg = Config.Instance.Get<ItemConfig>(id);
            if (_itemCfg != null)
            {
                IsRuneCream = _itemCfg.Type == RuneModel.RUNE_CREAMTYPE;
            }
        }
    }
}