using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
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("BetterNoRevivePenalty")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BetterNoRevivePenalty")]
[assembly: AssemblyTitle("BetterNoRevivePenalty")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 BetterNoRevivePenalty
{
	[BepInPlugin("BetterNoRevivePenalty", "BetterNoRevivePenalty", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string GUID = "BetterNoRevivePenalty";

		public const string NAME = "BetterNoRevivePenalty";

		public const string VERSION = "1.0.0";

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> BlockCurse;

		internal static ConfigEntry<bool> BlockHunger;

		internal static int CurseIndex = -1;

		internal static int HungerIndex = -1;

		internal static int ReviveScopeDepth;

		internal static int VoidEntryDepth;

		internal static bool BlockingAtSource;

		internal static bool InReviveScope
		{
			get
			{
				if (ReviveScopeDepth > 0)
				{
					return VoidEntryDepth == 0;
				}
				return false;
			}
		}

		internal static bool ShouldBlock(int statusIndex)
		{
			if (!InReviveScope)
			{
				return false;
			}
			if (statusIndex == CurseIndex)
			{
				if (BlockCurse != null)
				{
					return BlockCurse.Value;
				}
				return false;
			}
			if (statusIndex == HungerIndex)
			{
				if (BlockHunger != null)
				{
					return BlockHunger.Value;
				}
				return false;
			}
			return false;
		}

		private void Awake()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			BlockCurse = ((BaseUnityPlugin)this).Config.Bind<bool>("Revive Penalty", "Block Curse", true, "Prevent the Curse applied by being revived. Curse from every other source is untouched.");
			BlockHunger = ((BaseUnityPlugin)this).Config.Bind<bool>("Revive Penalty", "Block Hunger", false, "Also prevent the Hunger applied by being revived. Vanilla adds 30%.");
			CurseIndex = ResolveStatus("Curse");
			HungerIndex = ResolveStatus("Hunger");
			try
			{
				Install(new Harmony("BetterNoRevivePenalty"));
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Patching failed. The mod is inert but the game is untouched: " + ex));
			}
		}

		private void LateUpdate()
		{
			if (ReviveScopeDepth != 0)
			{
				ReviveScopeDepth = 0;
			}
			if (VoidEntryDepth != 0)
			{
				VoidEntryDepth = 0;
			}
		}

		private static int ResolveStatus(string name)
		{
			try
			{
				return (int)Enum.Parse(typeof(STATUSTYPE), name);
			}
			catch (Exception)
			{
				Log.LogWarning((object)("STATUSTYPE." + name + " no longer exists - that penalty will not be blocked."));
				return -1;
			}
		}

		private static void Install(Harmony harmony)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00b0: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0124: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Character), "ApplyPostReviveStatus", (Type[])null, (Type[])null);
			bool flag = methodInfo != null;
			if (methodInfo == null)
			{
				methodInfo = AccessTools.Method(typeof(Character), "ReviveCharacter", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					Log.LogWarning((object)"Character.ApplyPostReviveStatus is gone; scoping Character.ReviveCharacter instead.");
				}
			}
			if (methodInfo == null)
			{
				Log.LogError((object)"Found no revive method to scope - mod has no effect. PEAK probably renamed it.");
				return;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(ReviveScope), "Enter", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ReviveScope), "Exit", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			TryExcludeVoidEntry(harmony);
			BlockingAtSource = TryBlockAtSource(harmony);
			if (BlockingAtSource)
			{
				Log.LogInfo((object)"Ready. Revive penalties are blocked at CharacterAfflictions.AddStatus.");
			}
			else if (flag && SnapshotRestore.TargetIsCompatible(methodInfo))
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(SnapshotRestore), "Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.Method(typeof(SnapshotRestore), "Postfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Log.LogWarning((object)"CharacterAfflictions.AddStatus changed shape; using the snapshot/restore fallback.");
			}
			else
			{
				Log.LogError((object)"Neither strategy is available - mod has no effect, but revives still work normally.");
			}
		}

		private static void TryExcludeVoidEntry(Harmony harmony)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0083: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(MapHandler), "GoToVoidRoutine", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = ((methodInfo != null) ? AccessTools.EnumeratorMoveNext((MethodBase)methodInfo) : null);
			if (methodInfo2 == null)
			{
				Log.LogWarning((object)"Could not scope MapHandler.GoToVoidRoutine; entering the Void will have its curse blocked too.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(AccessTools.Method(typeof(VoidEntryScope), "Enter", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(VoidEntryScope), "Exit", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			}
		}

		private static bool TryBlockAtSource(Harmony harmony)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(CharacterAfflictions), "AddStatus", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				return false;
			}
			ParameterInfo[] parameters = methodInfo.GetParameters();
			if (parameters.Length < 1 || parameters[0].ParameterType != typeof(STATUSTYPE))
			{
				return false;
			}
			if (methodInfo.ReturnType != typeof(bool))
			{
				return false;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(BlockStatus), "Prefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			return true;
		}
	}
	internal static class ReviveScope
	{
		public static void Enter()
		{
			Plugin.ReviveScopeDepth++;
		}

		public static void Exit()
		{
			if (Plugin.ReviveScopeDepth > 0)
			{
				Plugin.ReviveScopeDepth--;
			}
		}
	}
	internal static class VoidEntryScope
	{
		public static void Enter()
		{
			Plugin.VoidEntryDepth++;
		}

		public static void Exit()
		{
			if (Plugin.VoidEntryDepth > 0)
			{
				Plugin.VoidEntryDepth--;
			}
		}
	}
	internal static class BlockStatus
	{
		public static bool Prefix(STATUSTYPE __0, ref bool __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected I4, but got Unknown
			if (!Plugin.ShouldBlock((int)__0))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	internal static class SnapshotRestore
	{
		public static bool TargetIsCompatible(MethodInfo target)
		{
			ParameterInfo[] parameters = target.GetParameters();
			if (parameters.Length >= 1)
			{
				return parameters[0].ParameterType == typeof(CharacterAfflictions);
			}
			return false;
		}

		public static void Prefix(CharacterAfflictions __0, out float[] __state)
		{
			__state = null;
			float[] array = (((Object)(object)__0 != (Object)null) ? __0.currentStatuses : null);
			if (array != null)
			{
				__state = new float[2];
				__state[0] = Read(array, Plugin.CurseIndex);
				__state[1] = Read(array, Plugin.HungerIndex);
			}
		}

		public static void Postfix(CharacterAfflictions __0, float[] __state)
		{
			if (__state != null && !((Object)(object)__0 == (Object)null) && __0.currentStatuses != null)
			{
				if (Plugin.BlockCurse.Value)
				{
					Write(__0.currentStatuses, Plugin.CurseIndex, __state[0]);
				}
				if (Plugin.BlockHunger.Value)
				{
					Write(__0.currentStatuses, Plugin.HungerIndex, __state[1]);
				}
			}
		}

		private static float Read(float[] statuses, int index)
		{
			if (index < 0 || index >= statuses.Length)
			{
				return 0f;
			}
			return statuses[index];
		}

		private static void Write(float[] statuses, int index, float value)
		{
			if (index >= 0 && index < statuses.Length)
			{
				statuses[index] = value;
			}
		}
	}
}