using System;
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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("RoR2LocalCoop")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RoR2LocalCoop")]
[assembly: AssemblyTitle("RoR2LocalCoop")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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 RoR2LocalCoop
{
	[BepInPlugin("com.splitux.ror2localcoop", "RoR2LocalCoop", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.splitux.ror2localcoop";

		public const string PluginName = "RoR2LocalCoop";

		public const string PluginVersion = "1.0.0";

		internal static ManualLogSource Log;

		private Harmony _harmony;

		internal static HashSet<ulong> AllowedSteamIds;

		static Plugin()
		{
			AllowedSteamIds = new HashSet<ulong>();
			for (ulong num = 1uL; num <= 10; num++)
			{
				AllowedSteamIds.Add(76561198000000000L + num);
			}
		}

		private void Awake()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"RoR2LocalCoop v1.0.0 loading...");
			_harmony = new Harmony("com.splitux.ror2localcoop");
			try
			{
				ApplyPatches();
				Log.LogInfo((object)"RoR2LocalCoop loaded successfully!");
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to apply patches: {arg}");
			}
		}

		private void ApplyPatches()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Expected O, but got Unknown
			Type type = FindType("RoR2.Networking.ServerAuthManager");
			if (type != null)
			{
				Log.LogInfo((object)("Found ServerAuthManager: " + type.FullName));
				MethodInfo method = type.GetMethod("FindConnectionForSteamID", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (method != null)
				{
					MethodInfo method2 = typeof(NetworkPatches).GetMethod("FindConnectionForSteamID_Postfix", BindingFlags.Static | BindingFlags.Public);
					_harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Log.LogInfo((object)("Patched FindConnectionForSteamID: " + method.DeclaringType.Name + "." + method.Name));
				}
				else
				{
					Log.LogWarning((object)"FindConnectionForSteamID not found in ServerAuthManager");
					ListMethods(type, "Find");
				}
			}
			else
			{
				Log.LogWarning((object)"ServerAuthManager not found");
			}
			Type type2 = FindType("RoR2.Networking.NetworkManagerSystemSteam");
			if (type2 != null)
			{
				Log.LogInfo((object)("Found NetworkManagerSystemSteam: " + type2.FullName));
				MethodInfo method3 = type2.GetMethod("OnSteamServerP2PIncomingConnection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method3 != null)
				{
					MethodInfo method4 = typeof(NetworkPatches).GetMethod("OnSteamServerP2PIncomingConnection_Postfix", BindingFlags.Static | BindingFlags.Public);
					_harmony.Patch((MethodBase)method3, (HarmonyMethod)null, new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Log.LogInfo((object)"Patched OnSteamServerP2PIncomingConnection");
				}
				else
				{
					Log.LogWarning((object)"OnSteamServerP2PIncomingConnection not found");
				}
				MethodInfo method5 = type2.GetMethod("OnSteamClientP2PIncomingConnection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method5 != null)
				{
					MethodInfo method6 = typeof(NetworkPatches).GetMethod("OnSteamClientP2PIncomingConnection_Postfix", BindingFlags.Static | BindingFlags.Public);
					_harmony.Patch((MethodBase)method5, (HarmonyMethod)null, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Log.LogInfo((object)"Patched OnSteamClientP2PIncomingConnection");
				}
				MethodInfo method7 = type2.GetMethod("OnSteamServerP2PData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method7 != null)
				{
					MethodInfo method8 = typeof(NetworkPatches).GetMethod("OnSteamServerP2PData_Prefix", BindingFlags.Static | BindingFlags.Public);
					_harmony.Patch((MethodBase)method7, new HarmonyMethod(method8), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Log.LogInfo((object)"Patched OnSteamServerP2PData");
				}
				else
				{
					Log.LogWarning((object)"OnSteamServerP2PData not found");
				}
				MethodInfo method9 = type2.GetMethod("OnP2PData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method9 != null)
				{
					MethodInfo method10 = typeof(NetworkPatches).GetMethod("OnP2PData_Prefix", BindingFlags.Static | BindingFlags.Public);
					_harmony.Patch((MethodBase)method9, new HarmonyMethod(method10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Log.LogInfo((object)"Patched OnP2PData");
				}
			}
			else
			{
				Log.LogWarning((object)"NetworkManagerSystemSteam not found");
			}
		}

		private void ListMethods(Type type, string filter)
		{
			Log.LogDebug((object)("Methods in " + type.Name + " containing '" + filter + "':"));
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name.Contains(filter))
				{
					string text = string.Join(", ", Array.ConvertAll(methodInfo.GetParameters(), (ParameterInfo p) => p.ParameterType.Name + " " + p.Name));
					Log.LogDebug((object)("  " + methodInfo.Name + "(" + text + ") -> " + methodInfo.ReturnType.Name));
				}
			}
		}

		public static void AllowSteamId(ulong steamId)
		{
			if (AllowedSteamIds.Add(steamId))
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"Allowing Steam ID: {steamId}");
				}
			}
		}

		internal static Type FindType(string typeName)
		{
			bool flag = typeName.Contains(".");
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type type = assembly.GetType(typeName, throwOnError: false, ignoreCase: true);
					if (type != null)
					{
						return type;
					}
					if (flag)
					{
						continue;
					}
					Type[] types = assembly.GetTypes();
					foreach (Type type2 in types)
					{
						if (type2.Name == typeName)
						{
							return type2;
						}
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class NetworkPatches
	{
		private static HashSet<ulong> _connectionAttempted = new HashSet<ulong>();

		private static Type _platformIdType;

		private static ConstructorInfo _platformIdCtor;

		private static bool _platformIdTypeInitialized;

		private static object CreatePlatformId(ulong steamId)
		{
			if (!_platformIdTypeInitialized)
			{
				_platformIdTypeInitialized = true;
				_platformIdType = Plugin.FindType("RoR2.PlatformID");
				if (_platformIdType != null)
				{
					ConstructorInfo[] constructors = _platformIdType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (ConstructorInfo constructorInfo in constructors)
					{
						ParameterInfo[] parameters = constructorInfo.GetParameters();
						if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ulong))
						{
							_platformIdCtor = constructorInfo;
							ManualLogSource log = Plugin.Log;
							if (log != null)
							{
								log.LogInfo((object)"Found PlatformID(ulong) constructor");
							}
							break;
						}
					}
					if (_platformIdCtor == null)
					{
						ManualLogSource log2 = Plugin.Log;
						if (log2 != null)
						{
							log2.LogWarning((object)"PlatformID(ulong) constructor not found, will use field injection");
						}
					}
				}
				else
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogError((object)"Could not find RoR2.PlatformID type");
					}
				}
			}
			if (_platformIdType == null)
			{
				return null;
			}
			if (_platformIdCtor != null)
			{
				try
				{
					object result = _platformIdCtor.Invoke(new object[1] { steamId });
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogDebug((object)$"Created PlatformID via constructor for {steamId}");
					}
					return result;
				}
				catch (Exception ex)
				{
					ManualLogSource log5 = Plugin.Log;
					if (log5 != null)
					{
						log5.LogWarning((object)("Constructor failed: " + ex.Message + ", falling back to fields"));
					}
				}
			}
			object obj = Activator.CreateInstance(_platformIdType);
			FieldInfo field = _platformIdType.GetField("ID", BindingFlags.Instance | BindingFlags.Public);
			FieldInfo field2 = _platformIdType.GetField("ID2", BindingFlags.Instance | BindingFlags.Public);
			FieldInfo field3 = _platformIdType.GetField("stringID", BindingFlags.Instance | BindingFlags.Public);
			if (field != null)
			{
				field.SetValue(obj, steamId);
				ManualLogSource log6 = Plugin.Log;
				if (log6 != null)
				{
					log6.LogDebug((object)$"Set ID field to {steamId}");
				}
			}
			if (field2 != null)
			{
				field2.SetValue(obj, steamId);
				ManualLogSource log7 = Plugin.Log;
				if (log7 != null)
				{
					log7.LogDebug((object)$"Set ID2 field to {steamId}");
				}
			}
			if (field3 != null)
			{
				field3.SetValue(obj, string.Empty);
			}
			ManualLogSource log8 = Plugin.Log;
			if (log8 != null)
			{
				log8.LogDebug((object)$"Created PlatformID via fields for {steamId}, type is {obj?.GetType().FullName}");
			}
			return obj;
		}

		private static object GetSteamworksInstance(object networkManager)
		{
			Type type = networkManager.GetType();
			object obj = type.GetField("serverSteamworks", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(networkManager);
			if (obj != null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)"Got steamworks from serverSteamworks field");
				}
				return obj;
			}
			Type type2 = Plugin.FindType("Facepunch.Steamworks.Server");
			if (type2 != null)
			{
				obj = type2.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj != null)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogDebug((object)"Got steamworks from Server.Instance");
					}
					return obj;
				}
			}
			Type type3 = Plugin.FindType("Facepunch.Steamworks.Client");
			if (type3 != null)
			{
				obj = type3.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj != null)
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogDebug((object)"Got steamworks from Client.Instance");
					}
					return obj;
				}
			}
			ManualLogSource log4 = Plugin.Log;
			if (log4 != null)
			{
				log4.LogWarning((object)"Could not get any steamworks instance");
			}
			return null;
		}

		private static void CreateConnectionForSteamId(ulong steamId, object networkManager)
		{
			if (_connectionAttempted.Contains(steamId))
			{
				return;
			}
			_connectionAttempted.Add(steamId);
			try
			{
				object steamworksInstance = GetSteamworksInstance(networkManager);
				if (steamworksInstance == null)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogError((object)"Cannot create connection: no steamworks instance");
					}
					return;
				}
				object obj = CreatePlatformId(steamId);
				if (obj == null)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogError((object)"Cannot create connection: failed to create PlatformID");
					}
					return;
				}
				MethodInfo method = networkManager.GetType().GetMethod("CreateServerP2PConnectionWithPeer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null)
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogWarning((object)"CreateServerP2PConnectionWithPeer method not found");
					}
					return;
				}
				method.Invoke(networkManager, new object[2] { steamworksInstance, obj });
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogInfo((object)$"Created server P2P connection for {steamId}");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log5 = Plugin.Log;
				if (log5 != null)
				{
					log5.LogError((object)$"Error creating connection for {steamId}: {arg}");
				}
			}
		}

		public static void FindConnectionForSteamID_Postfix(object steamId, ref object __result)
		{
			if (__result != null)
			{
				return;
			}
			ulong num = ExtractSteamId(steamId);
			if (num == 0)
			{
				return;
			}
			Plugin.AllowSteamId(num);
			if (Plugin.AllowedSteamIds.Contains(num))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"FindConnectionForSteamID: No connection for allowed ID {num}");
				}
			}
		}

		public static void OnSteamServerP2PIncomingConnection_Postfix(ulong senderSteamId, ref bool __result, object __instance)
		{
			Plugin.AllowSteamId(senderSteamId);
			if (!__result && Plugin.AllowedSteamIds.Contains(senderSteamId))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Force-accepting P2P server connection from {senderSteamId}");
				}
				__result = true;
				CreateConnectionForSteamId(senderSteamId, __instance);
			}
		}

		public static void OnSteamClientP2PIncomingConnection_Postfix(ulong senderSteamId, ref bool __result, object __instance)
		{
			Plugin.AllowSteamId(senderSteamId);
			if (!__result && Plugin.AllowedSteamIds.Contains(senderSteamId))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Force-accepting P2P client connection from {senderSteamId}");
				}
				__result = true;
				CreateConnectionForSteamId(senderSteamId, __instance);
			}
		}

		public static void OnSteamServerP2PData_Prefix(ulong senderSteamId, object __instance)
		{
			Plugin.AllowSteamId(senderSteamId);
			CreateConnectionForSteamId(senderSteamId, __instance);
		}

		public static void OnP2PData_Prefix(object senderSteamId)
		{
			ulong num = ExtractSteamId(senderSteamId);
			if (num != 0)
			{
				Plugin.AllowSteamId(num);
			}
		}

		private static ulong ExtractSteamId(object steamIdObj)
		{
			if (steamIdObj == null)
			{
				return 0uL;
			}
			try
			{
				if (steamIdObj is ulong result)
				{
					return result;
				}
				Type type = steamIdObj.GetType();
				FieldInfo field = type.GetField("ID", BindingFlags.Instance | BindingFlags.Public);
				if (field != null && field.GetValue(steamIdObj) is ulong num && num != 0)
				{
					return num;
				}
				FieldInfo field2 = type.GetField("Value");
				if (field2 != null)
				{
					return (ulong)field2.GetValue(steamIdObj);
				}
				PropertyInfo property = type.GetProperty("Value");
				if (property != null)
				{
					return (ulong)property.GetValue(steamIdObj);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Could not extract Steam ID: " + ex.Message));
				}
			}
			return 0uL;
		}
	}
}