using System;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using UnityEngine;
namespace Snxxz.UI
{
    public class RuneComposeModel : Model, IPlayerLoginOk
    {
        public override void Init()
        {
            presentSelectRuneQuality = 0;
            presentSelectComposeRune = -1;
            ParseConfig();

            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            runeModel.OnRefreshRuneTowerLv += OnRefreshRune;
            runeModel.OnRefreshRunePack += OnRefreshRune;
            runeModel.OnRefreshRuneHole += OnRefreshRune;

            foreach (var _key in runeComposeDict.Keys)
            {
                var _redpointTypeKey = 10803 * 100 + _key;
                m_RuneComposeTypeRedpoints.Add(_key, new Redpoint(10803, _redpointTypeKey));
                var _list = runeComposeDict[_key];
                List<Redpoint> redpoints = new List<Redpoint>();
                m_RuneComposeRedpoints.Add(_key, redpoints);
                for (int i = 0; i < _list.Count; i++)
                {
                    redpoints.Add(new Redpoint(_redpointTypeKey, _redpointTypeKey * 100 + i));
                }
            }
        }

        public override void UnInit()
        {

        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
        }

        RuneModel runeModel { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }

        #region 配置
        public Dictionary<int, List<RuneComposeConfig>> runeComposeDict = new Dictionary<int, List<RuneComposeConfig>>();
        public RuneComposeConfig GetRuneCompose(int _itemColor, int _index)
        {
            if (runeComposeDict.ContainsKey(_itemColor))
            {
                if (_index >= 0 && _index < runeComposeDict[_itemColor].Count)
                {
                    return runeComposeDict[_itemColor][_index];
                }
            }
            return null;
        }
        public List<int> m_RuneBothPropertys = new List<int>();
        void ParseConfig()
        {
            var allConfigs = ConfigManager.Instance.GetAllValues<RuneComposeConfig>();
            foreach (var _cfg in allConfigs)
            {
                ItemConfig _itemCfg = ConfigManager.Instance.GetTemplate<ItemConfig>(_cfg.TagItemID);
                if (_itemCfg != null)
                {
                    List<RuneComposeConfig> _list = null;
                    if (runeComposeDict.TryGetValue(_itemCfg.ItemColor, out _list) == false)
                    {
                        _list = new List<RuneComposeConfig>();
                        runeComposeDict.Add(_itemCfg.ItemColor, _list);
                    }
                    _list.Add(_cfg);
                }
            }

            var configs = ConfigManager.Instance.GetAllValues<RuneConfig>();
            foreach (var _cfg in configs)
            {
                if (_cfg.AttrType.Length > 1)
                {
                    m_RuneBothPropertys.Add(_cfg.ID);
                }
            }
        }
        #endregion

        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)
        {
            if (refreshType == PlayerDataRefresh.MagicEssence)
            {
                UpdateRedpoint();
            }
        }

        private void OnRefreshRune()
        {
            UpdateRedpoint();
        }

        public int presentSelectRuneQuality { get; set; }
        public int presentSelectComposeRune { get; set; }

        #region 红点
        private Redpoint m_RuneComposeRedpoint = new Redpoint(108, 10803);
        private Dictionary<int, Redpoint> m_RuneComposeTypeRedpoints = new Dictionary<int, Redpoint>();
        private Dictionary<int, List<Redpoint>> m_RuneComposeRedpoints = new Dictionary<int, List<Redpoint>>();
        void UpdateRedpoint()
        {
            foreach (var _key in m_RuneComposeRedpoints.Keys)
            {
                var _list = m_RuneComposeRedpoints[_key];
                for (int i = 0; i < _list.Count; i++)
                {
                    _list[i].state = RedPointState.None;
                }
            }
            foreach (var _key in runeComposeDict.Keys)
            {
                var _list = runeComposeDict[_key];
                for (int i = 0; i < _list.Count; i++)
                {
                    var _runeConfig = ConfigManager.Instance.GetTemplate<RuneConfig>(_list[i].TagItemID);
                    if (runeModel.RuneTowerOpenLV < _runeConfig.TowerID)
                    {
                        continue;
                    }
                    var _runeComposeConfig = ConfigManager.Instance.GetTemplate<RuneComposeConfig>(_list[i].TagItemID);
                    RuneData _data;
                    var count1 = runeModel.GetMaxLevelRuneCnt(_runeComposeConfig.NeedItem[0], out _data);
                    var count2 = runeModel.GetMaxLevelRuneCnt(_runeComposeConfig.NeedItem[1], out _data);
                    var magicEssence = PlayerDatas.Instance.extersion.magicEssence;
                    if (count1 > 0 && count2 > 0 && magicEssence >= _runeComposeConfig.NeedMJ)
                    {
                        m_RuneComposeRedpoints[_key][i].state = RedPointState.Simple;
                    }
                }
            }
        }

        public Redpoint GetRedpoint(int _quality)
        {
            if (m_RuneComposeTypeRedpoints.ContainsKey(_quality))
            {
                return m_RuneComposeTypeRedpoints[_quality];
            }
            return null;
        }
        #endregion
    }
}