using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using MelonLoader;
using MelonLoader.Utils;
using Mono.Cecil;
using Mono.Collections.Generic;
using Newtonsoft.Json;
using OverTheCounter.Loader;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(LoaderPlugin), "OTC Loader", "1.0.5", "hdlmrell", null)]
[assembly: MelonColor(100, 200, 180, 255)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace OverTheCounter.Loader;

internal enum Branch
{
	Mono,
	Il2Cpp
}
[Serializable]
internal class LoaderConfig
{
	public string[] Whitelist = Array.Empty<string>();
}
public class LoaderPlugin : MelonPlugin
{
	private const string DisabledExt = ".off";

	private const string ConfigFileName = "OTCLoader.config.json";

	private static readonly string[] BuiltinBlacklist = new string[2] { "OverTheCounter-Loader.dll", "SwapperPlugin.dll" };

	private const uint MB_OKCANCEL = 1u;

	private const uint MB_YESNO = 4u;

	private const uint MB_ICONQUESTION = 32u;

	private const uint MB_ICONWARNING = 48u;

	private const uint MB_ICONINFORMATION = 64u;

	private const int IDOK = 1;

	private const int IDCANCEL = 2;

	private const int IDYES = 6;

	private const int IDNO = 7;

	private static readonly Instance Logger = new Instance("OTC Loader");

	private static LoaderConfig _config = new LoaderConfig();

	private static string _configPath = "";

	[DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
	private static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type);

	public override void OnPreInitialization()
	{
		if (AppDomain.CurrentDomain.GetData("OTC_LOADER_INITIALIZED") != null)
		{
			Logger.Msg("Another OTC Loader instance already ran — skipping this copy.");
			return;
		}
		AppDomain.CurrentDomain.SetData("OTC_LOADER_INITIALIZED", true);
		string modsDirectory = MelonEnvironment.ModsDirectory;
		if (!Directory.Exists(modsDirectory))
		{
			return;
		}
		LoadConfig();
		Branch branch = (MelonUtils.IsGameIl2Cpp() ? Branch.Il2Cpp : Branch.Mono);
		string text = ((branch == Branch.Il2Cpp) ? "IL2CPP" : "Mono");
		string text2 = ((branch == Branch.Il2Cpp) ? "Mono" : "IL2CPP");
		string[] array = new string[256];
		int num = 0;
		string[] files = Directory.GetFiles(modsDirectory, "*", SearchOption.AllDirectories);
		foreach (string text3 in files)
		{
			bool flag = text3.EndsWith(".dll.off", StringComparison.OrdinalIgnoreCase);
			bool flag2 = text3.EndsWith(".dll.off.di", StringComparison.OrdinalIgnoreCase);
			bool flag3 = text3.EndsWith(".dll.di", StringComparison.OrdinalIgnoreCase);
			if (!flag && !flag2 && !flag3)
			{
				continue;
			}
			string text4 = (flag2 ? ".off.di" : (flag3 ? ".di" : ".off"));
			string text5 = text3.Substring(0, text3.Length - text4.Length);
			try
			{
				if (!File.Exists(text5))
				{
					File.Move(text3, text5);
					if ((flag || flag2) && num < array.Length)
					{
						array[num++] = Path.GetFileName(text5);
					}
				}
				else
				{
					File.Delete(text3);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not restore " + Path.GetFileName(text3) + ": " + ex.Message);
			}
		}
		string[] files2 = Directory.GetFiles(modsDirectory, "*.dll", SearchOption.AllDirectories);
		bool[] array2 = new bool[files2.Length];
		Branch?[] array3 = new Branch?[files2.Length];
		for (int j = 0; j < files2.Length; j++)
		{
			string fileName = Path.GetFileName(files2[j]);
			array2[j] = IsBlacklisted(fileName);
			if (!array2[j])
			{
				array3[j] = DetectBranch(files2[j]);
			}
		}
		for (int k = 0; k < files2.Length; k++)
		{
			if (array2[k] || !array3[k].HasValue)
			{
				continue;
			}
			string directoryName = Path.GetDirectoryName(files2[k]);
			if (!Path.GetFileName(directoryName).Equals("Plugins", StringComparison.OrdinalIgnoreCase))
			{
				continue;
			}
			string b = StripBranchKeyword(Path.GetFileName(files2[k]));
			bool flag4 = false;
			for (int l = 0; l < files2.Length; l++)
			{
				if (l != k && !array2[l] && string.Equals(Path.GetDirectoryName(files2[l]), directoryName, StringComparison.OrdinalIgnoreCase) && string.Equals(StripBranchKeyword(Path.GetFileName(files2[l])), b, StringComparison.OrdinalIgnoreCase))
				{
					flag4 = true;
					break;
				}
			}
			if (!flag4)
			{
				array2[k] = true;
			}
		}
		int num2 = 0;
		string[] array4 = new string[files2.Length];
		int num3 = 0;
		string[] array5 = new string[files2.Length];
		string[] array6 = new string[files2.Length];
		string[] array7 = new string[files2.Length];
		int num4 = 0;
		for (int m = 0; m < files2.Length; m++)
		{
			if (array2[m] || !array3[m].HasValue || array3[m] == branch)
			{
				continue;
			}
			string text6 = files2[m];
			string fileName2 = Path.GetFileName(text6);
			string directoryName2 = Path.GetDirectoryName(text6);
			bool flag5 = false;
			try
			{
				File.Move(text6, text6 + ".off");
				num2++;
				for (int n = 0; n < num; n++)
				{
					if (string.Equals(array[n], fileName2, StringComparison.OrdinalIgnoreCase))
					{
						flag5 = true;
						break;
					}
				}
				if (!flag5)
				{
					Logger.Msg("Disabled '" + fileName2 + "' — targets " + text2 + " but game is " + text + ".");
					if (num3 < array4.Length)
					{
						array4[num3++] = text6;
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Warning("Could not disable '" + fileName2 + "': " + ex2.Message);
				continue;
			}
			bool flag6 = string.Equals(directoryName2, modsDirectory, StringComparison.OrdinalIgnoreCase);
			bool flag7 = false;
			for (int num5 = 0; num5 < num4; num5++)
			{
				if (!flag6 && string.Equals(array5[num5], directoryName2, StringComparison.OrdinalIgnoreCase))
				{
					flag7 = true;
					break;
				}
			}
			if (flag7)
			{
				continue;
			}
			bool flag8 = false;
			string b2 = StripBranchKeyword(fileName2);
			for (int num6 = 0; num6 < files2.Length; num6++)
			{
				if (num6 != m && !array2[num6] && (!array3[num6].HasValue || array3[num6] == branch))
				{
					bool num7 = !flag6 && string.Equals(Path.GetDirectoryName(files2[num6]), directoryName2, StringComparison.OrdinalIgnoreCase);
					bool flag9 = string.Equals(StripBranchKeyword(Path.GetFileName(files2[num6])), b2, StringComparison.OrdinalIgnoreCase);
					if (num7 || flag9)
					{
						flag8 = true;
						break;
					}
				}
			}
			if (flag8)
			{
				if (flag5)
				{
					continue;
				}
				string text7 = "";
				for (int num8 = 0; num8 < files2.Length; num8++)
				{
					if (num8 != m && !array2[num8] && (!array3[num8].HasValue || array3[num8] == branch))
					{
						bool num9 = !flag6 && string.Equals(Path.GetDirectoryName(files2[num8]), directoryName2, StringComparison.OrdinalIgnoreCase);
						bool flag10 = string.Equals(StripBranchKeyword(Path.GetFileName(files2[num8])), b2, StringComparison.OrdinalIgnoreCase);
						if (num9 || flag10)
						{
							text7 = Path.GetFileName(files2[num8]);
							break;
						}
					}
				}
				Logger.Msg("  → Compatible version kept: " + text7);
				continue;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName2);
			string text8 = "";
			for (int num10 = 0; num10 < files2.Length; num10++)
			{
				if (!array2[num10] && array3[num10].HasValue && array3[num10] != branch && string.Equals(Path.GetDirectoryName(files2[num10]), directoryName2, StringComparison.OrdinalIgnoreCase) && (!flag6 || string.Equals(fileName2, Path.GetFileName(files2[num10]), StringComparison.OrdinalIgnoreCase)))
				{
					if (text8.Length > 0)
					{
						text8 += ", ";
					}
					text8 += Path.GetFileName(files2[num10]);
				}
			}
			array5[num4] = directoryName2;
			array6[num4] = fileNameWithoutExtension;
			array7[num4] = text8;
			num4++;
		}
		if (num4 > 0)
		{
			Logger.Warning("╔══════════════════════════════════════════════════════════╗");
			Logger.Warning("║  INCOMPATIBLE MODS — no " + text + "-compatible version found");
			Logger.Warning("║");
			for (int num11 = 0; num11 < num4; num11++)
			{
				Logger.Warning("║  • " + array6[num11]);
				Logger.Warning("║    Disabled: " + array7[num11]);
			}
			Logger.Warning("║");
			Logger.Warning("║  → Check each mod page for a " + text + "-compatible release,");
			Logger.Warning("║    or switch your game to the branch those mods support.");
			Logger.Warning("║");
			Logger.Warning("║  → Think this is a mistake? Open the config file and");
			Logger.Warning("║    add the filename to the Whitelist:");
			Logger.Warning("║    " + _configPath);
			Logger.Warning("╚══════════════════════════════════════════════════════════╝");
		}
		if (num2 > 0 || num4 > 0)
		{
			string text9 = "";
			for (int num12 = 0; num12 < num4; num12++)
			{
				if (text9.Length > 0)
				{
					text9 += ", ";
				}
				text9 += array6[num12];
			}
			string text10 = ((num4 > 0) ? (": " + text9) : "");
			Logger.Msg("Done — " + num2 + " wrong-branch DLL(s) correctly handled, " + num4 + " mod(s) have no compatible version" + text10 + ".");
		}
		else
		{
			Logger.Msg("All DLLs are compatible with " + text + ".");
		}
		if (num3 > 0)
		{
			InteractiveFlow(array4, num3, branch, files2, array2, array3, modsDirectory);
		}
	}

	private static void InteractiveFlow(string[] firstTimePaths, int count, Branch gameBranch, string[] allDlls, bool[] skip, Branch?[] branches, string modsPath)
	{
		string text = ((gameBranch == Branch.Il2Cpp) ? "IL2CPP" : "Mono");
		string text2 = ((gameBranch == Branch.Il2Cpp) ? "Mono" : "IL2CPP");
		string[] array = new string[count];
		int num = 0;
		for (int i = 0; i < count; i++)
		{
			string text3 = firstTimePaths[i];
			string? fileName = Path.GetFileName(text3);
			string directoryName = Path.GetDirectoryName(text3);
			string b = StripBranchKeyword(fileName);
			bool flag = false;
			for (int j = 0; j < allDlls.Length; j++)
			{
				if (j != i && !skip[j] && (!branches[j].HasValue || branches[j] == gameBranch))
				{
					bool num2 = !string.Equals(directoryName, modsPath, StringComparison.OrdinalIgnoreCase) && string.Equals(Path.GetDirectoryName(allDlls[j]), directoryName, StringComparison.OrdinalIgnoreCase);
					bool flag2 = string.Equals(StripBranchKeyword(Path.GetFileName(allDlls[j])), b, StringComparison.OrdinalIgnoreCase);
					if (num2 || flag2)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				array[num++] = text3;
			}
		}
		bool flag3 = false;
		try
		{
			if (_config.Whitelist != null && _config.Whitelist.Length != 0)
			{
				string text4 = "OTC Loader — Whitelist Management\n\nYour whitelist contains " + _config.Whitelist.Length + " mod(s).\nKeep the current whitelist or clear it entirely?\n\n[OK]     —  (Recommended) Keep current whitelist\n[Cancel] —  Clear whitelist";
				if (MessageBox(IntPtr.Zero, text4, "OTC Loader", 33u) == 2)
				{
					_config.Whitelist = Array.Empty<string>();
					flag3 = true;
					Logger.Msg("User chose to clear the whitelist.");
				}
			}
			bool flag4 = false;
			if (num > 0)
			{
				string text5 = "";
				for (int k = 0; k < num; k++)
				{
					if (k > 0)
					{
						text5 += "\n";
					}
					text5 = text5 + "• " + Path.GetFileName(array[k]);
					if (k >= 9)
					{
						text5 = text5 + "\n...and " + (num - 10) + " more.";
						break;
					}
				}
				string text6 = "OTC Loader — Incompatible Mods Detected\n\nThese mods target " + text2 + " but your game runs " + text + ".\nNo compatible versions were found, so they were disabled:\n\n" + text5 + "\n\nKeep all of them disabled, or review each mod to optionally whitelist them?\n\n[OK]     —  (Recommended) Keep all disabled\n[Cancel] —  Review each mod";
				flag4 = MessageBox(IntPtr.Zero, text6, "OTC Loader", 49u) == 2;
			}
			if (flag4)
			{
				for (int l = 0; l < num; l++)
				{
					string fileName2 = Path.GetFileName(array[l]);
					string text7 = "OTC Loader — Review Mod\n\n" + fileName2 + "\n\nThis mod targets " + text2 + " but your game runs " + text + ".\n\nKeep this mod disabled, or add it to the whitelist? (May cause crashes if whitelisted)\n\n[OK]     —  (Recommended) Keep disabled\n[Cancel] —  Whitelist this mod";
					if (MessageBox(IntPtr.Zero, text7, "OTC Loader", 33u) == 2)
					{
						string[] array2 = _config.Whitelist ?? Array.Empty<string>();
						string[] array3 = new string[array2.Length + 1];
						Array.Copy(array2, array3, array2.Length);
						array3[array2.Length] = fileName2;
						_config.Whitelist = array3;
						flag3 = true;
						Logger.Msg("User whitelisted: " + fileName2);
					}
				}
			}
			if (flag3)
			{
				SaveConfig();
			}
		}
		catch (Exception ex)
		{
			Logger.Warning("Interactive prompt failed (falling back to log-only): " + ex.Message);
		}
		string text8 = "";
		for (int m = 0; m < count; m++)
		{
			if (text8.Length > 0)
			{
				text8 += ", ";
			}
			text8 += Path.GetFileNameWithoutExtension(firstTimePaths[m]);
		}
		Logger.Warning("First-time disable of: " + text8);
		Logger.Warning("A restart is recommended so the disabled DLLs are fully unloaded.");
		string text9 = "SAFE TO RUN! Your compatible mods will work fine.\n\nOTC Loader safely disabled these incompatible mod files:\n" + text8 + "\n\nThe runtime may have already cached the old files. A restart is recommended.\n\n[OK]     —  (Recommended) Close game NOW. Restart via your mod manager.\n[Cancel] —  Continue anyway (may cause errors)";
		try
		{
			if (MessageBox(IntPtr.Zero, text9, "OTC Loader — Restart Recommended", 65u) == 1)
			{
				Environment.Exit(0);
			}
		}
		catch
		{
			Logger.Warning("╔══════════════════════════════════════════════════════════╗");
			Logger.Warning("║  RESTART RECOMMENDED                                     ║");
			Logger.Warning("║                                                          ║");
			Logger.Warning("║  Incompatible mods were disabled but may have already    ║");
			Logger.Warning("║  been cached. Please close and restart the game.         ║");
			Logger.Warning("║  Affected: " + text8);
			Logger.Warning("╚══════════════════════════════════════════════════════════╝");
		}
	}

	private static void LoadConfig()
	{
		_configPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "OTCLoader.config.json");
		string configPath = _configPath;
		if (File.Exists(configPath))
		{
			try
			{
				_config = JsonConvert.DeserializeObject<LoaderConfig>(File.ReadAllText(configPath)) ?? new LoaderConfig();
				return;
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not read config, using defaults: " + ex.Message);
				_config = new LoaderConfig();
				return;
			}
		}
		_config = new LoaderConfig();
		try
		{
			File.WriteAllText(configPath, "{\n  \"_readme\": \"Add DLL filenames to Whitelist to prevent OTC Loader from disabling them.\",\n  \"Whitelist\": [\n    \"ExampleMod-IL2Cpp.dll\",\n    \"AnotherExampleMod-IL2Cpp.dll\"\n  ]\n}\n");
			Logger.Msg("Created default config at " + configPath);
		}
		catch
		{
		}
	}

	private static void SaveConfig()
	{
		if (string.IsNullOrEmpty(_configPath))
		{
			return;
		}
		try
		{
			string contents = JsonConvert.SerializeObject((object)_config, (Formatting)1);
			File.WriteAllText(_configPath, contents);
		}
		catch (Exception ex)
		{
			Logger.Warning("Could not save config: " + ex.Message);
		}
	}

	private static string StripBranchKeyword(string filename)
	{
		string text = Path.GetFileNameWithoutExtension(filename).ToLowerInvariant();
		string[] array = new string[6] { "-il2cpp", "_il2cpp", ".il2cpp", "-mono", "_mono", ".mono" };
		foreach (string text2 in array)
		{
			if (text.EndsWith(text2))
			{
				return text.Substring(0, text.Length - text2.Length);
			}
		}
		return text;
	}

	private static bool IsBlacklisted(string filename)
	{
		if (!Array.Exists(BuiltinBlacklist, (string b) => string.Equals(b, filename, StringComparison.OrdinalIgnoreCase)) && !filename.StartsWith("S1API", StringComparison.OrdinalIgnoreCase))
		{
			return Array.Exists(_config.Whitelist ?? Array.Empty<string>(), (string w) => string.Equals(w, filename, StringComparison.OrdinalIgnoreCase));
		}
		return true;
	}

	private static Branch? DetectBranch(string path)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		string text = Path.GetFileName(path).ToLowerInvariant();
		if (text.Contains("mono"))
		{
			return Branch.Mono;
		}
		if (text.Contains("il2cpp"))
		{
			return Branch.Il2Cpp;
		}
		try
		{
			AssemblyDefinition val = AssemblyDefinition.ReadAssembly(path);
			try
			{
				Enumerator<ModuleDefinition> enumerator = val.Modules.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						foreach (TypeReference typeReference in enumerator.Current.GetTypeReferences())
						{
							string text2 = (typeReference.Namespace ?? "").ToLowerInvariant();
							if (text2.StartsWith("il2cppscheduleone") || text2.StartsWith("il2cppsystem"))
							{
								return Branch.Il2Cpp;
							}
							if (text2 == "scheduleone")
							{
								return Branch.Mono;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch
		{
		}
		return null;
	}
}