CoreAdvanced.cs

/*
name: null
description: null
tags: null
*/
//cs_include Scripts/CoreBots.cs
//cs_include Scripts/CoreFarms.cs
using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using CommunityToolkit.Mvvm.DependencyInjection;
using Newtonsoft.Json;
using Skua.Core.Interfaces;
using Skua.Core.Models;
using Skua.Core.Models.Items;
using Skua.Core.Models.Monsters;
using Skua.Core.Models.Quests;
using Skua.Core.Models.Shops;
using Skua.Core.Options;
using Skua.Core.Utils;

public class CoreAdvanced
{
    private IScriptInterface Bot => IScriptInterface.Instance;
    private CoreBots Core => CoreBots.Instance;
    private static CoreFarms Farm { get => _Farm ??= new CoreFarms(); set => _Farm = value; }
    private static CoreFarms _Farm;

    // Thousand-level Constants
    const int OneK = 1000;        // 1k
    const int TenK = 10000;       // 10k
    const int OneHundredK = 100000; // 100k
    const int FiveHundredK = 500000; // 500k

    // Million-level Constants
    const int OneMillion = 1000000;   // 1m
    const int FiveMillion = 5000000;  // 5m
    const int TenMillion = 10000000;  // 10m
    const int FiftyMillion = 50000000; // 50m
    const int OneHundredMillion = 100000000; // 100m

    //Max integer
    const int maxint = Int32.MaxValue;

    public void ScriptMain(IScriptInterface Bot)
    {
        Core.RunCore();
    }

    #region Shop

    /// <summary>
    /// Buys a item from a shop, but also try to obtain stuff like XP, Rep, Gold, and merge items (where possible)
    /// </summary>
    /// <param name="map">Map of the shop</param>
    /// <param name="shopID">ID of the shop</param>
    /// <param name="itemName">Name of the item</param>
    /// <param name="quant">Desired quantity</param>
    /// <param name="shopItemID">Use this for Merge shops that has 2 or more of the item with the same name and you need the second/third/etc., be aware that it will re-log you after to prevent ghost buy. To get the ShopItemID use the built in loader of Skua</param>
    /// <param name="index"></param>
    /// <param name="Log"></param>
    public void BuyItem(string map, int shopID, string itemName, int quant = 1, int shopItemID = 0, int index = 0, bool Log = true)
    {
        if (Core.CheckInventory(itemName, quant))
            return;

        Core.Join(map);
        Bot.Wait.ForMapLoad(map);
        Core.JumpWait();

        if (Bot.Player.InCombat || Bot.Player.HasTarget)
        {
            Core.JumpWait();
            Bot.Wait.ForCombatExit();
        }

        ShopItem? item = Core.parseShopItem(Core.GetShopItems(map, shopID).Where(x => shopItemID == 0 ? x.Name.ToLower() == itemName.ToLower() : x.ShopItemID == shopItemID).ToList(), shopID, itemName);
        if (item == null)
            return;

        _BuyItem(map, shopID, item, quant, item.Quantity, shopItemID, index, Log);
    }

    /// <summary>
    /// Buys a item from a shop, but also try to obtain stuff like XP, Rep, Gold, and merge items (where possible)
    /// </summary>
    /// <param name="map">Map of the shop</param>
    /// <param name="shopID">ID of the shop</param>
    /// <param name="itemID">ID of the item</param>
    /// <param name="quant">Desired quantity</param>
    /// <param name="shopQuant">How many items you get for 1 buy</param>
    /// <param name="shopItemID">Use this for Merge shops that has 2 or more of the item with the same name and you need the second/third/etc., be aware that it will relog you after to prevent ghost buy. To get the ShopItemID use the built in loader of Skua</param>
    /// <param name="index"></param>
    /// <param name="Log"></param>
    public void BuyItem(string map, int shopID, int itemID, int quant = 1, int shopQuant = 1, int shopItemID = 0, int index = 0, bool Log = true)
    {
        if (Core.CheckInventory(itemID, quant))
            return;

        Core.Join(map);
        Bot.Wait.ForMapLoad(map);
        Core.JumpWait();

        if (Bot.Player.InCombat || Bot.Player.HasTarget)
        {
            Core.JumpWait();
            Bot.Wait.ForCombatExit();
        }

        ShopItem? item = Core.parseShopItem(Core.GetShopItems(map, shopID).Where(x => shopItemID == 0 ? x.ID == itemID : x.ShopItemID == shopItemID).ToList(), shopID, itemID.ToString());
        if (item == null)
            return;

        _BuyItem(map, shopID, item, quant, shopQuant, shopItemID, index, Log);
    }


    private void _BuyItem(string map, int shopID, ShopItem item, int quant = 1, int shopquant = 1, int shopItemID = 1, int index = 0, bool Log = true)
    {

        int shopQuant = item.Quantity; // Quantity per purchase from the shop
        string shopName = Bot.Shops.Name; // Store the currently loaded shop name
        if (item.Requirements != null)
        {
            foreach (ItemBase req in item.Requirements)
            {
                // Determine how many total items are needed
                int totalBundlesNeeded = (int)Math.Ceiling((double)req.Quantity * quant / shopQuant);

                if (Core.CheckInventory(req.ID, totalBundlesNeeded))
                {
                    continue;
                }

                if (req.Name.Contains("Gold Voucher"))
                {
                    Farm.Voucher(req.Name, totalBundlesNeeded); // Will buy from shop if available
                    continue;
                }

                if (req.Name == "Dragon Runestone")
                {
                    Farm.DragonRunestone(totalBundlesNeeded);
                    continue;
                }

                while (!Bot.ShouldExit && !Core.CheckInventory(req.ID, totalBundlesNeeded))
                {
                    if (Bot.Map.Name != map)
                    {
                        Core.Join(map);
                        Bot.Wait.ForMapLoad(map);
                    }

                    // Load shop data
                    while (!Bot.ShouldExit && Bot.Shops.ID != shopID)
                    {
                        Bot.Shops.Load(shopID);
                        Bot.Wait.ForActionCooldown(GameActions.LoadShop);
                        Bot.Wait.ForTrue(() => Bot.Shops.IsLoaded && Bot.Shops.ID == shopID, 20);
                        Core.Sleep(1000);
                        if (Bot.Shops.ID == shopID)
                            break;
                    }

                    // int bundlesToBuy = totalBundlesNeeded - (QuantOwned / req.Quantity);
                    // Ensure we Reload the proper shop:
                    // Load shop data
                    while (!Bot.ShouldExit && Bot.Shops.ID != shopID)
                    {
                        Bot.Shops.Load(shopID);
                        Bot.Wait.ForActionCooldown(GameActions.LoadShop);
                        Bot.Wait.ForTrue(() => Bot.Shops.IsLoaded && Bot.Shops.ID == shopID, 20);
                        Core.Sleep(1000);
                        if (Bot.Shops.ID == shopID)
                            break;
                    }

                    ShopItem? shopItem = Bot.Shops.Items.FirstOrDefault(x => x.ID == req.ID);
                    if (shopItem != null)
                    {
                        BuyItem(map, shopID, req.ID, totalBundlesNeeded, shopItemID, Log: Log);
                        Bot.Wait.ForPickup(req.ID);
                    }
                    // Else return and hope it hits the `findingredients` area. when the req.name isnt in the shop.
                    else
                    {
                        Core.Logger($"Failed to find shop item: \"{req.Name} [{req.ID}]\" in ({Bot.Shops.Name} [{Bot.Shops.ID}].)\n"
                        + $"Its either a `mob drop` or a `daily`.\n"
                        + $"Check the Wiki: http://aqwwiki.wikidot.com/search:main/fullname/{req.Name.Replace(" ", "-")}.\n"
                        + $"Maybe the bot will just farm in a moment once it returns to the previous code..? if not then its probably from a daily or an mob we cannot kill with skua.");
                        return;
                    }
                }
            }

            // Ensure required items are available before purchasing the main item
            GetItemReq(item, quant);

            // Rejoin the map here incase getitemreq takes you elsewhere, to ensure that the shopitem is found (hopefully) 
            if (Bot.Map.Name != map)
                Core.Join(map);

            // Load shop data
            while (!Bot.ShouldExit && Bot.Shops.ID != shopID)
            {
                Bot.Shops.Load(shopID);
                Bot.Wait.ForActionCooldown(GameActions.LoadShop);
                Bot.Wait.ForTrue(() => Bot.Shops.IsLoaded && Bot.Shops.ID == shopID, 20);
                Core.Sleep(1000);
                if (Bot.Shops.ID == shopID)
                    break;
            }

            // Try to find the exact item match based on ID and ShopItemID
            List<ShopItem> matchingItems = Bot.Shops.Items
                .Where(x => x.ID == item.ID &&
                            x.ShopItemID == (item.ShopItemID != 1 ? item.ShopItemID : shopItemID) &&
                            !(x.Coins && x.Cost > 0) && // Exclude AC/paid items
                            item.Requirements.All(r => Core.CheckInventory(r.ID, r.Quantity)))
                .ToList(); // Convert to list to allow index selection

            // If no exact match is found, fall back to matching only by ID
            if (!matchingItems.Any())
            {
                matchingItems = Bot.Shops.Items
                    .Where(x => x.ID == item.ID &&
                                !(x.Coins && x.Cost > 0) && // Exclude AC/paid items
                                item.Requirements.All(r => Core.CheckInventory(r.ID, r.Quantity)))
                    .ToList();
            }

            // Select the item by index if possible, otherwise default to the first available match
            ShopItem? mainItem = matchingItems.Count > index ? matchingItems[index] : matchingItems.FirstOrDefault();

            if (mainItem != null)
            {
                // Attempt to buy the item using the correct ShopItemID if applicable
                Core.BuyItem(map, shopID, mainItem.ID, quant, mainItem.ShopItemID != 1 ? mainItem.ShopItemID : shopItemID, Log: Log);
                Core.Sleep();

                // Verify if the item was successfully purchased
                if (!Core.CheckInventory(mainItem.ID, quant))
                {
                    Core.Logger($"❌ Failed to buy {mainItem.Name} ({quant}x)");

                    // Log any missing requirements for debugging
                    foreach (ItemBase req in mainItem.Requirements.Where(r => r != null && !Core.CheckInventory(r.ID, r.Quantity)))
                    {
                        Core.Logger($"⚠️ Missing: {req.Name} x{req.Quantity}");
                    }
                }
            }
            else
            {
                Core.Logger($"❌ Failed to find the item: {item.Name} in shop {shopID} on map {map}");
            }

        }
    }
    /// <summary>
    /// Ensures that all necessary requirements (Experience, Reputation, Gold, and specific items)
    /// are met in order to purchase an item. This includes verifying player level, farming or purchasing 
    /// required reputation, acquiring specific items such as Gold Vouchers and Dragon Runestones,
    /// and ensuring enough gold is available for the transaction.
    /// </summary>
    /// <param name="item">
    /// The <see cref="ShopItem"/> object that contains all the details about the item, 
    /// including its requirements like reputation, level, gold cost, and additional items needed.
    /// </param>
    /// <param name="quant">
    /// The quantity of the item needed for purchase. The default value is 1, but can be adjusted
    /// to handle cases where multiple units of the item are required.
    /// </param>
    public void GetItemReq(ShopItem item, int quant = 1)
    {
        if (item?.Requirements == null)
        {
            Core.Logger("Invalid item or missing requirements.");
            return;
        }

        // Ensure required reputation for faction-based items
        if (!string.IsNullOrEmpty(item.Faction) && item.Faction != "None" && item.RequiredReputation > 0)
        {
            Core.Logger($"Farming reputation for {item.Faction} (Required: {item.RequiredReputation})");
            runRep(item.Faction, Core.PointsToLevel(item.RequiredReputation));
        }

        // Level up if the item requires a higher player level
        if (item.Level > Bot.Player.Level)
        {
            Core.Logger($"Farming experience to reach level {item.Level}");
            Farm.Experience(Math.Min(item.Level, 100));
        }

        // Farm gold if the item costs gold and isn't a premium currency purchase
        if (!item.Coins && item.Cost > 0)
        {
            int GoldtoFarm = Math.Min(item.Cost * quant, 100000000); // 100m gold cap
            Farm.Gold(GoldtoFarm);
        }

        // Handle Gold Vouchers (multiple types possible)
        if (item.Requirements.Any(x => x != null && x.Name.StartsWith("Gold Voucher")))
        {
            foreach (ItemBase req in item.Requirements.Where(x => x != null && x.Name.StartsWith("Gold Voucher")))
            {
                Farm.Voucher(req.Name, req.Quantity);
            }
        }

        // Handle Dragon Runestone farming if required
        if (item.Requirements.Any(x => x != null && x.Name.StartsWith("Dragon Runestone")))
        {
            Farm.DragonRunestone(item.Requirements.FirstOrDefault(x => x != null && x.Name == "Dragon Runestone").Quantity);
        }

        // Warn if a temp item is missing
        foreach (ItemBase req in item.Requirements.Where(x => x != null && x.Temp && x.Quantity > Bot.TempInv.GetQuantity(x.ID)))
            Core.Logger($"Temp item: {req.Name}, quant needed: {req.Quantity}... did the bot not farm them?");
    }

    private void runRep(string faction, int rank)
    {
        faction = faction.Replace(" ", "");
        Type farmClass = Farm.GetType();
        MethodInfo? theMethod = farmClass.GetMethod(faction + "REP");
        if (theMethod == null)
        {
            Core.Logger("Failed to find " + faction + "REP. Make sure you have the correct name and capitalization.");
            return;
        }
        try
        {
            switch (faction.ToLower())
            {
                case "alchemy":
                case "blacksmith":
                    theMethod.Invoke(Farm, new object[] { rank, true });
                    break;
                case "bladeofawe":
                    theMethod.Invoke(Farm, new object[] { rank, false });
                    break;
                default:
                    theMethod.Invoke(Farm, new object[] { rank });
                    break;
            }
        }
        catch
        {
            Core.Logger($"Faction {faction} has invalid paramaters, please report", messageBox: true, stopBot: true);
        }
    }

