protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			if (target.MaxPower == 0 || target.PowerType != (PowerType)m_spellEffect.MiscValue)
			{
				failReason = SpellFailedReason.BadTargets;
			}
		}

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if (m_targets != null && m_targets.Count > 0)
			{
				firstTarget = (Unit)m_targets[0];
			}
		}

		public static void IsFriendly(SpellEffectHandler effectHandler, WorldObject target, ref SpellFailedReason failedReason)
		{
			if (effectHandler.Cast.CasterObject.MayAttack(target))
			{
				failedReason = SpellFailedReason.TargetEnemy;
			}
		}

		protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
		{
			if (target.MaxPower == 0 || target.PowerType != (PowerType)m_spellEffect.MiscValue)
			{
				failReason = SpellFailedReason.BadTargets;
			}
		}

		protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
		{
			if (!(target is Character))
			{
				failReason = SpellFailedReason.TargetNotPlayer;
			}
		}

        protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
        {
            if (!(target is NPC))
            {
                failReason = SpellFailedReason.BadTargets;
            }

            if (casterRef != null && casterRef.Object is Unit)
            {
                var caster = (Unit)casterRef.Object;
                //if (target.Target == caster)
                //{
                //    failReason = SpellFailedReason.NoValidTargets;
                //}
                //else
                {
                    var spell = m_aura.Spell;
                    var hasSingleFriendTarget = spell.HasBeneficialEffects && !spell.IsAreaSpell && spell.HasTargets;
                    if (hasSingleFriendTarget && caster.Target != null && caster.IsFriendlyWith(caster.Target))
                    {
                        // taunting a friend, means we want to taunt his attackers
                        // needed for Righteous defense, amongst others
                        if (target.Target != caster.Target)
                        {
                            failReason = SpellFailedReason.NoValidTargets;
                        }
                    }
                }
            }
        }

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
 {
     if (!(target is Character))
     {
         failReason = SpellFailedReason.TargetNotPlayer;
     }
 }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			Caster = casterReference.Object as Unit;
			if (Caster == null || Caster is Vehicle)
			{
				log.Warn("Invalid SpellCaster \"{0}\" for Spell: {1}", Caster, SpellEffect.Spell);
				failReason = SpellFailedReason.Error;
				return;
			}

			Vehicle = target as Vehicle;
			if (Vehicle == null)
			{
				failReason = SpellFailedReason.BadTargets;
			}
			else
			{
				Seat = Vehicle.GetSeatFor(Caster);
				if (Seat == null)
				{
					// must never happen since Vehicle is unclickable when full
					failReason = SpellFailedReason.BadTargets;
				}
			}
		}

		/// <summary>
		/// Duel target type
		/// </summary>
		/// <param name="targets"></param>
		/// <param name="target"></param>
		/// <param name="failedReason"></param>
		public static void IsHostileOrHealable(SpellEffectHandler effectHandler, WorldObject target, ref SpellFailedReason failedReason)
		{
			var caster = effectHandler.Cast.CasterObject;
			var spell = effectHandler.Cast.Spell;
			var isHarmful = spell.HasHarmfulEffects;
			var isHarmfulAndBeneficial = spell.HasHarmfulEffects == spell.HasBeneficialEffects;

			if (!isHarmfulAndBeneficial)
			{
				if (isHarmful != caster.MayAttack(target))
				{
					if (isHarmful)
					{
						failedReason = SpellFailedReason.TargetFriendly;
					}
					else
					{
						failedReason = SpellFailedReason.TargetEnemy;
					}
				}
				else if (isHarmful && !target.CanBeHarmed)
				{
					failedReason = SpellFailedReason.NotHere;
				}
			}
		}

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if (m_cast.TargetItem == null)
			{
				failReason = SpellFailedReason.ItemGone;
				return;
			}

			if (m_cast.TargetItem.Template.Level < Effect.Spell.BaseLevel)
			{
				failReason = SpellFailedReason.TargetLowlevel;
				return;
			}

			enchantEntry = EnchantMgr.GetEnchantmentEntry((uint)Effect.MiscValue);
			if (enchantEntry == null)
			{
				log.Error("Spell {0} refers to invalid EnchantmentEntry {1}", Effect.Spell, Effect.MiscValue);
				failReason = SpellFailedReason.Error;
			}
			else if (!enchantEntry.CheckRequirements(m_cast.CasterUnit))
			{
				failReason = SpellFailedReason.MinSkill;
			}
		}

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
 {
     var caster = creatingCast.CasterReference.Object as Unit;
     if (caster == null)
     {
         failReason = SpellFailedReason.BadTargets;
     }
     else
     {
         if (caster.Charm != null)
         {
             failReason = SpellFailedReason.AlreadyHaveCharm;
         }
         else if (target.HasMaster)
         {
             failReason = SpellFailedReason.CantDoThatRightNow;
         }
         else if (caster.HasMaster)
         {
             failReason = SpellFailedReason.Possessed;
         }
         else if (caster is Character)
         {
             if (((Character)caster).ActivePet != null)
             {
                 failReason = SpellFailedReason.AlreadyHaveSummon;
             }
         }
     }
 }

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if (m_cast.InitialTargets == null || m_cast.InitialTargets.Length == 0 || !(m_cast.InitialTargets[0] is Unit))
			{
				failReason = SpellFailedReason.NoValidTargets;
			}
		}

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if (m_cast.CasterChar.ActivePet == null)
			{
				failReason = SpellFailedReason.NoPet;
			}
		}

		internal void Collect(SpellTargetCollection targets, ref SpellFailedReason failReason)
		{
			if (Adder != null)
			{
				Adder(targets, Filter, ref  failReason);
			}
		}

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if (m_cast.UsedItem.Amount < Effect.MinValue)
			{
				failReason = SpellFailedReason.NeedMoreItems;
			}
		}

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if(Effect.BasePoints < 0)
			{
				Effect.BasePoints = 0;
			}
			base.Initialize(ref failReason);
		}

		public override void Initialize(ref SpellFailedReason failReason)
		{
			if (Effect.TriggerSpell == null)
			{
				failReason = SpellFailedReason.Error;
				log.Warn("Tried to cast Spell \"{0}\" which has invalid TriggerSpellId {1}", Effect.Spell, Effect.TriggerSpellId);
			}
		}

		public static void IsSameClass(SpellEffectHandler effectHandler, WorldObject target, ref SpellFailedReason failedReason)
		{
			var caster = effectHandler.Cast.CasterUnit;
			if (caster == null || !(target is Unit) || caster.Class != ((Unit)target).Class)
			{
				failedReason = SpellFailedReason.BadTargets;
			}
		}

		internal void NotifyCancelled(SpellCast cast, SpellFailedReason reason)
		{
			var evt = Cancelling;
			if (evt != null)
			{
				evt(cast, reason);
			}
		}

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			if (m_spellEffect.TriggerSpell == null)
			{
				failReason = SpellFailedReason.Error;
				log.Warn("Tried to cast Spell \"{0}\" which has invalid TriggerSpellId {1}", m_spellEffect.Spell, m_spellEffect.TriggerSpellId);
			}
		}