using OKTW.Prediction;
using SharpDX;
using System.Collections.Generic;
using System.Linq;

namespace OKTW
{
    internal class Zed
    {
        internal enum UltCastStage
        {
            First,
            Second,
            Cooldown
        }

        internal enum ShadowCastStage
        {
            First,
            Second,
            Cooldown
        }

        private static int countults;

        private static int clockon;

        private static int countdanger;

        private static Spell _q;

        private static Spell _w;

        private static Spell _e;

        private static Spell _r;

        public static Menu _config;

        private static AIBaseClient _player => ObjectManager.Player;

        private static Vector3 rpos;

        private static int RcatTime;

        public static Menu TargetSelectorMenu;

        private static Vector3 linepos;

        public static List<string> DangerousList = new List<string>
        {
            "AatroxQ",
            "AhriSeduce",
            "CurseoftheSadMummy",
            "InfernalGuardian",
            "EnchantedCrystalArrow",
            "AzirR",
            "BrandWildfire",
            "CassiopeiaPetrifyingGaze",
            "DariusExecute",
            "DravenRCast",
            "EvelynnR",
            "EzrealTrueshotBarrage",
            "Terrify",
            "GalioIdolOfDurand",
            "GarenR",
            "GravesChargeShot",
            "HecarimUlt",
            "LissandraR",
            "LuxMaliceCannon",
            "UFSlash",
            "AlZaharNetherGrasp",
            "OrianaDetonateCommand",
            "LeonaSolarFlare",
            "SejuaniGlacialPrisonStart",
            "SonaCrescendo",
            "VarusR",
            "GragasR",
            "GnarR",
            "FizzMarinerDoom",
            "SyndraR"
        };

        public static bool UserR = false;

        private static int delayw = 500;

        private static int shadowdelay = 0;

        private static AIBaseClient GetEnemy
        {
            get
            {
                int assassinRange = TargetSelectorMenu.ItemAt("AssassinSearchRange").GetValue<Slider>().Value;
                IEnumerable<AIBaseClient> enumerable = from enemy in ObjectManager.GetHeroes(Enemies: true)
                                                      where enemy.Team != ObjectManager.Player.Team && !enemy.IsDead && enemy.IsVisible && TargetSelectorMenu.ItemAt("Assassin" + enemy.ChampionName) != null && TargetSelectorMenu.ItemAt("Assassin" + enemy.ChampionName).GetValue<bool>() && ObjectManager.Player.Distance(enemy.ServerPosition) < assassinRange
                                                      select enemy;
                if (TargetSelectorMenu.ItemAt("AssassinSelectOption").GetValue<StringList>().SelectedIndex == 1)
                {
                    enumerable = from vEn in enumerable
                                 select (vEn) into vEn
                                 orderby vEn.MaxHealth descending
                                 select vEn;
                }
                AIBaseClient[] array = (enumerable as AIBaseClient[]) ?? enumerable.ToArray();
                return (!array.Any()) ? TargetSelector.GetTarget(1400f, DamageType.Magical) : array[0];
            }
        }

        private static UltCastStage UltStage
        {
            get
            {
                if (!_r.IsReady)
                {
                    return UltCastStage.Cooldown;
                }
                if (!(_r.Name == "ZedR"))
                {
                    return UltCastStage.Second;
                }
                return UltCastStage.First;
            }
        }

        private static ShadowCastStage ShadowStage
        {
            get
            {
                if (!_w.IsReady)
                {
                    return ShadowCastStage.Cooldown;
                }
                if (!(_w.Name == "ZedW"))
                {
                    return ShadowCastStage.Second;
                }
                return ShadowCastStage.First;
            }
        }

        private static AIBaseClient WShadow => ObjectManager.GetMinions().FirstOrDefault((AIBaseClient minion) => minion.IsVisible && (minion.ServerPosition != rpos || Utils.TickCount - RcatTime > 6000) && minion.ServerPosition.DistanceToPlayer() < 3000 && !minion.IsDead && minion.ChampionName == "ZedShadow");

        private static AIBaseClient RShadow => ObjectManager.GetMinions().FirstOrDefault((AIBaseClient minion) => minion.IsVisible && Utils.TickCount - RcatTime < 6000 && minion.ServerPosition == rpos && minion.ServerPosition.DistanceToPlayer() < 3000 && !minion.IsDead && minion.ChampionName == "ZedShadow");

