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;
				}
			}
		}

 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;
             }
         }
     }
 }

		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;
			}
		}

        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 (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);
			}
		}

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			if (target.Class != ClassId.Hunter)
			{
				failReason = SpellFailedReason.BadTargets;
				return;
			}
		}

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
 {
     if (!(target is Character)) return;
     var chr = (Character)target;
     if (chr.Class != ClassId.Hunter)
     {
         failReason = SpellFailedReason.BadTargets;
     }
 }

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

        /// <summary>
        /// Ensure that the constraints are correct for the Flag aura to be applied
        /// </summary>
        protected override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
        {
			if (!(target is Character))
			{
				failReason = SpellFailedReason.BadTargets;
			}
			else
			{
				Instance = target.Region as WarsongGulch;
				if (Instance == null)
				{
					failReason = SpellFailedReason.IncorrectArea;
				}
			}
        }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			form = (ShapeshiftForm)SpellEffect.MiscValue;
			if (target.ShapeshiftForm == form)
			{
				// stances can't be undone:
				if (form != ShapeshiftForm.BattleStance &&
					form != ShapeshiftForm.BerserkerStance &&
					form != ShapeshiftForm.DefensiveStance)
				{
					target.Auras.RemoveWhere(aura => aura.Spell.Id == m_aura.Spell.Id);
					failReason = SpellFailedReason.DontReport;
				}
			}
		}

			protected override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
			{
				if (target is Character)
				{
					var chr = (Character)target;
					var ap = target.TotalMeleeAP;
					var sp = chr.GetDamageDoneMod(DamageSchool.Holy);
					if (ap > sp)
					{
						totalBonus = ap;
					}
					else
					{
						totalBonus = sp;
					}
				}
			}

		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 (!(target is NPC))
				{
					LogManager.GetCurrentClassLogger().Warn("{0} tried to Charm {1} which is not an NPC, but Player charming is not yet supported.", caster, target);
					failReason = SpellFailedReason.BadTargets;
				}
				if (caster.Charm != null)
				{
					failReason = SpellFailedReason.AlreadyHaveCharm;
				}
				else if (target.HasMaster)
				{
					failReason = SpellFailedReason.CantBeCharmed;
				}
				//else if (caster.Level < EffectValue)
				//{
				//    failReason = SpellFailedReason.Highlevel;
				//}
				else if (caster.HasMaster)
				{
					failReason = SpellFailedReason.Charmed;
				}
				else if (caster is Character)
				{
					if (((Character)caster).ActivePet != null)
					{
						failReason = SpellFailedReason.AlreadyHaveSummon;
					}
				}
			}
		}

		public float GetRadius(ObjectReference caster)
		{
			var radius = Radius;
			var chr = caster.UnitMaster;
			if (chr != null)
			{
				radius = chr.Auras.GetModifiedFloat(SpellModifierType.Radius, Spell, radius);
			}
			if (radius < 5)
			{
				return 5;
			}
			return radius;
		}

		public int CalcEffectValue(ObjectReference casterReference)
		{
			var caster = casterReference.UnitMaster;
			if (caster != null)
			{
				return CalcEffectValue(caster);
			}
			else
			{
				return CalcEffectValue(casterReference.Level, 0, false);
			}
		}

		internal AuraEffectHandler CreateAuraEffectHandler(ObjectReference caster,
			Unit target, ref SpellFailedReason failedReason, SpellCast triggeringCast)
		{
			var handler = AuraEffectHandlerCreator();

			if (triggeringCast != null &&
				triggeringCast.TriggerEffect != null &&
				triggeringCast.TriggerEffect.OverrideEffectValue)
			{
				if (Spell.Effects.Length > 1)
				{
					// it does not make sense to override multiple effects with a single effect...
					log.Warn("Spell {0} had overriding SpellEffect although the spell that was triggered had {2} (> 1) effects",
						Spell, Spell.Effects.Length);
				}
				handler.m_spellEffect = triggeringCast.TriggerEffect;
			}
			else
			{
				handler.m_spellEffect = this;
			}

			handler.BaseEffectValue = CalcEffectValue(caster);
			handler.CheckInitialize(triggeringCast, caster, target, ref failedReason);
			return handler;
		}

		/// <summary>		
		/// Check whether this handler can be applied to the given target.
		/// m_aura, as well as some other fields are not set when this method gets called.
		/// </summary>
		protected internal virtual void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
		}

		public AuraIndexId GetAuraUID(ObjectReference caster, WorldObject target)
		{
			return GetAuraUID(IsBeneficialFor(caster, target));
		}

        public static void WriteChanneledSpells()
        {
            List<Spell> spells = new List<Spell>(1000);
            foreach (Spell spell in SpellHandler.ById)
            {
                if (spell == null)
                    continue;

                if (spell.IsChanneled)
                {
                    spells.Add(spell);
                }
            }

            using (var writer = new StreamWriter(ToolConfig.OutputDir + "ChanneledSpells.txt", false))
            {
                var caster = new ObjectReference();
                foreach (var spell in spells)
                {
                    writer.WriteLine("Spell: " + spell);
                    bool hasAmpl = false;
                    bool hasCustomScript = false;
                    foreach (SpellEffect effect in spell.Effects)
                    {
                        effect.DumpInfo(writer, "\t");
                        hasAmpl = hasAmpl || effect.Amplitude > 0;
                        hasCustomScript = hasCustomScript || effect.IsScripted;
                    }
                    if (spell.GetDuration(caster, null) < 1)
                    {
                        Console.WriteLine(spell);
                    }
                    writer.WriteLine();
                    writer.WriteLine();
                }
            }
        }

		public static SpellCast ObtainPooledCast(ObjectReference caster, Map map, uint phase, ref Vector3 sourceLoc)
		{
			var cast = SpellCastPool.Obtain();
			cast.SetCaster(caster, map, phase, sourceLoc);
			return cast;
		}