    /// <summary>
    /// Buys merge items from a shop based on specified options. Filters ShopItems to ensure uniqueness by ID and ShopItemID,
    /// selecting items based on Upgrade requirements and excluding those ending with "insignia".
    /// </summary>
    /// <param name="map">The map from which the shop is loaded.</param>
    /// <param name="shopID">The shop ID to load shop data.</param>
    /// <param name="findIngredients">Action determining where to retrieve items.</param>
    /// <param name="buyOnlyThis">Optional. Limits purchases to a specific item.</param>
    /// <param name="itemBlackList">Optional. List of excluded items.</param>
    /// <param name="buyMode">Optional. Specifies buying mode.</param>
    /// <param name="Group">Optional. Specifies group selection method.</param>
    /// <param name="ShopItemID">Optional. Specifies ShopItem ID.</param>
    /// <param name="Log">Optional. Enables logging.</param>
    // We'll use this later
    public void StartBuyAllMerge(string map, int shopID, Action findIngredients, string? buyOnlyThis = null, string[]? itemBlackList = null, mergeOptionsEnum? buyMode = null, string Group = "First", int ShopItemID = 0, bool Log = true)
    {
        #region Setup and Initialization
        if (buyOnlyThis == null && buyMode == null && Bot.Config != null && !Bot.Config.Get<bool>(CoreBots.Instance.SkipOptions))
            Bot.Config!.Configure();

        int mode = 0;
        if (buyOnlyThis != null)
            mode = (int)mergeOptionsEnum.all;
        else if (buyMode != null)
            mode = (int)buyMode;
        else if (Bot.Config != null && Bot.Config.MultipleOptions.Any(o => o.Value.Any(x => x.Category == "Generic" && x.Name == "mode")))
            mode = (int)Bot.Config.Get<mergeOptionsEnum>("Generic", "mode");
        else Core.Logger("Invalid setup detected for StartBuyAllMerge. Please report", messageBox: true, stopBot: true);

        matsOnly = mode == 2;

        // HashSet for tracking unique item IDs to prevent redundant operations
        HashSet<int> uniqueItemIds = new(
                     new[] {
            Bot.Bank.Items.Select(item => item.ID),
            Bot.TempInv.Items.Select(item => item.ID),
            Bot.House.Items.Select(item => item.ID),
            Bot.Inventory.Items.Select(item => item.ID)
                    }.SelectMany(id => id)
                );

        // Filter shop items based on various conditions
        List<ShopItem> shopItems = Core.GetShopItems(map, shopID)
                                      .GroupBy(item => new { item.Name, item.ID, item.ShopItemID })
                                      .Select(group =>
                                      {
                                          IOrderedEnumerable<ShopItem> orderedGroup = group.OrderBy(item => item.ShopItemID != group.First().ShopItemID);
                                          return Group == "First" ? orderedGroup.First() : orderedGroup.Last();
                                      })
                                      .Where(x => !x.Name.ToLower().EndsWith("insignia"))
                                      .Where(x => !uniqueItemIds.Contains(x.ID))
                                      .ToList();

        uniqueItemIds = new HashSet<int>();  // Reset for re-use

        List<ShopItem> items = new();
        bool memSkipped = false;

        // Process shop items based on various conditions
        foreach (ShopItem item in shopItems)
        {
            if (miscCatagories.Contains(item.Category) ||
                    (!string.IsNullOrEmpty(buyOnlyThis) && buyOnlyThis != item.Name) ||
                    (itemBlackList != null && itemBlackList.Any(x => x.ToLower() == item.Name.ToLower())))
                continue;

            if (Core.IsMember || !item.Upgrade
            || item.Requirements.Any(x => x != null && Bot.Shops.Items.Any(x => x != null && x.Upgrade && !Core.IsMember)))
            {
                if (mode == 3)
                {
                    if (Bot.Config!.Get<bool>("Select", $"{item.ID}"))
                        items.Add(item);
                }
                else if (mode != 1)
                    items.Add(item);
                else if (item.Coins)
                    items.Add(item);
            }
            else if (mode == 3 && Bot.Config!.Get<bool>("Select", $"{item.ID}"))
            {
                Core.Logger($"\"{item.Name}\" will be skipped, as you aren't a member.");
                memSkipped = true;
            }
        }

        if (items.Count == 0)
        {
            Core.Logger($"Found {items.Count} items to purchase from shop [{shopID}] on map [{map}].");
            HandleNoItemsFound(mode, memSkipped);
            return;
        }
        #endregion

        int t = 0;
        // Why did we need the `for ( int i = 0; i < 2; i++)`?

        foreach (ShopItem item in items)
        {
            if (Core.CheckInventory(item.ID, toInv: false))
                continue;

            if (item.Upgrade && !Core.IsMember)
            {
                Core.Logger($"Skipping {item.Name} [{item.ID}] as it is member-only.");
                continue;
            }

            if (!matsOnly)
            {
                Core.Logger($"Farming to buy {item.Name} (#{t++}/{items.Count})");
            }

            foreach (ItemBase req in item.Requirements)
            {
                EnsureShopLoaded(map, shopID);
                HandleItemRequirements(req, req.Quantity, findIngredients);
            }

            if (item.Requirements.All(x => x != null && Core.CheckInventory(x.ID, x.Quantity)))
            {
                if (!matsOnly)
                    Core.Logger($"Buying {item.Name} (#{t++}/{items.Count})");

                // Attempt to purchase the required quantity of the shop item
                BuyItem(map, shopID, item.ID, shopItemID: item.ShopItemID, Log: Log);
                Bot.Wait.ForPickup(item.ID);
                if (Core.CheckInventory(item.ID, item.Quantity))
                {
                    continue;
                }
                else
                {
                    IEnumerable<string> missing = item.Requirements
                    .Where(x => !Core.CheckInventory(x.ID, x.Quantity))
                    .Select(x => $"\"{x.Name} x{x.Quantity}\"");

                    Core.Logger($"Failed to meet requirements for {item.Name} [{item.ID}] due to missing: {string.Join(", ", missing)}.");
                    continue;
                }

            }
        }


        // Helper methods
        bool EnsureShopLoaded(string? map, int shopID)
        {
            if (map == null)
            {
                Core.Logger("Map is null, unable to load shop.");
                return false;
            }
            Core.Join(map);
            Bot.Wait.ForMapLoad(map);
            while (!Bot.ShouldExit && Bot.Shops.ID != shopID)
            {
                Bot.Shops.Load(shopID);
                Bot.Wait.ForActionCooldown(GameActions.LoadShop);
                Bot.Wait.ForTrue(() => Bot.Shops.IsLoaded && Bot.Shops.ID == shopID, 20);
                Core.Sleep(1000);
                if (Bot.Shops.ID == shopID)
                    return true;
            }
            return true;
        }

        void HandleItemRequirements(ItemBase Req, int ReqQuant, Action findIngredients)
        {
            if (Core.CheckInventory(Req.ID, ReqQuant))
                return;

            EnsureShopLoaded(map, shopID);
            ShopItem? wasinshop = Bot.Shops.Items.FirstOrDefault(x => x.ID == Req.ID);
            if (wasinshop != null && !wasinshop.Name.Contains("Gold Voucher"))
            {
                Core.Logger($"Item: \"{Req.Name}  [{Req.ID}\"] is in the shop!");
                while (!Bot.ShouldExit && !Core.CheckInventory(Req.ID, ReqQuant))
                {
                    // for requirements that are in the shop, but are just buyable with gold. (excludes ac buyable items)
                    if (wasinshop.Requirements.Count <= 0 && (wasinshop.Coins && wasinshop.Cost <= 0 || !wasinshop.Coins)) //|| wasinshop.Name.Contains("Gold Voucher") || wasinshop.Name.Contains("Dragon Runestone"))
                    {
                        // // Handle special cases for Gold Vouchers and Dragon Runestones
                        // if (wasinshop.Name.Contains("Gold Voucher"))
                        // {
                        //     Farm.Voucher(wasinshop.Name, ReqQuant);
                        //     return;
                        // }
                        // if (wasinshop.Name.Contains("Dragon Runestone"))
                        // {
                        //     Farm.DragonRunestone(ReqQuant);
                        //     return;
                        // }

                        // Otherwise buy the item directly
                        BuyItem(map, shopID, Req.ID, ReqQuant, shopItemID: wasinshop.ShopItemID, Log: Log);
                        Bot.Wait.ForPickup(Req.ID);
                    }
                    else IngredientWasintheShop(wasinshop, ReqQuant);
                    if (Core.CheckInventory(Req.ID, ReqQuant))
                        break;
                    else
                        Core.Logger($"Failed to meet requirements for \"{Req.Name}\" [{Req.ID}] x{ReqQuant}, Retrying the farm (items may have been used).");
                }
            }
            else if (wasinshop == null)
            {
                // Items not in the shop, so we have to get it externally
                externalItem = Req;
                externalQuant = Req.Quantity;
                Core.AddDrop(externalItem.ID);
                Core.Logger($"{externalItem.Name} [{externalItem.ID}] is an external item (not from this shop), attempting to farm it from The ingredient list.");

                // These are here inacse ae forgot to put vouchers in the original merge... like idiots (more of a fail safe) 
                if (Req.Name.Contains("Dragon Runestone"))
                {
                    Farm.DragonRunestone(ReqQuant);
                    return;
                }
                if (Req.Name.StartsWith("Gold Voucher"))
                {
                    Farm.Voucher(Req.Name, ReqQuant);
                    return;
                }

                findIngredients();
                Bot.Wait.ForPickup(externalItem.ID);
            }
            Bot.Wait.ForPickup(Req.ID);
        }

        void IngredientWasintheShop(ShopItem item, int craftingQ)
        {
            // Ensure we are checking for items in the shop and inventory properly
            if (item == null)
            {
                Core.Logger($"Item not found in the shop.");
                return;
            }

            // If item is already in inventory, no need to continue
            if (Core.CheckInventory(item.ID, item.Quantity))
                return;

            // Ensure shop is loaded before proceeding
            EnsureShopLoaded(map, shopID);
            foreach (ItemBase req in item.Requirements)
            {
                if (Core.CheckInventory(req.ID, req.Quantity))
                    continue;

                EnsureShopLoaded(map, shopID);
                int ReqQuant = req.Quantity * craftingQ;
                ShopItem? wasinshop = Bot.Shops.Items.FirstOrDefault(x => x.ID == req.ID);

                if (wasinshop != null && !wasinshop.Name.Contains("Gold Voucher"))
                {
                    Core.Logger($"Item: \"{wasinshop.Name}  [{wasinshop.ID}\"] is in the shop.");
                    ReqQuant = Math.Min(ReqQuant, wasinshop.MaxStack);
                    // for requirements that are in the shop, but are just buyable with gold. (excludes ac buyable items)
                    if (wasinshop.Requirements.Count <= 0 && wasinshop.Cost <= 0)
                    {
                        BuyItem(map, shopID, wasinshop.ID, ReqQuant, shopItemID: wasinshop.ShopItemID, Log: Log);
                        Bot.Wait.ForPickup(wasinshop.ID);
                    }

                    else IngredientWasintheShop(wasinshop, ReqQuant);
                    continue;
                }
                else if (wasinshop == null)
                {
                    // Items not in the shop, so we have to get it externally
                    if (req.Name.Contains("Dragon Runestone"))
                    {
                        Farm.DragonRunestone(ReqQuant);
                        continue;
                    }
                    if (req.Name.StartsWith("Gold Voucher"))
                    {
                        Farm.Voucher(req.Name, ReqQuant);
                        continue;
                    }
                    externalItem = req;
                    externalQuant = ReqQuant;
                    Core.AddDrop(externalItem.ID);
                    Core.Logger($"{externalItem.Name} [{externalItem.ID}] is an external item (not a shop item), attempting to farm it from The ingredient list.");
                    findIngredients();
                }

            }

            EnsureShopLoaded(map, shopID);
            if (item.Requirements.All(x => x != null && Core.CheckInventory(x.ID, x.Quantity)))
            {
                // If all requirements are met, attempt to buy the item
                if (!matsOnly)
                    Core.Logger($"Buying {item.Name} [{item.ID}] from the shop.");

                // Attempt to purchase the Requirement of Main / Sub-Main item
                BuyItem(map, shopID, item.ID, craftingQ, shopItemID: item.ShopItemID, Log: Log);
                Bot.Wait.ForPickup(item.ID);
            }
            else
                // If the purchase was unsuccessful, log the failure
                Core.Logger($"Failed to meet requirements for {item.Name} [{item.ID}].");
        }

        void HandleNoItemsFound(int mode, bool memSkipped)
        {
            if (buyOnlyThis != null)
                return;

            switch (mode)
            {
                case 0:
                case 2:
                    Core.Logger("The bot fetched 0 items to farm. Something must have gone wrong.");
                    break;
                case 1:
                    if (shopItems.All(x => !x.Coins))
                        Core.Logger("The bot fetched 0 items to farm. This is because none of the items in this shop are AC tagged.");
                    else
                        Core.Logger("The bot fetched 0 items to farm. Something must have gone wrong.");
                    break;
                case 3:
                    if (memSkipped)
                        Core.Logger("The bot fetched 0 items to farm. This is because you aren't a member.");
                    else
                        Core.Logger("The bot fetched 0 items to farm. Something must have gone wrong.");
                    break;
            }
        }
    }

    public List<ItemCategory> miscCatagories = new() { ItemCategory.Note, ItemCategory.Item, ItemCategory.QuestItem, ItemCategory.ServerUse };
    public ItemBase externalItem = new();
    public int externalQuant = 0;
    public bool matsOnly = false;
    public List<string> MaxStackOneItems = new();
    public List<string> AltFarmItems = new();

    /// <summary>
    /// The list of ScriptOptions for any merge script.
    /// </summary>
    public List<IOption> MergeOptions = new()
    {
        CoreBots.Instance.SkipOptions,
        new Option<mergeOptionsEnum>("mode", "Select the mode to use", "Regardless of the mode you pick, the bot wont (attempt to) buy Legend-only items if you're not a Legend.\n" +
                                                                     "Select the Mode Explanation item to get more information", mergeOptionsEnum.all),
        new Option<string>(" ", "Mode Explanation [all]", "Mode [all]: \t\tYou get all the items from shop, even if non-AC ones if any.", "click here"),
        new Option<string>(" ", "Mode Explanation [acOnly]", "Mode [acOnly]: \tYou get all the AC tagged items from the shop.", "click here"),
        new Option<string>(" ", "Mode Explanation [mergeMats]", "Mode [mergeMats]: \tYou dont buy any items but instead get the materials to buy them yourself, this way you can choose.", "click here"),
        new Option<string>(" ", "Mode Explanation [select]", "Mode [select]: \tYou are able to select what items you get and which ones you dont in the Select Category below.", "click here"),
    };

