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

namespace vnxbqy.UI
{
    public class MainWinSkillController : Singleton<MainWinSkillController>
    {
        const int SKILL_COUNT_MAX = 8;

        public bool enable { get; set; }

        public readonly LogicStruct<SkillCD> skillcd0 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd1 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd2 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd3 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd4 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd5 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd6 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd7 = new LogicStruct<SkillCD>();
        public readonly LogicStruct<SkillCD> skillcd8 = new LogicStruct<SkillCD>();

        public readonly LogicBool forbid0 = new LogicBool();
        public readonly LogicBool forbid1 = new LogicBool();
        public readonly LogicBool forbid2 = new LogicBool();
        public readonly LogicBool forbid3 = new LogicBool();
        public readonly LogicBool forbid4 = new LogicBool();
        public readonly LogicBool forbid5 = new LogicBool();
        public readonly LogicBool forbid6 = new LogicBool();
        public readonly LogicBool forbid7 = new LogicBool();
        public readonly LogicBool forbid8 = new LogicBool();

        Dictionary<int, int> skillPlaceMap = new Dictionary<int, int>();
        Dictionary<int, int> placeSkillMap = new Dictionary<int, int>();

        SkillModel model { get { return ModelCenter.Instance.GetModel<SkillModel>(); } }

        public MainWinSkillController()
        {
            PlayerSkillDatas.OnRefreshSkill += OnSkillRefresh;
            Skill.RefreshCD += OnSkillCDRefresh;

            GA_Hero.OnStateEnter += OnSkillStateEnter;
            GA_Hero.OnStateEnd += OnSkillStateEnd;

            StatusMgr.OnGainCantCastSkillStatus += OnGainCantCastSkillStatus;
            StatusMgr.OnReleaseCantCastSkillStatus += OnReleaseCantCastSkillStatus;
        }

        public void InitSkill()
        {
            skillPlaceMap.Clear();
            placeSkillMap.Clear();
            if(PlayerDatas.Instance.skill == null) return;
            for (int i = 0; i < SKILL_COUNT_MAX; i++)
            {
                var skillData = PlayerDatas.Instance.skill.GetQuickSkillByPos(i);
                placeSkillMap[i + 1] = skillData != null ? skillData.id : 0;
                if (skillData != null)
                {
                    skillPlaceMap[skillData.id] = i + 1;
                }
            }

            var blinkSkill = PlayerDatas.Instance.skill.GetSKillById(190);
            placeSkillMap[0] = blinkSkill != null ? blinkSkill.id : 0;
            if (blinkSkill != null)
            {
                skillPlaceMap[blinkSkill.id] = 0;
            }

            //var skillXpId = model.GetXpSkillID();
            //var skillXpData = PlayerDatas.Instance.skill.GetSKillById(skillXpId);
            //placeSkillMap[8] = skillXpData != null ? skillXpData.id : 0;
            //if (skillXpData != null)
            //{
            //    skillPlaceMap[skillXpId] = 8;
            //}

            if (PlayerDatas.Instance.hero != null)
            {
                foreach (var skillId in skillPlaceMap.Keys)
                {
                    if (PlayerDatas.Instance.hero.SkillMgr == null) break;
                    var skill = PlayerDatas.Instance.hero.SkillMgr.Get(skillId);
                    if (skill != null)
                    {
                        UpdateSkillExclusiveCountDown(skillId, skill.cd, skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA);
                    }
                }
            }

            UpdateSkillForbidStates();
        }

        public void Reset()
        {
            skillcd0.value = default(SkillCD);
            skillcd1.value = default(SkillCD);
            skillcd2.value = default(SkillCD);
            skillcd3.value = default(SkillCD);
            skillcd4.value = default(SkillCD);
            skillcd5.value = default(SkillCD);
            skillcd6.value = default(SkillCD);
            skillcd7.value = default(SkillCD);
            skillcd8.value = default(SkillCD);

            forbid0.value = false;
            forbid1.value = false;
            forbid2.value = false;
            forbid3.value = false;
            forbid4.value = false;
            forbid5.value = false;
            forbid6.value = false;
            forbid7.value = false;
            forbid8.value = false;

            skillPlaceMap.Clear();
            placeSkillMap.Clear();
        }

        public LogicStruct<SkillCD> GetSkillCD(int index)
        {
            switch (index)
            {
                case 0:
                    return skillcd0;
                case 1:
                    return skillcd1;
                case 2:
                    return skillcd2;
                case 3:
                    return skillcd3;
                case 4:
                    return skillcd4;
                case 5:
                    return skillcd5;
                case 6:
                    return skillcd6;
                case 7:
                    return skillcd7;
                case 8:
                    return skillcd8;
                default:
                    return null;
            }
        }

