using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("UnityHotReload")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+bcfa4c369b6149b8781209a4d6a848e88aad5aca")]
[assembly: AssemblyProduct("UnityHotReload")]
[assembly: AssemblyTitle("UnityHotReload")]
[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 UnityHotReloadNS
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public static class UnityHotReload
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__GatherOriginalReferences;

			public static Manipulator <1>__GatherInstructionsFromNewMethodAndMakeThemReferenceOriginalAssembly;
		}

		private const BindingFlags allFlags = (BindingFlags)(-1);

		internal static int CompilationCount = 0;

		private static List<ILHook> _activeILHooks = new List<ILHook>();

		private static Assembly OriginalAss = null;

		private static Dictionary<string, TypeReference> OriginalAssTypeRefs = new Dictionary<string, TypeReference>();

		private static Dictionary<string, MethodReference> OriginalAssMethodRefs = new Dictionary<string, MethodReference>();

		private static Dictionary<string, FieldReference> OriginalAssFieldRefs = new Dictionary<string, FieldReference>();

		private static Dictionary<string, CallSite> OriginalAssCallSites = new Dictionary<string, CallSite>();

		public static void LoadNewAssemblyVersion(Assembly originalAss, string pathOfTheNewAssembly)
		{
			LoadNewAssemblyVersionInternal(originalAss, pathOfTheNewAssembly);
		}

		private static void LoadNewAssemblyVersionInternal(Assembly originalAss, string path)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			OriginalAss = originalAss;
			DefaultAssemblyResolver val = new DefaultAssemblyResolver();
			((BaseAssemblyResolver)val).AddSearchDirectory(Paths.ManagedPath);
			((BaseAssemblyResolver)val).AddSearchDirectory(Paths.BepInExAssemblyDirectory);
			Log.Debug(path);
			AssemblyDefinition val2 = AssemblyDefinition.ReadAssembly(path, new ReaderParameters
			{
				AssemblyResolver = (IAssemblyResolver)(object)val,
				ReadSymbols = true
			});
			try
			{
				((AssemblyNameReference)val2.Name).Name = $"{originalAss.GetName().Name}_HotReload_{++CompilationCount}";
				Assembly assembly;
				using (MemoryStream memoryStream = new MemoryStream())
				{
					val2.Write((Stream)memoryStream);
					assembly = Assembly.Load(memoryStream.ToArray());
				}
				Log.Debug("originalAss: " + originalAss.GetName().Name);
				Log.Debug("newAss: " + assembly.GetName().Name);
				foreach (Type item in GetTypesSafe(assembly))
				{
					MethodInfo[] methods = item.GetMethods((BindingFlags)(-1));
					foreach (MethodInfo method in methods)
					{
						Type type = originalAss.GetType(item.FullName);
						MethodInfo methodInfo = GetMethodResolveAmbiguous(method, type);
						if (methodInfo == null)
						{
							methodInfo = method;
						}
						try
						{
							List<ILHook> activeILHooks = _activeILHooks;
							MethodInfo methodInfo2 = methodInfo;
							object obj = <>O.<0>__GatherOriginalReferences;
							if (obj == null)
							{
								Manipulator val3 = GatherOriginalReferences;
								<>O.<0>__GatherOriginalReferences = val3;
								obj = (object)val3;
							}
							activeILHooks.Add(new ILHook((MethodBase)methodInfo2, (Manipulator)obj));
							List<ILHook> activeILHooks2 = _activeILHooks;
							MethodInfo methodInfo3 = method;
							object obj2 = <>O.<1>__GatherInstructionsFromNewMethodAndMakeThemReferenceOriginalAssembly;
							if (obj2 == null)
							{
								Manipulator val4 = GatherInstructionsFromNewMethodAndMakeThemReferenceOriginalAssembly;
								<>O.<1>__GatherInstructionsFromNewMethodAndMakeThemReferenceOriginalAssembly = val4;
								obj2 = (object)val4;
							}
							activeILHooks2.Add(new ILHook((MethodBase)methodInfo3, (Manipulator)obj2));
							if (!(methodInfo != method))
							{
								continue;
							}
							_activeILHooks.Add(new ILHook((MethodBase)methodInfo, (Manipulator)delegate(ILContext il)
							{
								//IL_0001: Unknown result type (might be due to invalid IL or missing references)
								//IL_0007: Expected O, but got Unknown
								//IL_000c: 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_0042: Unknown result type (might be due to invalid IL or missing references)
								ILCursor val5 = new ILCursor(il);
								for (int j = 0; j < ((MethodReference)il.Method).Parameters.Count; j++)
								{
									val5.Emit(OpCodes.Ldarg, j);
								}
								val5.Emit(OpCodes.Call, (MethodBase)method);
								val5.Emit(OpCodes.Ret);
							}));
						}
						catch (Exception arg)
						{
							Log.Error($"Failed to hot reload method: {item.FullName}.{method.Name}\n{arg}");
						}
					}
				}
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}

		private static MethodInfo GetMethodResolveAmbiguous(MethodReference methodRef, Type originalType)
		{
			List<MethodInfo> list = (from m in originalType.GetMethods((BindingFlags)(-1))
				where m.Name == ((MemberReference)methodRef).Name
				select m).ToList();
			if (list.Count == 1)
			{
				return list[0];
			}
			if (list.Count > 1)
			{
				foreach (MethodInfo item in list)
				{
					ParameterInfo[] parameters = item.GetParameters();
					Collection<ParameterDefinition> parameters2 = methodRef.Parameters;
					if (parameters.Length != parameters2.Count)
					{
						continue;
					}
					bool flag = true;
					for (int i = 0; i < parameters.Length; i++)
					{
						if (parameters[i].ParameterType.FullName != ((MemberReference)((ParameterReference)parameters2[i]).ParameterType).FullName)
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						Log.Debug("Resolved ambiguous method: " + originalType.FullName + "." + ((MemberReference)methodRef).Name);
						return item;
					}
				}
			}
			return null;
		}

		private static MethodInfo GetMethodResolveAmbiguous(MethodInfo method, Type originalType)
		{
			List<MethodInfo> list = (from m in originalType.GetMethods((BindingFlags)(-1))
				where m.Name == method.Name
				select m).ToList();
			if (list.Count == 1)
			{
				return list[0];
			}
			if (list.Count > 1)
			{
				foreach (MethodInfo item in list)
				{
					ParameterInfo[] parameters = item.GetParameters();
					ParameterInfo[] parameters2 = method.GetParameters();
					if (parameters.Length != parameters2.Length)
					{
						continue;
					}
					bool flag = true;
					for (int i = 0; i < parameters.Length; i++)
					{
						if (parameters[i].ParameterType.ToString() != parameters2[i].ParameterType.ToString())
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						Log.Debug("Resolved ambiguous method: " + originalType.FullName + "." + method.Name);
						return item;
					}
				}
			}
			return null;
		}

		private static IEnumerable<Type> GetTypesSafe(Assembly ass)
		{
			try
			{
				return ass.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("\r\n-- LoaderExceptions --");
				Exception[] loaderExceptions = ex.LoaderExceptions;
				foreach (Exception ex2 in loaderExceptions)
				{
					stringBuilder.AppendLine(ex2.ToString());
				}
				stringBuilder.AppendLine("\r\n-- StackTrace --");
				stringBuilder.AppendLine(ex.StackTrace);
				Log.Error(stringBuilder.ToString());
				return ex.Types.Where((Type x) => x != null);
			}
		}

		private static void GatherOriginalReferences(ILContext il)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Instruction> enumerator = il.Instrs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					object operand = current.Operand;
					TypeReference val = (TypeReference)((operand is TypeReference) ? operand : null);
					if (val != null)
					{
						if (!OriginalAssTypeRefs.ContainsKey(((MemberReference)val).FullName))
						{
							OriginalAssTypeRefs.Add(((MemberReference)val).FullName, val);
						}
						continue;
					}
					object operand2 = current.Operand;
					MethodReference val2 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
					if (val2 != null)
					{
						if (!OriginalAssMethodRefs.ContainsKey(((MemberReference)val2).FullName))
						{
							OriginalAssMethodRefs.Add(((MemberReference)val2).FullName, val2);
						}
						continue;
					}
					object operand3 = current.Operand;
					FieldReference val3 = (FieldReference)((operand3 is FieldReference) ? operand3 : null);
					if (val3 != null)
					{
						if (!OriginalAssFieldRefs.ContainsKey(((MemberReference)val3).FullName))
						{
							OriginalAssFieldRefs.Add(((MemberReference)val3).FullName, val3);
						}
						continue;
					}
					object operand4 = current.Operand;
					CallSite val4 = (CallSite)((operand4 is CallSite) ? operand4 : null);
					if (val4 != null && !OriginalAssCallSites.ContainsKey(val4.FullName))
					{
						OriginalAssCallSites.Add(val4.FullName, val4);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		private static void GatherInstructionsFromNewMethodAndMakeThemReferenceOriginalAssembly(ILContext il)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Instruction> enumerator = il.Instrs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					object operand = current.Operand;
					object operand2 = current.Operand;
					TypeReference val = (TypeReference)((operand2 is TypeReference) ? operand2 : null);
					if (val != null)
					{
						if (!OriginalAssTypeRefs.ContainsKey(((MemberReference)val).FullName))
						{
							Type type = OriginalAss.GetType(((MemberReference)val).FullName);
							if (type != null)
							{
								Log.Debug("Adding missing type ref: " + ((MemberReference)val).FullName + " / " + ((ModuleReference)((MemberReference)il.Method).Module).Name);
								OriginalAssTypeRefs.Add(((MemberReference)val).FullName, il.Import(type));
							}
						}
						if (OriginalAssTypeRefs.TryGetValue(((MemberReference)val).FullName, out var value))
						{
							operand = value;
						}
					}
					else
					{
						object operand3 = current.Operand;
						MethodReference val2 = (MethodReference)((operand3 is MethodReference) ? operand3 : null);
						if (val2 != null)
						{
							if (!OriginalAssMethodRefs.ContainsKey(((MemberReference)val2).FullName))
							{
								Type type2 = OriginalAss.GetType(((MemberReference)((MemberReference)val2).DeclaringType).FullName);
								if (type2 != null)
								{
									MethodInfo methodResolveAmbiguous = GetMethodResolveAmbiguous(val2, type2);
									if (methodResolveAmbiguous != null)
									{
										Log.Debug("Adding missing method ref: " + ((MemberReference)val2).FullName + " / " + ((ModuleReference)((MemberReference)il.Method).Module).Name);
										OriginalAssMethodRefs.Add(((MemberReference)val2).FullName, il.Import((MethodBase)methodResolveAmbiguous));
									}
								}
							}
							if (OriginalAssMethodRefs.TryGetValue(((MemberReference)val2).FullName, out var value2))
							{
								operand = value2;
							}
						}
						else
						{
							object operand4 = current.Operand;
							FieldReference val3 = (FieldReference)((operand4 is FieldReference) ? operand4 : null);
							if (val3 != null)
							{
								if (!OriginalAssFieldRefs.ContainsKey(((MemberReference)val3).FullName))
								{
									FieldInfo fieldInfo = OriginalAss.GetType(((MemberReference)((MemberReference)val3).DeclaringType).FullName)?.GetField(((MemberReference)val3).Name, (BindingFlags)(-1));
									if (fieldInfo != null)
									{
										Log.Debug("Adding missing field ref: " + ((MemberReference)val3).FullName + " / " + ((ModuleReference)((MemberReference)il.Method).Module).Name);
										OriginalAssFieldRefs.Add(((MemberReference)val3).FullName, il.Import(fieldInfo));
									}
								}
								if (OriginalAssFieldRefs.TryGetValue(((MemberReference)val3).FullName, out var value3))
								{
									operand = value3;
								}
							}
							else
							{
								object operand5 = current.Operand;
								CallSite val4 = (CallSite)((operand5 is CallSite) ? operand5 : null);
								if (val4 != null && OriginalAssCallSites.TryGetValue(val4.FullName, out var value4))
								{
									operand = value4;
								}
							}
						}
					}
					current.Operand = operand;
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}
	}
	[BepInPlugin("iDeathHD.UnityHotReload", "UnityHotReload", "1.0.1")]
	public class UnityHotReloadPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "iDeathHD.UnityHotReload";

		public const string PluginAuthor = "iDeathHD";

		public const string PluginName = "UnityHotReload";

		public const string PluginVersion = "1.0.1";

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
		}
	}
}