using CommonAI.Zone;
using XmdsCommonSkill.Plugin.Buffs;
using XmdsCommonServer.XLS.Data;
using CommonAI.Zone.Helper;
using CommonAI.Zone.Instance;
using XmdsCommonSkill.Plugin.Skills;
using XmdsCommon.Plugin;
using XmdsCommonServer.Plugin;
using CommonAI.Zone.Formula;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.DamageCalculator;
using CommonLang;
using CommonAI.Data;

namespace XmdsCommonSkill.Plugin.PassiveSkills.Monster
{
    /// <summary>
    /// 科斯林伯爵 - 狂怒1：在接下来10秒内，攻击增加x，暴击增加x.
    /// 10秒后释放愤怒，对身边敌人造成x%物攻伤害并短暂击飞敌人在Boss生命小于30%时释放.
    /// 该被动效果为，血量小于30%激活主动技能.
    /// 10340512、10340513不要加入怪物技能列表，被动技能触发时候会主动调用.
    /// </summary>
    public class Monster_10340502 : XmdsPassiveSkillBase
    {
        /// <summary>
        /// 技能ID.
        /// </summary>
        public static int ID = 10340502;

        /// <summary>
        /// 血量小于%多少.
        /// </summary>
        public static int Condition_1 = 3000;

        /// <summary>
        /// 激活的技能1.
        /// </summary>
        public static int ActiveSkillID_1 = 10340512;

        /// <summary>
        /// 激活的技能2.
        /// </summary>
        public static int ActiveSkillID_2 = 10340522;

        /// <summary>
        /// 倒计时X秒后施放狂怒2段.
        /// </summary>
        public static int CountTime = 10000;

        /// <summary>
        /// 是否使用.
        /// </summary>
        private bool HasDone = false;

        private int mUUID_1 = 0;
        private int mUUID_2 = 0;

        /// <summary>
        /// 拥有者.
        /// </summary>
        private XmdsVirtual mOwner = null;


        /// <summary>
        ///计时器.
        /// </summary>
        private TimeExpire<int> mBuffTimer = null;

        /// <summary>
        /// 是否开始计时.
        /// </summary>
        private bool mStartCountTime = false;



        /// <summary>
        /// 获取技能ID.
        /// </summary>
        public override int SkillID
        {
            get
            {
                return ID;
            }
        }


        protected override void OnInit(GameSkill skillInfo, XmdsVirtual owner)
        {
            mOwner = owner;
            //注册招架监听.
            mUUID_1 = owner.RegistOnHitDamage(OnHandleOnHitDamage, skillInfo, true);
            mUUID_2 = owner.RegistTryLaunchSkillEvent(OnTryLaunchSkillEventHandle, skillInfo, true);
        }

        private float OnHandleOnHitDamage(float damage, XmdsVirtual hitter, XmdsVirtual attacker, AttackSource source,
            ref XmdsVirtual.AtkResult result, DamageType damageType, GameSkill skill, ref bool isEndDispatch)
        {
            if (HasDone == false)
            {
                int v1 = CUtils.CastInt(hitter.mUnit.MaxHP * (Condition_1 * 1.0f / XmdsDamageCalculator.PERER));

                //小于指定血量.
                if (hitter.mUnit.CurrentHP - damage < v1 || hitter.mUnit.CurrentHP < v1)
                {
                    //只用一次.
                    HasDone = true;
                    mOwner.UnRegistOnHitDamage(mUUID_1);

                    //激活指定技能.
                    GameSkill gs = new GameSkill();
                    gs.SkillID = ActiveSkillID_1;
                    gs.SkillType = XmdsSkillType.active;
                    gs.SkillLevel = 1;
                    //狂怒第一阶段.
                    hitter.SkillHelper.AddActiveSkill(gs);

                    gs = new GameSkill();
                    gs.SkillID = ActiveSkillID_2;
                    gs.SkillType = XmdsSkillType.active;
                    gs.SkillLevel = 1;
                    hitter.SkillHelper.AddActiveSkill(gs);
                    //狂怒第二阶段.
                    hitter.mUnit.SetSkillActive(ActiveSkillID_2, false);
                }
            }

            return damage;
        }

        protected override void OnDispose(XmdsVirtual owner)
        {
            owner.UnRegistOnHitDamage(mUUID_1);
            mOwner = null;
        }

        private bool OnTryLaunchSkillEventHandle(GameSkill skillInfo, ref InstanceUnit.SkillState skill, XmdsVirtual launcher, ref InstanceUnit.LaunchSkillParam param)
        {
            //技能只有在符合血量条件的情况下才能触发.
            if (skill.ID == ActiveSkillID_1 || skill.ID == ActiveSkillID_2)
            {
                int v1 = CUtils.CastInt(launcher.mUnit.MaxHP * (Condition_1 * 1.0f / XmdsDamageCalculator.PERER));
                if (launcher.mUnit.MaxHP >= v1)
                {
                    return false;
                }
            }

            if (skill.ID == ActiveSkillID_1)
            {
                if (mStartCountTime == false)
                {
                    //启动计时器.

                    if (mBuffTimer == null)
                    {
                        mBuffTimer = new TimeExpire<int>(CountTime);
                    }
                    else
                    {
                        mBuffTimer.Reset(CountTime);
                    }

                    mStartCountTime = true;
                }
                else
                {
                    //倒计时中不能再次施放该技能.
                    return false;
                }
            }


            return true;
        }

        protected override void OnUpdate(int intervalMS, bool slowRefresh)
        {
            if (mBuffTimer != null && mStartCountTime == true)
            {
                if (mBuffTimer.Update(intervalMS))
                {
                    mStartCountTime = false;
                    mBuffTimer.Reset();

                    LaunchSkill();
                }
            }

            base.OnUpdate(intervalMS, slowRefresh);
        }

        private void LaunchSkill()
        {
            if (mOwner != null)
            {
                mOwner.mUnit.SetSkillActive(ActiveSkillID_2, true);
                mOwner.mUnit.ClearSkillCD(ActiveSkillID_2);
                mOwner.mUnit.launchSkill(ActiveSkillID_2, new InstanceUnit.LaunchSkillParam());
            }
        }
    }
}