    /// <summary>
    /// The name of ScriptOptions for any merge script.
    /// </summary>
    public string OptionsStorage = "MergeOptionStorage";
    #endregion

    #region Kill
#nullable enable

    /// <summary>
    /// Joins a map, jumps to a specified cell and pad, sets the spawn point, and kills the specified monster using the best available race gear.
    /// </summary>
    /// <param name="map">The map to join.</param>
    /// <param name="cell">The cell to jump to.</param>
    /// <param name="pad">The pad to jump to.</param>
    /// <param name="monster">The name of the monster to kill.</param>
    /// <param name="item">The item to kill the monster for. If null or empty, will just kill the monster once.</param>
    /// <param name="quant">The desired quantity of the item to collect.</param>
    /// <param name="isTemp">Whether the item is temporary.</param>
    /// <param name="log">Whether to log the killing of the monster.</param>
    /// <param name="publicRoom">Whether the action should take place in a public room.</param>
    public void BoostKillMonster(string map, string cell, string pad, string monster, string item = "", int quant = 1, bool isTemp = true, bool log = true, bool publicRoom = false)
    {
        if (item != "" && Core.CheckInventory(item, quant))
            return;

        Core.Join(map, cell, pad, publicRoom: publicRoom);

        // _RaceGear(monster);
        Core.KillMonster(map, cell, pad, monster, item, quant, isTemp, log, publicRoom);

        GearStore(true);
    }

    /// <summary>
    /// Kills a monster using it's ID, with the specified monsters the best available race gear
    /// </summary>
    /// <param name="map">Map to join</param>
    /// <param name="cell">Cell to jump to</param>
    /// <param name="pad">Pad to jump to</param>
    /// <param name="monsterID">ID of the monster</param>
    /// <param name="item">Item to kill the monster for, if null will just kill the monster 1 time</param>
    /// <param name="quant">Desired quantity of the item</param>
    /// <param name="isTemp">Whether the item is temporary</param>
    /// <param name="log">Whether it will log that it is killing the monster</param>
    /// <param name="publicRoom"></param>
    public void BoostKillMonster(string map, string cell, string pad, int monsterID, string item = "", int quant = 1, bool isTemp = true, bool log = true, bool publicRoom = false)
    {
        if (item != "" && Core.CheckInventory(item, quant))
            return;

        Core.Join(map, cell, pad, publicRoom: publicRoom);

        // _RaceGear(monsterID);

        Core.KillMonster(map, cell, pad, monsterID, item, quant, isTemp, log, publicRoom);

        GearStore(true);
    }

    /// <summary>
    /// Joins a map, hunts for the monster, and kills the specified monster using the best available race gear.
    /// </summary>
    /// <param name="map">The map to join.</param>
    /// <param name="monster">The name of the monster to hunt and kill.</param>
    /// <param name="item">The item to hunt the monster for. If null, it will just hunt and kill the monster once.</param>
    /// <param name="quant">The desired quantity of the item to collect.</param>
    /// <param name="isTemp">Whether the item is temporary.</param>
    /// <param name="log">Whether to log the hunting and killing of the monster.</param>
    /// <param name="publicRoom">Whether the action should take place in a public room.</param>
    public void BoostHuntMonster(string map, string monster, string? item = null, int quant = 1, bool isTemp = true, bool log = true, bool publicRoom = false)
    {
        if (item != null && Core.CheckInventory(item, quant))
            return;

        Core.Join(map, publicRoom: publicRoom);

        // _RaceGear(monster);

        Core.HuntMonster(map, monster, item, quant, isTemp, log, publicRoom);

        GearStore(true);
    }

    /// <summary>
    /// Joins a map, jumps to a specified cell and pad, sets the spawn point, and kills the specified monster using the best available race gear. Additionally, it listens for counter-attacks.
    /// </summary>
    /// <param name="map">The map to join.</param>
    /// <param name="cell">The cell to jump to.</param>
    /// <param name="pad">The pad to jump to.</param>
    /// <param name="monster">The name of the monster to kill.</param>
    /// <param name="item">The item to kill the monster for. If null, it will just kill the monster once.</param>
    /// <param name="quant">The desired quantity of the item to collect.</param>
    /// <param name="isTemp">Whether the item is temporary.</param>
    /// <param name="log">Whether to log the killing of the monster.</param>
    /// <param name="publicRoom">Whether the action should take place in a public room.</param>
    /// <param name="forAuto">Whether the method is used for an automated process.</param>
    public void KillUltra(string map, string cell, string pad, string monster, string? item = null, int quant = 1, bool isTemp = true, bool log = true, bool publicRoom = true, bool forAuto = false)
    {
        if (item != null && Core.CheckInventory(item, quant))
            return;
        if (item != null && !isTemp)
            Core.AddDrop(item);

        Core.Join(map, cell, pad, publicRoom: publicRoom);
        // if (!forAuto)
        //     _RaceGear(monster);
        Core.Jump(cell, pad);

        bool ded = false;
        Bot.Events.MonsterKilled += b => ded = true;
        if (item == null)
        {
            if (log)
                Core.Logger($"Killing Ultra-Boss {monster}");
            while (!Bot.ShouldExit && !ded)
            {
                ded = false;
                Core.Jump(cell, pad);
                if (!Bot.Combat.StopAttacking)
                    Bot.Combat.Attack(monster);
                Core.Sleep();
            }
            Core.Rest();
            return;
        }
        Bot.Events.MonsterKilled -= b => ded = true;

        if (log)
            Core.Logger($"Killing Ultra-Boss {monster} for {item} ({quant}) [Temp = {isTemp}]");

        Bot.Hunt.ForItem(monster, item, quant, isTemp);

        if (!forAuto)
            GearStore(true);
    }

    #region WIP/Proof of Concept Methods(W.I.P)
    /// <summary>
    /// Kills a monster while monitoring for a specific aura.
    /// </summary>
    public void KillWithAura(
        string map, string cell, string pad, string monster,
        string[] auraNames,
        Dictionary<string, Action>? auraReactions = null,
        string? item = null, int quant = 1, bool isTemp = false, bool log = true,
        int ItemToUse = 0, int SafeItem = 0,
        CancellationToken cancellationToken = default)
    {
        if (item != null && (isTemp ? Bot.TempInv.Contains(item, quant) : Core.CheckInventory(item, quant)))
            return;

        DateTime lastAuraTrigger = DateTime.MinValue;
        TimeSpan auraCooldown = TimeSpan.FromSeconds(0);
        monster = monster.Trim().FormatForCompare();

        Bot.Events.ExtensionPacketReceived += AuraListener;

        #region Setup Item Equip (optional)
        if (ItemToUse > 0)
        {
            int fallbackPotion = 1749;
            int equipSafe = SafeItem > 0 ? SafeItem : fallbackPotion;

            if (!Core.CheckInventory(equipSafe))
                BuyItem("embersea", 1100, fallbackPotion, 10, 1, 17966);

            EquipRetry(equipSafe);
            Core.Equip(ItemToUse);
        }
        #endregion

        if (item == null)
        {
            if (log)
                Core.Logger($"Killing {monster}");
            Bot.Kill.Monster(monster);
        }
        else
        {
            if (!isTemp)
                Core.AddDrop(item);
            if (log)
                Core.FarmingLogger(item, quant);

            while (!Bot.ShouldExit && !Core.CheckInventory(item, quant) && !cancellationToken.IsCancellationRequested)
            {
                while (!Bot.ShouldExit && !Bot.Player.Alive && !cancellationToken.IsCancellationRequested) { }

                if (Bot.Map.Name != map)
                    Core.Join(map, cell, pad);
                if (Bot.Player.Cell != cell)
                    Core.Jump(cell, pad);

                Bot.Combat.Attack(monster);
                Bot.Sleep(500);

                if (isTemp ? Bot.TempInv.Contains(item, quant) : (Bot.Inventory.Contains(item, quant) || Bot.Bank.Contains(item, quant)))
                    break;
            }
        }

        Bot.Events.ExtensionPacketReceived -= AuraListener;

        void AuraListener(dynamic packet)
        {
            if (cancellationToken.IsCancellationRequested)
                return;

            if ((string?)packet["params"]?.type != "json")
                return;

            dynamic? data = packet["params"]?.dataObj;
            if (data?.cmd?.ToString() != "ct" || data?.a is null)
                return;

            if (data == null)
                return;

            foreach (dynamic a in data.a)
            {
                string? auraName = a?.aura?["nam"]?.ToString();
                if (string.IsNullOrEmpty(auraName) || !auraNames.Contains(auraName))
                    continue;

                // Throttle cooldown
                if (DateTime.Now - lastAuraTrigger < auraCooldown)
                    continue;

                lastAuraTrigger = DateTime.Now;

                if (auraReactions != null && auraReactions.TryGetValue(auraName, out Action? reaction))
                {
                    Bot.Log($"Invoking reaction for aura: {auraName}");
                    try
                    {
                        reaction?.Invoke();
                    }
                    catch (Exception ex)
                    {
                        Core.Logger($"Exception during aura reaction '{auraName}': {ex}");
                    }
                }
                else
                {
                    // fallback switch logic if no reaction found
                    switch (auraName)
                    {
                        case "Shapeshifted":
                            Bot.Log($"Detected aura (switch fallback): {auraName}");
                            break;

                        default:
                            Core.Logger($"Unhandled aura (switch fallback): {auraName}");
                            break;
                    }
                }

                break; // react to only one aura per packet
            }
        }

        void EquipRetry(int id)
        {
            Core.Equip(id);
            Bot.Wait.ForTrue(() => Bot.Inventory.IsEquipped(id), 20);
            Bot.Sleep(2000);
            Core.Equip(id); // Flash refresh workaround
            Bot.Sleep(2000);
        }
    }

    /* Example:
     Adv.KillWithAura(
            map: "kitsune",
            cell: "Boss",
            pad: "Left",
            monster: "kitsune",
            auraNames: new[] { "Shapeshifted" },
            auraReactions: new Dictionary<string, Action>
            {
                ["Shapeshifted"] = () => Core.Logger("Aura: Shapeshifted", "Example"),
            },
            item: "Fox Tail",
            quant: 3,
            log: true,
            ItemToUse: 0,
            SafeItem: 0,
            cancellationToken: CancellationToken.None
        );
        */

    #endregion WIP/Proof of Concept Methods(W.I.P)

    #endregion

    #region Gear

    /// <summary>
    /// Ranks up your class
    /// </summary>
    /// <param name="className"></param>
    /// <param name="gearRestore"></param>
    /// <param name="itemid"></param>
    public void RankUpClass(string className, bool gearRestore = true, int itemid = 0)
    {
        // Determine search condition based on itemid
        bool classMatch(InventoryItem i) => (itemid > 0 ? i.ID == itemid : i.Name.Equals(className, StringComparison.OrdinalIgnoreCase)) && i.Category == ItemCategory.Class;

        // Find the class item in inventory and bank
        InventoryItem? itemInv = Bot.Inventory.Items.Concat(Bot.Bank.Items).FirstOrDefault(classMatch);

        if (itemInv == null)
        {
            Core.Logger($"Can't level up {(itemid > 0 ? $"item ID {itemid}" : $"\"{className}\"")} because you don't own it.");
            return;
        }

        // Check if the class is already Rank 10 or unavailable due to membership requirement
        if ((itemInv.Upgrade && !Bot.Player.IsMember) || (Bot.Inventory.Contains(itemInv.ID) && itemInv.Quantity >= 302500))
        {
            Core.Logger($"\"{itemInv.Name}\" is already Rank 10 or you are not a member and the item is members.");
            return;
        }

