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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Afflictions;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CursedSkullEnhanced")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+4ae62c83b75fb9dfd6ceece03fabe4a630bf3840")]
[assembly: AssemblyProduct("CursedSkullEnhanced")]
[assembly: AssemblyTitle("CursedSkullEnhanced")]
[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 CursedSkullEnhanced
{
	[BepInPlugin("jill920.cursedskullenhanced", "Cursed Skull Enhanced", "1.0.0")]
	public class CursedSkullEnhancedPlugin : BaseUnityPlugin
	{
		public const string MOD_GUID = "jill920.cursedskullenhanced";

		public const string MOD_NAME = "Cursed Skull Enhanced";

		public const string MOD_VERSION = "1.0.0";

		public static CursedSkullEnhancedPlugin Instance;

		public static ManualLogSource Logger;

		public static bool IsDizzinessModInstalled;

		public static bool IsFatigueModInstalled;

		public static bool debugMode;

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			debugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableLogs", false, "Enable debug logging").Value;
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "jill920.cursedskullenhanced");
			CheckForInstalledMods();
			Logger.LogInfo((object)"[Cursed Skull Enhanced 1.0.0] Loaded successfully!");
			Logger.LogInfo((object)$"  Dizziness Mod detected: {IsDizzinessModInstalled}");
			Logger.LogInfo((object)$"  Fatigue Mod detected: {IsFatigueModInstalled}");
		}

		private void CheckForInstalledMods()
		{
			IsDizzinessModInstalled = false;
			IsFatigueModInstalled = false;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					if (assembly.GetType("DizzinessMod.DizzinessTracker") != null)
					{
						IsDizzinessModInstalled = true;
					}
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						IsFatigueModInstalled = true;
					}
				}
				catch
				{
				}
			}
		}
	}
}
namespace CursedSkullEnhanced.Patches
{
	[HarmonyPatch(typeof(Action_ApplyMassAffliction), "TryAddAfflictionToLocalCharacter")]
	internal static class Action_ApplyMassAffliction_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(Action_ApplyMassAffliction __instance)
		{
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && ((Action_ApplyAffliction)__instance).affliction is Affliction_ClearAllStatus)
			{
				ClearDizzinessAndFatigue(localCharacter);
				if (CursedSkullEnhancedPlugin.debugMode)
				{
					CursedSkullEnhancedPlugin.Logger.LogInfo((object)("Cursed Skull: Cleared Dizziness/Fatigue for " + localCharacter.characterName));
				}
			}
		}

		private static void ClearDizzinessAndFatigue(Character character)
		{
			if (IsDizzinessModPresent())
			{
				ClearDizziness(character);
			}
			if (IsFatigueModPresent())
			{
				ClearFatigue(character);
			}
		}

		private static bool IsDizzinessModPresent()
		{
			if (CursedSkullEnhancedPlugin.IsDizzinessModInstalled)
			{
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("DizzinessMod.DizzinessTracker") != null)
					{
						CursedSkullEnhancedPlugin.IsDizzinessModInstalled = true;
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsFatigueModPresent()
		{
			if (CursedSkullEnhancedPlugin.IsFatigueModInstalled)
			{
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						CursedSkullEnhancedPlugin.IsFatigueModInstalled = true;
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void ClearDizziness(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("DizzinessMod.DizzinessTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("dizzinessValue", BindingFlags.Instance | BindingFlags.Public);
				if (field == null)
				{
					return;
				}
				float num = (float)field.GetValue(component);
				if (num > 0.01f)
				{
					field.SetValue(component, 0f);
					if (CursedSkullEnhancedPlugin.debugMode)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared Dizziness: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Dizziness: " + ex.Message));
			}
		}

		private static void ClearFatigue(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("FatigueMod.FatigueTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("fatigueValue", BindingFlags.Instance | BindingFlags.Public);
				if (field == null)
				{
					return;
				}
				FieldInfo field2 = ((object)component).GetType().GetField("pendingStaminaFromActions", BindingFlags.Instance | BindingFlags.NonPublic);
				float num = (float)field.GetValue(component);
				field.SetValue(component, 0f);
				if (field2 != null)
				{
					float num2 = (float)field2.GetValue(component);
					if (num2 > 0.01f)
					{
						field2.SetValue(component, 0f);
						if (CursedSkullEnhancedPlugin.debugMode)
						{
							CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared pending stamina: {num2:F3} → 0");
						}
					}
				}
				if (CursedSkullEnhancedPlugin.debugMode && num > 0.01f)
				{
					CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared Fatigue: {num:F3} → 0");
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Fatigue: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(ItemCooking), "RPC_CookingExplode")]
	internal static class ItemCooking_Explode_Patch
	{
		private const float CURSED_SKULL_RADIUS = 900f;

		private const int CURSED_SKULL_ITEM_ID = 25;

		[HarmonyPrefix]
		private static void Prefix(ItemCooking __instance)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Item item = ((ItemComponent)__instance).item;
			if ((Object)(object)item == (Object)null || item.itemID != 25)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!((Object)(object)allCharacter == (Object)null))
				{
					float num = Vector3.Distance(position, allCharacter.Center);
					if (!(num > 900f))
					{
						ClearDizzinessAndFatigue(allCharacter);
					}
				}
			}
			CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cursed Skull explosion: Cleared Dizziness/Fatigue for players within {900f} units");
		}

		private static void ClearDizzinessAndFatigue(Character character)
		{
			if (CursedSkullEnhancedPlugin.IsDizzinessModInstalled)
			{
				ClearDizziness(character);
			}
			if (CursedSkullEnhancedPlugin.IsFatigueModInstalled)
			{
				ClearFatigue(character);
			}
		}

		private static void ClearDizziness(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("DizzinessMod.DizzinessTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("dizzinessValue", BindingFlags.Instance | BindingFlags.Public);
				if (field == null)
				{
					return;
				}
				float num = (float)field.GetValue(component);
				if (num > 0.01f)
				{
					field.SetValue(component, 0f);
					if (CursedSkullEnhancedPlugin.debugMode)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared Dizziness for {character.characterName}: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Dizziness: " + ex.Message));
			}
		}

		private static bool IsFatigueModPresent()
		{
			if (CursedSkullEnhancedPlugin.IsFatigueModInstalled)
			{
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						CursedSkullEnhancedPlugin.IsFatigueModInstalled = true;
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void ClearFatigue(Character character)
		{
			if (!IsFatigueModPresent())
			{
				return;
			}
			try
			{
				Component component = ((Component)character).GetComponent("FatigueMod.FatigueTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("fatigueValue", BindingFlags.Instance | BindingFlags.Public);
				if (!(field == null))
				{
					FieldInfo field2 = ((object)component).GetType().GetField("pendingStaminaFromActions", BindingFlags.Instance | BindingFlags.NonPublic);
					field.SetValue(component, 0f);
					if (field2 != null)
					{
						field2.SetValue(component, 0f);
					}
					if (CursedSkullEnhancedPlugin.debugMode)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)("Cleared Fatigue for " + character.characterName));
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Fatigue: " + ex.Message));
			}
		}
	}
}