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

using UnityEngine;
namespace vnxbqy.UI
{
    
    
    public class JadeDynastySkillModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, List<int>> jadeDynastySkills = new Dictionary<int, List<int>>();
        Dictionary<int, JadeDynastySkillCondition> skillConditions = new Dictionary<int, JadeDynastySkillCondition>();
        Dictionary<int, Sprite[]> skillFrames = new Dictionary<int, Sprite[]>();
        List<int> alreadyUnlockSkills = new List<int>();

        bool serverInited = false;

        public List<int> mySkills
        {
            get
            {
                var job = PlayerDatas.Instance.baseData.Job;
                var key = (int)Mathf.Pow(2, job);
                if (jadeDynastySkills.ContainsKey(key))
                {
                    return jadeDynastySkills[key];
                }
                else
                {
                    jadeDynastySkills[key] = new List<int>();
                }
                return jadeDynastySkills[key];
            }
        }

        public readonly Redpoint redpoint = new Redpoint(117, 11702);

        int m_SelectSkill;
        public int selectSkill
        {
            get { return m_SelectSkill; }
            set
            {
                if (m_SelectSkill != value)
                {
                    m_SelectSkill = value;
                    if (selectSkillRefresh != null)
                    {
                        selectSkillRefresh(value);
                    }
                }
            }
        }

        public event Action<int> skillRefresh;
        public event Action<int> selectSkillRefresh;

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

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

        public void OnBeforePlayerDataInitialize()
        {
            alreadyUnlockSkills.Clear();
            serverInited = false;
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
            UpdateRedpoint();
        }

        public override void UnInit()
        {
            packModel.refreshItemCountEvent -= RefreshItemCountAct;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
        }

        void ParseConfig()
        {
            {
                var config = FuncConfigConfig.Get("EquipZhuXian");
                var json = LitJson.JsonMapper.ToObject(config.Numerical3);
                foreach (var skillIdKey in json.Keys)
                {
                    var skillTypeId = int.Parse(skillIdKey);
                    var skillConfig = SkillConfig.Get(skillTypeId);
                    if (skillConfig == null)
                    {
                        continue;
                    }
                    List<int> list;
                    if (!jadeDynastySkills.TryGetValue(skillConfig.UseType, out list))
                    {
                        list = new List<int>();
                        jadeDynastySkills.Add(skillConfig.UseType, list);
                    }
                    list.Add(skillTypeId);
                    var levelKey = json[skillIdKey].Keys.First();
                    var level = int.Parse(levelKey);
                    skillConditions.Add(skillTypeId, new JadeDynastySkillCondition()
                    {
                        level = level,
                        equipPlaces = new List<int>(LitJson.JsonMapper.ToObject<int[]>(json[skillIdKey][levelKey].ToJson())),
                    });
                }
            }

            foreach (var skills in jadeDynastySkills.Values)
            {
                skills.Sort(Compare);
            }
        }

        public bool IsSatisfyEquipLevel(int equipPlace, int level)
        {
            return false;
        }

        public JadeDynastySkillState GetSkillState(int skillId)
        {
            if (alreadyUnlockSkills.Contains(skillId))
            {
                return JadeDynastySkillState.Unlocked;
            }
            JadeDynastySkillCondition condition;
            if (TryGetSkillCondition(skillId, out condition))
            {
                foreach (var equipPlace in condition.equipPlaces)
                {
                    if (!IsSatisfyEquipLevel(equipPlace, condition.level))
                    {
                        return JadeDynastySkillState.Lock;
                    }
                }
            }
            return JadeDynastySkillState.Unlockable;
        }

        public bool TryGetSkillCondition(int skillId, out JadeDynastySkillCondition condition)
        {
            return skillConditions.TryGetValue(skillId, out condition);
        }

        public bool TryGetSkillFrames(int skillId, out Sprite[] _sprites)
        {
            if (!skillFrames.ContainsKey(skillId))
            {
                var config = SkillFrameAnimationConfig.Get(skillId);
                if (config != null)
                {
                    Sprite[] sprites = new Sprite[config.spriteKeys.Length];
                    for (int i = 0; i < config.spriteKeys.Length; i++)
                    {
                        var sprite = UILoader.LoadSprite(config.spriteKeys[i]);
                        sprites[i] = sprite;
                    }
                    skillFrames.Add(skillId, sprites);
                }
            }
            return skillFrames.TryGetValue(skillId, out _sprites);
        }

        public void OnReceivePackage(H0310_tagRoleSkillChange package)
        {
            var skillConfig = SkillConfig.Get(package.NewSkillID);
            if (skillConfig != null &&
                mySkills.Contains(skillConfig.SkillTypeID))
            {
                if (!alreadyUnlockSkills.Contains(skillConfig.SkillTypeID))
                {
                    alreadyUnlockSkills.Add(skillConfig.SkillTypeID);
                    if (skillRefresh != null)
                    {
                        skillRefresh(skillConfig.SkillTypeID);
                    }

                    if (serverInited)
                    {
                        if (!NewBieCenter.Instance.inGuiding
                            && !WindowCenter.Instance.IsOpen<RealmPropertyUpWin>()
                            && WindowCenter.Instance.IsOpen<JadeDynastySkillWin>())
                        {
                            ActivateShow.JadeDynastySkillUnlock(skillConfig.SkillTypeID);
                        }
                    }
                }
                UpdateRedpoint();
            }
        }

        private int Compare(int lhs, int rhs)
        {
            if (skillConditions.ContainsKey(lhs)
                && skillConditions.ContainsKey(rhs))
            {
                return skillConditions[lhs].level.CompareTo(skillConditions[rhs].level);
            }
            return 0;
        }

        private void RefreshItemCountAct(PackType packType, int arg2, int arg3)
        {
        }

        private void OnFuncStateChangeEvent(int id)
        {
            if (id == 167)
            {
                UpdateRedpoint();
            }
        }

        void UpdateRedpoint()
        {
            var unlockable = false;
            if (FuncOpen.Instance.IsFuncOpen(167))
            {
                foreach (var skill in mySkills)
                {
                    var state = GetSkillState(skill);
                    if (state == JadeDynastySkillState.Unlockable)
                    {
                        unlockable = true;
                        break;
                    }
                }
            }
            redpoint.state = unlockable ? RedPointState.Simple : RedPointState.None;
        }
    }

    public struct JadeDynastySkillCondition
    {
        public int level;
        public List<int> equipPlaces;
    }

    public enum JadeDynastySkillState
    {
        Lock,
        Unlockable,
        Unlocked,
    }
}