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.CombatType;
using GameLogic.Combat.Hero.Turntable;
using GameLogic.Combat.Skill;
using GameLogic.Hero;
using GameLogic.Player;
using UnityEngine;


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

        public SkillBasic[] GetSkillQueue()
        {
            return SkillCommands.ToArray(true);
        }

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

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


        /// <summary>
        /// 大道技能
        /// </summary>
        public SkillBasic taoismSkillBasic;


        public SkillTurntable SkillTurntable;


        protected override async CTask ProInit()
        {
            SkillTurntable = new SkillTurntable();
            SkillTurntable.Init(10, this, _combatHeroEntity);
            if (_combatHeroEntity.IsEnemy)
            {
                await SetNewSkill(_combatHeroEntity.CurrCombatHeroInfo.unLockSkills.ToArray());
            }
            else
            {
                if (_combatHeroEntity.CurrCombatHeroInfo.MonsterPowerUpConfig.ID > 0)
                {
                    await SetNewSkill(_combatHeroEntity.CurrCombatHeroInfo.unLockSkills.ToArray());
                }
                else

                {
                    await SetNewSkill(PlayerManager.Instance.GongFaControl.allUseSkill);
                }
            }

            InitTaoismSkill(_combatHeroEntity.CurrCombatHeroInfo.TaoismSkillId);
        }

        public void InitTaoismSkill(int TaoismSkillId)
        {
            if (taoismSkillBasic != null)
            {
                taoismSkillBasic.Dispose();
            }

            int id = TaoismSkillId;
            if (id != 0)
            {
                SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(id);

                SkillBasic skillBasic = SkillScriptManager.Instance.CreateSkillBasic(skillConfig);
                if (skillBasic == null)
                {
                    return;
                }

                SkillInfo skillInfo = new SkillInfo(id, 1);
                skillBasic.InitSkillConfig(_combatHeroEntity, skillInfo);
                taoismSkillBasic = skillBasic;
                // _combatHeroEntity.CurrCombatHeroInfo.SetSkillAttSpeed(skillConfig.addcd+SkillTurntable.skillAddSkillCd);
                TaoismSkillAlterEventData taoismSkillAlterEventData = TaoismSkillAlterEventData.Create();
                taoismSkillAlterEventData.CombatHeroEntity = _combatHeroEntity;
                CombatEventManager.Instance.Dispatch(CombatEventType.TaoismSkillAlter, taoismSkillAlterEventData);
            }

            if (!_combatHeroEntity.IsEnemy)
            {
                float cd = _combatHeroEntity.CurrCombatHeroInfo.powerUpConfig.MaxActiveGongfaNum *
                    PlayerManager.Instance.gameConstantConfig.BasicCDperSkill / 1000;
                _combatHeroEntity.CurrCombatHeroInfo.SetSkillAttSpeed(
                    cd + SkillTurntable.skillAddSkillCd + _combatHeroEntity.CurrCombatHeroInfo.modelConfig.speed_atk);
            }
            else
            {
                float cd = (SkillTurntable.skillCount * PlayerManager.Instance.gameConstantConfig.BasicCDperSkill) /
                           1000;
                _combatHeroEntity.CurrCombatHeroInfo.SetSkillAttSpeed(
                    cd + SkillTurntable.skillAddSkillCd + _combatHeroEntity.CurrCombatHeroInfo.modelConfig.speed_atk);
            }
        }

        public override async CTask SetNewSkill(SkillInfo[] allSkill)
        {
            await SkillTurntable.SetNewSkill(allSkill);
        }

        public SkillBasic GetSkillQueueForIndex(int index)
        {
            return SkillTurntable.GetSkillQueueForIndex(index);
        }


        public void AddCommandSkill(SkillBasic skill)
        {
            if (_combatHeroEntity.isZhanZhuang)
            {
                return;
            }

            skill.DelayUseSkillCd = 0.5f;

            SkillCommands.Add(skill);
        }

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

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

        public void UseSkillFinish(SkillBasic skill)
        {
            if (skill == null)
            {
                return;
            }

            SkillTurntable.UseSkillFinish(skill);
        }

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

        /// <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++)
            {
                if (!SkillCommands[i].IsCanUse())
                {
                    continue;
                }

                return SkillCommands[i];
            }

            return null;
        }


        protected override void ProUpdate(float t)
        {
            if (CombatController.currActiveCombat.IsFightState)
            {
                float speed = _combatHeroEntity.CurrCombatHeroInfo.GetAttSpeed;
                float angle = 360 / (1.0f / speed);
                SkillTurntable.Update(t, angle * t);
            }

            if (taoismSkillBasic != null)
            {
                taoismSkillBasic.CombatUpdate(t);
            }
        }


        public override void Dispose()
        {
            SkillTurntable.Dispose();
            base.Dispose();
            _combatHeroEntity = null;

            currUseSkill = null;
            SkillTurntable = null;
        }

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

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

        
    }
}