using System;
using System.Collections;
using System.Collections.Generic;

using UnityEngine;
namespace vnxbqy.UI
{
    
	public class RuneComposeModel : Model, IPlayerLoginOk
    {
        RuneModel runeModel { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
        VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }


        public override void Init()
        {
            presentSelectRuneQuality = 0;
            presentSelectComposeRune = -1;
            ParseConfig();

            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
            runeModel.onRuneTowerRefresh += OnRefreshRune;
            virtualPackModel.virtualPackRefresh += VirtualPackRefresh;
            runeModel.onRuneHoleRefresh += 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()
        {
            runeModel.onRuneTowerRefresh -= OnRefreshRune;
            runeModel.onRuneHoleRefresh -= OnRefreshRune;
            virtualPackModel.virtualPackRefresh -= VirtualPackRefresh;
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
        }

        #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 = RuneComposeConfig.GetValues();
            foreach (var _cfg in allConfigs)
            {
                ItemConfig _itemCfg = ItemConfig.Get(_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 = RuneConfig.GetValues();
            foreach (var _cfg in configs)
            {
                if (_cfg.AttrType.Length > 1)
                {
                    m_RuneBothPropertys.Add(_cfg.ID);
                }
            }
        }
        #endregion

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

        private void VirtualPackRefresh(PackType packType)
        {
            if (packType == PackType.RunePack)
            {
                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 = RuneConfig.Get(_list[i].TagItemID);
                    if (runeModel.passRuneTowerFloor < _runeConfig.TowerID)
                    {
                        continue;
                    }
                    var _runeComposeConfig = RuneComposeConfig.Get(_list[i].TagItemID);
                    RuneItem item;
                    var count1 = runeModel.TryGetComposeRuneCount(_runeComposeConfig.NeedItem[0], out item);
                    var count2 = runeModel.TryGetComposeRuneCount(_runeComposeConfig.NeedItem[1], out item);
                    var magicEssence = PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.MagicEssence);
                    if (count1 > 0 && count2 > 0 && magicEssence >= (ulong)_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
    }
}