using System;
using System.Collections;
using System.Collections.Generic;
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 GameNetcodeStuff;
using HarmonyLib;
using LethalParrying.Patches;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[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("Redcom1988")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Lethal Company Parrying")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2")]
[assembly: AssemblyProduct("LethalParryingRebind")]
[assembly: AssemblyTitle("Redcom1988.LethalParryingRebind")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.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 LethalParrying
{
	public class ParryNetworkHandler : NetworkBehaviour
	{
	}
	[BepInPlugin("Redcom1988.LethalParryingRebind", "LethalParryingRebind", "1.0.2")]
	[BepInProcess("Lethal Company.exe")]
	public class LethalParryBase : BaseUnityPlugin
	{
		public static LethalParryBase instance;

		public static ManualLogSource logger;

		public static bool serverModCheck = true;

		public static bool stun = false;

		internal static ConfigEntry<int> DropProbability;

		internal static ConfigEntry<bool> Notify;

		internal static ConfigEntry<bool> DisplayCooldown;

		internal static ConfigEntry<float> ParryWindow;

		internal static ConfigEntry<float> ParryCooldown;

		internal static ConfigEntry<string> Keybind;

		private readonly Harmony harmony = new Harmony("Redcom1988.LethalParryingRebind");

		private void NetCodeWeaver()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}

		private void Awake()
		{
			DropProbability = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Drop chance", 15, "Probability for how often you might drop your weapon when failing to parry or holding R.");
			ParryWindow = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Parry Window", 0.25f, "Time for parry window.");
			ParryCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Parry Cooldown", 2f, "Time for parry cooldown.");
			Keybind = ((BaseUnityPlugin)this).Config.Bind<string>("General", "Parry Keybind", "f", "Keybind to trigger parry.");
			Notify = ((BaseUnityPlugin)this).Config.Bind<bool>("Screen Information", "Display Parry Notifications", false, "Enables/Disables screen notifications for parry information. (Will be removed when sounds and effects are added)");
			DisplayCooldown = ((BaseUnityPlugin)this).Config.Bind<bool>("Screen Information", "Display Parry Cooldown (Notification)", true, "Will show you a notification if your parry is on cooldown. (Display Parry Notifications does not affect this.)");
			if (DropProbability.Value < (int)((ConfigEntryBase)DropProbability).DefaultValue)
			{
				DropProbability.Value = (int)((ConfigEntryBase)DropProbability).DefaultValue;
			}
			NetCodeWeaver();
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
				logger = ((BaseUnityPlugin)this).Logger;
			}
			logger.LogInfo((object)"---[Only skill issue can kill you now..]---");
			logger.LogInfo((object)"---[Plugin Redcom1988.LethalParryingRebind is loaded!]---");
			logger.LogInfo((object)"---[Only skill issue can kill you now..]---");
			harmony.PatchAll(typeof(LethalParryBase));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(ShovelPatch));
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "Redcom1988.LethalParryingRebind";

		public const string PLUGIN_NAME = "LethalParryingRebind";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}
