context: #region License
  
  /*
   Copyright 2014 - 2015 Nikita Bernthaler
   UltimateManager.cs is part of SFXChallenger.
  
   SFXChallenger is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
  
   SFXChallenger is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with SFXChallenger. If not, see <http://www.gnu.org/licenses/>.
  */
  
  #endregion License
  
  #region
  
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using LeagueSharp;
  using LeagueSharp.Common;
  using SFXChallenger.Args;
  using SFXChallenger.Enumerations;
  using SFXChallenger.Library;
  using SFXChallenger.Library.Logger;
  using Spell = SFXChallenger.Wrappers.Spell;
  using Utils = SFXChallenger.Helpers.Utils;
  
  #endregion
  
  namespace SFXChallenger.Managers
  {
      public class UltimateManager
      {
          private bool _autoDamageCheck = true;
          private int _damagePercent = 100;
          private bool _forceDamageCheck = true;
          private Menu _menu;
          private int _singleDamagePercent = 150;
          public bool Combo { get; set; }
          public bool Assisted { get; set; }
          public bool Auto { get; set; }
          public bool Flash { get; set; }
          public bool Required { get; set; }
          public bool Force { get; set; }
          public bool Gapcloser { get; set; }
          public bool GapcloserDelay { get; set; }
          public bool Interrupt { get; set; }
          public bool InterruptDelay { get; set; }
          public List<Spell> Spells { get; set; }
          public Func<Obj_AI_Hero, float, bool, float> DamageCalculation { get; set; }
  
          public int DamagePercent
          {
              get { return _damagePercent; }
              set { _damagePercent = Math.Min(200, Math.Max(1, value)); }
          }
  
          public int SingleDamagePercent
          {
              get { return _singleDamagePercent; }
              set { _singleDamagePercent = Math.Min(200, Math.Max(1, value)); }
          }
  
          public bool ForceDamageCheck
          {
              get { return _forceDamageCheck; }
              set { _forceDamageCheck = value; }
          }
  
          public bool ComboDamageCheck { get; set; }
  
          public bool AutoDamageCheck
          {
              get { return _autoDamageCheck; }
              set { _autoDamageCheck = value; }
          }
  
          public bool AssistedDamageCheck { get; set; }
  
          public Menu AddToMenu(Menu menu)
          {
              try
              {
                  _menu = menu;
  
                  var ultimateMenu = menu.AddSubMenu(new Menu("Ultimate", menu.Name + ".ultimate"));
  
                  if (Required)
                  {
                      var requiredMenu =
                          ultimateMenu.AddSubMenu(new Menu("Required Targets", ultimateMenu.Name + ".required"));
  
                      var modes = new List<UltimateModeType>();
                      if (Combo)
                      {
                          modes.Add(UltimateModeType.Combo);
                      }
                      if (Auto)
                      {
                          modes.Add(UltimateModeType.Auto);
                      }
                      if (Assisted)
                      {
                          modes.Add(UltimateModeType.Assisted);
                      }
  
                      requiredMenu.AddItem(
                          new MenuItem(requiredMenu.Name + ".mode", "Mode").SetValue(
                              new StringList(modes.Select(m => m.ToString()).ToArray()))).ValueChanged +=
                          delegate(object sender, OnValueChangeEventArgs eventArgs)
                          {
                              Utils.UpdateVisibleTags(requiredMenu, eventArgs.GetNewValue<StringList>().SelectedIndex + 1);
                          };
  
                      for (var i = 0; i < modes.Count; i++)
                      {
                          requiredMenu.AddItem(
                              new MenuItem(
                                  requiredMenu.Name + "." + GetModeString(modes[i], true) + ".min", "Min. Required")
                                  .SetValue(new Slider(1, 1, 5))).SetTag(i + 1);
                          HeroListManager.AddToMenu(
                              requiredMenu,
                              new HeroListManagerArgs("ultimate-required-" + GetModeString(modes[i], true))
                              {
                                  IsWhitelist = true,
                                  Allies = false,
                                  Enemies = true,
                                  DefaultValue = false,
                                  DontSave = true,
                                  Enabled = true,
                                  MenuTag = i + 1,
                                  EnabledButton = false
                              });
                      }
  
                      Utils.UpdateVisibleTags(
                          requiredMenu, _menu.Item(requiredMenu.Name + ".mode").GetValue<StringList>().SelectedIndex + 1);
                  }
  
                  if (Force)
                  {
                      var uForceMenu = ultimateMenu.AddSubMenu(new Menu("Forced Targets", ultimateMenu.Name + ".force"));
                      if (DamageCalculation != null)
                      {
                          uForceMenu.AddItem(
                              new MenuItem(uForceMenu.Name + ".damage-check", "Damage Check").SetValue(ForceDamageCheck));
                      }
                      uForceMenu.AddItem(
                          new MenuItem(uForceMenu.Name + ".additional", "Additional Targets").SetValue(
                              new Slider(0, 0, 4)));
                      HeroListManager.AddToMenu(
                          uForceMenu,
                          new HeroListManagerArgs("ultimate-force")
                          {
                              IsWhitelist = true,
                              Allies = false,
                              Enemies = true,
                              DefaultValue = false,
                              DontSave = true,
                              Enabled = true,
                              EnabledButton = false
                          });
                  }
  
                  if (Combo)
                  {
                      var uComboMenu = ultimateMenu.AddSubMenu(new Menu("Combo", ultimateMenu.Name + ".combo"));
                      uComboMenu.AddItem(
                          new MenuItem(uComboMenu.Name + ".min", "Min. Hits").SetValue(new Slider(2, 1, 5)));
                      if (DamageCalculation != null)
                      {
                          uComboMenu.AddItem(
                              new MenuItem(uComboMenu.Name + ".damage-check", "Damage Check").SetValue(ComboDamageCheck));
                      }
                      uComboMenu.AddItem(new MenuItem(uComboMenu.Name + ".enabled", "Enabled").SetValue(true));
                  }
  
                  if (Auto)
                  {
                      var uAutoMenu = ultimateMenu.AddSubMenu(new Menu("Auto", ultimateMenu.Name + ".auto"));
                      if (Interrupt)
                      {
                          var autoInterruptMenu =
                              uAutoMenu.AddSubMenu(new Menu("Interrupt", uAutoMenu.Name + ".interrupt"));
                          if (InterruptDelay)
                          {
                              DelayManager.AddToMenu(
                                  autoInterruptMenu, "ultimate-interrupt-delay", string.Empty, 0, 0, 500);
                          }
                          HeroListManager.AddToMenu(
                              autoInterruptMenu,
                              new HeroListManagerArgs("ultimate-interrupt")
                              {
                                  IsWhitelist = false,
                                  Allies = false,
                                  Enemies = true,
                                  DefaultValue = false,
                                  DontSave = false,
                                  Enabled = true
                              });
                      }
                      if (Gapcloser)
                      {
                          var autoGapcloserMenu =
                              uAutoMenu.AddSubMenu(new Menu("Gapcloser", uAutoMenu.Name + ".gapcloser"));
                          if (GapcloserDelay)
                          {
                              DelayManager.AddToMenu(
                                  autoGapcloserMenu, "ultimate-gapcloser-delay", string.Empty, 0, 0, 500);
                          }
                          HeroListManager.AddToMenu(
                              autoGapcloserMenu,
                              new HeroListManagerArgs("ultimate-gapcloser")
                              {
                                  IsWhitelist = false,
                                  Allies = false,
                                  Enemies = true,
                                  DefaultValue = false,
                                  DontSave = false,
                                  Enabled = false
                              });
                          BestTargetOnlyManager.AddToMenu(autoGapcloserMenu, "r-gapcloser", true);
                      }
                      uAutoMenu.AddItem(new MenuItem(uAutoMenu.Name + ".min", "Min. Hits").SetValue(new Slider(3, 1, 5)));
                      if (DamageCalculation != null)
                      {
                          uAutoMenu.AddItem(
                              new MenuItem(uAutoMenu.Name + ".damage-check", "Damage Check").SetValue(AutoDamageCheck));
                      }
                      uAutoMenu.AddItem(new MenuItem(uAutoMenu.Name + ".enabled", "Enabled").SetValue(true));
                  }
  
                  if (Assisted)
                  {
                      var uAssistedMenu = ultimateMenu.AddSubMenu(new Menu("Assisted", ultimateMenu.Name + ".assisted"));
                      if (Flash)
                      {
                          uAssistedMenu.AddItem(
                              new MenuItem(ultimateMenu.Name + ".flash.min", "Flash Min. Hits").SetValue(
                                  new Slider(3, 1, 5)));
                      }
                      uAssistedMenu.AddItem(
                          new MenuItem(uAssistedMenu.Name + ".min", "Min. Hits").SetValue(new Slider(1, 1, 5)));
                      if (Flash)
                      {
                          uAssistedMenu.AddItem(
                              new MenuItem(ultimateMenu.Name + ".flash.hotkey", "Flash").SetValue(
                                  new KeyBind('Y', KeyBindType.Press)));
                      }
                      uAssistedMenu.AddItem(
                          new MenuItem(uAssistedMenu.Name + ".hotkey", "Hotkey").SetValue(
                              new KeyBind('T', KeyBindType.Press)));
                      uAssistedMenu.AddItem(
                          new MenuItem(uAssistedMenu.Name + ".move-cursor", "Move to Cursor").SetValue(true));
  
gt:                     if (DamageCalculation != null)