public DecoratorIfElse(CanRunDecoratorDelegate runFunc, params Composite []children)
     : base(children)
 {
     Debug.Assert(runFunc != null);
     Debug.Assert(children.Count() == 2);
     Runner = runFunc;
 }

 public static Composite CastFocus(int spell, CanRunDecoratorDelegate condition)
 {
     return new Decorator(
         ret =>
         condition(ret) && SpellManager.CanCast(spell, Helpers.Focus) && SpellManager.Cast(spell, Helpers.Focus),
         new SpellLog(spell, Helpers.Focus));
 }

        public static Composite Cast(int spellId, CanRunDecoratorDelegate cond, WoWUnitDelegate target)
        {
            return new Decorator(ret => target != null && cond(ret) && CanCast(spellId),
                new Action(ret =>
                    {
                        SpellManager.Cast(spellId, target(ret));
                        Logging.Write(LogLevel.Diagnostic, Colors.White, "" + WoWSpell.FromId(spellId).Name);
                        string temp;
                        if (target(ret).IsPlayer)
                            temp = "Casting " + WoWSpell.FromId(spellId).Name + " on Player at " +
                                             Math.Round(target(ret).HealthPercent, 0) + " with " + Helpers.Rogue.me.ComboPoints + "CP and " +
                                             Rogue.mCurrentEnergy + " energy";
                        else
                            temp = "Casting " + WoWSpell.FromId(spellId).Name + " on " + target(ret).Name + " at " +
                                             Math.Round(target(ret).HealthPercent, 0) + " with " + Helpers.Rogue.me.ComboPoints + "CP and " +
                                             Rogue.mCurrentEnergy + " energy";

                        Logging.Write(LogLevel.Normal, temp );
                    }
                )
            );
        }

 public Composite TargetAoEPummel(CanRunDecoratorDelegate extra)
 {
     return new Decorator(ret => extra(ret) && Me.CurrentTarget != ((WoWUnit)AoECastingAdds().FirstOrDefault()),
                          new Action(delegate
                          {
                              ((WoWUnit)AoECastingAdds().FirstOrDefault()).Target();
                              Logging.Write("[DWCC]: Targeting AoE Pummel target.");
                          }
                              ));
 }

 public static Composite UseItem(WoWItemDelegate item, CanRunDecoratorDelegate cond)
 {
     return new Decorator(ret => item(ret) != null && cond(ret) && ItemUsable(item(ret)),
         new Action(ret =>
             {
                 item(ret).Use();
                 Logging.Write(LogLevel.Normal, item(ret).Name);
                 return RunStatus.Failure;
             }
         )
     );
 }

 /// <summary>
 ///   Creates a new Wait decorator using the specified timeout, run delegate, and child composite.
 /// </summary>
 /// <param name = "timeoutSeconds"></param>
 /// <param name = "runFunc"></param>
 /// <param name = "child"></param>
 public Wait(int timeoutSeconds, CanRunDecoratorDelegate runFunc, Composite child)
     : base(runFunc, child)
 {
     Timeout =  TimeSpan.FromSeconds(timeoutSeconds);
 }

 /// <summary>
 /// Allows waiting for SleepForLagDuration() but ending sooner if condition is met
 /// </summary>
 /// <param name="orUntil">if true will stop waiting sooner than lag maximum</param>
 /// <returns></returns>
 public static Composite CreateWaitForLagDuration( CanRunDecoratorDelegate orUntil)
 {
     return new WaitContinue(TimeSpan.FromMilliseconds((StyxWoW.WoWClient.Latency * 2) + 150), orUntil, new ActionAlwaysSucceed());
 }

        public static Composite BuffSelfAndWait(SimpleStringDelegate name, SimpleBooleanDelegate requirements = null, int expirSecs = 0, CanRunDecoratorDelegate until = null, bool measure = false, HasGcd gcd = HasGcd.Yes)
        {
            if (requirements == null)
                requirements = req => true;

            if (until == null)
                until = u => StyxWoW.Me.HasAura(name(u));

            return new Sequence(
                BuffSelf(name, requirements, expirSecs, gcd),
                new PrioritySelector(
                    new DynaWait(
                        time => TimeSpan.FromMilliseconds(Me.Combat ? 500 : 1000),
                        until,
                        new ActionAlwaysSucceed(),
                        measure
                        ),
                    new Action(r =>
                    {
                        Logger.WriteDiagnostic("BuffSelfAndWait: buff of [{0}] failed", name(r));
                        return RunStatus.Failure;
                    })
                    )
                );
        }

 /// <summary>
 ///   Creates a new Wait decorator using the specified timeout, run delegate, and child composite.
 /// </summary>
 /// <param name = "timeoutSeconds"></param>
 /// <param name = "runFunc"></param>
 /// <param name = "child"></param>
 public Wait(int timeoutSeconds, CanRunDecoratorDelegate runFunc, Composite child)
     : base(runFunc, child)
 {
     Timeout = new TimeSpan(0, 0, timeoutSeconds);
 }

 public Composite FindThreats(CanRunDecoratorDelegate cond, RefineFilter filter, Comparison<HealableUnit> compare, string reason, params Composite[] children)
 {
     return FindTarget(cond, TargetFilter.Threats, filter, compare, "[CLU TARGETING] " + CLU.Version + ": " + "Targeting THREAT {0}:  Max {1}, Current {2}, Defecit {3}, TimeTaken: {4} ms, REASON: " + reason, children);
 }

 /// <summary>Targeting myself when no target</summary>
 /// <param name="cond">The conditions that must be true</param>
 /// <returns>Target myself</returns>
 public static Composite EnsureTarget(CanRunDecoratorDelegate cond)
 {
     return new Decorator(
                cond,
                new Sequence(
                    new Action(a => CLULogger.TroubleshootLog("[CLU] " + CLU.Version + ": CLU targeting activated. I dont have a target, someone must have died. Targeting myself")),
                    new Action(a => Me.Target())));
 }

 public static Composite Cast(int spell, WoWUnit target, CanRunDecoratorDelegate condition)
 {
     return new Decorator(
         ret => condition(ret) && SpellManager.CanCast(spell, target) && SpellManager.Cast(spell, target),
         new SpellLog(spell, target));
 }

        public static Composite UseSpecialAbilities(CanRunDecoratorDelegate cond)
        {
            return new PrioritySelector(
                UseItem(ret => mTrinket1, ret => cond(ret) && mTrinket1Usable),
                UseItem(ret => mTrinket2, ret => cond(ret) && mTrinket2Usable),
                UseItem(ret => mGloves, ret => cond(ret) && mGlovesUsable),

                new Decorator(ret => mRacialName != null && Helpers.Rogue.mCurrentEnergy < 65 && mRacialName.Equals("Arcane Torrent"),
                    Spells.CastSelf(mRacialName)),

                new Decorator(ret => mRacialName != null && mRacialName.Length > 3 && !mRacialName.Equals("Arcane Torrent"),
                    Spells.CastSelf(mRacialName))
            );
        }

 /// <summary>Attempts to use the bag item provided it is usable and its not on cooldown</summary>
 /// <param name="name">the name of the bag item to use</param>
 /// <param name="cond">The conditions that must be true</param>
 /// <param name="label">A descriptive label for the clients GUI logging output</param>
 /// <returns>The use bag item.</returns>
 public static Composite UseBagItem(string name, CanRunDecoratorDelegate cond, string label)
 {
     WoWItem item = null;
     return new Decorator(
         delegate(object a) {
             if (!cond(a))
                 return false;
             item = Me.BagItems.FirstOrDefault(x => x.Name == name && x.Usable && x.Cooldown <= 0);
             return item != null;
     },
     new Sequence(
         new Action(a => CLULogger.Log(" [BagItem] {0} ", label)),
         new Action(a => item.UseContainerItem())));
 }

 /// <summary>Runs Lua MacroText</summary>
 /// <param name="macro">the macro text to run</param>
 /// <param name="cond">The conditions that must be true</param>
 /// <param name="label">A descriptive label for the clients GUI logging output</param>
 /// <returns>The run macro text.</returns>
 public static Composite RunMacroText(string macro, CanRunDecoratorDelegate cond, string label)
 {
     return new Decorator(
                cond,
                new Sequence(
                    new Action(a => CLULogger.Log(" [RunMacro] {0} ", label)),
                    new Action(a => Lua.DoString("RunMacroText(\"" + Spell.RealLuaEscape(macro) + "\")"))));
 }

        /// <summary>
        /// Finds a target that does not have the specified spell and applys it.
        /// </summary>
        /// <param name="cond">The conditions that must be true</param>
        /// <param name="spell">The spell to be cast</param>
        /// <returns>success we have aquired a target and failure if not.</returns>
        public static Composite FindMultiDotTarget(CanRunDecoratorDelegate cond, string spell)
        {
            return new Decorator(
                       cond,
                       new Sequence(
                // get a target
                           new Action(
                            delegate
                            {
                                if (!CLUSettings.Instance.EnableMultiDotting)
                                {
                                    return RunStatus.Failure;
                                }

                                WoWUnit target = EnemyRangedUnits.FirstOrDefault(u => !u.HasAura(spell) && u.Distance2DSqr < 40 * 40);
                                if (target != null)
                                {
                                    CLULogger.DiagnosticLog(target.Name);
                                    target.Target();
                                    return RunStatus.Success;
                                }

                                return RunStatus.Failure;
                            }),
                           new Action(a => StyxWoW.SleepForLagDuration()),
                // if success, keep going. Else quit
                           new PrioritySelector(Buff.CastDebuff(spell, cond, spell))));
        }

 /// <summary>
 /// Finds a Party that needs healing
 /// </summary>
 /// <param name="cond">The conditions that must be true</param>
 /// <param name="minAverageHealth">Minimum Average health of the Party Members</param>
 /// <param name="maxAverageHealth">MaximumAverage health of the Party Members</param>
 /// <param name="maxDistanceBetweenPlayers">The maximum distance between other party members from the targeted party member</param>
 /// <param name="minUnits">Minumum units to be affected</param>
 /// <param name="reason">text to indicate the reason for using this method </param>
 /// <param name="children">Execute the child subroutines</param>
 /// <returns>A party member</returns>
 public Composite FindParty(CanRunDecoratorDelegate cond, int minAverageHealth, int maxAverageHealth, float maxDistanceBetweenPlayers, int minUnits, string reason, params Composite[] children)
 {
     return new Decorator(
                cond,
                new Sequence(
                    new PrioritySelector(
                        FindPartySubroutine(0, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 1 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(1, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 2 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(2, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 3 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(3, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 4 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(4, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 5 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(5, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 6 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(6, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 7 MEMBER: {0} REASON: " + reason),
                        FindPartySubroutine(7, minAverageHealth, maxAverageHealth, maxDistanceBetweenPlayers, minUnits, "[CLU TARGETING] " + CLU.Version + ": " + "Target PARTY 8 MEMBER: {0} REASON: " + reason)
                    ),
                    new Action(a => StyxWoW.SleepForLagDuration()),
         // if success, keep going. Else quit sub routine
                    new PrioritySelector(children)
                )
            );
 }

 public static Composite CastStatus(int spell, CanRunDecoratorDelegate conditions)
 {
     return new Decorator(ret => conditions(ret) && SpellManager.CanCast(spell),
                          new Action(context =>
                                         {
                                             if (SpellManager.Cast(spell))
                                             {
                                                 LogSpell(spell);
                                                 return RunStatus.Success;
                                             }
                                             return RunStatus.Failure;
                                         }));
 }

        private static Composite FindTarget(CanRunDecoratorDelegate cond, TargetFilter filter, RefineFilter refineFilter, Comparison<HealableUnit> compare, string label, params Composite[] children)
        {
            return new Decorator(
                       cond,
                       new Sequence(
                         // get a target
                           new Action(
                            delegate
                            {
                                var targetPerformanceTimer = new Stopwatch(); // lets see if we can get some performance on this one.
                                targetPerformanceTimer.Start(); // lets see if we can get some performance on this one.

                                //CrabbyProfiler.Instance.Runs.Add(new Run("FindTarget"));

                                // Nothing to filter against
                                if (!UnitsFilter(filter).Any())
                                {
                                    HealableUnit.HealTarget = null;
                                    return RunStatus.Failure;
                                }

                                // Filter the Healable Units
                                var raid = UnitsFilter(filter).Where(x => x != null && (ObjectManager.ObjectList.Any(y => y.Guid == x.ToUnit().Guid) && refineFilter(x)) && x.ToUnit().Distance2DSqr < 40 * 40 && !x.ToUnit().ToPlayer().IsGhost && !x.ToUnit().HasAura("Deep Corruption")).ToList();

                                // Nothing to heal.
                                if (!IsPlayingWoW() || !raid.Any())
                                {
                                    HealableUnit.HealTarget = null;
                                    return RunStatus.Failure;
                                }

                                raid.Sort(compare);
                                var target = raid.FirstOrDefault();
                                if (target != null)
                                {
                                    Log(
                                        label,
                                        CLULogger.SafeName(target.ToUnit()),
                                        target.MaxHealth,
                                        target.CurrentHealth,
                                        target.MaxHealth - target.CurrentHealth,
                                        targetPerformanceTimer.ElapsedMilliseconds); // lets see if we can get some performance on this one.

                                    //target.ToUnit().Target();
                                    HealableUnit.HealTarget = target;
                                    return RunStatus.Success;
                                }
                                HealableUnit.HealTarget = null;
                                //CrabbyProfiler.Instance.EndLast();
                                return RunStatus.Failure;
                            }),
                           new Action(a => StyxWoW.SleepForLagDuration()),
                // if success, keep going. Else quit sub routine
                           new PrioritySelector(children)));
        }

 public DecoratorContinue(CanRunDecoratorDelegate func, Composite decorated)
     : base(func, decorated)
 {
 }