using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Skill;
using GameLogic.Player;
using UnityEngine;


namespace GameLogic.Combat.Hero
{
    public class CombatHeroSkillControl : CombatHeroSkillControlBasic
    {
        /// <summary>
        /// 技能指令，0表示没有技能；
        /// </summary>
        private BetterList<SkillBasic> SkillCommands = new BetterList<SkillBasic>();

        public int useSkillCount
        {
            get { return SkillCommands.size; }
        }

        /// <summary>
        /// 当前能使用的技能
        /// </summary>
        public SkillBasic currUseSkill;


        // public float NormalAttSpeedScale;


        public BetterList<SkillBasic> _skillQueue = new BetterList<SkillBasic>();
        public float skillQueueTime = 5f;

        // private BetterList<SkillBasic> _skillQueue = new BetterList<SkillBasic>();
        private int _currUseQueueIndex = 0;

        public float allMagic = 500;
        protected float addMaicSpeed = 5000;
        public float addChongNeng;
        public bool isKuoLiQuanKai;
        protected float qiankaiTime;

        protected override async CTask ProInit()
        {
            // NormalAttSpeedScale = 2;
            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();

            List<int> skillId = _combatHeroEntity.CurrCombatHeroInfo.unLockSkills;
            if (skillId != null)
            {
                for (int i = 0; i < skillId.Count; i++)
                {
                    SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(skillId[i]);
                    SkillBasic skillBasic = AddSkill(skillConfig);
                    if (skillBasic == null)
                    {
                        continue;
                    }

                    _skillQueue.Add(skillBasic);
                    if (!string.IsNullOrEmpty(skillConfig.scriptName))
                    {
                        cTaskAwaitBuffer.AddTask(AssetBundleLoadManager.Instance.LoadAssetAsyncTask<TextAsset>(
                            skillConfig.timelineName + ".txt",
                            delegate(AssetHandle handle)
                            {
                                if (handle != null)
                                {
                                    TextAsset textAsset = handle.AssetObject<TextAsset>();
                                    TimeLienData timeLienData = JsonManager.FromJson<TimeLienData>(textAsset.text);
                                    timeLienData.DeserializeData();
                                    handle.Release();
                                    _combatHeroEntity.combatHeroTimeLineControl.AddTimeLienData(timeLienData);
                                }
                            }));
                    }
                }
            }

            await cTaskAwaitBuffer.WaitAll();
            for (int i = 0; i < _skillQueue.Count; i++)
            {
                _skillQueue[i].angle -= i * 25;
            }

            CombatEventManager.Instance.Dispatch(CombatEventType.ExercisesAlter, null);
        }


        public void UpdateSkill(List<int> skillIDs)
        {
            for (int i = 0; i < skillIDs.Count; i++)
            {
                SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(skillIDs[i]);
                // SkillConfig skillConfig = skillIDs[i];
                SkillBasic skillBasic = GetSkillBasic(skillConfig.IDGroup);
                if (skillBasic == null)
                {
                    AddSkill(skillConfig);
                }
                else
                {
                    skillBasic.InitSkillConfig(skillConfig);
                    skillBasic.InitSkill(_combatHeroEntity);
                }
            }
        }


        public void AddCommandSkill(SkillBasic skill)
        {
            SkillCommands.Add(skill);
        }

        public void RemoveCommandSkill(SkillBasic skill)
        {
            SkillCommands.Remove(skill);
        }

        public void ClearCommandSkill()
        {
            SkillCommands.Clear();
        }

        public void UseSkill(SkillBasic skill)
        {
            CombatUseSkillEventData combatUseSkillEventData = CombatUseSkillEventData.Create();
            combatUseSkillEventData.useSkill = skill;
            CombatEventManager.Instance.Dispatch(CombatEventType.UseSkill, combatUseSkillEventData);
            currUseSkill = skill;
            skill.UseSkill();

            if (skill.SelfSkillConfig.SkillType == 1)
            {
                SetNormalAttCd();
            }
        }

        /// <summary>
        /// 判断是否有技能可释放
        /// </summary>
        /// <returns></returns>
        public SkillBasic CanReleaseSkill()
        {
            // if (_combatHeroEntity.IsControl())
            // {
            //     return null;
            // }
            if (!_combatHeroEntity.IsEnemy && _combatHeroEntity.CombatAIBasic.currFocusTarget is BannerHero)
            {
                return null;
            }

            SkillBasic skillBasic = null;
            for (int i = 0; i < SkillCommands.size; i++)
            {
                skillBasic = SkillCommands[i];
                break;
            }

            return skillBasic;
        }

        public void StartPolling()
        {
            for (int i = 0; i < _skillQueue.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                skillBasic.PollingInitBefore(_skillQueue);
            }

            for (int i = 0; i < _skillQueue.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                skillBasic.PollingInit(_skillQueue);
            }

            _currUseQueueIndex = 0;
        }

