using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[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("InfiniteEmote")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Adjusts CheckConditionsForEmote conditions")]
[assembly: AssemblyFileVersion("1.3.3.0")]
[assembly: AssemblyInformationalVersion("1.3.3+5772b8680c25c78aa9b8ebb313ada9a0f346c305")]
[assembly: AssemblyProduct("InfiniteEmote")]
[assembly: AssemblyTitle("InfiniteEmote")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.3.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 InfiniteEmote
{
	[Serializable]
	public class Config : SyncedInstance<Config>
	{
		public bool WhileJumping = true;

		public bool WhileWalking = true;

		public bool WhileSprinting = true;

		public bool WhileCrouching;

		public bool WhileLadder;

		public bool WhileGrabbing;

		public bool WhileTyping;

		public bool WhileTerminal;

		public bool WhileHolding = true;

		public bool WhileHoldingTwoHand = true;

		[NonSerialized]
		private static string Section = "Emote while";

		public Config(ConfigFile configFile)
		{
			InitInstance(this);
			Plugin.Debug("Loading emote while options");
			WhileJumping = configFile.Bind<bool>(Section, "Jumping", WhileJumping, "Whether or not to allow emoting while Jumping").Value;
			WhileWalking = configFile.Bind<bool>(Section, "Walking", WhileWalking, "Whether or not to allow emoting while Walking").Value;
			WhileSprinting = configFile.Bind<bool>(Section, "Sprinting", WhileSprinting, "Whether or not to allow emoting while Sprinting").Value;
			WhileCrouching = configFile.Bind<bool>(Section, "Crouching", WhileCrouching, "Whether or not to allow emoting while Crouching").Value;
			WhileLadder = configFile.Bind<bool>(Section, "Ladder", WhileLadder, "Whether or not to allow emoting while climbing Ladder").Value;
			WhileGrabbing = configFile.Bind<bool>(Section, "Grabbing", WhileGrabbing, "Whether or not to allow emoting while Grabbing").Value;
			WhileTyping = configFile.Bind<bool>(Section, "Typing", WhileTyping, "Whether or not to allow emoting while Typing").Value;
			WhileTerminal = configFile.Bind<bool>(Section, "Terminal", WhileTerminal, "Whether or not to allow emoting while in the Terminal").Value;
			WhileHolding = configFile.Bind<bool>(Section, "Holding", WhileHolding, "Whether or not to allow emoting while Holding an object").Value;
			WhileHoldingTwoHand = configFile.Bind<bool>(Section, "HoldingTwoHand", WhileHoldingTwoHand, "Whether or not to allow emoting while Holding a two handed object").Value;
		}

		public void DebugValues()
		{
			Plugin.Debug($"WhileJumping '{WhileJumping}'");
			Plugin.Debug($"WhileWalking '{WhileWalking}'");
			Plugin.Debug($"WhileSprinting '{WhileSprinting}'");
			Plugin.Debug($"WhileCrouching '{WhileCrouching}'");
			Plugin.Debug($"WhileLadder '{WhileLadder}'");
			Plugin.Debug($"WhileGrabbing '{WhileGrabbing}'");
			Plugin.Debug($"WhileTyping '{WhileTyping}'");
			Plugin.Debug($"WhileTerminal '{WhileTerminal}'");
			Plugin.Debug($"WhileHoldingTwoHand '{WhileHoldingTwoHand}'");
		}

		public static void RequestSync()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(SyncedInstance<Config>.IntSize, (Allocator)2, -1);
			try
			{
				SyncedInstance<Config>.MessageManager.SendNamedMessage("ModName_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0047: 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)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsHost)
			{
				return;
			}
			Plugin.Logger.LogInfo((object)$"Config sync request received from client: {clientId}");
			byte[] array = SyncedInstance<Config>.SerializeToBytes(SyncedInstance<Config>.Instance);
			int num = array.Length;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<Config>.IntSize, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				SyncedInstance<Config>.MessageManager.SendNamedMessage("ModName_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<Config>.IntSize))
			{
				Plugin.Logger.LogError((object)"Config sync error: Could not begin reading buffer.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				Plugin.Logger.LogError((object)"Config sync error: Host could not sync.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			SyncedInstance<Config>.SyncInstance(data);
			Plugin.Logger.LogInfo((object)"Successfully synced config with host.");
		}
	}
	internal class Keybinds : LcInputActions
	{
		public InputAction StopEmote => ((LcInputActions)this).Asset["StopEmote"];

		public override void CreateInputActions(in InputActionMapBuilder builder)
		{
			((LcInputActions)this).CreateInputActions(ref builder);
			builder.NewActionBinding().WithActionId("StopEmote").WithActionType((InputActionType)1)
				.WithKbmPath(Patches.stopEmoteKey)
				.WithGamepadPath(Patches.stopEmoteController)
				.WithBindingName("Stop Emote")
				.Finish();
		}
	}
	internal class Patches
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action<CallbackContext> <0>__onStopEmoteKey;

			public static HandleNamedMessageDelegate <1>__OnRequestSync;

			public static HandleNamedMessageDelegate <2>__OnReceiveSync;
		}

		public static Keybinds keybinds;

		public static string stopEmoteKey;

		public static string stopEmoteController;

		public static bool moreEmotes;

		private static PlayerControllerB localPlayerController
		{
			get
			{
				StartOfRound instance = StartOfRound.Instance;
				if (!((Object)(object)instance != (Object)null))
				{
					return null;
				}
				return instance.localPlayerController;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Start")]
		[HarmonyPostfix]
		private static void StartPostfix(PlayerControllerB __instance)
		{
			Plugin.Debug("PlayerControllerB.StartPostfix");
			keybinds.StopEmote.performed += onStopEmoteKey;
			keybinds.StopEmote.Enable();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "OnDisable")]
		[HarmonyPostfix]
		public static void OnDisablePostfix(PlayerControllerB __instance)
		{
			Plugin.Debug("OnDisablePostfix");
			if ((Object)(object)__instance == (Object)(object)localPlayerController)
			{
				Plugin.Debug("localPlayerController is instance");
				keybinds.StopEmote.performed -= onStopEmoteKey;
				keybinds.StopEmote.Disable();
			}
		}

		private static void onStopEmoteKey(CallbackContext context)
		{
			Plugin.Debug("onStopEmoteKey");
			if (localPlayerController.isPlayerControlled && ((NetworkBehaviour)localPlayerController).IsOwner)
			{
				Plugin.Debug("isPlayerControlled and IsOwner");
				localPlayerController.performingEmote = false;
				localPlayerController.StopPerformingEmoteServerRpc();
				localPlayerController.timeSinceStartingEmote = 0f;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "CheckConditionsForEmote")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "BetterEmotes", "MoreEmotes" })]
		private static void CheckConditionsForEmotePatch(PlayerControllerB __instance, ref bool __result)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			if (__instance.inSpecialInteractAnimation || __instance.isPlayerDead)
			{
				Plugin.Debug($"inSpecialInteractAnimation ({__instance.inSpecialInteractAnimation}) or isPlayerDead ({__instance.isPlayerDead})");
				__result = false;
				return;
			}
			if (__instance.isGrabbingObjectAnimation)
			{
				Plugin.Debug($"isGrabbingObjectAnimation ({__instance.isGrabbingObjectAnimation}), whileGrabbing ({SyncedInstance<Config>.Instance.WhileGrabbing})");
				if (!SyncedInstance<Config>.Instance.WhileGrabbing)
				{
					__result = false;
					return;
				}
				__result = true;
			}
			if (__instance.isHoldingObject)
			{
				Plugin.Debug($"isHoldingObject ({__instance.isHoldingObject}), whileHolding ({SyncedInstance<Config>.Instance.WhileHolding})");
				if (!SyncedInstance<Config>.Instance.WhileHolding)
				{
					__result = false;
					return;
				}
				if (__instance.twoHanded)
				{
					Plugin.Debug($"twoHanded ({__instance.twoHanded}), whileHoldingTwoHand ({SyncedInstance<Config>.Instance.WhileHoldingTwoHand})");
					if (!SyncedInstance<Config>.Instance.WhileHoldingTwoHand)
					{
						__result = false;
						return;
					}
					__result = true;
				}
				else
				{
					__result = true;
				}
			}
			if (__instance.isJumping)
			{
				Plugin.Debug($"isJumping, whileJumping ({SyncedInstance<Config>.Instance.WhileJumping})");
				__result = SyncedInstance<Config>.Instance.WhileJumping;
			}
			if (__instance.isWalking)
			{
				Plugin.Debug($"isWalking, whileWalking ({SyncedInstance<Config>.Instance.WhileWalking})");
				__result = SyncedInstance<Config>.Instance.WhileWalking;
			}
			if (__instance.isSprinting)
			{
				Plugin.Debug($"isSprinting, whileSprinting ({SyncedInstance<Config>.Instance.WhileSprinting})");
				__result = SyncedInstance<Config>.Instance.WhileSprinting;
			}
			if (__instance.isCrouching)
			{
				Plugin.Debug($"isCrouching, whileCrouching ({SyncedInstance<Config>.Instance.WhileCrouching})");
				__result = SyncedInstance<Config>.Instance.WhileCrouching;
			}
			if (__instance.isClimbingLadder)
			{
				Plugin.Debug($"isClimbingLadder, whileLadder ({SyncedInstance<Config>.Instance.WhileLadder})");
				__result = SyncedInstance<Config>.Instance.WhileLadder;
			}
			if (__instance.isTypingChat)
			{
				int integer = __instance.playerBodyAnimator.GetInteger("emoteNumber");
				Plugin.Debug($"isTypingChat, whileTyping ({SyncedInstance<Config>.Instance.WhileTyping}), moreEmotes ({moreEmotes}), currentEmote ({integer})");
				if (moreEmotes && integer == 10)
				{
					Plugin.Debug("isEmoteNumber 10 (Sign for MoreEmotes)");
					__result = true;
				}
				else
				{
					__result = SyncedInstance<Config>.Instance.WhileTyping;
				}
			}
			if (__instance.inTerminalMenu)
			{
				Plugin.Debug($"inTerminalMenu, whileTerminal ({SyncedInstance<Config>.Instance.WhileTerminal})");
				__result = SyncedInstance<Config>.Instance.WhileTerminal;
			}
			if (!__result)
			{
				Plugin.Debug("__result false, following values");
				Plugin.Debug($"!__instance.inSpecialInteractAnimation ({!__instance.inSpecialInteractAnimation})");
				Plugin.Debug($"!__instance.isPlayerDead ({!__instance.isPlayerDead})");
				Plugin.Debug($"!__instance.isJumping ({!__instance.isJumping})");
				Plugin.Debug($"!__instance.isWalking ({!__instance.isWalking})");
				Plugin.Debug($"!__instance.isCrouching ({!__instance.isCrouching})");
				Plugin.Debug($"!__instance.isClimbingLadder ({!__instance.isClimbingLadder})");
				Plugin.Debug($"!__instance.isGrabbingObjectAnimation ({!__instance.isGrabbingObjectAnimation})");
				Plugin.Debug($"!__instance.inTerminalMenu ({!__instance.inTerminalMenu})");
				Plugin.Debug($"!__instance.isTypingChat ({!__instance.isTypingChat})");
				bool flag = !__instance.inSpecialInteractAnimation && !__instance.isPlayerDead && !__instance.isJumping && !__instance.isWalking && !__instance.isCrouching && !__instance.isClimbingLadder && !__instance.isGrabbingObjectAnimation && !__instance.inTerminalMenu && !__instance.isTypingChat;
				Plugin.Debug($"result ({flag})");
				__result = flag;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		private static void InitializeLocalPlayer()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Plugin.Debug("InitializeLocalPlayer()");
			if (SyncedInstance<Config>.IsHost)
			{
				try
				{
					CustomMessagingManager messageManager = SyncedInstance<Config>.MessageManager;
					object obj = <>O.<1>__OnRequestSync;
					if (obj == null)
					{
						HandleNamedMessageDelegate val = Config.OnRequestSync;
						<>O.<1>__OnRequestSync = val;
						obj = (object)val;
					}
					messageManager.RegisterNamedMessageHandler("ModName_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
					SyncedInstance<Config>.Synced = true;
					return;
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)ex);
					return;
				}
			}
			SyncedInstance<Config>.Synced = false;
			CustomMessagingManager messageManager2 = SyncedInstance<Config>.MessageManager;
			object obj2 = <>O.<2>__OnReceiveSync;
			if (obj2 == null)
			{
				HandleNamedMessageDelegate val2 = Config.OnReceiveSync;
				<>O.<2>__OnReceiveSync = val2;
				obj2 = (object)val2;
			}
			messageManager2.RegisterNamedMessageHandler("ModName_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
			Config.RequestSync();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
		public static void PlayerLeave()
		{
			Plugin.Debug("PlayerLeave()");
			SyncedInstance<Config>.RevertSync();
		}
	}
	[BepInPlugin("InfiniteEmote", "InfiniteEmote", "1.3.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static Texture2D texture;

		public static bool debug;

		public static ManualLogSource Logger;

		private void Awake()
		{
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin InfiniteEmote loading...");
			debug = ((BaseUnityPlugin)this).Config.Bind<bool>("Dev", "Debug", false, "Whether or not to enable debug logging and debug helpers").Value;
			Logger.LogInfo((object)$"Debug enabled: {debug}");
			new Config(((BaseUnityPlugin)this).Config);
			Debug("Loading keybind defaults");
			ConfigEntry<string> val = ((BaseUnityPlugin)this).Config.Bind<string>("Keys", "Stop Emote Key", "<Keyboard>/minus", "Default keybind to stop emoting");
			Patches.stopEmoteKey = validatePrefixes(new string[2] { "<Keyboard>", "<Mouse>" }, "<Keyboard>", val.Value);
			ConfigEntry<string> val2 = ((BaseUnityPlugin)this).Config.Bind<string>("Keys", "Stop Emote Button", "<Gamepad>/leftStickPress", "Default controller button to stop emoting");
			Patches.stopEmoteController = validatePrefixes(new string[1] { "<Gamepad>" }, "<Gamepad>", val2.Value);
			Debug("Loaded key '" + Patches.stopEmoteKey + "'");
			Debug("Loaded button '" + Patches.stopEmoteController + "'");
			checkForMods();
			Patches.keybinds = new Keybinds();
			new Harmony("InfiniteEmote").PatchAll(typeof(Patches));
			Logger.LogInfo((object)"Plugin InfiniteEmote is loaded!");
		}

		public static string validatePrefixes(string[] prefixes, string defaultPrefix, string value)
		{
			if (value.Equals(""))
			{
				return "";
			}
			foreach (string text in prefixes)
			{
				if (value.ToLower().StartsWith(text.ToLower()))
				{
					return value;
				}
			}
			return defaultPrefix + "/" + value;
		}

		public static void Debug(string message)
		{
			if (debug)
			{
				Logger.LogDebug((object)message);
			}
		}

		public static void checkForMods()
		{
			Debug("checkForMods");
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				BepInPlugin metadata = pluginInfo.Value.Metadata;
				if (metadata.GUID.Equals("MoreEmotes") || metadata.GUID.Equals("BetterEmotes"))
				{
					Debug("Found MoreEmotes/BetterEmotes");
					Patches.moreEmotes = true;
					break;
				}
			}
		}
	}
	[Serializable]
	public class SyncedInstance<T>
	{
		[NonSerialized]
		protected static int IntSize = 4;

		internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

		internal static bool IsClient => NetworkManager.Singleton.IsClient;

		internal static bool IsHost => NetworkManager.Singleton.IsHost;

		public static T Default { get; private set; }

		public static T Instance { get; private set; }

		public static bool Synced { get; internal set; }

		protected void InitInstance(T instance)
		{
			Default = instance;
			Instance = instance;
			IntSize = 4;
		}

		internal static void SyncInstance(byte[] data)
		{
			Instance = DeserializeFromBytes(data);
			Synced = true;
		}

		internal static void RevertSync()
		{
			Instance = Default;
			Synced = false;
		}

		public static byte[] SerializeToBytes(T val)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream memoryStream = new MemoryStream();
			try
			{
				binaryFormatter.Serialize(memoryStream, val);
				return memoryStream.ToArray();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error serializing instance: {arg}");
				return null;
			}
		}

		public static T DeserializeFromBytes(byte[] data)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream serializationStream = new MemoryStream(data);
			try
			{
				return (T)binaryFormatter.Deserialize(serializationStream);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error deserializing instance: {arg}");
				return default(T);
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "InfiniteEmote";

		public const string PLUGIN_NAME = "InfiniteEmote";

		public const string PLUGIN_VERSION = "1.3.3";
	}
}