namespace LethalParrying.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		internal static bool isPerfectParryFrame = false;

		internal static bool isSlow = false;

		internal static float perfectParryWindow = LethalParryBase.ParryWindow.Value;

		internal static float lastParryTime;

		internal static float perfectParryCooldown = LethalParryBase.ParryCooldown.Value;

		internal static Key convertedKey = GetKeyFromString(LethalParryBase.Keybind.Value);

		internal static GrabbableObject currentItem;

		internal static Shovel shovel = null;

		internal static bool ParriedDeath = false;

		internal static Coroutine currentCoroutine;

		[HarmonyPatch("KillPlayer")]
		[HarmonyPrefix]
		private static bool KillPlayerPatch(PlayerControllerB __instance, CauseOfDeath causeOfDeath)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between Unknown and I4
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			if (!LethalParryBase.serverModCheck)
			{
				return true;
			}
			if (!((NetworkBehaviour)__instance).IsOwner)
			{
				return false;
			}
			if (__instance.isPlayerDead)
			{
				return false;
			}
			if (!__instance.AllowPlayerDeath())
			{
				return false;
			}
			if (ParriedDeath)
			{
				LethalParryBase.logger.LogWarning((object)"Server called KillPlayer method again. Might have to patch this method properly.");
				ParriedDeath = false;
				return false;
			}
			if ((int)causeOfDeath == 0 || (int)causeOfDeath == 2 || (int)causeOfDeath == 10 || (int)causeOfDeath == 5 || (int)causeOfDeath == 9 || (Object)(object)shovel == (Object)null)
			{
				return true;
			}
			if (isPerfectParryFrame)
			{
				if (LethalParryBase.Notify.Value)
				{
					HUDManager.Instance.DisplayTip("Parried Death..", "Nothing can stop you.", true, false, "LC_Tip1");
				}
				HUDManager.Instance.ShakeCamera((ScreenShakeType)3);
				__instance.DropAllHeldItems(true, false);
				lastParryTime = 0f;
				ParriedDeath = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch("DamagePlayer")]
		[HarmonyPrefix]
		private static bool DamagePlayerPatch(PlayerControllerB __instance, ref int damageNumber, CauseOfDeath causeOfDeath)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			if (!LethalParryBase.serverModCheck)
			{
				return true;
			}
			if (!((NetworkBehaviour)__instance).IsOwner)
			{
				return false;
			}
			if (__instance.isPlayerDead)
			{
				return false;
			}
			if (!__instance.AllowPlayerDeath())
			{
				return false;
			}
			if ((int)causeOfDeath == 10 || (int)causeOfDeath == 5 || (int)causeOfDeath == 9 || (Object)(object)shovel == (Object)null)
			{
				return true;
			}
			if (isPerfectParryFrame)
			{
				isSlow = false;
				if (currentCoroutine == null)
				{
					currentCoroutine = ((MonoBehaviour)__instance).StartCoroutine(DoHit(__instance, shovel));
				}
				MakeCriticallyInjured(__instance, enable: false);
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
				if (LethalParryBase.Notify.Value)
				{
					HUDManager.Instance.DisplayTip("Parried!", "Nice job!", false, false, "LC_Tip1");
				}
				__instance.ResetFallGravity();
				lastParryTime = 0f;
			}
			else if ((int)convertedKey != 0 && ((ButtonControl)Keyboard.current[convertedKey]).isPressed)
			{
				int num = Random.Range(0, damageNumber - Random.Range(0, damageNumber));
				damageNumber -= num;
				if (LethalParryBase.Notify.Value)
				{
					HUDManager.Instance.DisplayTip("Blocked Damage", $"Damage negated: {num}", false, false, "LC_Tip1");
				}
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
				int num2 = Random.Range(1, 100);
				if (num2 <= LethalParryBase.DropProbability.Value && (Object)(object)currentItem != (Object)null)
				{
					__instance.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
				}
			}
			return !isPerfectParryFrame;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePatch(PlayerControllerB __instance)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (!LethalParryBase.serverModCheck || ((!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled || (((NetworkBehaviour)__instance).IsServer && !__instance.isHostPlayerObject)) && !__instance.isTestingPlayer))
			{
				return;
			}
			currentItem = __instance.ItemSlots[__instance.currentItemSlot];
			if ((int)convertedKey == 0 || !((ButtonControl)Keyboard.current[convertedKey]).isPressed || (Object)(object)currentItem == (Object)null || (Object)(object)shovel == (Object)null)
			{
				if (__instance.bleedingHeavily)
				{
					isSlow = false;
					return;
				}
				if (isSlow && __instance.criticallyInjured)
				{
					isSlow = false;
					MakeCriticallyInjured(__instance, enable: false);
				}
			}
			if ((Object)(object)currentItem == (Object)null)
			{
				return;
			}
			shovel = (Shovel)((currentItem is Shovel) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)shovel == (Object)null || (int)convertedKey == 0 || !((ButtonControl)Keyboard.current[convertedKey]).isPressed)
			{
				return;
			}
			if (shovel.reelingUp || __instance.bleedingHeavily)
			{
				if (LethalParryBase.Notify.Value)
				{
					HUDManager.Instance.DisplayTip("Can't parry.", "You are attacking or injured.", false, false, "LC_Tip1");
				}
			}
			else if (!IsParryOnCooldown())
			{
				((MonoBehaviour)__instance).StartCoroutine(PerfectParryWindow(__instance, shovel));
				MakeCriticallyInjured(__instance, enable: true);
				LethalParryBase.stun = true;
				isSlow = true;
			}
			else if (!isPerfectParryFrame && LethalParryBase.DisplayCooldown.Value)
			{
				HUDManager.Instance.DisplayTip("Can't parry. On cooldown", $"Can parry again after {Math.Round(perfectParryCooldown - Time.time + lastParryTime, 1)} seconds.", false, false, "LC_Tip1");
			}
		}

		private static Key GetKeyFromString(string keyString)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			foreach (Key value in Enum.GetValues(typeof(Key)))
			{
				Key result = value;
				if (((object)(Key)(ref result)).ToString().ToLower() == keyString.ToLower())
				{
					return result;
				}
			}
			return (Key)0;
		}

		private static IEnumerator DoHit(PlayerControllerB player, Shovel shovel)
		{
			AccessTools.Field(typeof(Shovel), "previousPlayerHeldBy").SetValue(shovel, player);
			shovel.reelingUp = true;
			if (currentCoroutine == null)
			{
				player.activatingItem = true;
				player.twoHanded = true;
				player.playerBodyAnimator.ResetTrigger("shovelHit");
				player.playerBodyAnimator.SetBool("reelingUp", true);
				shovel.shovelAudio.PlayOneShot(shovel.reelUp);
				yield return (object)new WaitForSeconds(0.1f);
				if (shovel != null)
				{
					shovel.SwingShovel(!((GrabbableObject)shovel).isHeld);
				}
				yield return (object)new WaitForSeconds(0.15f);
				if (shovel != null)
				{
					shovel.HitShovel(!((GrabbableObject)shovel).isHeld);
				}
				shovel.reelingUp = false;
				AccessTools.Field(typeof(Shovel), "reelingUpCoroutine").SetValue(shovel, null);
				currentCoroutine = null;
			}
		}

		private static IEnumerator PerfectParryWindow(PlayerControllerB player, Shovel shovel)
		{
			if (!isPerfectParryFrame)
			{
				isPerfectParryFrame = true;
				lastParryTime = Time.fixedTime;
				shovel.shovelAudio.PlayOneShot(shovel.reelUp);
				shovel.ReelUpSFXServerRpc();
				yield return (object)new WaitForSeconds(perfectParryWindow);
				isPerfectParryFrame = false;
			}
		}

		private static void MakeCriticallyInjured(PlayerControllerB player, bool enable)
		{
			player.criticallyInjured = enable;
			player.playerBodyAnimator.SetBool("Limp", enable);
		}

		private static bool IsParryOnCooldown()
		{
			return Time.fixedTime - lastParryTime < perfectParryCooldown;
		}
	}
	[HarmonyPatch(typeof(Shovel))]
	internal class ShovelPatch
	{
		[HarmonyPatch("HitShovel")]
		[HarmonyPostfix]
		public static void HitShovelPostfix(ref Shovel __instance, ref List<RaycastHit> ___objectsHitByShovelList, ref PlayerControllerB ___previousPlayerHeldBy)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (___objectsHitByShovelList == null && (___objectsHitByShovelList.Count == 0 || !LethalParryBase.stun || !LethalParryBase.serverModCheck))
			{
				return;
			}
			LethalParryBase.logger.LogInfo((object)"Got hit list");
			EnemyAI val = default(EnemyAI);
			foreach (RaycastHit ___objectsHitByShovel in ___objectsHitByShovelList)
			{
				RaycastHit current = ___objectsHitByShovel;
				if (((Component)((RaycastHit)(ref current)).transform.parent).TryGetComponent<EnemyAI>(ref val) && (Object)(object)((RaycastHit)(ref current)).transform != (Object)(object)___previousPlayerHeldBy && (Object)(object)val != (Object)null)
				{
					try
					{
						LethalParryBase.logger.LogInfo((object)$"Stunned enemy {val.enemyType}!");
						val.SetEnemyStunned(true, 1f, ___previousPlayerHeldBy);
					}
					catch (Exception arg)
					{
						Debug.Log((object)$"Exception caught when hitting object with shovel from player #{___previousPlayerHeldBy.playerClientId}: {arg}");
					}
				}
			}
			LethalParryBase.stun = false;
		}
	}
}
namespace LethalParrying.Netcode
{
	[HarmonyPatch]
	public class ServerModCheck
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnRequest;

