using CommonAI.Zone;
using XmdsCommonServer.XLS.Data;
using XmdsCommon.Plugin;
using XmdsCommonServer.Plugin;
using XmdsCommonServer.Plugin.Units;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.Skills;
using XmdsCommonSkill.Plugin.Buffs;
using System.Collections.Generic;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.DamageCalculator;
using CommonLang;

namespace XmdsCommonSkill.Plugin.Skills.Monster
{
    /// <summary>
    /// 卵之束缚：喷吐蛛液，被命中的敌人将被虫卵覆盖，被虫卵覆盖后无法移动和攻击，并每秒持续流失生命x%。
    /// 虫卵具有y点生命值，可被打破，打破后敌人将恢复自由.
    /// </summary>
    public class Monster_10490403 : XmdsSkillBase
    {
        /// <summary>
        /// 技能ID.
        /// </summary>
        public static int ID = 10490403;

        /// <summary>
        /// Buff效果.
        /// </summary>
        public static int Buff_ID = 104000;
        public static XmdsSkillValue Buff_Damage;
        public static XmdsSkillValue Buff_Bug_Life;

        /// <summary>
        /// 虫卵.
        /// </summary>
        public static int SummonUnit = 60402;

        /// <summary>
        /// 虫卵血量.
        /// </summary>
        public static int SummonUnit_HP;

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

        protected override void OnInit(GameSkill info, XmdsVirtual unit, ref SkillTemplate template)
        {
            XmdsBuffPack pack = XmdsBuffFactory.GetInstance().GetXmdsBuffPack(Buff_ID);
            BuffTemplate bt = pack.mBuffTemplate;
            bt.IsHarmful = true;
            pack.BindTemplateAndDispose();
            unit.RegistSendBuff(bt);
        }

        protected override void OnSkillLogicEvent(BattleParams param)
        {
            //此次攻击没有伤害.
            param.UseDamageType = CommonAI.Data.DamageType.None;

            //关联.
            var buff2 = param.Attacker.GetRegisBuffVirtual(Buff_ID, 0) as XmdsBuff_UnitLink;

            buff2.OnHandleBuffBeginEvent += ((hitter, attacker, state) =>
            {
                {
                    UnitInfo info = XmdsBattleSkill.GetUnitInfo(SummonUnit);

                    List<XmdsBuffVirtual> list = null;
                    if (state.Tag != null)
                    {
                        list = state.Tag as List<XmdsBuffVirtual>;
                    }

                    XmdsBuff_UnitLink b = null;

                    if (list != null && list.Count > 0)
                    {
                        for (int i = 0; i < list.Count; i++)
                        {
                            if (list[i] is XmdsBuff_UnitLink)
                            {
                                b = list[i] as XmdsBuff_UnitLink;

                                AddUnitEvent aue = null;
                                info.LifeTimeMS = 5000;

                                var unit = (attacker.mUnit.Parent.AddUnit(
                                       info, info.Name,
                                       attacker.mUnit.Force, 1,
                                       hitter.mUnit.X,
                                       hitter.mUnit.Y,
                                       attacker.mUnit.Direction,
                                       out aue,
                                       attacker.mUnit)) as XmdsInstanceSummonUnit;

                                if (unit != null)
                                {
                                    //关联单位设置.
                                    b.LinkTarget = unit.Virtual as XmdsVirtual;
                                    //设置虫卵血量.
                                    SummonUnit_HP = this.GetTargetFormulaValue(param.GameSkill.SkillLevel, Buff_Bug_Life);
                                    unit.MaxHP = SummonUnit_HP;
                                    unit.CurrentHP = SummonUnit_HP;
                                    //召唤单位坐标与玩家绑定.
                                    unit.BindUnit = hitter.mUnit;
                                    unit.Master = null;
                                }
                            }
                        }
                    }
                }
            });

            //单位不受伤害.
            var buff3 = param.Attacker.GetRegisBuffVirtual(Buff_ID, 1) as XmdsBuff_Nothingness;
            //受buff影响.
            buff3.ChangeType = XmdsBuff_Nothingness.NothingnessType.NothingnessIgnoreSkill;

            //持续受到BUFF伤害.
            var buff4 = param.Attacker.GetRegisBuffVirtual(Buff_ID, 2) as XmdsBuff_Bleed;
            float pec = this.GetTargetFormulaValue(param.GameSkill.SkillLevel, Buff_Damage) / XmdsDamageCalculator.PERER;
            buff4.ChangeValue = CUtils.CastInt(param.Hitter.mUnit.MaxHP * pec);

            BuffTemplate bt = param.Attacker.GetRegistBuff(Buff_ID);
            bt.LifeTimeMS = 5000;
            bt.IsHarmful = true;
            (bt.Properties as XmdsBuffProperties).Dispelled = true;

            param.Hitter.mUnit.AddBuff(Buff_ID, param.Attacker.mUnit);
        }

        protected override void OnInitSkillParam()
        {
            XmdsSkillData data = XmdsDataMgr.GetInstance().GetXmdsSkillData(ID);
            InitData(data, out Buff_Damage, XmdsSkillData.XmdsSkillDataKey.ValueSet2);
            InitData(data, out Buff_Bug_Life, XmdsSkillData.XmdsSkillDataKey.ValueSet);
        }
    }
}