        // Unbank the item if it's in the bank but not in the inventory
        if (Bot.Bank.Contains(itemInv.ID) && !Bot.Inventory.Contains(itemInv.ID))
        {
            Core.Unbank(itemInv.ID);
            Core.Sleep();

            // Recheck the item in inventory after unbanking
            itemInv = Bot.Inventory.Items.FirstOrDefault(classMatch);
            if (itemInv == null)
            {
                Core.Logger($"Failed to unbank {(itemid > 0 ? $"item ID {itemid}" : $"\"{className}\"")}.");
                return;
            }
        }

        // Check if the class is already Rank 10
        if (itemInv.Quantity == 302500)
        {
            Core.Logger($"\"{itemInv.Name}\" is already Rank 10");
            return;
        }

        // Check if the class cannot be leveled past Rank 1
        if (itemInv.Name.Equals("Hobo Highlord") || itemInv.Name.Equals("No Class") || itemInv.Name.Equals("Obsidian No Class"))
        {
            Core.Logger($"\"{itemInv.Name}\" cannot be leveled past Rank 1");
            return;
        }

        // Optionally restore gear
        if (gearRestore)
            GearStore();

        Core.JumpWait();

        // Attempt to enhance the class if applicable
        SmartEnhance(className);

        // Find the class item in inventory after enhancement
        InventoryItem? classItem = Bot.Inventory.Items.FirstOrDefault(classMatch);
        if (classItem == null)
        {
            Core.Logger($"Class item {(itemid > 0 ? $"ID {itemid}" : $"\"{className}\"")} not found in inventory.");
            return;
        }

        // Ensure the class item is enhanced before leveling up
        if (classItem.EnhancementLevel <= 0)
        {
            Core.Logger($"Can't level up \"{classItem.Name}\" because it's not enhanced, and AutoEnhance is turned off");
            return;
        }

        // Equip the class if it's not already equipped
        if (!Bot.Inventory.IsEquipped(classItem.ID))
        {
            Core.Equip(classItem.ID);
            Bot.Wait.ForTrue(() => Bot.Inventory.IsEquipped(classItem.ID), 20);
        }

        // Activate the class boost
        Farm.ToggleBoost(BoostType.Class);
        Farm.IcestormArena(Bot.Player.Level, true);
        Core.Jump("Enter");
        Bot.Options.AggroMonsters = false;

        // Recheck the class item after jumping
        classItem = Bot.Inventory.Items.FirstOrDefault(classMatch);
        if (classItem == null)
        {
            Core.Logger($"Class item {(itemid > 0 ? $"ID {itemid}" : $"\"{className}\"")} not found in inventory.");
            return;
        }

        // Check if the class reached Rank 10
        if (classItem.Quantity == 302500)
            Core.Logger($"\"{classItem.Name}\" is now Rank 10");
        else
            Core.Logger($"\"{classItem.Name}\" is somehow... not rank 10??");

        // Deactivate the class boost
        Farm.ToggleBoost(BoostType.Class, false);

        // Optionally restore gear
        if (gearRestore)
            GearStore(true);
    }

    /// <summary>
    /// Stores the gear a player has so that it can later restore these
    /// </summary>
    /// <param name="Restore">Set true to restore previously stored gear</param>
    /// <param name="EnhAfter"></param>
    public void GearStore(bool Restore = false, bool EnhAfter = false)
    {
        if (!Restore)
        {
            foreach (InventoryItem Item in Bot.Inventory.Items.FindAll(i => i.Equipped == true))
                ReEquippedItems.Add(Item.Name);

            ReEnhanceAfter = CurrentClassEnh();
            if (Bot.Inventory.Items.Any(x => x.Category == ItemCategory.Cape && x.Equipped))
                ReCEnhanceAfter = CurrentCapeSpecial();
            if (Bot.Inventory.Items.Any(x => x.Category == ItemCategory.Helm && x.Equipped))
                ReHEnhanceAfter = CurrentHelmSpecial();
            ReWEnhanceAfter = CurrentWeaponSpecial();
        }
        else if (ReEquippedItems.Count > 0)
        {
            Core.JumpWait();
            Core.Equip(ReEquippedItems.ToArray());
            if (EnhAfter)
                EnhanceEquipped(ReEnhanceAfter, ReCEnhanceAfter, ReHEnhanceAfter, ReWEnhanceAfter);
        }
    }
    private readonly List<string> ReEquippedItems = new();
    private EnhancementType ReEnhanceAfter = EnhancementType.Lucky;
    private CapeSpecial ReCEnhanceAfter = CapeSpecial.None;
    private HelmSpecial ReHEnhanceAfter = HelmSpecial.None;
    private WeaponSpecial ReWEnhanceAfter = WeaponSpecial.None;

    /// <summary>
    /// Find out if an item is a weapon or not
    /// </summary>
    /// <param name="Item">The ItemBase object of the item</param>
    /// <returns>Returns if its a weapon or not</returns>
    public bool isWeapon(ItemBase Item) => Item.ItemGroup == "Weapon";

    /// <summary>
    /// Will do GearStore() and then figure out the race of the monster paramater and equip bestGear on it
    /// </summary>
    /// <param name="Monster">The Monster object of the monster</param>
    public void _RaceGear(string Monster)
    {
        if (!Bot.Monsters.MapMonsters.Any(x => x.Name.ToLower() == Monster.ToLower()))
        {
            Core.Logger("Could not find any monster with the name " + Monster);
            return;
        }
        GearStore();
        string Map = Bot.Map.LastMap;
        string MonsterRace = "";
        if (Monster != "*")
            MonsterRace = Bot.Monsters.MapMonsters.First(x => x.Name.ToLower() == Monster.ToLower())?.Race ?? "";
        else
        {
            if (Bot.Monsters.CurrentMonsters.Count == 0)
            {
                Core.Logger($"No monsters are present in cell \"{Bot.Player.Cell}\" in /{Bot.Map.Name}");
                return;
            }
            MonsterRace = Bot.Monsters.CurrentMonsters.First().Race ?? "";
        }

        if (MonsterRace == null || MonsterRace == "")
            return;

        // string[] _BestGear = BestGear((RacialGearBoost)Enum.Parse(typeof(RacialGearBoost), MonsterRace), false);
        // if (_BestGear.Length == 0)
        //     return;
        // EnhanceItem(_BestGear, CurrentClassEnh(), CurrentCapeSpecial(), CurrentHelmSpecial(), CurrentWeaponSpecial());
        // Core.Equip(_BestGear);
        Core.Logger("BestGear Disabled");

        //EnhanceEquipped(CurrentClassEnh(), CurrentCapeSpecial(), CurrentHelmSpecial(), CurrentWeaponSpecial());
        Core.Join(Map);
    }

    /// <summary>
    /// Will do GearStore() and then figure out the race of the monster paramater and equip bestGear on it
    /// </summary>
    /// <param name="MonsterID">The MonsterID of the monster</param>
    public void _RaceGear(int MonsterID)
    {
        GearStore();
        string Map = Bot.Map.LastMap;
        string MonsterRace = Bot.Monsters.MapMonsters.First(x => x.ID == MonsterID).Race;

        if (MonsterRace == null || MonsterRace == "")
            return;

        // string[] _BestGear = BestGear((RacialGearBoost)Enum.Parse(typeof(RacialGearBoost), MonsterRace), false);
        // if (_BestGear.Length == 0)
        //     return;
        // EnhanceItem(_BestGear, CurrentClassEnh(), CurrentCapeSpecial(), CurrentHelmSpecial(), CurrentWeaponSpecial());
        // Core.Equip(_BestGear);

        Core.Logger("BestGear Disabled");
        //EnhanceEquipped(CurrentClassEnh(), CurrentCapeSpecial(), CurrentHelmSpecial(), CurrentWeaponSpecial());
        Core.Join(Map);
    }

    public bool HasMinimalBoost(GenericGearBoost boostType, int percentage)
        => Bot.Inventory.Items.Concat(Bot.Bank.Items).Any(x => Core.GetBoostFloat(x, boostType.ToString()) >= ((percentage / (float)100) + 1));
    public bool HasMinimalBoost(RacialGearBoost boostType, int percentage)
        => Bot.Inventory.Items.Concat(Bot.Bank.Items).Any(x => Core.GetBoostFloat(x, boostType.ToString()) >= ((percentage / (float)100) + 1));

    #endregion

    #region Enhancement

    /// <summary>
    /// Enhances your currently equipped gear
    /// </summary>
    /// <param name="type"></param>
    /// <param name="cSpecial"></param>
    /// <param name="hSpecial"></param>
    /// <param name="wSpecial"></param>
    public void EnhanceEquipped(EnhancementType type, CapeSpecial cSpecial = CapeSpecial.None, HelmSpecial hSpecial = HelmSpecial.None, WeaponSpecial wSpecial = WeaponSpecial.None)
    {
        if (Core.CBOBool("DisableAutoEnhance", out bool _disableAutoEnhance) && _disableAutoEnhance)
            return;

        List<InventoryItem> EquippedItems = Bot.Inventory.Items.FindAll(i => i.Equipped == true && EnhanceableCatagories.Contains(i.Category));
        try
        {
            AutoEnhance(EquippedItems, type, cSpecial, hSpecial, wSpecial);
        }
        catch (Exception e)
        {
            AdvCrash(e);
        }
    }

    /// <summary>
    /// Enhances a selected item
    /// </summary>
    /// <param name="item"></param>
    /// <param name="type"></param>
    /// <param name="cSpecial"></param>
    /// <param name="hSpecial"></param>
    /// <param name="wSpecial"></param>
    /// <param name="logging"></param>
    public void EnhanceItem(string item, EnhancementType type, CapeSpecial cSpecial = CapeSpecial.None, HelmSpecial hSpecial = HelmSpecial.None, WeaponSpecial wSpecial = WeaponSpecial.None, bool logging = false)
    {
        if (string.IsNullOrEmpty(item) || (Core.CBOBool("DisableAutoEnhance", out bool _disableAutoEnhance) && _disableAutoEnhance))
            return;

        if (!Core.CheckInventory(item))
        {
            Core.Logger($"Enhancement Failed: Could not find \"{item}\"");
            return;
        }

        while (!Bot.ShouldExit && Bot.Player.InCombat)
        {
            if (Bot.Player.HasTarget)
                Bot.Combat.CancelTarget();
            Core.JumpWait();
            Core.Sleep();
        }

        InventoryItem? SelectedItem = Bot.Inventory.Items.Find(i => i.Name.ToLower().Trim() == item.ToLower().Trim() && EnhanceableCatagories.Contains(i.Category)); ;
        if (SelectedItem == null)
        {
            if (Bot.Inventory.Items.Any(i => i.Name.ToLower().Trim() == item.ToLower().Trim()))
                Core.Logger($"Enhancement Failed: {item} cannot be enhanced");
            return;
        }

        try
        {
            AutoEnhance(new() { SelectedItem }, type, cSpecial, hSpecial, wSpecial);
        }
        catch (Exception e)
        {
            AdvCrash(e);
        }
    }

    /// <summary>
    /// Enhances multiple selected items
    /// </summary>
    /// <param name="items"></param>
    /// <param name="type"></param>
    /// <param name="cSpecial"></param>
    /// <param name="hSpecial"></param>
    /// <param name="wSpecial"></param>
    public void EnhanceItem(string[] items, EnhancementType type, CapeSpecial cSpecial = CapeSpecial.None, HelmSpecial hSpecial = HelmSpecial.None, WeaponSpecial wSpecial = WeaponSpecial.None)
    {
        if (items.Length == 0 || (Core.CBOBool("DisableAutoEnhance", out bool _disableAutoEnhance) && _disableAutoEnhance))
            return;

        // If any of the items in the items array cant be found, return
        List<string>? notFound = new();
        foreach (string item in items)
            if (!Core.CheckInventory(item))
                notFound.Add(item);

        if (notFound.Count > 0)
        {
            if (notFound.Count == 1)
                Core.Logger($"Enhancement Failed: Could not find {notFound.First()}");
            else Core.Logger($"Enhancement Failed: Could not find the following items: {string.Join(", ", notFound)}");
            return;
        }
        notFound = null;

        // Find all the items in the items array
        List<InventoryItem> SelectedItems = Bot.Inventory.Items.FindAll(i => items.Contains(i.Name) && EnhanceableCatagories.Contains(i.Category));

        // If any of the items in the items array cant be enhanced, return
        if (SelectedItems.Count != items.Length)
        {
            List<string> unEnhanceable = new();

            foreach (string item in items)
                if (!Bot.Inventory.Items.Any(i => i.Name == item && EnhanceableCatagories.Contains(i.Category)))
                    unEnhanceable.Add(item);

            if (unEnhanceable.Count == 1)
                Core.Logger($"Enhancement Failed: Unenhanceable item found, {unEnhanceable.First()}");
            else Core.Logger($"Enhancement Failed: The following items are unenhanceable, {string.Join(", ", unEnhanceable)}");

            return;
        }

        try
        {
            AutoEnhance(SelectedItems, type, cSpecial, hSpecial, wSpecial);
        }
        catch (Exception e)
        {
            AdvCrash(e);
        }
    }

    private static bool IsEnhancedWithBaseForge(InventoryItem item) => item.EnhancementPatternID == 0 && item.EnhancementLevel > 0;

    // private void AdvCrash(Exception e, [CallerMemberName] string? caller = null)
    // {
    //     if (e == null || (Bot.ShouldExit && e is OperationCanceledException))
    //         return;
    //     List<string> logs = Ioc.Default.GetRequiredService<ILogService>().GetLogs(LogType.Script);
    //     logs = logs.Skip(logs.Count > 5 ? (logs.Count - 5) : logs.Count).ToList();
    //     Bot.Handlers.RegisterOnce(1, Bot => Bot.ShowMessageBox($"{caller} has crashed. Please fill in the Skua Bug Report/Request for under the topic: Crashed\n" +
    //             $"Due to special handling for this type of crash, your script will continue without using {caller} in this instance.\n\n" +
    //             "---------------------------------------------------" +
    //             "Last 5 logs:\n\t" +
    //             logs.Join("\n\t") +
    //             "\n\n" +
    //             "---------------------------------------------------" +
    //             "Crash Log:\n\t" +
    //             e.Message + "\n" + e.InnerException,
    //         caller + " crashed"));
    // }

    private void AdvCrash(Exception e, [CallerMemberName] string? caller = null)
    {
        if (e == null || (Bot.ShouldExit && e is OperationCanceledException))
            return;

        // Determine severity
        string GetSeverity(Exception ex)
        {
            return ex is NullReferenceException or InvalidOperationException ? "❗ Major" :
                   ex is ArgumentException or FormatException ? "⚠️ Minor" : "🔥 Critical";
        }

        string severity = GetSeverity(e);

        // Grab last 5 logs, truncate lines
        List<string> logs = Ioc.Default.GetRequiredService<ILogService>().GetLogs(LogType.Script)
            .Skip(Math.Max(0, Ioc.Default.GetRequiredService<ILogService>().GetLogs(LogType.Script).Count - 5))
            .Select((l, i) => $"{i + 1}. {(l.Length > 80 ? string.Concat(l.AsSpan(0, 77), "…") : l)}")
            .ToList();

        // Helper: compact exception info
        string GetExceptionDetails(Exception ex, int maxFrames = 5, int maxInnerLines = 5, int maxFrameLength = 80)
        {
            StackTrace st = new(ex, true);
            StackFrame? frame = st.GetFrames()?.FirstOrDefault(f => f.GetFileLineNumber() > 0);

            string location = frame != null
                ? $"{frame.GetFileName()?.Split('\\').LastOrDefault()} @ line {frame.GetFileLineNumber()} in {frame.GetMethod()?.Name}"
                : "No line info. Top stack frames:\n" +
                  string.Join("\n", st.GetFrames()?.Take(maxFrames)
                      .Select(f => f.ToString().Length > maxFrameLength ? string.Concat(f.ToString().AsSpan(0, maxFrameLength), "…") : f.ToString())
                      ?? Array.Empty<string>()) +
                  (st.FrameCount > maxFrames ? "\n…" : "");

            string inner = "";
            if (ex.InnerException != null)
            {
                string[] innerLines = ex.InnerException.StackTrace?.Split('\n') ?? Array.Empty<string>();
                inner = $"\n🔹 **Inner Exception** 🔹\nMessage: {ex.InnerException.Message}\n" +
                        string.Join("\n", innerLines.Take(maxInnerLines)
                            .Select(l => l.Length > maxFrameLength ? string.Concat(l.AsSpan(0, maxFrameLength), "…") : l)) +
                        (innerLines.Length > maxInnerLines ? "\n…" : "");
            }

            return $"🔥 **Outer Exception** 🔥\nSeverity: {severity}\nMessage: {ex.Message}\n📍 Location: {location}{inner}";
        }

        string crashDetails = GetExceptionDetails(e);

        // Build one-line summary
        string oneLineSummary = $"📌 {caller} Crash | {severity} | Location: {crashDetails.Split('\n')[3]}";

        // Build ultimate MessageBox
        string message =
            "══════════════════════════════════════════\n" +
            $"🛑 **{caller} Crash Report** 🛑\n" +
            "══════════════════════════════════════════\n\n" +
            $"{oneLineSummary}\n\n" +
            $"⚠️ Script will continue without `{caller}`.\n" +
            $"📸 Take a screenshot and post it to Discord.\n\n" +
            "────────────── 📜 Last 5 Logs ──────────────\n" +
            string.Join("\n", logs) + "\n" +
            "────────────── 💻 Crash Details ────────────\n" +
            crashDetails + "\n" +
            "══════════════════════════════════════════";

        Bot.Handlers.RegisterOnce(1, Bot => Bot.ShowMessageBox(message, $"{caller} crashed"));
    }



    /// <summary>
    /// Determines what Enhancement Type the player has on their currently equipped class
    /// </summary>
    /// <returns>Returns the equipped Enhancement Type</returns>
    public EnhancementType CurrentClassEnh()
    {
        int? EnhPatternID = Bot.Player.CurrentClass?.EnhancementPatternID;
        if (EnhPatternID == 1 || EnhPatternID == 23 || EnhPatternID == null)
            EnhPatternID = 9;
        return (EnhancementType)EnhPatternID;
    }

    /// <summary>
    /// Determines what Cape Special the player has on their currently equipped cape
    /// </summary>
    /// <returns>Returns the equipped Cape Special</returns>
    public CapeSpecial CurrentCapeSpecial()
    {
        InventoryItem? EquippedCape = Bot.Inventory.Items.Find(i => i.Equipped && i.Category == ItemCategory.Cape);
        if (EquippedCape == null)
            return CapeSpecial.None;
        int pattern_id = EquippedCape.EnhancementPatternID;
        if (Enum.IsDefined(typeof(EnhancementType), pattern_id))
            return CapeSpecial.None;
        return (CapeSpecial)pattern_id;
    }

    /// <summary>
    /// Determines what Helm Special the player has on their currently equipped helm
    /// </summary>
    /// <returns>Returns the equipped Helm Special</returns>
    public HelmSpecial CurrentHelmSpecial()
    {
        InventoryItem? EquippedHelm = Bot.Inventory.Items.Find(i => i.Equipped && i.Category == ItemCategory.Helm);
        if (EquippedHelm == null)
            return HelmSpecial.None;
        int pattern_id = EquippedHelm.EnhancementPatternID;
        if (Enum.IsDefined(typeof(EnhancementType), pattern_id))
            return HelmSpecial.None;
        return (HelmSpecial)pattern_id;
    }

    /// <summary>
    /// Determines what Weapon Special the player has on their currently equipped weapon
    /// </summary>
    /// <returns>Returns the equipped Weapon Special</returns>
    public WeaponSpecial CurrentWeaponSpecial()
    {
        InventoryItem? EquippedWeapon = Bot.Inventory.Items.Find(i => i.Equipped && WeaponCatagories.Contains(i.Category));
        if (EquippedWeapon == null)
            return WeaponSpecial.None;
        int pattern_id = getProcID(EquippedWeapon);
        if (Enum.IsDefined(typeof(EnhancementType), pattern_id))
            return WeaponSpecial.None;
        return (WeaponSpecial)pattern_id;
    }

    private static readonly ItemCategory[] EnhanceableCatagories =
    {
        ItemCategory.Sword,
        ItemCategory.Axe,
        ItemCategory.Dagger,
        ItemCategory.Gun,
        ItemCategory.HandGun,
        ItemCategory.Rifle,
        ItemCategory.Bow,
        ItemCategory.Mace,
        ItemCategory.Gauntlet,
        ItemCategory.Polearm,
        ItemCategory.Staff,
        ItemCategory.Wand,
        ItemCategory.Whip,
        ItemCategory.Class,
        ItemCategory.Helm,
        ItemCategory.Cape,

    };

    public readonly ItemCategory[] WeaponCatagories = EnhanceableCatagories[..12];

    private void AutoEnhance(List<InventoryItem> ItemList, EnhancementType type, CapeSpecial cSpecial, HelmSpecial hSpecial, WeaponSpecial wSpecial, bool logging = false)
    {
        // In case the 'CurrentEnhancement()' failed and returned 0
        if (type == 0)
            return;

        // Empty check
        if (ItemList.Count == 0)
        {
            Core.Logger("Enhancement Failed:\t\"ItemList\" is empty");
            return;
        }

        // Defining cape
        InventoryItem? cape = null;
        if (cSpecial != CapeSpecial.None && ItemList.Any(i => i.Category == ItemCategory.Cape))
        {
            cape = ItemList.Find(i => i.Category == ItemCategory.Cape);

            // Removing cape from the list because it needs to be enhanced seperately
            if (cape != null)
                ItemList.Remove(cape);
        }

        // Defining helm
        InventoryItem? helm = null;
        if (hSpecial != HelmSpecial.None && ItemList.Any(i => i.Category == ItemCategory.Helm))
        {
            helm = ItemList.Find(i => i.Category == ItemCategory.Helm);

            // Removing helm from the list because it needs to be enhanced seperately
            if (helm != null)
                ItemList.Remove(helm);
        }

        // Defining weapon
        InventoryItem? weapon = null;
        // If Awe-Enhancements aren't unlocked, enhance them with normal enhancements
        if (wSpecial != WeaponSpecial.None && ItemList.Any(i => i.ItemGroup == "Weapon") && (uAwe() || (int)wSpecial > 6))
        {
            weapon = ItemList.Find(i => i.ItemGroup == "Weapon");

            // Removing weapon from the list because it needs to be enhanced seperately
            if (weapon != null)
                ItemList.Remove(weapon);
        }

        int skipCounter = 0;

        // Setting the shop ID for the enhancement type
        if (ItemList.Count > 0)
        {
            int shopID = 0;

            switch (type)
            {
                case EnhancementType.Fighter:
                    shopID = Bot.Player.Level >= 50 ? 768 : 141;
                    break;
                case EnhancementType.Thief:
                    shopID = Bot.Player.Level >= 50 ? 767 : 142;
                    break;
                case EnhancementType.Hybrid:
                    shopID = Bot.Player.Level >= 50 ? 766 : 143;
                    break;
                case EnhancementType.Wizard:
                    shopID = Bot.Player.Level >= 50 ? 765 : 144;
                    break;
                case EnhancementType.Healer:
                    shopID = Bot.Player.Level >= 50 ? 762 : 145;
                    break;
                case EnhancementType.SpellBreaker:
                    shopID = Bot.Player.Level >= 50 ? 764 : 146;
                    break;
                case EnhancementType.Lucky:
                    shopID = Bot.Player.Level >= 50 ? 763 : 147;
                    break;
                default:
                    Core.Logger($"Enhancement Failed:\tInvalid EnhancementType given, received {(int)type} | {type}");
                    return;
            }

            // Enhancing the remaining items
            foreach (InventoryItem item in ItemList)
            {
                _AutoEnhance(item, shopID, Bot.Map?.Name, logging);
                Core.Sleep();
            }
        }

        // Enhancing the cape with the cape special
        if (cape != null)
        {
            bool canEnhance = true;

            switch (cSpecial)
            {
                case CapeSpecial.Forge:
                    if (!uForgeCape())
                    {
                        Core.Logger("Enhancement Failed:\tYou did not unlock the Forge (Cape) Enhancement yet");
                        canEnhance = false;
                    }
                    break;
                case CapeSpecial.Absolution:
                    if (!uAbsolution())
                        Fail();
                    break;
                case CapeSpecial.Avarice:
                    if (!uAvarice())
                        Fail();
                    break;
                case CapeSpecial.Vainglory:
                    if (!uVainglory())
                        Fail();
                    break;
                case CapeSpecial.Penitence:
                    if (!uPenitence())
                        Fail();
                    break;
                case CapeSpecial.Lament:
                    if (!uLament())
                        Fail();
                    break;
                default:
                    Core.Logger($"Enhancement Failed:\tInvalid \"CapeSpecial\" given, received {(int)cSpecial} | {cSpecial}");
                    return;

                    void Fail()
                    {
                        Core.Logger($"Enhancement Failed:\tYou did not unlock the {cSpecial} Enhancement yet");
                        canEnhance = false;
                    }
            }

            if (canEnhance)
                _AutoEnhance(cape, 2143, ((int)cSpecial > 0) ? "forge" : null, logging);
            else skipCounter++;
        }

        // Enhancing the helm with the helm special
        if (helm != null)
        {
            bool canEnhance = true;

            switch (hSpecial)
            {
                case HelmSpecial.Vim:
                    if (!uVim())
                        Fail();
                    break;
                case HelmSpecial.Examen:
                    if (!uExamen())
                        Fail();
                    break;
                case HelmSpecial.Forge:
                    if (!uForgeHelm())
                        Fail();
                    break;
                case HelmSpecial.Anima:
                    if (!uAnima())
                        Fail();
                    break;
                case HelmSpecial.Pneuma:
                    if (!uPneuma())
                        Fail();
                    break;
                case HelmSpecial.Hearty:
                    if (!uHearty())
                        Fail();
                    break;
                default:
                    Core.Logger($"Enhancement Failed:\tInvalid \"HelmSpecial\" given, received {(int)hSpecial} | {hSpecial}");
                    return;

                    void Fail()
                    {
                        Core.Logger($"Enhancement Failed:\tYou did not unlock the {hSpecial} Enhancement yet");
                        canEnhance = false;
                    }
            }

            if (canEnhance)
                _AutoEnhance(helm, 2164, ((int)hSpecial > 0) ? "forge" : null);
            else skipCounter++;
        }

        // Enhancing the weapon with the weapon special
        if (weapon != null)
        {
            int shopID = 0;
            bool canEnhance = true;

            if ((int)wSpecial <= 6)
            {
                switch (type)
                {
                    case EnhancementType.Fighter:
                        shopID = 635;
                        break;
                    case EnhancementType.Thief:
                        shopID = 637;
                        break;
                    case EnhancementType.Hybrid:
                        shopID = 633;
                        break;
                    case EnhancementType.Wizard:
                    case EnhancementType.SpellBreaker:
                        shopID = 636;
                        break;
                    case EnhancementType.Healer:
                        shopID = 638;
                        break;
                    case EnhancementType.Lucky:
                        shopID = 639;
                        break;
                    default:
                        Core.Logger($"Enhancement Failed:\tInvalid \"EnhancementType\" given, received {(int)wSpecial} | {wSpecial}");
                        return;
                }
            }
            else
            {
                switch (wSpecial)
                {
                    case WeaponSpecial.Forge:
                        if (!uForgeWeapon())
                        {
                            Core.Logger("Enhancement Failed:\tYou did not unlock the Forge (Weapon) Enhancement yet");
                            canEnhance = false;
                        }
                        break;
                    case WeaponSpecial.Lacerate:
                        if (!uLacerate())
                            Fail();
                        break;
                    case WeaponSpecial.Smite:
                        if (!uSmite())
                            Fail();
                        break;
                    case WeaponSpecial.Valiance:
                        if (!uValiance())
                            Fail();
                        break;
                    case WeaponSpecial.Arcanas_Concerto:
                        if (!uArcanasConcerto())
                        {
                            Core.Logger("Enhancement Failed:\tYou did not unlock the Arcana's Concerto Enhancement yet");
                            canEnhance = false;
                        }
                        break;
                    case WeaponSpecial.Elysium:
                        if (!uElysium())
                            Fail();
                        break;
                    case WeaponSpecial.Acheron:
                        if (!uAcheron())
                            Fail();
                        break;
                    case WeaponSpecial.Praxis:
                        if (!uPraxis())
                            Fail();
                        break;
                    case WeaponSpecial.Dauntless:
                        if (!uDauntless())
                            Fail();
                        break;
                    case WeaponSpecial.Ravenous:
                        if (!uRavenous())
                            Fail();
                        break;

                    default:
                        Core.Logger($"Enhancement Failed:\tInvalid \"WeaponSpecial\" given, received {(int)wSpecial} | {wSpecial}");
                        return;

                        void Fail()
                        {
                            Core.Logger($"Enhancement Failed:\tYou did not unlock the {wSpecial} Enhancement yet");
                            canEnhance = false;
                        }
                }

                shopID = 2142;
            }

            if (canEnhance)
                _AutoEnhance(weapon, shopID, ((int)wSpecial > 6) ? "forge" : null, logging);
            else skipCounter++;
        }

        if (skipCounter > 0)
            Core.Logger($"Enhancement Skipped:\t{skipCounter} item{(skipCounter > 1 ? 's' : null)}");

        void _AutoEnhance(InventoryItem item, int shopID, string? map = null, bool logging = false)
        {
            bool specialOnCape = item.Category == ItemCategory.Cape && cSpecial != CapeSpecial.None;
            bool specialOnHelm = item.Category == ItemCategory.Helm && hSpecial != HelmSpecial.None;
            bool specialOnWeapon = item.ItemGroup == "Weapon" && wSpecial.ToString() != "None";
            string mapName = map ?? Bot.Map?.Name ?? "whitemap";
            List<ShopItem> shopItems = Core.GetShopItems(mapName, shopID);

            // Shopdata complete check
            if (!shopItems.Any(x => x.Category == ItemCategory.Enhancement) || shopItems.Count == 0)
            {
                Core.Logger($"Enhancement Failed for {item.Name}[{item.ID}], (EnhancementLevel: {item.EnhancementLevel}, map: {mapName}, shopID: {shopID}):\n" + $"Couldn't find enhancements in shop {shopID}");
                return;
            }

            // Checking if the item is already optimally enhanced
            if (Bot.Player.Level == item.EnhancementLevel)
            {
                if (specialOnCape)
                {
                    if ((int)cSpecial == item.EnhancementPatternID)
                    {
                        skipCounter++;
                        return;
                    }
                }
                else if (specialOnHelm)
                {
                    if ((int)hSpecial == item.EnhancementPatternID)
                    {
                        skipCounter++;
                        return;
                    }
                }
                else if (specialOnWeapon)
                {
                    if (((int)wSpecial <= 6 ? (int)type : 10) == item.EnhancementPatternID && ((int)wSpecial == getProcID(item) || ((int)wSpecial == 99 && getProcID(item) == 0)))
                    {
                        skipCounter++;
                        return;
                    }
                }
                else if ((int)type == item.EnhancementPatternID)
                {
                    skipCounter++;
                    return;
                }
            }

            // Logging
            if (logging)
            {
                if (specialOnCape)
                    Core.Logger($"Searching Enhancement:\tForge/{cSpecial.ToString().Replace("_", " ")} - \"{item.Name}\"");
                else if (specialOnWeapon)
                    Core.Logger($"Searching Enhancement:\t{((int)wSpecial <= 6 ? type : "Forge")}/{wSpecial.ToString().Replace("_", " ")} - \"{item.Name}\"");
                else
                    Core.Logger($"Searching Enhancement:\t{type} - \"{item.Name}\"");
            }

            List<ShopItem> availableEnh = new();

            // Filters
            foreach (ShopItem enh in shopItems)
            {
                // Remove enhancments that you dont have access to
                if ((!Bot.Player.IsMember && enh.Upgrade) || (enh.Level > Bot.Player.Level))
                {
                    continue;
                }

                string enhName = enh.Name.Replace(" ", "").Replace("\'", "").ToLower();

                // Cape if cSpecial
                if (specialOnCape && enhName.Contains(cSpecial.ToString().Replace("_", "").ToLower()))
                    availableEnh.Add(enh);
                // Weapon if wSpecial
                else if (specialOnWeapon && enhName.Contains(wSpecial.ToString().Replace("_", "").ToLower()))
                    availableEnh.Add(enh);
                //Helm if hSpecial
                else if (specialOnHelm && enhName.Contains(hSpecial.ToString().Replace("_", "").ToLower()))
                    availableEnh.Add(enh);
                // Class
                else if (item.Category == ItemCategory.Class && enhName.Contains("armor"))
                    availableEnh.Add(enh);
                // Helm
                else if (item.Category == ItemCategory.Helm && enhName.Contains("helm"))
                    availableEnh.Add(enh);
                // Cape if not cSpecial
                else if (item.Category == ItemCategory.Cape && enhName.Contains("cape"))
                    availableEnh.Add(enh);
                // Weapon2 if not wSpecial
                else if (item.ItemGroup == "Weapon" && enhName.Contains("weapon"))
                    availableEnh.Add(enh);
            }

            // Empty check
            ShopItem? bestEnhancement = null;
            if (availableEnh.Count == 0)
            {
                if (logging)
                    Core.Logger($"Enhancement Failed:\t\"availableEnh\" is empty");
                return;
            }
            else if (availableEnh.Count == 1)
                bestEnhancement = availableEnh.First();
            else
            {
                // Sorting by level (descending)
                List<ShopItem> sortedList = availableEnh.OrderByDescending(x => x.Level)
                    .ThenByDescending(x => x.Upgrade ? 1 : 0).ToList();
                bestEnhancement = sortedList[0];
            }

            // Null check
            if (bestEnhancement == null)
            {
                if (logging)
                    Core.Logger($"Enhancement Failed:\tCould not find the best enhancement for \"{item.Name}\"");
                return;
            }

            // Compare with current enhancement
            if (bestEnhancement.ID == getEnhID(item) && item.EnhancementLevel > 0 && bestEnhancement.Level == item.EnhancementLevel)
            {
                if (logging)
                    Core.Logger($"Enhancement Canceled:\tBest enhancement is already applied for \"{item.Name}\"");
                return;
            }

            // Enhancing the item
            int roomId = Bot.Map?.RoomID ?? 1;

            Bot.Send.Packet($"%xt%zm%enhanceItemShop%{roomId}%{item.ID}%{bestEnhancement.ID}%{shopID}%");

            // Final logging
            if (specialOnCape)
            {
                if (logging)
                    Core.Logger($"Enhancement Applied:\tForge/{cSpecial.ToString().Replace("_", " ")} - \"{item.Name}\" (Lvl {bestEnhancement.Level})");
            }
            else if (specialOnWeapon)
            {
                if (logging)
                    Core.Logger($"Enhancement Applied:\t{((int)wSpecial <= 6 ? type : "Forge")}/{wSpecial.ToString().Replace("_", " ")} - \"{item.Name}\" (Lvl {bestEnhancement.Level})");
            }
            else
            {
                if (logging)
                    Core.Logger($"Enhancement Applied:\t{type} - \"{item.Name}\" (Lvl {bestEnhancement.Level})");
            }
            Core.Sleep();
        }
    }

    private int getProcID(InventoryItem? item)
        => item == null ? 0 : Core.GetItemProperty<int>(item, "ProcID");
    private int getEnhID(InventoryItem? item)
        => item == null ? 0 : Core.GetItemProperty<int>(item, "iEnh");

    public bool uAwe()
        => Core.isCompletedBefore(2937);
    public bool uForgeWeapon()
        => Core.isCompletedBefore(8738);
    public bool uLacerate()
        => Core.isCompletedBefore(8739);
    public bool uSmite()
        => Core.isCompletedBefore(8740);
    public bool uValiance()
        => Core.isCompletedBefore(8741);
    public bool uArcanasConcerto()
        => Core.isCompletedBefore(8742);
    public bool uAbsolution()
        => Core.isCompletedBefore(8743);
    public bool uVainglory()
        => Core.isCompletedBefore(8744);
    public bool uAvarice()
        => Core.isCompletedBefore(8745);
    public bool uForgeCape()
        => Core.isCompletedBefore(8758);
    public bool uElysium()
        => Core.isCompletedBefore(8821);
    public bool uAcheron()
        => Core.isCompletedBefore(8820);
    public bool uPenitence()
        => Core.isCompletedBefore(8822);
    public bool uLament()
        => Core.isCompletedBefore(8823);
    public bool uVim()
        => Core.isCompletedBefore(8824);
    public bool uExamen()
        => Core.isCompletedBefore(8825);
    public bool uForgeHelm()
        => Core.isCompletedBefore(8828);
    public bool uPneuma()
        => Core.isCompletedBefore(8827);
    public bool uAnima()
        => Core.isCompletedBefore(8826);
    public bool uDauntless()
        => Core.isCompletedBefore(9172);
    public bool uPraxis()
        => Core.isCompletedBefore(9171);
    public bool uRavenous()
        => Core.isCompletedBefore(9560);
    public bool uHearty()
    {
        return Core.isCompletedBefore(9466) && Farm.FactionRank("Grimskull Trolling") >= 7;
    }

    #endregion

    #region SmartEnhance

    /// <summary>
    /// Automatically finds the best Enhancement for the given class and enhances all equipped gear with it too
    /// </summary>
    /// <param name="className">Name of the class you wish to enhance</param>
    public void SmartEnhance(string? className)
    {
        if (string.IsNullOrEmpty(className))
        {
            Core.Logger($"{className} is null");
            return;
        }

        if (!Core.CheckInventory(className))
        {
            Core.Logger($"SmartEnhance Failed: Class {className} was not found in inventory");
            return;
        }

        if (Bot.Player.InCombat)
            Core.JumpWait();

        // Error correction
        className = className.ToLower().Trim();
        InventoryItem? SelectedClass = Bot.Inventory.Items.Find(i => i.Name.ToLower().Trim() == className.ToLower().Trim() && i.Category == ItemCategory.Class);
        if (SelectedClass == null)
        {
            Core.Logger($"SmartEnhance Failed: Class {className} was not found in inventory");
            return;
        }

        // Creating variables that can be assigned to
        className = SelectedClass.Name.ToLower();
        EnhancementType? type = null;
        CapeSpecial cSpecial = CapeSpecial.None;
        HelmSpecial hSpecial = HelmSpecial.None;
        WeaponSpecial wSpecial = WeaponSpecial.None;

        // If the item doesnt exist in the forge enh lib, or the player doesn't have the Forge enh unlocked, use Awe enh instead
        if (!ForgeEnhancementLibrary())
            AweEnhancementLibrary();

        // Can't be too careful
        if (type == null)
        {
            Core.Logger($"SmartEnhance Failed: 'type' for {className} is NULL");
            return;
        }

        // If the class isn't enhanced yet, enhance it with the enhancement type
        if (SelectedClass.EnhancementLevel <= 0)
        {
            EnhanceItem(SelectedClass.Name ?? className, (EnhancementType)type);
        }
        Core.Equip(SelectedClass.Name ?? className);
        Bot.Wait.ForTrue(() => Bot.Player.CurrentClass?.Name == className, 40);
        EnhanceEquipped((EnhancementType)type, cSpecial, hSpecial, wSpecial);

        bool ForgeEnhancementLibrary()
        {
            switch (className)
            {

                #region Lucky Region

                #region Luck - Awe_Blast | Arcanas_Concerto - ForgeHelm - Penitence
                case "lord of order":
                    if (!uAwe() || !uForgeHelm() || !uPenitence())
                        goto default;

                    type = EnhancementType.Lucky;
                    wSpecial = uArcanasConcerto() ? WeaponSpecial.Arcanas_Concerto : WeaponSpecial.Awe_Blast;
                    hSpecial = HelmSpecial.Forge;
                    cSpecial = CapeSpecial.Penitence;
                    break;
                #endregion

                #region Ravenous
                case "PlaceHolder":
                    if (!uRavenous())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Ravenous;
                    break;
                #endregion Ravenous


                #region Lucky - Dauntless - Vim - Lament
                case "great thief":
                    if (!uDauntless() || !uVim() || !uLament())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Lament;
                    wSpecial = WeaponSpecial.Dauntless;
                    hSpecial = HelmSpecial.Vim;
                    break;
                #endregion Lucky - Dauntless - Vim - Penitence

                #region Lucky - Lacerate - Vim - Lament
                case "timekeeper":
                case "timekiller":
                    if (!uLacerate() || !uVim() || !uLament())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Lament;
                    wSpecial = WeaponSpecial.Lacerate;
                    hSpecial = HelmSpecial.Vim;
                    break;
                #endregion Lucky - Lacerate - Vim - Lament

                #region Lucky - Forge - Spiral Carve
                case "corrupted chronomancer":
                case "underworld chronomancer":
                case "eternal chronomancer":
                case "immortal chronomancer":
                case "dark metal necro":
                    if (!uForgeCape())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Spiral_Carve;
                    break;
                #endregion

                #region Lucky - Forge - Awe Blast
                case "glacial berserker":
                    if (!Core.isCompletedBefore(8758))
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Awe_Blast;
                    break;
                #endregion

                #region Lucky - Forge - Mana Vamp
                case "legendary elemental warrior":
                case "mythic elemental warrior":
                case "ultra elemental warrior":
                    if (!uForgeCape())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Mana_Vamp;
                    break;
                #endregion

                #region Lucky - Forge - Smite
                case "Draconic Chronomancer":
                    if (!uSmite() || !uForgeCape())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Smite;
                    break;
                #endregion

                #region Lucky - Forge - Elysium
                case "ultra omniknight":
                case "dark ultra omninight":
                    if (!uElysium() || !uForgeCape())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Elysium;
                    break;
                #endregion

                #region Lucky - Vainglory - Valiance - Anima
                case "archfiend":
                case "eternal inversionist":
                case "dragonlord":
                    if (!uVainglory() || !uValiance() || !uAnima())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Anima;

                    break;
                #endregion

                #region Lucky - Vainglory - Valiance - Vim
                case "continuum chronomancer":
                case "quantum chronomancer":
                case "chaos avenger":
                    if (!uPenitence()
                    || (!uDauntless() || !uValiance()) || !uRavenous() || !uValiance()
                    || !uAnima())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous :
                                uDauntless() ? WeaponSpecial.Dauntless : WeaponSpecial.Valiance;

                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Lucky - Lacerate - Forge - Lament

                case "doom metal necro":
                case "neo metal necro":
                    if (!uLacerate() || !uForgeHelm() || !uLament())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = uLament() ? CapeSpecial.Lament : CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Lacerate;
                    hSpecial = HelmSpecial.Forge;
                    break;
                #endregion Lucky - lacerate - forge

                #region Lucky - Vainglory - Dauntless|Valiance|Smite - Vim
                case "yami no ronin":
                case "martial artist":
                case "master martial artist":
                    if ((!uDauntless() && !uValiance() && !uSmite()) || !uVainglory() || !uVim())
                        goto default;


                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uDauntless() ? WeaponSpecial.Dauntless :
                                uValiance() ? WeaponSpecial.Valiance :
                                WeaponSpecial.Smite; // else do smite, if no smite > do Awe
                    hSpecial = HelmSpecial.Vim;
                    break;
                #endregion

                #region Lucky - Vainglory - Valiance - Anima
                case "nechronomancer":
                case "necrotic chronomancer":
                    if (!uVainglory() || !uArcanasConcerto() || !uAnima())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Lucky - Vainglory - Elysium - Vim
                case "shadowwalker of time":
                case "shadowstalker of time":
                case "shadowweaver of time":
                    if (!uVainglory() || !uElysium() || !uVim())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Vim;
                    break;
                #endregion

                #region Lucky - Vainglory - Valiance - None
                case "legion doomknight":
                    if (!uVainglory() || !uValiance())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Valiance;
                    hSpecial = CurrentHelmSpecial();
                    break;
                #endregion

                #region Lucky - Vainglory - Elysium - Pneuma
                case "antique hunter":
                case "artifact hunter":
                    if (!uVainglory() || !uElysium() || !uPneuma())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Lucky - Lament - Elysium - Pneuma
                case "abyssal angel":
                case "abyssal angel's shadow":
                    if (!uLament() || !uElysium() || !uPneuma())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Lucky - Dauntless | Ravenous - Anima | ForgeHelm - Vainglory
                case "verus doomknight":
                    if (!uRavenous() || !uForgeHelm() || !uVainglory())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uDauntless() ? WeaponSpecial.Dauntless : WeaponSpecial.Ravenous;
                    hSpecial = uAnima() ? HelmSpecial.Anima : HelmSpecial.Forge;
                    break;
                #endregion

                #region Lucky - Vainglory - Dauntless/Valiance - Anima
                case "void highlord":
                case "void highlord (ioda)":
                    if (!uAnima() || !uValiance() || !uVainglory())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = !uDauntless() ?
                    (uRavenous() ? WeaponSpecial.Ravenous
                    : (uValiance() ? WeaponSpecial.Valiance : WeaponSpecial.Forge))
                    : WeaponSpecial.Dauntless;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion



                #region Lucky - Avarice - Dauntless - Anima
                case "flame dragon warrior":
                    if (!uAvarice() || !uDauntless() || !uAnima())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Avarice;
                    wSpecial = WeaponSpecial.Dauntless;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Lucky - Avarice - Elysium - Anima
                case "chaos slayer":
                case "chaos slayer berserker":
                case "chaos slayer cleric":
                case "chaos slayer mystic":
                case "chaos slayer thief":
                    if (!uAvarice() || !uElysium() || !uAnima())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Avarice;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Lucky - Penitence - Ravenous | Praxis | Lacerate - Forge | None 
                case "archpaladin":
                    if (!uLacerate() || !uForgeHelm() || !uPenitence())
                        goto default;

                    type = EnhancementType.Lucky;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : (uPraxis() ? WeaponSpecial.Praxis : WeaponSpecial.Lacerate);
                    hSpecial = uForgeHelm() ? HelmSpecial.Forge : HelmSpecial.None;
                    cSpecial = CapeSpecial.Penitence;
                    break;
                #endregion

                #region Fighter - Ravenous | Valiance - Anima - Absolution
                case "stonecrusher":
                    if (!uValiance() || !uAnima() || !uAbsolution())
                        goto default;

                    type = EnhancementType.Fighter;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Anima;
                    cSpecial = CapeSpecial.Absolution;
                    break;
                #endregion

                #endregion

                #region Wizard Region

                #region Wizard -  Valiance|Praxis - Pneuna - Vainglory|Lament
                case "lightcaster":
                    if (!uValiance() || !uPneuma() || !uVainglory())
                    {
                        if (!uLament() || !uPraxis())
                            goto default;
                    }
                    type = EnhancementType.Wizard;
                    cSpecial = !uVainglory() ? CapeSpecial.Lament : CapeSpecial.Vainglory;
                    wSpecial = !uValiance() ? WeaponSpecial.Praxis : WeaponSpecial.Valiance;
                    hSpecial = !uPneuma() ? CurrentHelmSpecial() : HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Forge - Awe Blast
                case "infinity knight":
                    if (!uForgeCape())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Forge;
                    wSpecial = WeaponSpecial.Awe_Blast;
                    hSpecial = CurrentHelmSpecial();
                    break;
                #endregion

                #region Wizard - Vainglory - Valiance - Pneuma
                case "archmage":
                case "darklord":
                case "arcana invoker":
                    if (!uVainglory() || !uValiance() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Penitence - Acheron - Pneuma
                case "master of moglins":
                case "dark master of moglins":
                    if (!uPenitence() || !uAcheron() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Penitence;
                    wSpecial = WeaponSpecial.Acheron;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Vainglory - Ravenous | Valiance - Pneuma | Wizard
                case "legion revenant":
                case "legion revenant (ioda)":
                    if (!uVainglory() || !uValiance() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Avarice - Elysium - Pneuma
                case "vampire lord":
                case "enchanted vampire lord":
                case "royal vampire lord":
                case "darkside":
                case "dark lord":
                    if (!uAvarice() || !uElysium() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Avarice;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region  Wizard - Vainglory - Elysium - Pneuma   
                case "shaman":
                    if (!uVainglory() || !uElysium() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Avarice - Acheron - Pneuma
                case "blaze binder":
                    if (!uAvarice() || !uAcheron() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Avarice;
                    wSpecial = WeaponSpecial.Acheron;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Lament - Elysium - Pneuma
                case "royal battlemage":
                    if (!uLament() || !uElysium() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Lament;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Wizard - Lament - Valiance - Pneuma
                case "scarlet sorceress":
                    if (!uLament() || !uValiance() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Lament;
                    wSpecial = WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion


                #region Wizard - Vainglory / Forge - Daunt / Ravenous / Forge - Pneuma / Forge       
                case "sovereign of storms":
                    if (!uVainglory() || !uDauntless() || !uRavenous() || !uPneuma())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = uVainglory() ? CapeSpecial.Vainglory : CapeSpecial.Forge;
                    wSpecial = uDauntless() ? WeaponSpecial.Dauntless : (uRavenous() ? WeaponSpecial.Ravenous : WeaponSpecial.Forge);
                    hSpecial = uPneuma() ? HelmSpecial.Pneuma : HelmSpecial.Forge;
                    break;
                #endregion


                #region Wizard - Ravenous - Lament - Examen
                case "lich":
                    if (!(uRavenous() && uLament() && uExamen()))
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Lament;
                    wSpecial = WeaponSpecial.Ravenous;
                    hSpecial = HelmSpecial.Examen;
                    break;
                #endregion                
                #endregion

                #region Healer Region

                #region Healer - Avarice - Elysium - Pneuma
                case "dragon of time":
                    if (!uAvarice() || !uElysium() || !uPneuma())
                        goto default;

                    type = EnhancementType.Healer;
                    cSpecial = CapeSpecial.Avarice;
                    wSpecial = WeaponSpecial.Elysium;
                    hSpecial = HelmSpecial.Pneuma;
                    break;

                #endregion

                #region  Healer - None - Valiance - Nine
                case "obsidian paladin chronomancer":
                case "paladin chronomancer":
                    if (!uValiance())
                        goto default;

                    type = EnhancementType.Healer;
                    cSpecial = CapeSpecial.None;
                    wSpecial = WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.None;
                    break;

                #endregion

                #region Fighter - Ravenous | Valiance - Anima - Absolution
                case "frostval barbarian":
                    if (!uAbsolution() || !uValiance() || !uAnima())
                        goto default;
                    type = EnhancementType.Fighter;
                    cSpecial = CapeSpecial.Absolution;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Lucky - Penitence | Absolution - Elysium | Valiance - Vim
                case "arachnomancer":
                    if (!uAbsolution() || !uAbsolution() || !uVim())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = uPenitence() ? CapeSpecial.Penitence : CapeSpecial.Absolution;
                    wSpecial = uElysium() ? WeaponSpecial.Elysium : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Vim;
                    break;
                #endregion

                #region Healer - Valiance - Current - Current

                #endregion

                #region Wizard - Elysium - Pneuma | Wizard - Vainglory

                #endregion

                #region Healer - Current - Valiance/Awe - Current
                case "healer":
                case "healer (rare)":
                    type = EnhancementType.Healer;
                    cSpecial = CurrentCapeSpecial();
                    wSpecial = uValiance() ? WeaponSpecial.Valiance : WeaponSpecial.Awe_Blast;
                    hSpecial = CurrentHelmSpecial();
                    break;
                #endregion

                #region Luck - Vim - Lam - Rav
                case "Chrono ShadowSlayer":
                case "chrono shadowhunter":
                    type = EnhancementType.Lucky;
                    cSpecial = uLament() ? CapeSpecial.Lament : (uForgeCape() ? CapeSpecial.Forge : CurrentCapeSpecial());
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : (uArcanasConcerto() ? WeaponSpecial.Arcanas_Concerto : (uForgeWeapon() ? WeaponSpecial.Forge : WeaponSpecial.Awe_Blast));
                    hSpecial = uVim() ? HelmSpecial.Vim : (uForgeHelm() ? HelmSpecial.Forge : CurrentHelmSpecial());
                    break;
                #endregion

                #region Lucky - Vainglory - Valiance / Dauntless - Anima
                case "glacial warlord":
                case "glaceran warlord":
                case "dark glaceran warlord":
                case "savage glaceran warlord":
                    if (!uVainglory() || !uValiance() || !uAnima())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uDauntless() ? WeaponSpecial.Dauntless : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Lucky - Ravenous - Examen - Vainglory
                case "king's echo":
                    if (!uRavenous() || !uExamen() || !uVainglory())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Ravenous;
                    hSpecial = HelmSpecial.Examen;
                    break;
                #endregion

                #region Luck - Val/Smite/Mana - Anima - Vg
                case "dragonslayer general":
                    type = EnhancementType.Lucky;

                    cSpecial = uVainglory()
                        ? CapeSpecial.Vainglory
                        : uForgeCape()
                            ? CapeSpecial.Forge
                            : CurrentCapeSpecial();

                    wSpecial = uValiance()
                        ? WeaponSpecial.Valiance
                        : uSmite()
                            ? WeaponSpecial.Smite
                            : WeaponSpecial.Mana_Vamp;

                    hSpecial = uAnima()
                        ? HelmSpecial.Anima
                        : uForgeHelm()
                            ? HelmSpecial.Forge
                            : CurrentHelmSpecial();

                    break;
                #endregion

                #region Luck - Dauntless | Ravenous - Anima - Vainglory
                case "chrono chaorruptor":
                    if (!uRavenous() || !uAnima() || !uVainglory())
                        goto default;

                    type = EnhancementType.Lucky;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = uDauntless() ? WeaponSpecial.Dauntless : WeaponSpecial.Ravenous;
                    hSpecial = HelmSpecial.Anima;
                    break;
                #endregion

                #region Wizard - Ravenous - Pneuma - Vainglory
                case "chrono dataknight":
                case "chrono dragonknight":
                    if (!uRavenous() || !uPneuma() || !uVainglory())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Vainglory;
                    wSpecial = WeaponSpecial.Ravenous;
                    hSpecial = HelmSpecial.Pneuma;
                    break;
                #endregion

                #region Luck - Ravenous | Valiance - ForgeHelm | Luck - Absolution
                case "legendary hero":
                    if (!uValiance() || !uForgeHelm() || !uAbsolution())
                        goto default;

                    type = EnhancementType.Wizard;
                    cSpecial = CapeSpecial.Absolution;
                    wSpecial = uRavenous() ? WeaponSpecial.Ravenous : WeaponSpecial.Valiance;
                    hSpecial = HelmSpecial.Forge;
                    break;
                #endregion

                #endregion

                #region Unassigned Region

                // This list serves as an overview of what classes dont have a Forge Enhancement yet, when adding a setup for it, remove it from here
                case "acolyte":
                case "alpha doommega":
                case "alpha omega":
                case "alpha pirate":
                case "arcane dark caster":
                case "assassin":
                case "barber":
                case "bard":
                case "battlemage of love":
                case "battlemage":
                case "beast warrior":
                case "beastmaster":
                case "berserker":
                case "beta berserker":
                case "blademaster assassin":
                case "blademaster":
                case "blood ancient":
                case "blood sorceress":
                case "blood titan":
                case "frostblood titan":
                case "cardclasher":
                case "chaos avenger member preview":
                case "chaos champion prime":
                case "chaos shaper":
                case "chrono assassin":
                case "chrono commandant":
                case "chronocommander":
                case "chronocorrupter":
                case "chronomancer prime":
                case "chronomancer":
                case "chunin":
                case "classic alpha pirate":
                case "classic barber":
                case "classic defender":
                case "classic doomknight":
                case "classic dragonlord":
                case "classic exalted soul cleaver":
                case "classic guardian":
                case "classic paladin":
                case "classic pirate":
                case "classic soul cleaver":
                case "clawsuit":
                case "cryomancer mini pet coming soon":
                case "cryomancer":
                case "daimon":
                case "dark battlemage":
                case "dark caster":
                case "dark chaos berserker":
                case "dark cryomancer":
                case "dark harbinger":
                case "dark legendary hero":
                case "darkblood stormking":
                case "deathknight lord":
                case "deathknight":
                case "defender":
                case "doomknight overlord":
                case "doomknight":
                case "dragon knight":
                case "dragon shinobi":
                case "dragonslayer":
                case "dragonsoul shinobi":
                case "drakel warlord":
                case "elemental dracomancer":
                case "empyrean chronomancer":
                case "enforcer":
                case "evolved clawsuit":
                case "evolved dark caster":
                case "evolved leprechaun":
                case "evolved pumpkin lord":
                case "evolved shaman":
                case "exalted harbinger":
                case "exalted soul cleaver":
                case "firelord summoner":
                case "frost spiritreaver":
                case "glacial berserker test":
                case "grim necromancer":
                case "grunge rocker":
                case "guardian":
                case "heavy metal necro":
                case "heavy metal rockstar":
                case "heroic naval commander":
                case "highseas commander":
                case "hobo highlord":
                case "horc evader":
                case "immortal dark caster":
                case "imperial chunin":
                case "infinite dark caster":
                case "infinite legion dark caster":
                case "infinity titan":
                case "legendary naval commander":
                case "legion blademaster assassin":
                case "legion doomknight tester":
                case "legion evolved dark caster":
                case "legion paladin":
                case "legion revenant member test":
                case "legion swordmaster assassin":
                case "leprechaun":
                case "lightcaster test":
                case "lightmage":
                case "love caster":
                case "lycan":
                case "master ranger":
                case "mechajouster":
                case "mindbreaker":
                case "mystical dark caster":
                case "naval commander":
                case "necromancer":
                case "ninja warrior":
                case "no class":
                case "northlands monk":
                case "not a mod":
                case "nu metal necro":
                case "obsidian no class":
                case "oracle":
                case "overworld chronomancer":
                case "paladin highlord":
                case "paladin":
                case "paladinslayer":
                case "pink romancer":
                case "pinkomancer":
                case "pirate":
                case "prismatic clawsuit":
                case "protosartorium":
                case "psionic mindbreaker":
                case "pumpkin lord":
                case "pyromancer":
                case "ranger":
                case "renegade":
                case "rustbucket":
                case "sakura cryomancer":
                case "sentinel":
                case "shadow dragon shinobi":
                case "shadow ripper":
                case "shadow rocker":
                case "shadowflame dragonlord":
                case "shadowscythe general":
                case "silver paladin":
                case "skycharged grenadier":
                case "skyguard grenadier":
                case "sorcerer":
                case "soul cleaver":
                case "star captain":
                case "starlord":
                case "swordmaster assassin":
                case "swordmaster":
                case "the collector":
                case "thief of hours":
                case "timeless chronomancer":
                case "timeless dark caster":
                case "troubador of love":
                case "unchained rocker":
                case "unchained rockstar":
                case "undead leperchaun":
                case "undeadslayer":
                case "unlucky leperchaun":
                case "vampire":
                case "vindicator of they":
                case "void highlord tester":
                case "warlord":
                case "warrior":
                case "classic warrior":
                case "warrior (rare)":
                case "warriorscythe general":
                case "witch":
                default: // If the correct enhancement arent unlocked, or the class in question isnt in the Forge Enhancement Lib, use Awe Enhancements Lib
                    type = EnhancementType.Lucky;
                    return false;

                    #endregion
            }
            return true;

            // // Always place this check as the last one in a 'if' + '||' stack.
            // // See EXAMPLE_CLASS as an example. 
            // bool uDauntlessExtra()
            // {
            //     // Check if Dauntless is unlocked, and set it as wSpecial if true.
            //     if (uDauntless())
            //     {
            //         wSpecial = WeaponSpecial.Dauntless;
            //         return true;
            //     }
            //     // If Dauntless is not unlocked, try Valiance and it's extras
            //     // If neither Valiance nor its bonusses are unlocked, this will return false so that it can be used with the 'goto default' lines
            //     else return uValianceExtra();
            // }

            // // Always place this check as the last one in a 'if' + '||' stack.
            // // See ArchPaladin as an example. 
            // bool uValianceExtra()
            // {
            //     // Check if Valiance is unlocked, and set it as wSpecial if true.
            //     if (uValiance())
            //         wSpecial = WeaponSpecial.Valiance;
            //     // Otherwise, check if Praxis is unlocked, and set it as wSpecial if true.
            //     else if (uPraxis())
            //         wSpecial = WeaponSpecial.Praxis;
            //     // If neither Valiance and Praxis are not unlocked, return false so that it can be used in conjunction with the 'goto default' lines.
            //     else return false;

            //     // This will only occur if Valiance or Praxis is unlocked.
            //     return true;
            // }
        }

        void AweEnhancementLibrary()
        {
            //tolower incase we accidentaly use capitals.. it breaks
            switch (className)
            {
                #region Lucky Region

                #region Lucky - Spiral Carve
                case "abyssal angel":
                case "abyssal angel's shadow":
                case "artifact hunter":
                case "assassin":
                case "archmage":
                case "beastmaster":
                case "berserker":
                case "beta berserker":
                case "blademaster assassin":
                case "blademaster":
                case "blood titan":
                case "frostblood titan":
                case "cardclasher":
                case "chaos avenger member preview":
                case "chaos champion prime":
                case "chaos slayer":
                case "chaos slayer berserker":
                case "chaos slayer cleric":
                case "chaos slayer mystic":
                case "chaos slayer thief":
                case "chrono chaorruptor":
                case "chrono commandant":
                case "chronocommander":
                case "chronocorrupter":
                case "chunin":
                case "classic alpha pirate":
                case "classic barber":
                case "classic doomknight":
                case "classic exalted soul cleaver":
                case "classic guardian":
                case "classic paladin":
                case "classic pirate":
                case "classic soul cleaver":
                case "continuum chronomancer":
                case "corrupted chronomancer":
                case "dark chaos berserker":
                case "dark harbinger":
                case "doomknight":
                case "empyrean chronomancer":
                case "eternal chronomancer":
                case "evolved clawsuit":
                case "evolved dark caster":
                case "evolved leprechaun":
                case "exalted harbinger":
                case "exalted soul cleaver":
                case "glaceran warlord":
                case "dark glaceran warlord":
                case "savage glaceran warlord":
                case "glacial warlord":
                case "great thief":
                case "hollowborn vindicator member preview":
                case "immortal chronomancer":
                case "imperial chunin":
                case "infinite dark caster":
                case "infinite legion dark caster":
                case "infinity titan":
                case "legion blademaster assassin":
                case "legion evolved dark caster":
                case "legion swordmaster assassin":
                case "leprechaun":
                case "lycan":
                case "master ranger":
                case "mechajouster":
                case "necromancer":
                case "ninja warrior":
                case "not a mod":
                case "overworld chronomancer":
                case "pinkomancer":
                case "prismatic clawsuit":
                case "quantum chronomancer":
                case "ranger":
                case "renegade":
                case "rogue":
                case "classic rogue":
                case "rogue (rare)":
                case "scarlet sorceress":
                case "shadowscythe general":
                case "skycharged grenadier":
                case "skyguard grenadier":
                case "sovereign of storms":
                case "soul cleaver":
                case "starlord":
                case "swordmaster assassin":
                case "swordmaster":
                case "timekeeper":
                case "timekiller":
                case "timeless chronomancer":
                case "undead leperchaun":
                case "undeadslayer":
                case "underworld chronomancer":
                case "unlucky leperchaun":
                case "void highlord":
                case "void highlord (ioda)":
                case "verus doomknight":
                    type = EnhancementType.Lucky;
                    wSpecial = WeaponSpecial.Spiral_Carve;
                    break;
                #endregion

                #region Lucky - Mana Vamp
                case "alpha doommega":
                case "alpha omega":
                case "alpha pirate":
                case "beast warrior":
                case "blood ancient":
                case "chaos avenger":
                case "chaos shaper":
                case "classic defender":
                case "clawsuit":
                case "cryomancer mini pet coming soon":
                case "dark legendary hero":
                case "dragonsoul shinobi":
                case "ultra omniknight":
                case "dark ultra omninight":
                case "doomknight overlord":
                case "dragonslayer general":
                case "drakel warlord":
                case "glacial berserker test":
                case "heroic naval commander":
                case "legendary elemental warrior":
                case "mythic elemental warrior":
                case "horc evader":
                case "legendary naval commander":
                case "legion revenant member test":
                case "naval commander":
                case "paladin high lord":
                case "paladin":
                case "paladinslayer":
                case "pirate":
                case "pumpkin lord":
                case "shadowflame dragonlord":
                case "shadowstalker of time":
                case "shadowwalker of time":
                case "shadowweaver of time":
                case "silver paladin":
                case "thief of hours":
                case "ultra elemental warrior":
                case "void highlord tester":
                case "warlord":
                case "warrior":
                case "warrior (rare)":
                case "warriorscythe general":
                case "yami no ronin":
                case "arachnomancer":
                    type = EnhancementType.Lucky;
                    wSpecial = WeaponSpecial.Mana_Vamp;
                    break;
                #endregion

                #region Lucky - Awe Blast
                case "archpaladin":
                case "bard":
                case "chrono assassin":
                case "chronomancer":
                case "chronomancer prime":
                case "dark metal necro":
                case "deathknight lord":
                case "dragon shinobi":
                case "dragonlord":
                case "evolved pumpkin lord":
                case "glacial berserker":
                case "grunge rocker":
                case "guardian":
                case "heavy metal necro":
                case "heavy metal rockstar":
                case "hollowborn vindicator":
                case "Hollowborn Vindicator Member Preview":
                case "hobo highlord":
                case "lord of order":
                case "legendary hero":
                case "nechronomancer":
                case "necrotic chronomancer":
                case "Draconic Chronomancer":
                case "no class":
                case "nu metal necro":
                case "obsidian no class":
                case "protosartorium":
                case "shadow dragon shinobi":
                case "shadow ripper":
                case "shadow rocker":
                case "star captain":
                case "troubador of love":
                case "unchained rocker":
                case "unchained rockstar":
                case "undead goat":
                case "unundead goat":
                case "doom metal necro":
                case "neo metal necro":
                case "martial artist":
                case "master martial artist":
                case "antique hunter":
                case "king's echo":
                    type = EnhancementType.Lucky;
                    wSpecial = WeaponSpecial.Awe_Blast;
                    break;
                #endregion

                #region Lucky - Health Vamp
                case "eternal inversionist":
                case "archfiend":
                case "barber":
                case "classic dragonlord":
                case "dragonslayer":
                case "enforcer":
                case "flame dragon warrior":
                case "rustbucket":
                case "sentinel":
                case "vampire":
                case "vampire lord":
                case "enchanted vampire lord":
                case "royal vampire lord":
                case "chrono shadowhunter":
                    type = EnhancementType.Lucky;
                    wSpecial = WeaponSpecial.Health_Vamp;
                    break;
                #endregion

                #endregion

                #region  Theif Region

                #region  Theif - Mana Vamp
                case "ninja":
                case "classic ninja":
                case "ninja (rare)":
                    type = EnhancementType.Thief;
                    wSpecial = WeaponSpecial.Mana_Vamp;
                    break;
                #endregion

                #endregion

                #region Wizard Region

                #region Wizard - Awe Blast
                case "acolyte":
                case "arcane dark caster":
                case "battlemage":
                case "battlemage of love":
                case "blaze binder":
                case "blood sorceress":
                case "dark battlemage":
                case "dragon knight":
                case "firelord summoner":
                case "grim necromancer":
                case "highseas commander":
                case "infinity knight":
                case "interstellar knight":
                case "master of moglins":
                case "dark master of moglins":
                case "lich":
                case "mystical dark caster":
                case "northlands monk":
                case "royal battlemage":
                case "timeless dark caster":
                case "witch":
                case "stonecrusher":
                    type = EnhancementType.Wizard;
                    wSpecial = WeaponSpecial.Awe_Blast;
                    break;
                #endregion

                #region Wizard - Spiral Carve
                case "chrono dataknight":
                case "chrono dragonknight":
                case "cryomancer":
                case "dark caster":
                case "dark cryomancer":
                case "darkblood stormking":
                case "darkside":
                case "defender":
                case "frost spiritreaver":
                case "immortal dark caster":
                case "legion paladin":
                case "legion revenant":
                case "legion revenant (ioda)":
                case "lightcaster":
                case "pink romancer":
                case "psionic mindbreaker":
                case "pyromancer":
                case "sakura cryomancer":
                case "troll spellsmith":
                case "classic legion doomknight":
                case "legion doomknight":
                case "legion doomknight tester":
                case "arcana invoker":
                    type = EnhancementType.Wizard;
                    wSpecial = WeaponSpecial.Spiral_Carve;
                    break;
                #endregion

                #region Wizard - Health Vamp
                case "daimon":
                case "dark lord":
                case "evolved shaman":
                case "lightmage":
                case "mindbreaker":
                case "vindicator of they":
                case "elemental dracomancer":
                case "lightcaster test":
                case "love caster":
                case "mage":
                case "classic mage":
                case "mage (rare)":
                case "sorcerer":
                case "the collector":
                    type = EnhancementType.Wizard;
                    wSpecial = WeaponSpecial.Health_Vamp;
                    break;
                #endregion

                #region Wizard - Mana Vamp
                case "oracle":
                case "shaman":
                    type = EnhancementType.Wizard;
                    wSpecial = WeaponSpecial.Mana_Vamp;
                    break;
                #endregion

                #endregion

                #region Fighter Region

                #region Fighter - Awe Blast
                case "deathknight":
                case "frostval barbarian":
                    type = EnhancementType.Fighter;
                    wSpecial = WeaponSpecial.Awe_Blast;
                    break;
                #endregion

                #endregion

                #region Healer Region

                #region Healer - Health Vamp
                case "dragon of time":
                    type = EnhancementType.Healer;
                    wSpecial = WeaponSpecial.Health_Vamp;
                    break;
                #endregion

                #region Healer - Mana Vamp
                case "obsidian paladin chronomancer":
                case "paladin chronomancer":
                    type = EnhancementType.Healer;
                    wSpecial = WeaponSpecial.Mana_Vamp;
                    break;
                #endregion

                #endregion

                default:
                    Core.Logger($"SmartEnhance Failed: \"{className}\" is not found in the Smart Enhance Library, please report to @tato2", messageBox: true);
                    return;
            }
        }
    }

    #endregion
}


public enum Auras
{
    Shapeshifted,
    stuff2
}

public enum GenericGearBoost
{
    cp,
    gold,
    rep,
    exp,
    dmgAll,
}
public enum RacialGearBoost
{
    None,
    Chaos,
    Dragonkin,
    Drakath,
    Elemental,
    Human,
    Orc,
    Undead,
}

public enum EnhancementType // Enhancement Pattern ID
{
    Fighter = 2,
    Thief = 3,
    Hybrid = 5,
    Wizard = 6,
    Healer = 7,
    SpellBreaker = 8,
    Lucky = 9,
}
public enum CapeSpecial // Enhancement Pattern ID
{
    None = 0,
    Forge = 10,
    Absolution = 11,
    Avarice = 12,
    Vainglory = 24,
    Penitence = 29,
    Lament = 30,

}
public enum WeaponSpecial // Proc ID
{
    None = 0,
    Spiral_Carve = 2,
    Awe_Blast = 3,
    Health_Vamp = 4,
    Mana_Vamp = 5,
    Powerword_Die = 6,
    Ravenous = 7,

    Forge = 99, // Not really 99, but cant have 0 3 times
    Lacerate = 8,
    Smite = 9,
    Valiance = 10,
    Arcanas_Concerto = 11,
    Elysium = 12,
    Acheron = 13,
    Praxis = 14,
    Dauntless = 15
}

public enum HelmSpecial //Enhancement Pattern ID
{
    None = 0,
    Forge = 99, // Not really 99, but cant have 0 3 times
    Vim = 25,
    Examen = 26,
    Anima = 28,
    Pneuma = 27,
    Hearty = 32
}

public enum mergeOptionsEnum
{
    all = 0,
    acOnly = 1,
    mergeMats = 2,
    select = 3
};