using CommonAI.Zone.Helper;
using CommonAI.Zone.Instance;
using XmdsCommonServer.Plugin;
using XmdsCommonServer.XLS.Data;
using XmdsCommonSkill.Plugin.Buffs;
using System;
using static CommonAI.Zone.Instance.InstanceUnit;
using XmdsCommon.Plugin;
using CommonAI.Zone;
using XmdsCommonServer.Plugin.Units;
using CommonAI.Zone.Formula;
using XmdsCommonSkill.Plugin.Skills;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.DamageCalculator;
using XmdsCommonSkill.Plugin.Skills.Magic;
using CommonLang;
using CommonAI.Data;
using System.Collections.Generic;

namespace XmdsCommonSkill.Plugin.PassiveSkills.Magic
{
    /// <summary>
    /// 封神战-旗子被动
	/// </summary>
    public class Other_100005 : XmdsPassiveSkillBase
    {
        /// 技能ID.
        public static readonly int ID = 100005;
        private static readonly int BuffID = (int)XmdsBuffBase.XmdsBuffList.PVP_FLAG_DAMAGEREDUCE;

        private static XmdsSkillValue valueSet;
		private static int HIT_DAMAGE = 1;						//单次攻击掉血
		private static int HIT_DAMAGE_REDUCE = 0;               //免伤逻辑
		private static int HPRebornInterval = 0;				//HP恢复频率
		private static int NotDamgeAddHPTime = 0;               //没有收到伤害多久，开始回血
		private static int HPRebornValue = 0;					//HP恢复比例

		private int mNeedHitTimes = 0;
	
        private int mUUID_1 = 0;
        private int mUUID_2 = 0;
        private int mOpID1 = 0;

        //私有数据
        private XmdsVirtual mOwner = null;
        private int timePass = 0;               //旗子被动刷新间隔
        private long lastHitTime = 0;           //最后一次被攻击时间

        public override int SkillID { get { return ID; } }

        protected override void OnInit(GameSkill skillInfo, XmdsVirtual owner)
        {
            this.mOwner = owner;

            mNeedHitTimes = Math.Max(10, valueSet.GetValue(owner.mUnit.gameServerFlag == 0 ? skillInfo.SkillLevel : owner.mUnit.gameServerFlag));
            XmdsVirtual.PropChangeOperation pco = owner.CreatePropChangeOpertation(null);
            pco.Type = XmdsVirtual.UnitAttributeType.SetMaxHP;
            pco.Value = mNeedHitTimes * HIT_DAMAGE;
            mOpID1 = owner.AddPropChangeOperation(pco);

            mUUID_1 = owner.RegistOnHitDamage(OnHandleHitDmage, skillInfo, true);
            mUUID_2 = owner.RegistTryAddBuffEvent(OnTryAddBuffEvent, skillInfo);
        }

        private float OnHandleHitDmage(float damage, XmdsVirtual hitted, XmdsVirtual attacker, AttackSource source, 
            ref XmdsVirtual.AtkResult result, DamageType damageType, GameSkill skill, ref bool isEndDispatch)
        {
			this.lastHitTime = CommonLang.CUtils.localTimeMS;
			isEndDispatch = true;
			if (source.FromSkillType == XmdsSkillType.normalAtk && attacker.mUnit.IsPlayer)
            {
				if(HIT_DAMAGE > 1 && HIT_DAMAGE_REDUCE > 0 && hitted.mUnit.GetBuffByID(BuffID) != null)
				{
					float damageReduce = HIT_DAMAGE * HIT_DAMAGE_REDUCE * XmdsUnitProp.PER;
					return HIT_DAMAGE - damageReduce;
				}

                return HIT_DAMAGE;
            }

			attacker.SendBattleHintNumberB2C(0, XmdsVirtual.UnitHitEventState.Immunity, hitted.mUnit.ID);
            return 0;
        }

        private bool OnTryAddBuffEvent(ref BuffTemplate buff, XmdsVirtual attacker, XmdsVirtual hitter, GameSkill skill)
        {
            // 只允许加这个buff
            return (buff.TemplateID == BuffID) ? true : false;
        }

