using System.Collections.Generic;
using HarmonyLib;
using UnityEngine;

/// Make sure to use a unique namespace to avoid conflicts!
namespace ExampleMod
{
    /// <summary>
    /// The entry class that will serve as the mod's driver.
    /// </summary>
    public static class ExampleModClass
    {

        /// <summary>
        /// The entry point of the mod.
        /// This function will be called on game startup by the mod loader.
        /// </summary>
        public static void Init()
        {
            // Set up a harmony instance 
            // Make sure to use a unique identifer for it
            // Otherwise you can conflict with other Harmony setups
            // atlyss.mod.creator.ModName is a good format to follow
            Harmony harmony = new Harmony("atlyss.mod.robocat999.ExampleMod");

            // Enable debugging if you desire debug logs for testing
            // Do NOT release a mod with Harmony.DEBUG = true, it will be bothersome to users
            Harmony.DEBUG = true;

            // Tell harmony to start patching
            harmony.PatchAll();
        }
    }

    /// <summary>
    /// This is a harmony patch. They must be identifed by the tag.
    /// </summary>
    [HarmonyPatch]
    class Test_Item_Patch
    {
        // These flags tell Harmony where exactly to patch
        // This will patch the GameManager function Cache_ScriptableAssets
        // It will apply a Postfix patch, which will fire *after* the orginal function completes
        [HarmonyPatch(typeof(GameManager), "Cache_ScriptableAssets")]
        [HarmonyPostfix]
        public static void AssetCacheAddition_Postfix(GameManager __instance)
        {
            // Harmony provides simple logging features
            // Note that these will functions will only produce logs if Harmony.DEBUG = true
            FileLog.Log("The test item postfix is running");

            // Create a new Item object
            ScriptableTradeItem testItem = ScriptableObject.CreateInstance<ScriptableTradeItem>();
            testItem._vendorCost = 2;
            testItem._itemName = "Example Mod Item";
            testItem._itemDescription = "Wow, what a drop!";
            testItem._itemIcon = Sprite.Create(Texture2D.blackTexture, new Rect(0.0f, 0.0f, Texture2D.blackTexture.width, Texture2D.blackTexture.height), new Vector2(0.5f, 0.5f), 100.0f);

            FileLog.Log("  Attempting GameManager cache insert");

            // Get access to the GameManager's private variables by using Traverse. See Harmony documentation for further explanation
            // Note that the ealier passed in __instance variable was used. This variable holds the instance of the class triggering our patch
            // Using the active __instance is very important if the class is not static 
            Traverse gameManager = Traverse.Create(__instance);
            Dictionary<string, ScriptableItem> itemCache = gameManager.Field("_cachedScriptableItems").GetValue<Dictionary<string, ScriptableItem>>();
            itemCache.Add(testItem._itemName, testItem);
            gameManager.Field("_cachedScriptableItems").SetValue(itemCache);

            FileLog.Log("The test item postfix is complete");
        }
    }

    /// <summary>
    /// This is another harmony patch. One way of organizing is to use a new class for each ATLYSS class you patch.
    /// </summary>
    [HarmonyPatch]
    class Drop_Item_Patch
    {
        // Note that this is a Prefix patch, and will run *before* the orginal function starts
        [HarmonyPatch(typeof(ItemDropEntity), "Client_DropItems")]
        [HarmonyPrefix]
        public static void Server_DropItem(ItemDropEntity __instance)
        {
            FileLog.Log("The Server_DropItem prefix is running");

            // Recreate the ealier item
            // This duplication is done for ease of understanding. In a real mod, avoid this kind of manual duplication
            ScriptableTradeItem testItem = ScriptableObject.CreateInstance<ScriptableTradeItem>();
            testItem._vendorCost = 2;
            testItem._itemName = "Example Mod Item";
            testItem._itemDescription = "Wow, what a drop!";
            testItem._itemIcon = Sprite.Create(Texture2D.blackTexture, new Rect(0.0f, 0.0f, Texture2D.blackTexture.width, Texture2D.blackTexture.height), new Vector2(0.5f, 0.5f), 100.0f);

            FileLog.Log("  Generated testItem");

            // Create a new ItemDrop object 
            ItemDrop testDrop = new ItemDrop();
            testDrop._item = testItem;
            testDrop._dropChance = 1f;
            testDrop._dropQuantity = 20;

            FileLog.Log("  Generated testDrop");

            // Access another private field and alter it with our new item
            Traverse itemDropEntity = Traverse.Create(__instance);
            ItemDrop[] itemDrops = itemDropEntity.Field("_itemDrops").GetValue<ItemDrop[]>();
            itemDrops[0] = testDrop;
            itemDropEntity.Field("_itemDrops").SetValue(itemDrops);

            FileLog.Log("The Server_DropItem prefix is complete");
        }
    }
}