        protected override void ProUpdate(float t)
        {
            if (CombatController.currActiveCombat.IsFightState)
            {
                float speed = _combatHeroEntity.CurrCombatHeroInfo.attSpeed.Value * (isKuoLiQuanKai ? 3 : 1f);
                for (int i = 0; i < _skillQueue.Count; i++)
                {
                    SkillBasic skillBasic = _skillQueue[i];
                    skillBasic.angle += 1 * speed;
                    float jd = skillBasic.angle % 360;
                    if (jd > skillBasic.useAngle && skillBasic.angle > skillBasic.lasetAngle)
                    {
                        skillBasic.lasetAngle += 360;
                        if (allMagic > 30)
                        {
                            allMagic -= 30;
                            skillBasic.useCount++;
                            if (!isKuoLiQuanKai)
                            {
                                addChongNeng += 10;
                                if (addChongNeng >= 150)
                                {
                                    isKuoLiQuanKai = true;
                                }
                            }

                         
                            if (skillBasic.WuXingType.HasFlag(WuXingType.Gold))
                            {
                                int odds = Random.Range(0, 100);
                                if (odds < 50)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Water_Injury -= Random.Range(2, 5);
                                    if (_combatHeroEntity.CurrCombatHeroInfo.Water_Injury < 0)
                                    {
                                        _combatHeroEntity.CurrCombatHeroInfo.Water_Injury = 0;
                                    }
                                }
                            }

                            if (skillBasic.WuXingType.HasFlag(WuXingType.Wood))
                            {
                                int odds = Random.Range(0, 100);
                                if (odds < 50)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Fire_Injury -= Random.Range(2, 5);
                                    if (_combatHeroEntity.CurrCombatHeroInfo.Fire_Injury < 0)
                                    {
                                        _combatHeroEntity.CurrCombatHeroInfo.Fire_Injury = 0;
                                    }
                                }
                            }

                            if (skillBasic.WuXingType.HasFlag(WuXingType.Water))
                            {
                                int odds = Random.Range(0, 100);
                                if (odds < 50)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Wood_Injury -= Random.Range(2, 5);
                                    if (_combatHeroEntity.CurrCombatHeroInfo.Wood_Injury < 0)
                                    {
                                        _combatHeroEntity.CurrCombatHeroInfo.Wood_Injury = 0;
                                    }
                                }
                            }

                            if (skillBasic.WuXingType.HasFlag(WuXingType.Fire))
                            {
                                int odds = Random.Range(0, 100);
                                if (odds < 50)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Earth_Injury -= Random.Range(2, 5);
                                    if (_combatHeroEntity.CurrCombatHeroInfo.Earth_Injury < 0)
                                    {
                                        _combatHeroEntity.CurrCombatHeroInfo.Earth_Injury = 0;
                                    }
                                }
                            }

                            if (skillBasic.WuXingType.HasFlag(WuXingType.Earth))
                            {
                                int odds = Random.Range(0, 100);
                                if (odds < 50)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Metal_Injury -= Random.Range(2, 5);
                                    if (_combatHeroEntity.CurrCombatHeroInfo.Metal_Injury < 0)
                                    {
                                        _combatHeroEntity.CurrCombatHeroInfo.Metal_Injury = 0;
                                    }
                                }
                            }

                            AddCommandSkill(skillBasic);
                            AddUseGongFaEventData addUseGongFaEventData = AddUseGongFaEventData.Create();
                            addUseGongFaEventData.SkillBasic = skillBasic;
                            CombatEventManager.Instance.Dispatch(CombatEventType.AddUseGongFa, addUseGongFaEventData);
                            // Debug.Log("旋转一圈");
                        }
                    }
                }
            }

            if (isKuoLiQuanKai)
            {
                qiankaiTime += t;
                if (qiankaiTime > 3)
                {
                    isKuoLiQuanKai = false;
                    qiankaiTime = 0;
                    addChongNeng = 0;
                }
            }

            allMagic += t * addMaicSpeed;
            if (allMagic > 500)
            {
                allMagic = 500;
            }

            // if (currUseSkill == null && SkillCommands.Count <= 0)
            // {
            //     while (_currUseQueueIndex < _skillQueue.Count && SkillCommands.Count <= 0)
            //     {
            //         SkillBasic skillBasic = _skillQueue[_currUseQueueIndex];
            //         if (skillBasic.SelfSkillConfig.SkillType == 1)
            //         {
            //             if (skillBasic.IsCanUse())
            //             {
            //                 AddCommandSkill(skillBasic);
            //             }
            //         }
            //
            //         _currUseQueueIndex++;
            //     }
            // }

            // if (_currUseQueueIndex >= _skillQueue.Count)
            // {
            //     StartPolling();
            // }
        }


        public void SetNormalAttCd()
        {
            // if (NormalAttack == null)
            // {
            //     return;
            // }
            //
            // string timeLineName = "attack";
            // float maxTime = _combatHeroEntity.combatHeroTimeLineControl.TimeLineData.GetTimeLineEventLogicGroupForTime(
            //     timeLineName, null);
            // float attackSpeed = _combatHeroEntity.CurrCombatHeroInfo.attSpeed.Value;
            // float cd = 1.0f / attackSpeed;
            // float attSpeed = (float)1;
            // if (cd < maxTime)
            // {
            //     attSpeed = maxTime / cd;
            // }
            //
            // NormalAttSpeedScale = attSpeed;
            // // Debug.Log(NormalAttSpeedScale);
            // NormalAttCd = cd;
        }

        public virtual void Dispose()
        {
            _combatHeroEntity = null;

            currUseSkill = null;
        }

        public virtual void ProDormancyObj()
        {
            for (int i = 0; i < allSkill.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                CObjectPool.Instance.Recycle(skillBasic);
            }

            allSkill.Clear();
            SkillCommands.Clear();
        }
    }
}