        public LogicBool GetSkillForbid(int index)
        {
            switch (index)
            {
                case 0:
                    return forbid0;
                case 1:
                    return forbid1;
                case 2:
                    return forbid2;
                case 3:
                    return forbid3;
                case 4:
                    return forbid4;
                case 5:
                    return forbid5;
                case 6:
                    return forbid6;
                case 7:
                    return forbid7;
                case 8:
                    return forbid8;
                default:
                    return null;
            }
        }

        private void OnSkillRefresh()
        {
            InitSkill();
        }

        private void OnSkillCDRefresh(int skillId, float cd, float total)
        {
            UpdateSkillExclusiveCountDown(skillId, cd, total);
        }

        private void OnSkillStateEnter(float time)
        {
            UpdateSkillCommonCountDown(time);
        }

        private void OnSkillStateEnd()
        {
            UpdateSkillCommonCountDown(0);
        }

        private void OnGainCantCastSkillStatus(float duration)
        {
            UpdateSkillForbidStates();
        }

        private void OnReleaseCantCastSkillStatus()
        {
            UpdateSkillForbidStates();
        }

        private void UpdateSkillExclusiveCountDown(int skillId, float cd, float total)
        {
            ILSkillManager.Instance.OnSkillCDRefresh(skillId, cd, total);
            if (skillPlaceMap.ContainsKey(skillId))
            {
                var place = skillPlaceMap[skillId];
                var skillcd = GetSkillCD(place);
                skillcd.value = skillcd.value.SetExclusiveCountDown(cd, total);
            }
        }

        private void UpdateSkillCommonCountDown(float time)
        {
            for (int i = 0; i <= 8; i++)
            {
                if (placeSkillMap.ContainsKey(i) && placeSkillMap[i] != 0)
                {
                    var skillcd = GetSkillCD(i);
                    skillcd.value = skillcd.value.SetCommonCountDown(time);
                }
            }
        }

        private void UpdateSkillForbidStates()
        {
            var forbid = !StatusMgr.Instance.CanCastSkill(PlayerDatas.Instance.baseData.PlayerID);
            for (int i = 0; i <= 8; i++)
            {
                if (placeSkillMap.ContainsKey(i))
                {
                    int _skillId = placeSkillMap[i];
                    var _tsModel = ModelCenter.Instance.GetModel<TreasureSkillModel>();
                    if (_tsModel.TryGetExpertSkill(_skillId, out _skillId))
                    {
                        int _level = 0;
                        if (_tsModel.TryGetExpertActiveLevel(_skillId, out _level))
                        {
                            _skillId += (_level - 1);
                        }
                        var _skillInfo = SkillHelper.Instance.Get(_skillId);
                        SkillHelper.EffectValue _effectValue;
                        if (_skillInfo.effectValue.TryGetValue(4093, out _effectValue))
                        {
                            if (forbid)
                            {
                                continue;
                            }
                        }
                    }
                }
                var skillForbid = GetSkillForbid(i);
                skillForbid.value = forbid;
            }
        }

        public struct SkillCD
        {
            public float exclusiveTotal;
            public float exclusiveOverTime;
            public float commonTotal;
            public float commonOverTime;

            public SkillCD SetCommonCountDown(float time)
            {
                commonTotal = time;
                commonOverTime = Time.realtimeSinceStartup + time;

                return this;
            }

            public SkillCD SetExclusiveCountDown(float cd, float total)
            {
                exclusiveTotal = total;
                exclusiveOverTime = Time.realtimeSinceStartup + cd;

                return this;
            }

            public bool IsCountDown()
            {
                if (exclusiveOverTime > Time.realtimeSinceStartup)
                {
                    return true;
                }

                if (commonOverTime > Time.realtimeSinceStartup)
                {
                    return true;
                }

                return false;
            }

            public bool IsExclusiveCountDown()
            {
                if (exclusiveOverTime > Time.realtimeSinceStartup)
                {
                    return true;
                }

                return false;
            }

            public float GetCountDownFillAmount()
            {
                if (exclusiveOverTime > Time.realtimeSinceStartup)
                {
                    return (exclusiveOverTime - Time.realtimeSinceStartup) / exclusiveTotal;
                }

                if (commonOverTime > Time.realtimeSinceStartup)
                {
                    return (commonOverTime - Time.realtimeSinceStartup) / commonTotal;
                }

                return 0f;
            }

            public float GetCountDown()
            {
                if (exclusiveOverTime > Time.realtimeSinceStartup)
                {
                    return exclusiveOverTime - Time.realtimeSinceStartup;
                }

                return 0f;
            }

        }


    }
}