using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using InverseTeleporterToPlayer.Properties;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
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("InverseTeleporterToPlayer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A mod for Lethal Company, that changes inverse teleporter to teleport players to another player")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+16dcba073931d09211fc56de80e19b8169edd5f1")]
[assembly: AssemblyProduct("InverseTeleporterToPlayer")]
[assembly: AssemblyTitle("InverseTeleporterToPlayer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
	static <Module>()
	{
	}
}
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 InverseTeleporterToPlayer
{
	[BepInPlugin("InverseTeleporterToPlayer", "InverseTeleporterToPlayer", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin Instance { get; private set; }

		public Harmony Patcher { get; private set; }

		public AssetBundle MainAssetBundle { get; private set; }

		public ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Patcher = new Harmony("InverseTeleporterToPlayer");
			Patcher.PatchAll();
			MainAssetBundle = AssetBundle.LoadFromMemory(Resources.brazil);
			Log = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"{MainAssetBundle}");
			NetcodeWeaver();
		}

		private static void NetcodeWeaver()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				MethodInfo[] methods = types[i].GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "InverseTeleporterToPlayer";

		public const string PLUGIN_NAME = "InverseTeleporterToPlayer";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace InverseTeleporterToPlayer.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("InverseTeleporterToPlayer.Properties.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] brazil => (byte[])ResourceManager.GetObject("brazil", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace InverseTeleporterToPlayer.Patches
{
	[HarmonyPatch]
	internal class InverseTeleporterToPlayerPatch
	{
		private struct LocationData
		{
			public bool isInElevator;

			public bool isInHangarShipRoom;

			public bool isInsideFactory;
		}

		[HarmonyPatch]
		public class BrazilNetworkManager
		{
			public static GameObject brazilNetworkPrefab;

			[HarmonyPostfix]
			[HarmonyPatch(typeof(GameNetworkManager), "Start")]
			public static void Init()
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected O, but got Unknown
				if (!((Object)(object)brazilNetworkPrefab != (Object)null))
				{
					brazilNetworkPrefab = (GameObject)Plugin.Instance.MainAssetBundle.LoadAsset("BrazilTransmiterNetworkHandler");
					brazilNetworkPrefab.AddComponent<BrazilTransmiterNetworkHandler>();
					NetworkManager.Singleton.AddNetworkPrefab(brazilNetworkPrefab);
				}
			}

			[HarmonyPostfix]
			[HarmonyPatch(typeof(StartOfRound), "Awake")]
			private static void SpawnNetworkHandler()
			{
				//IL_001d: 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)
				if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
				{
					Object.Instantiate<GameObject>(brazilNetworkPrefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>().Spawn(false);
				}
			}
		}

		private class BrazilTransmiterNetworkHandler : NetworkBehaviour
		{
			[ServerRpc(RequireOwnership = false)]
			public void BrazilTransmissionServerRPC(int clientId)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: 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_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: 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(2303024269u, val, (RpcDelivery)0);
						BytePacker.WriteValueBitPacked(val2, clientId);
						((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2303024269u, val, (RpcDelivery)0);
					}
					if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
					{
						ClientRpcParams val3 = default(ClientRpcParams);
						val3.Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { (ulong)clientId }
						};
						ClientRpcParams clientRpcParams = val3;
						BrazilTransmissionClientRpc(clientRpcParams);
					}
				}
			}

			[ClientRpc]
			public void BrazilTransmissionClientRpc(ClientRpcParams clientRpcParams = default(ClientRpcParams))
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: 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_007c: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
					{
						FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4080983649u, clientRpcParams, (RpcDelivery)0);
						((NetworkBehaviour)this).__endSendClientRpc(ref val, 4080983649u, clientRpcParams, (RpcDelivery)0);
					}
					if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
					{
						((MonoBehaviour)HUDManager.Instance).StartCoroutine(BrazilTransmissionClient());
					}
				}
			}

			private IEnumerator BrazilTransmissionClient()
			{
				HUDManager.Instance.signalTranslatorAnimator.SetBool("transmitting", true);
				((TMP_Text)HUDManager.Instance.signalTranslatorText).text = "Welcome to Brazil";
				yield return (object)new WaitForSeconds(3f);
				HUDManager.Instance.signalTranslatorAnimator.SetBool("transmitting", false);
			}

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

			[RuntimeInitializeOnLoadMethod]
			internal static void InitializeRPCS_BrazilTransmiterNetworkHandler()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				NetworkManager.__rpc_func_table.Add(2303024269u, new RpcReceiveHandler(__rpc_handler_2303024269));
				NetworkManager.__rpc_func_table.Add(4080983649u, new RpcReceiveHandler(__rpc_handler_4080983649));
			}

			private static void __rpc_handler_2303024269(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					int clientId = default(int);
					ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((BrazilTransmiterNetworkHandler)(object)target).BrazilTransmissionServerRPC(clientId);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_4080983649(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_0023: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: 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)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ClientRpcParams client = rpcParams.Client;
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((BrazilTransmiterNetworkHandler)(object)target).BrazilTransmissionClientRpc(client);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			protected internal override string __getTypeName()
			{
				return "BrazilTransmiterNetworkHandler";
			}
		}

		private static readonly MethodInfo TeleportPlayerOutWithInverseTeleporter = typeof(ShipTeleporter).GetMethod("TeleportPlayerOutWithInverseTeleporter", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly Vector3 BrazilPosition = new Vector3(9.33f, 5.2f, 1021f);

		private static HashSet<int> playersToBeTeleported = new HashSet<int>();

		private static Dictionary<ulong, LocationData> dropableObjectDroppedData = new Dictionary<ulong, LocationData>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ShipTeleporter), "TeleportPlayerOutWithInverseTeleporter")]
		public static bool TeleportToPlayer(int playerObj, ref Vector3 teleportPos, ShipTeleporter __instance)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (playersToBeTeleported.Contains(playerObj))
			{
				playersToBeTeleported.Remove(playerObj);
				return true;
			}
			int targetTransformIndex = StartOfRound.Instance.mapScreen.targetTransformIndex;
			if (targetTransformIndex < 0 || targetTransformIndex >= StartOfRound.Instance.mapScreen.radarTargets.Count)
			{
				Plugin.Instance.Log.LogWarning((object)$"Invalid target index {targetTransformIndex} for inverse teleporter target");
				return false;
			}
			TransformAndName obj = StartOfRound.Instance.mapScreen.radarTargets[targetTransformIndex];
			string name = obj.name;
			Vector3 targetPosition = obj.transform.position;
			LocationData? locationData = GetValidLocationData(obj, name, ref targetPosition);
			if (!locationData.HasValue || Vector3.Distance(BrazilPosition, targetPosition) < 25f)
			{
				Plugin.Instance.Log.LogInfo((object)"Brazil");
				BrazilTransmiterNetworkHandler brazilTransmiterNetworkHandler = Object.FindObjectOfType<BrazilTransmiterNetworkHandler>();
				if (Object.op_Implicit((Object)(object)brazilTransmiterNetworkHandler))
				{
					brazilTransmiterNetworkHandler.BrazilTransmissionServerRPC(playerObj);
				}
				locationData = new LocationData
				{
					isInElevator = true,
					isInHangarShipRoom = true,
					isInsideFactory = true
				};
				targetPosition = BrazilPosition;
			}
			playersToBeTeleported.Add(playerObj);
			Plugin.Instance.Log.LogDebug((object)$"Setting inverse teleporter target to {name} at position {targetPosition}");
			TeleportPlayerOutWithInverseTeleporter.Invoke(__instance, new object[2] { playerObj, targetPosition });
			PlayerControllerB obj2 = StartOfRound.Instance.allPlayerScripts[playerObj];
			obj2.isInElevator = locationData.Value.isInElevator;
			obj2.isInHangarShipRoom = locationData.Value.isInHangarShipRoom;
			obj2.isInsideFactory = locationData.Value.isInsideFactory;
			return false;
		}

		private static LocationData? GetValidLocationData(TransformAndName target, string targetName, ref Vector3 targetPosition)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			LocationData value;
			if (target.isNonPlayer)
			{
				GrabbableObject component = ((Component)target.transform).GetComponent<GrabbableObject>();
				if (Object.op_Implicit((Object)(object)component.playerHeldBy))
				{
					LocationData locationData = default(LocationData);
					locationData.isInElevator = component.playerHeldBy.isInElevator;
					locationData.isInHangarShipRoom = component.playerHeldBy.isInHangarShipRoom;
					locationData.isInsideFactory = component.playerHeldBy.isInsideFactory;
					value = locationData;
				}
				else
				{
					if (!dropableObjectDroppedData.ContainsKey(((NetworkBehaviour)component).OwnerClientId))
					{
						Plugin.Instance.Log.LogWarning((object)("Not handled non-player target " + targetName + " for inverse teleporter target"));
						return null;
					}
					value = dropableObjectDroppedData[((NetworkBehaviour)component).OwnerClientId];
				}
			}
			else
			{
				PlayerControllerB targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
				if (!((Behaviour)targetedPlayer).isActiveAndEnabled || !StartOfRound.Instance.allPlayerScripts.Contains(targetedPlayer))
				{
					Plugin.Instance.Log.LogWarning((object)("Invalid player target " + targetName + " for inverse teleporter target"));
					return null;
				}
				LocationData locationData = default(LocationData);
				locationData.isInElevator = targetedPlayer.isInElevator;
				locationData.isInHangarShipRoom = targetedPlayer.isInHangarShipRoom;
				locationData.isInsideFactory = targetedPlayer.isInsideFactory;
				value = locationData;
				if (targetedPlayer.isPlayerDead)
				{
					targetPosition = ((Component)targetedPlayer.deadBody).transform.position;
				}
			}
			return value;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GrabbableObject), "DiscardItem")]
		public static bool StoreDroppedItemLocation(GrabbableObject __instance)
		{
			PlayerControllerB playerHeldBy = __instance.playerHeldBy;
			if (Object.op_Implicit((Object)(object)playerHeldBy))
			{
				dropableObjectDroppedData[((NetworkBehaviour)__instance).OwnerClientId] = new LocationData
				{
					isInElevator = playerHeldBy.isInElevator,
					isInHangarShipRoom = playerHeldBy.isInHangarShipRoom,
					isInsideFactory = playerHeldBy.isInsideFactory
				};
			}
			return true;
		}
	}
}