using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AmmoLab;
using AmmoLab.Mods;
using AmmoLab.Utils;
using BoneLib.BoneMenu;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Data;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "AmmoLab", "6.7.0", "freakycheesy", "https://github.com/freakycheesy/AmmoLab/")]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AmmoLab")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+343ec4d2d829bea101029af1917bc3850da6db46")]
[assembly: AssemblyProduct("AmmoLab")]
[assembly: AssemblyTitle("AmmoLab")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AmmoLab
{
	public class Core : MelonMod
	{
		public static DefaultMod mod;

		public static GamblingLabMod gamblingMod;

		public static MelonPreferences_Category PrefsCategory;

		public static Color red => Color.HSVToRGB(0f, 0.7f, 1f);

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
			mod = new DefaultMod();
			gamblingMod = new GamblingLabMod();
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
			MagazineUtils.magazines.Clear();
		}
	}
}
namespace AmmoLab.Utils
{
	public static class MagazineUtils
	{
		public static List<Magazine> magazines = new List<Magazine>();

		public static Action<Magazine> OnSpawn;

		public static Action<Magazine> OnDespawn;

		public static Action<Magazine> OnEject;

		public static void RefillAllMagazines()
		{
			foreach (Magazine magazine in magazines)
			{
				magazine.magazineState.Refill();
			}
		}

		public static void RefillMagazine(Magazine mag)
		{
			mag.magazineState.Refill();
		}
	}
	public static class AmmoInventoryUtils
	{
		public static int defaultammo = 2000;

		public static Action<CartridgeData, int> OnAmmoChanged;

		public static AmmoInventory AmmoInventory => AmmoInventory.Instance;

		public static void AddAmmoToInventory()
		{
			AmmoInventory.ClearAmmo();
			AmmoInventory.AddCartridge(AmmoInventory.lightAmmoGroup, defaultammo);
			AmmoInventory.AddCartridge(AmmoInventory.mediumAmmoGroup, defaultammo);
			AmmoInventory.AddCartridge(AmmoInventory.heavyAmmoGroup, defaultammo);
		}

		public static void AddAmmoToInventory(int ammo)
		{
			AmmoInventory.ClearAmmo();
			AmmoInventory.AddCartridge(AmmoInventory.lightAmmoGroup, ammo);
			AmmoInventory.AddCartridge(AmmoInventory.mediumAmmoGroup, ammo);
			AmmoInventory.AddCartridge(AmmoInventory.heavyAmmoGroup, ammo);
		}

		public static void AddCartridgeToInventory(AmmoGroup ammoGroup, int ammo)
		{
			AmmoInventory.AddCartridge(ammoGroup, ammo);
		}

		public static void RemoveCartridgeToInventory(AmmoGroup ammoGroup, int ammo)
		{
			foreach (CartridgeData item in (Il2CppArrayBase<CartridgeData>)(object)ammoGroup.cartridges)
			{
				AmmoInventory.RemoveCartridge(item, ammo);
			}
		}
	}
	internal static class Patches
	{
		[HarmonyPatch(typeof(Magazine))]
		internal static class MagazinePatches
		{
			[HarmonyPatch("OnPoolInitialize")]
			[HarmonyPrefix]
			private static void _Spawn(Magazine __instance)
			{
				MagazineUtils.magazines.Add(__instance);
				MagazineUtils.OnSpawn?.Invoke(__instance);
			}

			[HarmonyPatch("OnPoolDeInitialize")]
			[HarmonyPrefix]
			private static void _Despawn(Magazine __instance)
			{
				MagazineUtils.magazines.Remove(__instance);
				MagazineUtils.OnDespawn?.Invoke(__instance);
			}

			[HarmonyPatch("OnEject")]
			[HarmonyPrefix]
			private static void _OnEject(Magazine __instance)
			{
				MagazineUtils.OnEject?.Invoke(__instance);
			}
		}

		[HarmonyPatch(typeof(AmmoInventory))]
		internal static class AmmoInvPatches
		{
			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			private static void Awake()
			{
				AmmoInventoryUtils.OnAmmoChanged?.Invoke(null, 0);
			}

