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

namespace Snxxz.UI
{
    public class MagicianModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        PlayerPackModel _playerPack;
        PlayerPackModel playerPack
        {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
        }

        bool serverInited = false;

        public override void Init()
        {
            ParseConfig();
            playerPack.RefreshItemCountAct += RefreshPackItem;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
        }

        private void OnFuncStateChangeEvent(int func)
        {
            if (func == (int)FuncOpenEnum.Magician)
            {
                UpdateRedPoint();
            }
        }

        private void RefreshPackItem(PackType packType, int index, int id)
        {
            if (packType != PackType.rptItem)
            {
                return;
            }
            UpdateRedPoint();
        }

        public override void UnInit()
        {
            playerPack.RefreshItemCountAct -= RefreshPackItem;
        }

        public void OnBeforePlayerDataInitialize()
        {
            serverInited = false;
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
        }

        private Dictionary<int, int[]> godWeaponLvUpItem = new Dictionary<int, int[]>();
        public int[] GetLvUpItemByType(int type)
        {
            return godWeaponLvUpItem[type];
        }
        public List<int> magicianTypes { get; private set; }
        public Dictionary<int, string> godWeaponIcons { get; private set; }
        public Dictionary<int, Dictionary<int, int>> godWeaponSkillDict = new Dictionary<int, Dictionary<int, int>>();
        public int selectType = 0;
        public int selectItemIndex = 0;
        public int gotoType = 0;
        void ParseConfig()
        {
            magicianTypes = GodWeaponConfig.GetGodWeaponType();
            for (int i = 0; i < magicianTypes.Count; i++)
            {
                FuncConfigConfig _funcCfg = Config.Instance.Get<FuncConfigConfig>(string.Format("GodWeapon{0}", magicianTypes[i]));
                int[] itemarray = ConfigParse.GetMultipleStr<int>(_funcCfg.Numerical1);
                godWeaponLvUpItem.Add(magicianTypes[i], itemarray);
            }
            godWeaponIcons = new Dictionary<int, string>();
            var _cfg = Config.Instance.Get<FuncConfigConfig>("GodModel");
            var _godWeaponJson = LitJson.JsonMapper.ToObject(_cfg.Numerical2);
            foreach (var _key in _godWeaponJson.Keys)
            {
                var _godWeaponType = int.Parse(_key);
                if (!godWeaponIcons.ContainsKey(_godWeaponType))
                {
                    godWeaponIcons.Add(_godWeaponType, _godWeaponJson[_key].ToString());
                }
            }

            var configs = Config.Instance.GetAllValues<GodWeaponConfig>();
            for (int i = 0; i < configs.Count; i++)
            {
                if (configs[i].SkillID != 0)
                {
                    Dictionary<int, int> _dict = null;
                    if (!godWeaponSkillDict.TryGetValue(configs[i].Type, out _dict))
                    {
                        _dict = new Dictionary<int, int>();
                        godWeaponSkillDict.Add(configs[i].Type, _dict);
                    }
                    _dict.Add(configs[i].Lv, configs[i].SkillID);
                }
            }
        }
        #region 红点
        public const int MAGICAIN_REDPOINT = 10104;
        public const int MAGICAIN_INTERVAL = 100;
        public Dictionary<int, Redpoint> redpointDict = new Dictionary<int, Redpoint>();
        Redpoint magicianPoint = new Redpoint(101, MAGICAIN_REDPOINT);
        public Redpoint magicianRedpoint { get { return magicianPoint; } }
        public void UpdateRedPoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Magician))
            {
                return;
            }
            foreach (var key in redpointDict.Keys)
            {
                int[] items = GetLvUpItemByType((int)key);
                redpointDict[key].state = RedPointState.None;
                for (int i = 0; i < items.Length; i++)
                {
                    if (playerPack.GetItemCountByID(PackType.rptItem, items[i]) > 0)
                    {
                        MagicianData data = null;
                        if (magicianDict.TryGetValue(key, out data))
                        {
                            var _godWeaponCfg = Config.Instance.Get<GodWeaponConfig>(data.level + 1);
                            if (_godWeaponCfg == null)
                            {
                                redpointDict[key].state = RedPointState.None;
                                break;
                            }
                        }
                        redpointDict[key].state = RedPointState.Simple;
                        break;
                    }
                }
            }
        }
        public bool CanTemperMagician()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Magician))
            {
                return false;
            }
            foreach (var key in redpointDict.Keys)
            {
                if (redpointDict[key].state == RedPointState.Simple)
                {
                    return true;
                }
            }
            return false;
        }
        public bool GetRedpointLightByType(int _type)
        {
            if (redpointDict.ContainsKey(_type))
            {
                return redpointDict[_type].state == RedPointState.Simple;
            }
            return false;
        }
        #endregion
        public void TemperMagician(int type)
        {
            MagicianData data = GetMagicianData(type);
            if (data != null)
            {
                if (IsGodWeaponMaxLevel(type))
                {
                    MessageWin.Inst.ShowFixedTip(Language.Get("L1054"));
                    return;
                }
            }
            int[] items = GetLvUpItemByType(type);
            if (selectItemIndex >= items.Length)
            {
                return;
            }
            ItemConfig itemCfg = Config.Instance.Get<ItemConfig>(items[selectItemIndex]);
            var _itemCnt = playerPack.GetItemCountByID(PackType.rptItem, itemCfg.ID);
            if (_itemCnt < 1)
            {
                ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(itemCfg.ID);
                if (!IsGodWeaponTemperItem(3, itemCfg.ID) && !NewBieCenter.Instance.completeGuidesBuf.Contains(85))
                {
                    NewBieCenter.Instance.StartNewBieGuide(85);
                }
                return;
            }
            CA555_tagCMGodWeaponPlus _pak = new CA555_tagCMGodWeaponPlus();
            _pak.WeaponType = (uint)type;
            _pak.ItemID = (uint)items[selectItemIndex];
            GameNetSystem.Instance.SendInfo(_pak);
        }
        public event Action OnRefresh;
        private Dictionary<int, MagicianData> magicianDict = new Dictionary<int, MagicianData>();
        public void OnMagicianChange(HA31D_tagMCGodWeaponLVList vNetData)
        {
            for (byte i = 0; i < vNetData.WeaponNum; i++)
            {
                HA31D_tagMCGodWeaponLVList.tagMCGodWeaponLVInfo _sData = vNetData.WeaponInfoList[i];
                MagicianData data = null;
                magicianDict.TryGetValue(_sData.WeaponType, out data);
                if (data == null)
                {
                    data = new MagicianData();
                    magicianDict.Add(_sData.WeaponType, data);
                }

                CheckActivate((int)data.type, data.level, _sData.WeaponLV);

                data.exp = _sData.WeaponExp;
                data.level = _sData.WeaponLV;
                data.type = _sData.WeaponType;
                if (!redpointDict.ContainsKey((int)data.type))
                {
                    Redpoint redpoint = new Redpoint(MAGICAIN_REDPOINT, MAGICAIN_REDPOINT * MAGICAIN_INTERVAL + (int)data.type);
                    redpointDict.Add((int)data.type, redpoint);
                    redpoint.state = RedPointState.None;
                }
            }
            UpdateRedPoint();
            if (OnRefresh != null)
            {
                OnRefresh();
            }
        }

        void CheckActivate(int _type, int _beforeLv, int _nowLv)
        {
            var _skillId = 0;
            if (serverInited && _beforeLv != _nowLv
                && (_beforeLv == 0 || TryGetUnlockSkill(_type, _beforeLv, _nowLv, out _skillId)))
            {
                if (WindowCenter.Instance.CheckOpen<MagicianWin>()
                    && !NewBieCenter.Instance.inGuiding)
                {
                    ActivateShow.GodWeaponActivate(_type, _nowLv, _beforeLv);
                }
            }
        }

        public bool TryGetUnlockSkill(int _type, int _beforeLv, int _nowLv,out int _skillid)
        {
            _skillid = 0;
            if (godWeaponSkillDict.ContainsKey(_type))
            {
                var _dict = godWeaponSkillDict[_type];
                foreach (var _lv in _dict.Keys)
                {
                    if (_beforeLv < _lv && _lv <= _nowLv)
                    {
                        _skillid = _dict[_lv];
                        return true;
                    }
                }
            }
            return false;
        }


        public MagicianData GetMagicianData(int type)
        {
            MagicianData data = null;
            magicianDict.TryGetValue(type, out data);
            return data;
        }

        public bool IsGodWeaponMaxLevel(int _type)
        {
            var _data = GetMagicianData(_type);
            var config = Config.Instance.Get<GodWeaponConfig>(_data.level + 1);
            return config == null;
        }

        public bool IsGodWeaponTemperItem(int _type,int _itemId)
        {
            var items = GetLvUpItemByType(_type);
            if (items == null)
            {
                return false;
            }
            for (int i = 0; i < items.Length; i++)
            {
                if (items[i] == _itemId)
                {
                    return true;
                }
            }
            return false;
        }

        public bool IsGodWeaponMaxLevelByItem(int _itemId)
        {
            foreach (var _key in godWeaponLvUpItem.Keys)
            {
                for (int i = 0; i < godWeaponLvUpItem[_key].Length; i++)
                {
                    if (godWeaponLvUpItem[_key][i] == _itemId)
                    {
                        return IsGodWeaponMaxLevel(_key);
                    }
                }
            }
            return false;
        }

    }

    public class MagicianData
    {
        public uint type;
        public int level;
        public uint exp;
    }
}