			public static HandleNamedMessageDelegate <1>__OnReceive;
		}

		public static PlayerControllerB localPlayer;

		public static bool hasMod;

		public static bool synced;

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void InitLocalPlayer(PlayerControllerB __instance)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			localPlayer = __instance;
			if (NetworkManager.Singleton.IsServer)
			{
				hasMod = true;
				CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
				object obj = <>O.<0>__OnRequest;
				if (obj == null)
				{
					HandleNamedMessageDelegate val = OnRequest;
					<>O.<0>__OnRequest = val;
					obj = (object)val;
				}
				customMessagingManager.RegisterNamedMessageHandler("LethalParryingOnRequestModCheck", (HandleNamedMessageDelegate)obj);
				LethalParryBase.logger.LogInfo((object)"Setting up Server CustomMessagingManager");
				SyncOnLocalClient();
			}
			else
			{
				CustomMessagingManager customMessagingManager2 = NetworkManager.Singleton.CustomMessagingManager;
				object obj2 = <>O.<1>__OnReceive;
				if (obj2 == null)
				{
					HandleNamedMessageDelegate val2 = OnReceive;
					<>O.<1>__OnReceive = val2;
					obj2 = (object)val2;
				}
				customMessagingManager2.RegisterNamedMessageHandler("LethalParryingOnReceiveModCheck", (HandleNamedMessageDelegate)obj2);
				LethalParryBase.logger.LogInfo((object)"Setting up Client CustomMessagingManager");
				SendRequestToServer();
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPrefix]
		public static bool OnDestroy()
		{
			if ((Object)(object)NetworkManager.Singleton != (Object)null)
			{
				if (NetworkManager.Singleton.IsServer)
				{
					NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler("LethalParryingOnRequestModCheck");
					LethalParryBase.logger.LogInfo((object)"Destroying Server CustomMessagingManager");
				}
				else
				{
					NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler("LethalParryingOnReceiveModCheck");
					LethalParryBase.logger.LogInfo((object)"Destroying Client CustomMessagingManager");
				}
			}
			hasMod = false;
			LethalParryBase.serverModCheck = false;
			LethalParryBase.logger.LogInfo((object)"Setting mod check to false");
			return true;
		}

		public static void SendRequestToServer()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsClient)
			{
				LethalParryBase.logger.LogInfo((object)"Sending request to server.");
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("LethalParryingOnRequestModCheck", 0uL, val, (NetworkDelivery)3);
			}
			else
			{
				LethalParryBase.logger.LogError((object)"Faile to send request if server has mod.");
			}
		}

		public static void OnRequest(ulong clientId, FastBufferReader reader)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer)
			{
				LethalParryBase.logger.LogInfo((object)$"Player_ID: {clientId} Requested for Mod Check.");
				bool flag = true;
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(FastBufferWriter.GetWriteSize<bool>(ref flag, default(ForStructs)), (Allocator)2, -1);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("LethalParryingOnReceiveModCheck", clientId, val, (NetworkDelivery)3);
			}
		}

		public static void OnReceive(ulong clientId, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			hasMod = flag;
			LethalParryBase.logger.LogInfo((object)$"Received mod check: {hasMod} from server!");
			SyncOnLocalClient();
		}

		public static void SyncOnLocalClient()
		{
			LethalParryBase.serverModCheck = hasMod;
		}
	}
}