			[HarmonyPatch("RemoveCartridge")]
			[HarmonyPostfix]
			private static void RemoveCartridge(CartridgeData cartridge, int count)
			{
				AmmoInventoryUtils.OnAmmoChanged?.Invoke(cartridge, count);
			}
		}
	}
}
namespace AmmoLab.Mods
{
	public class Mod
	{
	}
	public class DefaultMod : Mod
	{
		public static Page mainPage;

		public static MelonPreferences_Entry<bool> ActivateMod;

		public static MelonPreferences_Entry<bool> EmptyRefill;

		public static MelonPreferences_Entry<bool> AutoMagazineRefill;

		public static MelonPreferences_Entry<bool> EnableStaticAmmo;

		public static MelonPreferences_Entry<bool> MakeMagazinesGold;

		private static MelonPreferences_Entry<int> StaticAmmo;

		private static MelonPreferences_Entry<Color> gold;

		private static Color defaultGold = new Color(1f, 1f, 0f);

		public DefaultMod()
		{
			OnStart();
		}

		public static void AmmoInventoryUpdate(CartridgeData _, int __)
		{
			if (ActivateMod.Value)
			{
				if (AutoMagazineRefill.Value)
				{
					MagazineUtils.RefillAllMagazines();
				}
				if (EnableStaticAmmo.Value)
				{
					AmmoInventoryUtils.AddAmmoToInventory(StaticAmmo.Value);
				}
			}
		}

		private void OnStart()
		{
			MelonLogger.Msg("Initialized Ammo Lab BoneMenu");
			Core.PrefsCategory = MelonPreferences.CreateCategory("AmmoLab");
			Menu.Initialize();
			InitSettings();
			CreateBonemenu();
			MagazineUtils.OnEject = (Action<Magazine>)Delegate.Combine(MagazineUtils.OnEject, new Action<Magazine>(RefillMagazine));
			MagazineUtils.OnSpawn = (Action<Magazine>)Delegate.Combine(MagazineUtils.OnSpawn, new Action<Magazine>(MakeMagsGold));
			AmmoInventoryUtils.OnAmmoChanged = (Action<CartridgeData, int>)Delegate.Combine(AmmoInventoryUtils.OnAmmoChanged, new Action<CartridgeData, int>(AmmoInventoryUpdate));
		}

