using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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.6.6", "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+b73c4ca7b9f0e9b464907525a5486ba977f8df5d")]
[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 MelonPreferences_Category PrefsCategory;

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

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
			((MelonBase)this).HarmonyInstance.PatchAll(typeof(Patches));
			mod = new DefaultMod();
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
			MagazineUtils.magazines.Clear();
		}
	}
}
namespace AmmoLab.Mods
{
	public class DefaultMod
	{
		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;

		public void AmmoInventoryUpdate()
		{
			if (ActivateMod.Value)
			{
				if (AutoMagazineRefill.Value)
				{
					MagazineUtils.RefillAllMagazines();
				}
				if (EnableStaticAmmo.Value)
				{
					AmmoInventoryUtils.AddAmmoToInventory(StaticAmmo.Value);
				}
			}
		}

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

		private static void InitSettings()
		{
			//IL_00c0: 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", new Color(218f, 165f, 32f), (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		}

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

		private static void MakeMagsGold(Magazine __instance)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!ActivateMod.Value || !MakeMagazinesGold.Value)
			{
				return;
			}
			List<Renderer> list = ((IEnumerable<Renderer>)((Component)__instance).GetComponentsInParent<Renderer>()).ToList();
			list.AddRange((IEnumerable<Renderer>)((Component)__instance).GetComponentsInChildren<Renderer>());
			foreach (Renderer item in list)
			{
				Material val = new Material(item.material.shader);
				val.color = gold.Value;
				val.SetFloat("_Metallic", 1f);
				val.SetFloat("_Smoothness", 1f);
				for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)item.materials).Length; i++)
				{
					Material[] array = ((IEnumerable<Material>)item.materials).ToArray();
					array.SetValue(val, i);
					item.materials = Il2CppReferenceArray<Material>.op_Implicit(array);
				}
			}
		}

		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
	{
		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()
		{
			MelonLogger.Msg("Initialized Gambling Lab");
			MakeMenu();
		}

		private void MakeMenu()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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 is AmmoGroupEnum)
			{
				switch ((AmmoGroupEnum)(object)i)
				{
				case AmmoGroupEnum.light:
					ammoGroup = AmmoInventory.Instance.lightAmmoGroup;
					break;
				case AmmoGroupEnum.medium:
					ammoGroup = AmmoInventory.Instance.mediumAmmoGroup;
					break;
				case AmmoGroupEnum.heavy:
					ammoGroup = AmmoInventory.Instance.mediumAmmoGroup;
					break;
				}
			}
		}
	}
}
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> OnInsert;

		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 OnAmmoUpdate;

		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(AmmoInventory))]
		internal static class AmmoInventoryPatches
		{
			[HarmonyPatch("RemoveCartridge")]
			[HarmonyPostfix]
			private static void RemoveCartridge(CartridgeData cartridge, int count)
			{
				AmmoInventoryUtils.OnAmmoUpdate?.Invoke();
			}
		}

		[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("OnInsert")]
			[HarmonyPostfix]
			private static void _OnInsert(Magazine __instance)
			{
				MagazineUtils.OnInsert?.Invoke(__instance);
			}

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