        public static void Main()
        {
            if (!(ObjectManager.Player.ChampionName != "Zed"))
            {

                _q = new Spell(SpellSlot.Q, 900f);
                _w = new Spell(SpellSlot.W, 700f);
                _e = new Spell(SpellSlot.E, 270f);
                _r = new Spell(SpellSlot.R, 650f);
                _q.SetSkillshot(0.25f, 50f, 1700f, collision: false, SkillshotType.SkillshotLine);
                _w.SetSkillshot(0.75f, 75f, 1000f, collision: false, SkillshotType.SkillshotLine);
                _config = new Menu("Zed Is Back", "Zed Is Back", isRootMenu: true);
                TargetSelectorMenu = new Menu("Target Selector", "Target Selector");
                _config.AddSubMenu(TargetSelectorMenu);
                _config.AddSubMenu(new Menu("Combo", "Combo"));
                _config.SubMenu("Combo").AddItem(new MenuItem("UseWC", "Use W")).SetValue(newValue: false);
                _config.SubMenu("Combo").AddItem(new MenuItem("UseWCA", "Use W also gap close")).SetValue(newValue: false);
                _config.SubMenu("Combo").AddItem(new MenuItem("ActiveCombo", "Combo!").SetValue(new KeyBind(32u, KeyBindType.Press)));
                _config.SubMenu("Combo").AddItem(new MenuItem("TheLine", "The Line Combo").SetValue(new KeyBind("T".ToCharArray()[0], KeyBindType.Press)));
                _config.AddSubMenu(new Menu("Harass", "Harass"));
                _config.SubMenu("Harass").AddItem(new MenuItem("longhar", "Long Poke (toggle)").SetValue(new KeyBind("U".ToCharArray()[0], KeyBindType.Toggle)));
                _config.SubMenu("Harass").AddItem(new MenuItem("UseWH", "Use W")).SetValue(newValue: true);
                _config.SubMenu("Harass").AddItem(new MenuItem("ActiveHarass", "Harass!").SetValue(new KeyBind("C".ToCharArray()[0], KeyBindType.Press)));
                _config.AddSubMenu(new Menu("Farm", "Farm"));
                _config.SubMenu("Farm").AddSubMenu(new Menu("LaneFarm", "LaneFarm"));
                _config.SubMenu("Farm").SubMenu("LaneFarm").AddItem(new MenuItem("UseQL", "Q LaneClear"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("LaneFarm").AddItem(new MenuItem("UseEL", "E LaneClear"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("LaneFarm").AddItem(new MenuItem("Energylane", "Energy Lane% >").SetValue(new Slider(45, 1)));
                _config.SubMenu("Farm").SubMenu("LaneFarm").AddItem(new MenuItem("Activelane", "Lane clear!").SetValue(new KeyBind("V".ToCharArray()[0], KeyBindType.Press)));
                _config.SubMenu("Farm").AddSubMenu(new Menu("LastHit", "LastHit"));
                _config.SubMenu("Farm").SubMenu("LastHit").AddItem(new MenuItem("UseQLH", "Q LastHit"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("LastHit").AddItem(new MenuItem("UseELH", "E LastHit"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("LastHit").AddItem(new MenuItem("Energylast", "Energy lasthit% >").SetValue(new Slider(85, 1)));
                _config.SubMenu("Farm").SubMenu("LastHit").AddItem(new MenuItem("ActiveLast", "LastHit!").SetValue(new KeyBind("X".ToCharArray()[0], KeyBindType.Press)));
                _config.SubMenu("Farm").AddSubMenu(new Menu("Jungle", "Jungle"));
                _config.SubMenu("Farm").SubMenu("Jungle").AddItem(new MenuItem("UseQJ", "Q Jungle"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("Jungle").AddItem(new MenuItem("UseWJ", "W Jungle"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("Jungle").AddItem(new MenuItem("UseEJ", "E Jungle"))
                    .SetValue(newValue: true);
                _config.SubMenu("Farm").SubMenu("Jungle").AddItem(new MenuItem("Energyjungle", "Energy Jungle% >").SetValue(new Slider(85, 1)));
                _config.SubMenu("Farm").SubMenu("Jungle").AddItem(new MenuItem("Activejungle", "Jungle!").SetValue(new KeyBind("V".ToCharArray()[0], KeyBindType.Press)));
                _config.AddSubMenu(new Menu("Misc", "Misc"));
                _config.SubMenu("Misc").AddItem(new MenuItem("UseQM", "Use Q KillSteal")).SetValue(newValue: true);
                _config.SubMenu("Misc").AddItem(new MenuItem("UseEM", "Use E KillSteal")).SetValue(newValue: true);
                _config.SubMenu("Misc").AddItem(new MenuItem("AutoE", "Auto E")).SetValue(newValue: true);
                _config.SubMenu("Misc").AddItem(new MenuItem("rdodge", "R Dodge Dangerous")).SetValue(newValue: true);
                _config.SubMenu("Misc").AddItem(new MenuItem("", ""));
                foreach (AIBaseClient hero in ObjectManager.GetHeroes(Enemies: true))
                {
                    Spell spe = new Spell(SpellSlot.R, hero);
                    if (DangerousList.Any((string spell) => spell.Contains(spe.Name)))
                    {
                        _config.SubMenu("Misc").AddItem(new MenuItem("ds" + hero.ChampionName, spe.Name)).SetValue(newValue: true);
                    }
                }
                Menu menu = _config.AddSubMenu(new Menu("Drawings", "Drawings"));
                menu.AddItem(new MenuItem("DrawQ", "Draw Q Range").SetValue(newValue: true));
                menu.AddItem(new MenuItem("DrawW", "Draw W Range").SetValue(newValue: true));
                menu.AddItem(new MenuItem("DrawE", "Draw E Range").SetValue(newValue: true));
                menu.AddItem(new MenuItem("DrawR", "Draw R Range").SetValue(newValue: true));
                new ZedAssassinManager();
                _config.AddToMainMenu();
                AIBaseClient.OnCreate += OnCreate;
                Game.OnUpdate += OnUpdate;
                AIBaseClient.OnProcessSpellCast += OnProcessSpell;
                Drawing.OnDraw += OnDraw;
                Game.OnWndProc += Game_OnWndProc;
            }
        }

        private static void OnProcessSpell(AIBaseClient unit, GameObjectProcessSpellCastEventArgs castedSpell)
        {
            if (unit.Type != GameObjectType.AIHeroClient)
            {
                return;
            }
            if (unit.IsEnemy && unit.IsValidTarget(_r.Range + 100f) && DangerousList.Any((string spell) => spell.Contains(castedSpell.SpellName)) && _config.ItemAt("rdodge").GetValue<bool>() && _r.IsReady && UltStage == UltCastStage.First)
            {
                MenuItem menuItem = _config.ItemAt("ds" + unit.ChampionName);
                if (menuItem == null || !menuItem.GetValue<bool>())
                {
                    return;
                }
                if (unit.Distance(_player.ServerPosition) < 650f || _player.Distance(castedSpell.End) <= 250f)
                {
                    if (castedSpell.SpellName == "SyndraR")
                    {
                        clockon = Utils.TickCount + 150;
                        countdanger++;
                    }
                    else
                    {
                        AIBaseClient target = TargetSelector.GetTarget(640f, DamageType.Physical);
                        _r.CastOnUnit(target);
                    }
                }
            }
            if (unit.IsMe && castedSpell.slot == SpellSlot.R)
            {
                RcatTime = Utils.TickCount;
            }
        }

        public static void OnCreate(GameObject sender)
        {
            if (!sender.IsMinion)
                return;


            var o = sender as AIMinionClient;
            if (o.IsMinion && Utils.TickCount - RcatTime < 200 && o.ChampionName == "ZedShadow" && !o.IsEnemy && o.DistanceToPlayer() < 3000)
            {
                rpos = o.ServerPosition;
            }
        }

        private static void OnUpdate()
        {
            if (_config.ItemAt("ActiveCombo").GetValue<KeyBind>().Active)
            {
                Combo(GetEnemy);
            }
            if (_config.ItemAt("ActiveHarass").GetValue<KeyBind>().Active)
            {
                Harass(GetEnemy);
            }
            if (_config.ItemAt("TheLine").GetValue<KeyBind>().Active)
            {
                TheLine(GetEnemy);
            }
            if (_config.ItemAt("Activelane").GetValue<KeyBind>().Active)
            {
                Laneclear();
            }
            if (_config.ItemAt("Activejungle").GetValue<KeyBind>().Active)
            {
                JungleClear();
            }
            if (_config.ItemAt("ActiveLast").GetValue<KeyBind>().Active)
            {
                LastHit();
            }
            if (_config.ItemAt("AutoE").GetValue<bool>())
            {
                CastE();
            }
            if (Utils.TickCount >= clockon && countdanger > countults)
            {
                AIBaseClient target = TargetSelector.GetTarget(640f, DamageType.Physical);
                if (target != null)
                {
                    _r.CastOnUnit(target);
                    countults++;
                }
            }
            KillSteal();
        }

        private static void TheLine(AIBaseClient t)
        {
            if (t == null)
            {
                Orbwalking.MoveTo(Game.CursorPosition);
            }
            else if (Orbwalking.CanAttack() && Orbwalking.InAutoAttackRange(t))
            {
                Orbwalking.AttackTarget(t);
            }
            else if (Orbwalking.CanMove(50f))
            {
                Orbwalking.MoveTo(Game.CursorPosition);
            }
            if (!_r.IsReady || (t != null && t.Distance(_player.ServerPosition) >= 640f))
            {
                return;
            }
            if (t != null && UltStage == UltCastStage.First)
            {
                _r.CastOnUnit(t);
            }
            if (t != null)
            {
                linepos = t.ServerPosition.Extend(_player.ServerPosition, -500f);
            }
            if (t != null && ShadowStage == ShadowCastStage.First && UltStage == UltCastStage.Second)
            {
                if (Utils.TickCount - _w.LastCastAttemptT > 500)
                {
                    _w.Cast(linepos);
                }
                CastE();
                CastQ(t);
            }
            if (t != null && WShadow != null && UltStage == UltCastStage.Second && t.Distance(_player.ServerPosition) > 250f && t.Distance(WShadow.ServerPosition) < t.Distance(_player.ServerPosition))
            {
                _w.Cast();
            }
        }

        private static void KillSteal()
        {
            AIBaseClient target = TargetSelector.GetTarget(_q.Range, DamageType.Physical);
            if (target == null)
            {
                return;
            }
            if (target.IsValidTarget() && _q.IsReady && _config.ItemAt("UseQM").GetValue<bool>() && GetQDamage(target) > target.Health)
            {
                if (_player.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.CastSpell(target);
                }
                else if (WShadow != null && WShadow.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.UpdateSourcePosition(WShadow.ServerPosition, WShadow.ServerPosition);
                    _q.CastSpell(target);
                }
                else if (RShadow != null && RShadow.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.UpdateSourcePosition(RShadow.ServerPosition, RShadow.ServerPosition);
                    _q.CastSpell(target);
                }
            }
            if (target.IsValidTarget() && _q.IsReady && _config.ItemAt("UseQM").GetValue<bool>() && GetQDamage(target) > target.Health)
            {
                if (_player.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.CastSpell(target);
                }
                else if (WShadow != null && WShadow.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.UpdateSourcePosition(WShadow.ServerPosition, WShadow.ServerPosition);
                    _q.CastSpell(target);
                }
            }
            if (WShadow != null && _e.IsReady && _config.ItemAt("UseEM").GetValue<bool>())
            {
                AIBaseClient target2 = TargetSelector.GetTarget(_e.Range, DamageType.Physical);
                if (target2 != null && GetEDamage(target2) > target2.Health && (_player.Distance(target2.ServerPosition) <= _e.Range || WShadow.Distance(target2.ServerPosition) <= _e.Range))
                {
                    _e.Cast();
                }
            }
        }

        private static void Laneclear()
        {
            var list = (from x in ObjectManager.GetMinions(Enemies: true)
                                      where x.IsValidTarget(_q.Range)
                                      select x).ToList();
            var list2 = (from x in ObjectManager.GetMinions(Enemies: true)
                                       where x.IsValidTarget(_e.Range)
                                       select x).ToList();
            bool flag = _player.Mana >= _player.MaxMana * _config.ItemAt("Energylane").GetValue<Slider>().Value / 100f;
            bool value = _config.ItemAt("UseQL").GetValue<bool>();
            bool value2 = _config.ItemAt("UseEL").GetValue<bool>();
            if ((_q.IsReady && value) & flag)
            {
                FarmLocation lineFarmLocation = _q.GetLineFarmLocation(list, _q.Width);
                if (lineFarmLocation.MinionsHit >= 3)
                {
                    _q.Cast(lineFarmLocation.Position.To3D());
                }
                else
                {
                    foreach (AIBaseClient item in list)
                    {
                        if (!Orbwalking.InAutoAttackRange(item) && item.Health < 0.75 * GetQDamage(item))
                        {
                            _q.Cast(item.ServerPosition);
                        }
                    }
                }
            }
            if ((_e.IsReady && value2) & flag)
            {
                if (list2.Count > 2)
                {
                    _e.Cast();
                }
                else
                {
                    foreach (AIBaseClient item2 in list2)
                    {
                        if (!Orbwalking.InAutoAttackRange(item2) && item2.Health < 0.75 * GetEDamage(item2))
                        {
                            _e.Cast();
                        }
                    }
                }
            }
        }

        private static void JungleClear()
        {
            var list = (from x in ObjectManager.GetNeutralMinions()
                                      where x.IsValidTarget(_q.Range)
                                      select x).ToList();
            bool flag = _player.Mana >= _player.MaxMana * _config.ItemAt("Energyjungle").GetValue<Slider>().Value / 100f;
            bool value = _config.ItemAt("UseQJ").GetValue<bool>();
            bool value2 = _config.ItemAt("UseWJ").GetValue<bool>();
            bool value3 = _config.ItemAt("UseEJ").GetValue<bool>();
            if (list.Count > 0)
            {
                AIBaseClient AIBaseClient = list[0];
                if (((flag && _w.IsReady) & value2) && _player.Distance(AIBaseClient.ServerPosition) < _q.Range)
                {
                    _w.Cast(AIBaseClient.Position);
                }
                if (flag && value && _q.IsReady && _player.Distance(AIBaseClient.ServerPosition) < _q.Range)
                {
                    CastQ(AIBaseClient);
                }
                if (((flag && _e.IsReady) & value3) && _player.Distance(AIBaseClient.ServerPosition) < _e.Range)
                {
                    _e.Cast();
                }
            }
        }

        private static void LastHit()
        {
            IEnumerable<AIBaseClient> enumerable = from x in ObjectManager.GetMinions(Enemies: true)
                                                  where x.IsValidTarget(_q.Range)
                                                  select x;
            bool flag = _player.Mana >= _player.MaxMana * _config.ItemAt("Energylast").GetValue<Slider>().Value / 100f;
            bool value = _config.ItemAt("UseQLH").GetValue<bool>();
            bool value2 = _config.ItemAt("UseELH").GetValue<bool>();
            foreach (AIBaseClient item in enumerable)
            {
                if (flag && value && _q.IsReady && _player.Distance(item.ServerPosition) < _q.Range && item.Health < 0.75 * GetQDamage(item))
                {
                    _q.Cast(item.ServerPosition);
                }
                if (((flag && _e.IsReady) & value2) && _player.Distance(item.ServerPosition) < _e.Range && item.Health < 0.95 * GetEDamage(item))
                {
                    _e.Cast();
                }
            }
        }

        private static void Harass(AIBaseClient t)
        {
            if (t == null)
            {
                return;
            }
            if (t.IsValidTarget() && !_w.IsReady && _q.IsReady)
            {
                _q.CastSpell(t);
            }
            if (t != null)
            {
                if (t.IsValidTarget() && _config.ItemAt("longhar").GetValue<KeyBind>().Active && _w.IsReady && _q.IsReady && ObjectManager.Player.Mana > _q.Mana + _w.Mana && t.Distance(_player.ServerPosition) > 850f && t.Distance(_player.ServerPosition) < 1400f)
                {
                    CastW(t);
                }
                if (WShadow != null && t.IsValidTarget() && (ShadowStage == ShadowCastStage.Second || ShadowStage == ShadowCastStage.Cooldown || !_config.ItemAt("UseWH").GetValue<bool>()) && _q.IsReady && (t.Distance(_player.ServerPosition) <= 900f || t.Distance(WShadow.ServerPosition) <= 900f))
                {
                    CastQ(t);
                }
                if (t.IsValidTarget() && _w.IsReady && _q.IsReady && _config.ItemAt("UseWH").GetValue<bool>() && ObjectManager.Player.Mana > _q.Mana + _w.Mana && t.Distance(_player.ServerPosition) < 750f)
                {
                    CastW(t);
                }
                CastE();
            }
        }

        private static void Game_OnWndProc(WndEventArgs args)
        {
            if (args.Msg == 514 && args.WParam == 2)
            {
                UserR = true;
            }
        }

        private static void Combo(AIBaseClient t)
        {
            if (t == null)
            {
                return;
            }
            if (_config.ItemAt("UseWC").GetValue<bool>() && _w.IsReady && t.IsValidTarget(_w.Range + _e.Range))
            {
                if (ObjectManager.Player.HasBuff("zedr2") && ShadowStage == ShadowCastStage.First)
                {
                    CastW(t);
                }
                if (ShadowStage == ShadowCastStage.First && ObjectManager.Player.Mana > _w.Mana + _q.Mana + (_e.IsReady ? _e.Mana : 0f))
                {
                    CastW(t);
                }
                if (ShadowStage == ShadowCastStage.Second && WShadow != null && _config.ItemAt("UseWCA").GetValue<bool>() && t.Distance(WShadow.ServerPosition) < t.Distance(_player.ServerPosition))
                {
                    _w.Cast();
                }
            }
            UserR = false;
            CastE();
            CastQ(t);
            if (_q.IsReady && t.IsValidTarget(_q.Range))
            {
                _q.CastSpell(t);
            }
        }

        private static void CastW(AIBaseClient target)
        {
            if (delayw < Utils.TickCount - shadowdelay && ShadowStage == ShadowCastStage.First && (!target.HasBuff("zedulttargetmark") || UltStage != UltCastStage.Cooldown))
            {
                Vector3 position = target.ServerPosition.Extend(ObjectManager.Player.Position, -200f);
                _w.Cast(position);
                shadowdelay = Utils.TickCount;
            }
        }

        private static void CastQ(AIBaseClient target)
        {
            if (_player == null)
                return;

            if (!_q.IsReady || target == null || WShadow == null)
            {
                return;
            }
            if (target.Distance(WShadow.ServerPosition) <= 900f && target.Distance(_player.ServerPosition) > 450f)
            {
                _q.UpdateSourcePosition(WShadow.ServerPosition, WShadow.ServerPosition);
                _q.CastSpell(target);
                return;
            }
            _q.UpdateSourcePosition(_player.ServerPosition, _player.ServerPosition);
            PredictionOutput prediction = _q.GetPrediction(target);
            if (prediction.CastPosition.Distance(_player.ServerPosition) < 900f)
            {
                _q.CastSpell(target);
            }
        }

        private static void CastE()
        {
            if (_e.IsReady && (ObjectManager.GetHeroes(Enemies: true).Count((AIBaseClient hero) => hero.IsValidTarget() && hero.Distance(ObjectManager.Player.ServerPosition) <= _e.Range) > 0 || GetShadows().Any((AIBaseClient shadow) => ObjectManager.GetHeroes(Enemies: true).Any((AIBaseClient enemy) => !enemy.IsDead && !enemy.IsZombie && enemy.Distance(shadow) < _e.Range && enemy.IsValidTarget()))))
            {
                _e.Cast();
            }
        }

        public static List<AIMinionClient> GetShadows()
        {
            var list = new List<AIMinionClient>();
            foreach (AIMinionClient item in from obj in ObjectManager.GetMinions()
                                         where obj.ChampionName.ToLowerInvariant().Contains("shadow") && ( ObjectManager.GetObjectByNetworkId(obj.Owner_Caster_NetworkId) is AIHeroClient caster ) && caster !=null && caster.IsMe && !obj.IsDead
                                         select obj)
            {
                list.Add(item);
            }
            return list;
        }

        private static float GetQDamage(AIBaseClient target)
        {
            int level = _q.Level;
            if (level == 0 || !_q.IsReady)
            {
                return 0f;
            }
            float num = 0f;
            num = 80f + (level - 1) * 35f + ObjectManager.Player.ExtraPhysicalAttack;
            return Damage.CalcPhysicalDamage(ObjectManager.Player, target, num);
        }

        private static float GetEDamage(AIBaseClient target)
        {
            int level = _e.Level;
            if (level == 0 || !_e.IsReady)
            {
                return 0f;
            }
            float num = 0f;
            num = 70f + (level - 1) * 25f + ObjectManager.Player.ExtraPhysicalAttack * 0.8f;
            return Damage.CalcMagicDamage(ObjectManager.Player, target, num);
        }

        private static void OnDraw()
        {
            if (_config.GetBool("DrawQ") && _q.IsReady)
            {
           
                Render.Circle.DrawCircle(ObjectManager.Player.Position, (int)_q.Range, System.Drawing.Color.LimeGreen);
            }
            if (_config.GetBool("DrawW") && _w.IsReady)
            {
                Render.Circle.DrawCircle(ObjectManager.Player.Position, (int)_w.Range, System.Drawing.Color.LimeGreen);
            }
            if (_config.GetBool("DrawE") && _e.IsReady)
            {
                Render.Circle.DrawCircle(ObjectManager.Player.Position, (int)_e.Range, System.Drawing.Color.LimeGreen);
            }
            if (_config.GetBool("DrawR") && _r.IsReady)
            {
                Render.Circle.DrawCircle(ObjectManager.Player.Position, (int)_r.Range, System.Drawing.Color.LimeGreen);
            }
        }
    }
}