		private static void InitSettings()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			ActivateMod = Core.PrefsCategory.CreateEntry<bool>("ActivateMod", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			EmptyRefill = Core.PrefsCategory.CreateEntry<bool>("EmptyRefill", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			AutoMagazineRefill = Core.PrefsCategory.CreateEntry<bool>("AutoMagazineRefill", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			EnableStaticAmmo = Core.PrefsCategory.CreateEntry<bool>("EnableStaticAmmo", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			StaticAmmo = Core.PrefsCategory.CreateEntry<int>("StaticAmmo", 2000, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			MakeMagazinesGold = Core.PrefsCategory.CreateEntry<bool>("MakeMagazinesGold", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			gold = Core.PrefsCategory.CreateEntry<Color>("gold", defaultGold, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		}

		private static void RefillMagazine(Magazine magazine)
		{
			if (ActivateMod.Value && EmptyRefill.Value)
			{
				MagazineUtils.RefillMagazine(magazine);
			}
		}

		private static void MakeMagsGold(Magazine __instance)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (!ActivateMod.Value || !MakeMagazinesGold.Value)
			{
				return;
			}
			Il2CppArrayBase<Renderer> componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
			foreach (Renderer item in componentsInChildren)
			{
				foreach (Material item2 in (Il2CppArrayBase<Material>)(object)item.materials)
				{
					item2.mainTexture = null;
					item2.color = gold.Value;
					item2.SetFloat("_Metallic", 1f);
					item2.SetFloat("_Smoothness", 1f);
				}
			}
		}

		public static void CreateBonemenu()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			mainPage = Page.Root.CreatePage("Ammo Lab", Core.red, 0, true);
			Page val = mainPage.CreatePage("Refill Settings", Color.cyan, 0, true);
			Page val2 = mainPage.CreatePage("Ammo Settings", Core.red, 0, true);
			mainPage.CreateBool("Activate Mod", Core.red, ActivateMod.Value, (Action<bool>)delegate(bool a)
			{
				ActivateMod.Value = a;
				Save();
			});
			val.CreateBool("Refill on Empty", Color.white, EmptyRefill.Value, (Action<bool>)delegate(bool a)
			{
				EmptyRefill.Value = a;
				Save();
			});
			val.CreateBool("Auto Refill", Color.white, AutoMagazineRefill.Value, (Action<bool>)delegate(bool a)
			{
				AutoMagazineRefill.Value = a;
				Save();
			});
			val2.CreateBool("Enable Static Ammo", Color.white, EnableStaticAmmo.Value, (Action<bool>)delegate(bool a)
			{
				EnableStaticAmmo.Value = a;
				Save();
			});
			val2.CreateInt("Static Ammo Count", Color.white, StaticAmmo.Value, 10, 0, 2000, (Action<int>)delegate(int a)
			{
				StaticAmmo.Value = a;
				Save();
			});
			val2.CreateBool("Gold Magazines", Color.yellow, MakeMagazinesGold.Value, (Action<bool>)delegate(bool a)
			{
				MakeMagazinesGold.Value = a;
				Save();
			});
		}

		private static void Save()
		{
			MelonPreferences.Save();
		}
	}
	public class GamblingLabMod : Mod
	{
		public enum AmmoGroupEnum
		{
			light,
			medium,
			heavy
		}

		public static int gambleAmount;

		public static AmmoGroup ammoGroup;

		public AmmoGroupEnum ammoEnum = AmmoGroupEnum.light;

		public static Page page;

		private static FunctionElement gambleinfo;

		public GamblingLabMod()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			ChangeAmmoGroup(ammoEnum);
			page = Page.Root.CreatePage("Gambling Lab", Core.red, 0, true);
			page.Name = "Gambling <color=white>Lab";
			page.CreateEnum("Change Ammo Group", Color.yellow, (Enum)ammoEnum, (Action<Enum>)ChangeAmmoGroup);
			page.CreateInt("Amount", Color.blue, 10, 10, 10, 200, (Action<int>)ChangeAmount);
			gambleinfo = page.CreateFunction("the gamble info", Color.white, (Action)null);
			page.CreateFunction("Gamble", Core.red, (Action)Gamble);
		}

		public static void ChangeAmount(int amount)
		{
			gambleAmount = amount;
		}

		public static void Gamble()
		{
			if (!Object.op_Implicit((Object)(object)ammoGroup))
			{
				Log("No ammo in your dumb pouch");
				return;
			}
			if (AmmoInventory.Instance.GetCartridgeCount(((Il2CppArrayBase<CartridgeData>)(object)ammoGroup.cartridges)[0]) < gambleAmount)
			{
				Log("Not enough Ammo");
				return;
			}
			AmmoInventoryUtils.RemoveCartridgeToInventory(ammoGroup, gambleAmount);
			int num = Random.Range(0, gambleAmount);
			if (num <= Mathf.RoundToInt((float)(num / 2)))
			{
				int num2 = gambleAmount * Random.Range(0, 10);
				Log($"You won {num2} ammo\nwoohoo");
				AmmoInventoryUtils.AddAmmoToInventory(num2);
			}
			else
			{
				Log($"You lost {gambleAmount} ammo lol");
			}
		}

		public static void Log(string context)
		{
			((Element)gambleinfo).ElementName = "the gamble info:\n";
			FunctionElement obj = gambleinfo;
			((Element)obj).ElementName = ((Element)obj).ElementName + context;
		}

		public static void ChangeAmmoGroup(Enum i)
		{
			if (i == null)
			{
				i = AmmoGroupEnum.light;
			}
			Enum @enum = i;
			Enum enum2 = @enum;
			if (enum2 is AmmoGroupEnum)
			{
				switch ((AmmoGroupEnum)(object)enum2)
				{
				case AmmoGroupEnum.light:
					ammoGroup = AmmoInventory.Instance.lightAmmoGroup;
					break;
				case AmmoGroupEnum.medium:
					ammoGroup = AmmoInventory.Instance.mediumAmmoGroup;
					break;
				case AmmoGroupEnum.heavy:
					ammoGroup = AmmoInventory.Instance.mediumAmmoGroup;
					break;
				}
			}
		}
	}
}