		protected override void OnUpdate(int intervalMS, bool slowRefresh)
		{
			base.OnUpdate(intervalMS, slowRefresh);
			//开始回血判断
			long noDamageTimePass = CommonLang.CUtils.localTimeMS - lastHitTime;
			if (mOwner == null || noDamageTimePass < NotDamgeAddHPTime)
			{
				timePass = 0;
				return;
			}

			timePass += intervalMS;

			//回血判断
			if (mOwner.mUnit.CurrentHP < mOwner.mUnit.MaxHP && timePass > HPRebornInterval)
			{
				timePass = 0;
				//队伍范围内找友军
				//int addHp = (int)(mOwner.mUnit.MaxHP * XmdsUnitProp.PER * HPRebornValue);
				this.mOwner.mUnit.AddHP(HPRebornValue, this.mOwner.mUnit);
			}
		}

			//    //防御加成
			//    int damageReduce = GetDamageReduceByAlliesCount(alliestCount);
			//    if (damageReduce != preDamageReduce)
			//    {
			//        if (damageReduce > 0)
			//        {
			//            var buff = this.mOwner.GetRegisBuffVirtual(BuffID) as XmdsBuff_PropChange;
			//            buff.CurrentValue = damageReduce;
			//            this.mOwner.mUnit.AddBuff(BuffID, this.mOwner.mUnit);
			//        }
			//        else
			//        {
			//            this.mOwner.mUnit.removeBuff(BuffID);
			//        }
			//    }
			//}

			///** 获得附近队友数量 */
			//private int AlliesCounting()
			//{
			//    int alliesCount = 0;
			//    using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
			//    {
			//        mOwner.mUnit.Parent.getObjectsRoundRange<InstanceUnit>(
			//            (obj, dx, dy, dr) =>
			//            {
			//                var u = obj as InstanceUnit;

			//                if (u.Virtual is XmdsVirtual_Player && CMath.includeRoundPoint(dx, dy, dr, u.X, u.Y))
			//                {
			//                    //己方单位.
			//                    if (mOwner.IsAllies(u.Virtual as XmdsVirtual))
			//                    {
			//                        alliesCount++;
			//                    }
			//                }

			//                return true;
			//            },
			//            mOwner.mUnit.X,
			//            mOwner.mUnit.Y,
			//            6,
			//            list, mOwner.mUnit.AoiStatus);
			//    }

			//    return alliesCount++;
			//}

			///** 根据队友数量，获得减伤比例 */
			//private int GetDamageReduceByAlliesCount(int alliesCount)
			//{
			//    if(alliesCount <= 0)
			//    {
			//        return 0;
			//    }
			//    else if(alliesCount <= 3)
			//    {
			//        return 1000;
			//    }
			//    else if(alliesCount <= 5)
			//    {
			//        return 2000;
			//    }
			//    else if(alliesCount <= 10)
			//    {
			//        return 5000;
			//    }

			//    return 8000;
			//}


			///** 根据队友数量，获得减伤比例 */
			//private float GetHealByAlliesCount(int alliesCount)
			//{
			//    int precent = 1000;
			//    if (alliesCount <= 0)
			//    {
			//        precent = 500;
			//    }
			//    else if (alliesCount <= 3)
			//    {
			//        precent = 600;
			//    }
			//    else if (alliesCount <= 5)
			//    {
			//        precent = 800;
			//    }
			//    else if (alliesCount <= 10)
			//    {
			//        precent = 1000;
			//    }

			//    return precent * XmdsUnitProp.PER;
			//}

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

			XmdsSkillValue valueTemp;
			InitData(data, out valueTemp, XmdsSkillData.XmdsSkillDataKey.ValueSet2);
			HIT_DAMAGE = Math.Max(1, valueTemp.GetValue());

			InitData(data, out valueTemp, XmdsSkillData.XmdsSkillDataKey.ValueSet3);
			HIT_DAMAGE_REDUCE = valueTemp.GetValue();

			InitData(data, out valueTemp, XmdsSkillData.XmdsSkillDataKey.ValueSet4);
			NotDamgeAddHPTime = valueTemp.GetValue() * 1000;

			InitData(data, out valueTemp, XmdsSkillData.XmdsSkillDataKey.ValueSet5);
			HPRebornValue = valueTemp.GetValue();

			InitData(data, out valueTemp, XmdsSkillData.XmdsSkillDataKey.ValueSet6);
			HPRebornInterval = valueTemp.GetValue() * 1000;
		}

        protected override void OnDispose(XmdsVirtual owner)
        {
            owner.UnRegistOnHitDamage(mUUID_1);
            owner.UnRegistTryAddBuffEvent(mUUID_2);
            owner.RemovePropChangeOperation(mOpID1);
        }
    }
}