using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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 ConfigurableLockpicker.NetcodePatcher;
using ConfigurableLockpicker.Patches;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
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("ConfigurableLockpicker")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Makes The Lockpicker time configurable")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ConfigurableLockpicker")]
[assembly: AssemblyTitle("ConfigurableLockpicker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
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 ConfigurableLockpicker
{
	internal class Networker : NetworkBehaviour
	{
		public static Networker Instance { get; private set; }

		public override void OnNetworkSpawn()
		{
			Instance = this;
			((NetworkBehaviour)this).OnNetworkSpawn();
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void LockDoorServerRpc(ulong lockpickID, ulong doorID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2090514130u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, lockpickID);
					BytePacker.WriteValueBitPacked(val2, doorID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2090514130u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LockDoorClientRpc(lockpickID, doorID);
				}
			}
		}

		[ClientRpc]
		public void LockDoorClientRpc(ulong lockpickID, ulong doorID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4089986782u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, lockpickID);
				BytePacker.WriteValueBitPacked(val2, doorID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4089986782u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Plugin.CustomLogger.LogWarning((object)$"[ClientRpc] LockDoorClientRpc called on client {NetworkManager.Singleton.LocalClientId}");
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(lockpickID, out var value) && NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(doorID, out var value2))
			{
				LockPicker componentInChildren = ((Component)value).gameObject.GetComponentInChildren<LockPicker>();
				DoorLock componentInChildren2 = ((Component)value2).gameObject.GetComponentInChildren<DoorLock>();
				if (Object.op_Implicit((Object)(object)componentInChildren) && Object.op_Implicit((Object)(object)componentInChildren2))
				{
					LockpickerPatch.startLocking(componentInChildren, componentInChildren2);
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2090514130u, new RpcReceiveHandler(__rpc_handler_2090514130), "LockDoorServerRpc");
			((NetworkBehaviour)this).__registerRpc(4089986782u, new RpcReceiveHandler(__rpc_handler_4089986782), "LockDoorClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2090514130(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong lockpickID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref lockpickID);
				ulong doorID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref doorID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LockDoorServerRpc(lockpickID, doorID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4089986782(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong lockpickID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref lockpickID);
				ulong doorID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref doorID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LockDoorClientRpc(lockpickID, doorID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "Networker";
		}
	}
	[BepInPlugin("Slayer6409.ConfigurableLockpicker", "Configurable_Lockpicker", "0.0.3")]
	public class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "Slayer6409.ConfigurableLockpicker";

		private const string modName = "Configurable_Lockpicker";

		private const string modVersion = "0.0.3";

		public static ConfigEntry<float> LockpickTime;

		public static ConfigEntry<bool> Relock;

		public static ConfigEntry<float> RelockTime;

		private readonly Harmony harmony = new Harmony("Slayer6409.ConfigurableLockpicker");

		public static ManualLogSource CustomLogger;

		public static GameObject NetworkerPrefab;

		public static AssetBundle LoadedAssets;

		public void configStuff()
		{
			LockpickTime = ((BaseUnityPlugin)this).Config.Bind<float>("Lockpicker", "Time", 10f, "How long should the lockpicker take");
			Relock = ((BaseUnityPlugin)this).Config.Bind<bool>("Lockpicker", "Relock", true, "Should the lockpicker be able to re-lock doors?");
			RelockTime = ((BaseUnityPlugin)this).Config.Bind<float>("Lockpicker", "Relock Time", 5f, "How long should it take to re-lock doors?");
		}

		private void Awake()
		{
			LoadedAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "configurablelockpicker"));
			NetcodeWeaver();
			NetworkerPrefab = LoadedAssets.LoadAsset<GameObject>("Networker");
			NetworkerPrefab.AddComponent<Networker>();
			CustomLogger = Logger.CreateLogSource("Slayer6409.ConfigurableLockpicker");
			configStuff();
			harmony.PatchAll();
			NetworkPrefabs.RegisterNetworkPrefab(NetworkerPrefab);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin Configurable Lockpicker is loaded!");
		}

		private static void NetcodeWeaver()
		{
			try
			{
				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);
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ConfigurableLockpicker";

		public const string PLUGIN_NAME = "ConfigurableLockpicker";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ConfigurableLockpicker.Patches
{
	[HarmonyPatch(typeof(DoorLock))]
	public class DoorlockPatch
	{
		[HarmonyPatch(typeof(DoorLock), "Awake")]
		[HarmonyPostfix]
		public static void AwakePostfix(DoorLock __instance)
		{
			__instance.maxTimeLeft = Plugin.LockpickTime.Value;
			__instance.lockPickTimeLeft = Plugin.LockpickTime.Value;
		}

		[HarmonyPatch(typeof(DoorLock), "Update")]
		[HarmonyPostfix]
		public static void UpdatePostfix(DoorLock __instance)
		{
			if (__instance.isLocked && __instance.isPickingLock && __instance.lockPickTimeLeft > Plugin.LockpickTime.Value)
			{
				__instance.lockPickTimeLeft = Plugin.LockpickTime.Value;
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void AddPrefab(ref GameNetworkManager __instance)
		{
			((Component)__instance).GetComponent<NetworkManager>().AddNetworkPrefab(Plugin.NetworkerPrefab);
		}
	}
	[HarmonyPatch(typeof(LockPicker))]
	public class LockpickerPatch
	{
		[CompilerGenerated]
		private sealed class <LockWait>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LockPicker __instance;

			public DoorLock door;

			private float <waitTime>5__1;

			private float <elapsed>5__2;

			private float <remainingTime>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LockWait>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Plugin.CustomLogger.LogWarning((object)"LockWait");
					<waitTime>5__1 = Plugin.RelockTime.Value;
					<elapsed>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < <waitTime>5__1)
				{
					if ((Object)(object)__instance == (Object)null || (Object)(object)door == (Object)null || door.isLocked || (Object)(object)((Component)door).gameObject == (Object)null)
					{
						return false;
					}
					<elapsed>5__2 += Time.deltaTime;
					<remainingTime>5__3 = <waitTime>5__1 - <elapsed>5__2;
					door.doorTrigger.hoverTip = $"Locking in {Mathf.CeilToInt(<remainingTime>5__3)}s";
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				StopPicking(__instance, door);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPatch(typeof(LockPicker), "ItemActivate")]
		[HarmonyPostfix]
		public static void ItemActivatePostfix(LockPicker __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.Relock.Value)
			{
				return;
			}
			FieldInfo field = typeof(LockPicker).GetField("hit", BindingFlags.Instance | BindingFlags.NonPublic);
			RaycastHit val = (RaycastHit)field.GetValue(__instance);
			if (!((Object)(object)((GrabbableObject)__instance).playerHeldBy == (Object)null) && !((Object)(object)((RaycastHit)(ref val)).transform == (Object)null))
			{
				DoorLock component = ((Component)((RaycastHit)(ref val)).transform).GetComponent<DoorLock>();
				if (!((Object)(object)component == (Object)null) && !component.isLocked)
				{
					Networker.Instance.LockDoorServerRpc(((NetworkBehaviour)__instance).NetworkObject.NetworkObjectId, ((NetworkBehaviour)component).NetworkObject.NetworkObjectId);
				}
			}
		}

		public static void startLocking(LockPicker __instance, DoorLock door)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			Transform parent = ((Vector3.Distance(door.lockPickerPosition.position, ((Component)__instance).transform.position) < Vector3.Distance(door.lockPickerPosition2.position, ((Component)__instance).transform.position)) ? door.lockPickerPosition : door.lockPickerPosition2);
			if ((Object)(object)((GrabbableObject)__instance).playerHeldBy != (Object)null)
			{
				((GrabbableObject)__instance).playerHeldBy.DiscardHeldObject(true, ((NetworkBehaviour)door).NetworkObject, Vector3.zero, false);
				((Component)__instance).transform.SetParent(parent);
			}
			__instance.lockPickerAudio.PlayOneShot(__instance.finishPickingLockClips[Random.Range(0, __instance.finishPickingLockClips.Length)]);
			__instance.armsAnimator.SetBool("mounted", true);
			__instance.armsAnimator.SetBool("picking", true);
			__instance.currentlyPickingDoor = door;
			((GrabbableObject)__instance).grabbable = false;
			((GrabbableObject)__instance).grabbableToEnemies = false;
			((MonoBehaviour)Networker.Instance).StartCoroutine(LockWait(__instance, door));
		}

		[IteratorStateMachine(typeof(<LockWait>d__2))]
		private static IEnumerator LockWait(LockPicker __instance, DoorLock door)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LockWait>d__2(0)
			{
				__instance = __instance,
				door = door
			};
		}

		public static void StopPicking(LockPicker __instance, DoorLock door)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			Plugin.CustomLogger.LogWarning((object)"StopPicking");
			__instance.lockPickerAudio.PlayOneShot(__instance.finishPickingLockClips[Random.Range(0, __instance.finishPickingLockClips.Length)]);
			__instance.armsAnimator.SetBool("mounted", false);
			__instance.armsAnimator.SetBool("picking", false);
			((GrabbableObject)__instance).grabbable = true;
			((GrabbableObject)__instance).grabbableToEnemies = true;
			__instance.currentlyPickingDoor = null;
			((Component)__instance).transform.SetParent((Transform)null);
			((GrabbableObject)__instance).startFallingPosition = ((Component)__instance).transform.position;
			((GrabbableObject)__instance).FallToGround(false, false, default(Vector3));
			door.LockDoor(30f);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void InstantiateNetworker(StartOfRound __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(Plugin.NetworkerPrefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(true);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace ConfigurableLockpicker.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}