using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalSettings;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BarbedWireUnlocker")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d79dd39ac9cf6e683e9680f800e22b23dca4ca0e")]
[assembly: AssemblyProduct("BarbedWireUnlocker")]
[assembly: AssemblyTitle("BarbedWireUnlocker")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BarbedWireUnlocker
{
	public class BarbedWireModifier
	{
		private readonly ManualLogSource logger;

		private readonly BarbedWireUnlocker barbedWireUnlocker;

		public BarbedWireModifier(ManualLogSource logger, BarbedWireUnlocker barbedWireUnlocker)
		{
			this.logger = logger;
			this.barbedWireUnlocker = barbedWireUnlocker;
		}

		public void SetDamageDealtModifier()
		{
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageDealtMultiplier before: " + Gameplay.Get().barbedWireDamageDealtMultiplier));
			}
			Gameplay.Get().barbedWireDamageDealtMultiplier = barbedWireUnlocker.configUI.damageDealtMultipler.Value;
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageDealtMultiplier after: " + Gameplay.Get().barbedWireDamageDealtMultiplier));
			}
		}

		public void SetDamageDealtModifier(int value)
		{
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageDealtMultiplier before: " + Gameplay.Get().barbedWireDamageDealtMultiplier));
			}
			Gameplay.Get().barbedWireDamageDealtMultiplier = value;
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageDealtMultiplier after: " + Gameplay.Get().barbedWireDamageDealtMultiplier));
			}
		}

		public void SetDamageTakenModifier()
		{
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageTakenMultiplier before: " + Gameplay.Get().barbedWireDamageTakenMultiplier));
			}
			Gameplay.Get().barbedWireDamageTakenMultiplier = barbedWireUnlocker.configUI.damageTakenMultipler.Value;
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageTakenMultiplier after: " + Gameplay.Get().barbedWireDamageTakenMultiplier));
			}
		}

		public void SetDamageTakenModifier(int value)
		{
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageTakenMultiplier before: " + Gameplay.Get().barbedWireDamageTakenMultiplier));
			}
			Gameplay.Get().barbedWireDamageTakenMultiplier = value;
			if (barbedWireUnlocker.configUI.debugMode.Value)
			{
				logger.LogInfo((object)("barbedWireDamageTakenMultiplier after: " + Gameplay.Get().barbedWireDamageTakenMultiplier));
			}
		}
	}
	[HarmonyPatch]
	public class BarbedWirePatches
	{
		[HarmonyPatch]
		internal static class HeroController_Start_Patch
		{
			private static MethodBase TargetMethod()
			{
				Type type = AccessTools.TypeByName("HeroController");
				if (type == null)
				{
					throw new Exception("Could not find type HeroController");
				}
				return AccessTools.Method(type, "Start", (Type[])null, (Type[])null);
			}

			private static void Postfix(object __instance)
			{
				ManualLogSource? logger = BarbedWirePatches.logger;
				if (logger != null)
				{
					logger.LogInfo((object)"\ud83d\udd0d HeroController.Start patch triggered!");
				}
				BarbedWireUnlocker instance = BarbedWireUnlocker.Instance;
				if (instance.configUI.unlockBarbedWireAtStart.Value)
				{
					instance.configUI.unlockBarbedWire.Value = true;
					instance.UnlockBarbedWireTool();
					ManualLogSource? logger2 = BarbedWirePatches.logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)"Barbed wire tool unlocked at start");
					}
				}
				if (instance.configUI.equipBarbedWireAtStart.Value)
				{
					instance.EquipBarbedWireToolAtStart();
					ManualLogSource? logger3 = BarbedWirePatches.logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)"Barbed wire tool equipped at start");
					}
				}
				instance.barbedWireModifier.SetDamageDealtModifier();
				instance.barbedWireModifier.SetDamageTakenModifier();
			}
		}

		private static ManualLogSource? logger;

		private static bool hasAttemptedUnlock;

		public static void SetLogger(ManualLogSource logSource)
		{
			logger = logSource;
		}

		public static void ResetUnlockAttempt()
		{
			hasAttemptedUnlock = false;
			ManualLogSource? obj = logger;
			if (obj != null)
			{
				obj.LogInfo((object)"Reset unlock attempt flag - next unlock attempt will be allowed");
			}
		}
	}
	[BepInPlugin("BarbedWireUnlocker", "BarbedWireUnlocker", "1.0.0")]
	public class BarbedWireUnlocker : BaseUnityPlugin
	{
		private Harmony harmony;

		public ConfigUI configUI;

		public BarbedWireModifier barbedWireModifier;

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		public static BarbedWireUnlocker Instance { get; private set; }

		private void Awake()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			try
			{
				Logger.LogInfo((object)"=== BarbedWireUnlocker v1.0.0 Starting ===");
				Logger.LogInfo((object)"Plugin GUID: BarbedWireUnlocker");
				harmony = new Harmony("BarbedWireUnlocker");
				harmony.PatchAll();
				Logger.LogInfo((object)"Harmony patches applied successfully!");
				Instance = this;
				configUI = new ConfigUI(Logger, this);
				barbedWireModifier = new BarbedWireModifier(Logger, this);
				configUI.InitializeConfigUI(((BaseUnityPlugin)this).Config);
				BarbedWirePatches.SetLogger(Logger);
				if (configUI.debugMode.Value)
				{
					Logger.LogInfo((object)("Config file location: " + ((BaseUnityPlugin)this).Config.ConfigFilePath));
				}
				Logger.LogInfo((object)"=== BarbedWireUnlocker initialization COMPLETED ===");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("❌ ERROR during BarbedWireUnlocker initialization: " + ex.Message));
				Logger.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		public void UnlockBarbedWireTool()
		{
			Logger.LogInfo((object)"Manual unlock requested for barbedWire tool...");
			try
			{
				ToolItem barbedWireTool = Gameplay.BarbedWireTool;
				if ((Object)(object)barbedWireTool != (Object)null)
				{
					if (configUI.debugMode.Value)
					{
						Logger.LogInfo((object)"Found barbedWire tool, unlocking and equipping...");
					}
					barbedWireTool.Unlock((Action)null, (PopupFlags)3);
					Logger.LogInfo((object)"BarbedWire tool unlocked successfully!");
				}
				else
				{
					Logger.LogWarning((object)"Could not find barbedWire tool item");
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error unlocking/equipping barbedWire tool: " + ex.Message));
			}
		}

		public void LockBarbedWire()
		{
			Logger.LogInfo((object)"Manual unlock requested for barbedWire tool...");
			try
			{
				ToolItem barbedWireTool = Gameplay.BarbedWireTool;
				if ((Object)(object)barbedWireTool != (Object)null && barbedWireTool.IsUnlocked)
				{
					if (configUI.debugMode.Value)
					{
						Logger.LogInfo((object)"Found barbedWire tool, unlocking and equipping...");
					}
					barbedWireTool.Lock();
					Logger.LogInfo((object)"BarbedWire tool unlocked successfully!");
				}
				else
				{
					Logger.LogWarning((object)"Could not find barbedWire tool item");
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error unlocking/equipping barbedWire tool: " + ex.Message));
			}
		}

		public void ResetUnlockAttempt()
		{
			BarbedWirePatches.ResetUnlockAttempt();
		}

		public void EquipBarbedWireTool()
		{
			try
			{
				ToolItem barbedWireTool = Gameplay.BarbedWireTool;
				if ((Object)(object)barbedWireTool != (Object)null)
				{
					if (!configUI.unlockBarbedWire.Value)
					{
						configUI.unlockBarbedWire.Value = true;
					}
					if (!barbedWireTool.IsUnlockedNotHidden)
					{
						if (configUI.debugMode.Value)
						{
							Logger.LogInfo((object)(barbedWireTool.name + " is not unlocked! Unlocking now..."));
						}
						UnlockBarbedWireTool();
						if (configUI.debugMode.Value)
						{
							Logger.LogInfo((object)(barbedWireTool.name + " is now unlocked."));
						}
					}
					ToolItemManager.SetExtraEquippedTool("0", barbedWireTool);
					ToolItemManager.SendEquippedChangedEvent(false);
					Logger.LogInfo((object)"BarbedWire tool equipped successfully!");
				}
				else
				{
					Logger.LogWarning((object)"Could not find barbedWire tool item");
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error equipping barbedWire tool: " + ex.Message));
			}
		}

		public void EquipBarbedWireToolAtStart()
		{
			try
			{
				ToolItem barbedWireTool = Gameplay.BarbedWireTool;
				if ((Object)(object)barbedWireTool != (Object)null)
				{
					if (!configUI.unlockBarbedWireAtStart.Value)
					{
						configUI.unlockBarbedWireAtStart.Value = true;
					}
					if (!barbedWireTool.IsUnlockedNotHidden)
					{
						if (configUI.debugMode.Value)
						{
							Logger.LogInfo((object)(barbedWireTool.name + " is not unlocked! Unlocking now..."));
						}
						UnlockBarbedWireTool();
						if (configUI.debugMode.Value)
						{
							Logger.LogInfo((object)(barbedWireTool.name + " is now unlocked."));
						}
					}
					ToolItemManager.AutoEquip(barbedWireTool);
					ToolItemManager.SendEquippedChangedEvent(false);
					Logger.LogInfo((object)"BarbedWire tool equipped successfully!");
				}
				else
				{
					Logger.LogWarning((object)"Could not find barbedWire tool item");
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error equipping barbedWire tool: " + ex.Message));
			}
		}

		public void UnequipBarbedWireTool()
		{
			try
			{
				ToolItem barbedWireTool = Gameplay.BarbedWireTool;
				if ((Object)(object)barbedWireTool != (Object)null)
				{
					if (barbedWireTool.IsUnlockedNotHidden)
					{
						ToolItemManager.UnequipTool(barbedWireTool);
						Logger.LogInfo((object)"BarbedWire tool unequipped successfully!");
						ToolItemManager.SendEquippedChangedEvent(false);
					}
					else
					{
						Logger.LogInfo((object)"BarbedWire tool is not equiped!");
					}
				}
				else
				{
					Logger.LogWarning((object)"Could not find barbedWire tool item");
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error equipping barbedWire tool: " + ex.Message));
			}
		}

		public void ReadtoolItems()
		{
			foreach (ToolItem allTool in ToolItemManager.GetAllTools())
			{
				Logger.LogInfo((object)("ToolItem: " + allTool.name));
			}
		}
	}
	public class ConfigUI
	{
		private readonly ManualLogSource logger;

		private readonly BarbedWireUnlocker barbedWireUnlocker;

		public ConfigEntry<bool> debugMode;

		public ConfigEntry<bool> unlockBarbedWire;

		public ConfigEntry<bool> unlockBarbedWireAtStart;

		public ConfigEntry<bool> equipBarbedWire;

		public ConfigEntry<bool> equipBarbedWireAtStart;

		public ConfigEntry<float> damageDealtMultipler;

		public ConfigEntry<float> damageTakenMultipler;

		public ConfigEntry<bool> readAllTools;

		public ConfigUI(ManualLogSource logger, BarbedWireUnlocker barbedWireUnlocker)
		{
			this.logger = logger;
			this.barbedWireUnlocker = barbedWireUnlocker;
		}

		public void InitializeConfigUI(ConfigFile config)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00d7: Expected O, but got Unknown
			debugMode = config.Bind<bool>("Debug", "DebugMode", false, (ConfigDescription)null);
			unlockBarbedWireAtStart = config.Bind<bool>("Unlock", "Unlock Barbed Wire At Start", false, (ConfigDescription)null);
			unlockBarbedWire = config.Bind<bool>("Unlock", "Unlock Barbed Wire", false, (ConfigDescription)null);
			equipBarbedWireAtStart = config.Bind<bool>("Equip", "Equip Barbed Wire At Start", false, (ConfigDescription)null);
			equipBarbedWire = config.Bind<bool>("Equip", "Equip Barbed Wire", false, (ConfigDescription)null);
			damageDealtMultipler = config.Bind<float>("Modifier", "Modifies Damage Dealt Multiplaer", 1.5f, (ConfigDescription)null);
			damageTakenMultipler = config.Bind<float>("Modifier", "Modifies Damage Taken Multiplaer", 2f, (ConfigDescription)null);
			readAllTools = config.Bind<bool>(new ConfigDefinition("Barbed Wire Unlocker", "Read All Tools"), false, new ConfigDescription("Click to read all tools", (AcceptableValueBase)null, Array.Empty<object>()));
			readAllTools.SettingChanged += delegate
			{
				if (readAllTools.Value)
				{
					logger.LogInfo((object)"Read All Tools button clicked!");
					barbedWireUnlocker.ReadtoolItems();
					readAllTools.Value = false;
				}
			};
			unlockBarbedWire.SettingChanged += delegate
			{
				if (unlockBarbedWire.Value)
				{
					barbedWireUnlocker.UnlockBarbedWireTool();
				}
				else
				{
					barbedWireUnlocker.LockBarbedWire();
				}
			};
			equipBarbedWire.SettingChanged += delegate
			{
				if (equipBarbedWire.Value)
				{
					barbedWireUnlocker.EquipBarbedWireTool();
				}
				else
				{
					barbedWireUnlocker.UnequipBarbedWireTool();
				}
			};
			damageDealtMultipler.SettingChanged += delegate
			{
				barbedWireUnlocker.barbedWireModifier.SetDamageDealtModifier();
			};
			damageTakenMultipler.SettingChanged += delegate
			{
				barbedWireUnlocker.barbedWireModifier.SetDamageTakenModifier();
			};
		}
	}
	public class OnStartManager
	{
		private readonly ManualLogSource logger;

		public OnStartManager(ManualLogSource logger)
		{
			this.logger = logger;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "BarbedWireUnlocker";

		public const string PLUGIN_NAME = "BarbedWireUnlocker";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}