using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using HarmonyLib;
using MelonLoader;
using SledChatEmojis;
using SledChatEmojis.Util;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("SledChatEmojis")]
[assembly: AssemblyFileVersion("0.1.0")]
[assembly: MelonInfo(typeof(Mod), "SledChatEmojis", "0.1.0", "Natebag", null)]
[assembly: MelonGame("The Sledding Corporation", "Sledding Game")]
[assembly: MelonColor(255, 0, 255, 102)]
[assembly: MelonAuthorColor(255, 80, 160, 255)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyVersion("0.1.0.0")]
namespace SledChatEmojis
{
	public sealed class Mod : MelonMod
	{
		public const string Name = "SledChatEmojis";

		public const string Version = "0.1.0";

		public const string Author = "Natebag";

		private static readonly Dictionary<string, string> Map = new Dictionary<string, string>
		{
			{ ":smile:", ":)" },
			{ ":grin:", ":D" },
			{ ":joy:", "xD" },
			{ ":rofl:", "xDDD" },
			{ ":sob:", ":'(" },
			{ ":cry:", ":(" },
			{ ":angry:", ">:(" },
			{ ":sunglasses:", "B)" },
			{ ":tongue:", ":P" },
			{ ":wink:", ";)" },
			{ ":heart:", "<3" },
			{ ":broken:", "</3" },
			{ ":fire:", "(*fire*)" },
			{ ":star:", "*" },
			{ ":sparkles:", "*~*" },
			{ ":100:", "100/100" },
			{ ":eyes:", "0_0" },
			{ ":thumbsup:", "(y)" },
			{ ":thumbsdown:", "(n)" },
			{ ":wave:", "o/" },
			{ ":pray:", "/\\" },
			{ ":snowflake:", "*snow*" },
			{ ":sled:", "[sled]" },
			{ ":fish:", "><(((*>" },
			{ ":whale:", ".'(\\" },
			{ ":mountain:", "/^^^\\" },
			{ ":pumpkin:", "{O_O}" },
			{ ":party:", "\\(^o^)/" },
			{ ":skull:", "x_x" },
			{ ":poop:", "(_!_)" },
			{ ":fingerguns:", "(>'.')>" },
			{ ":shrug:", "\\_(--)_/" },
			{ ":lenny:", "( . Y . )" },
			{ ":table:", "(.□.)__" }
		};

		public override void OnInitializeMelon()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			SafeLog.Bind(((MelonBase)this).LoggerInstance);
			try
			{
				Harmony val = new Harmony("Natebag.SledChatEmojis");
				Type type = Refl.FindType("Assembly-CSharp", "_Scripts.Systems.Chat.ChatManager");
				if (type == null)
				{
					((MelonBase)this).LoggerInstance.Warning("SledChatEmojis: ChatManager type not found");
					return;
				}
				MethodInfo method = type.GetMethod("SendChatMessage", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
				if (method == null)
				{
					((MelonBase)this).LoggerInstance.Warning("SledChatEmojis: SendChatMessage method not found. Dumping ChatManager methods:");
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo in methods)
					{
						((MelonBase)this).LoggerInstance.Warning($"  - {methodInfo.ReturnType.Name} {methodInfo.Name}({string.Join(", ", Array.ConvertAll(methodInfo.GetParameters(), (ParameterInfo p) => p.ParameterType.Name + " " + p.Name))})");
					}
				}
				else
				{
					MethodInfo method2 = typeof(Mod).GetMethod("SendChatMessage_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
					val.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					((MelonBase)this).LoggerInstance.Msg($"SledChatEmojis v{"0.1.0"} ready — {Map.Count} shortcodes installed.");
				}
			}
			catch (Exception value)
			{
				((MelonBase)this).LoggerInstance.Error($"SledChatEmojis init failed: {value}");
			}
		}

		private static void SendChatMessage_Prefix(ref string cleanedString)
		{
			try
			{
				if (string.IsNullOrEmpty(cleanedString))
				{
					return;
				}
				foreach (KeyValuePair<string, string> item in Map)
				{
					cleanedString = cleanedString.Replace(item.Key, item.Value);
				}
			}
			catch
			{
			}
		}
	}
}
namespace SledChatEmojis.Util
{
	internal static class Refl
	{
		private static readonly Dictionary<string, Type> _typeCache = new Dictionary<string, Type>();

		private static bool _loggedAssemblies = false;

		private static MethodInfo _il2cppCastGeneric;

		public static Type FindType(string assemblyHint, string fullName)
		{
			if (_typeCache.TryGetValue(fullName, out var value))
			{
				return value;
			}
			try
			{
				string[] array = new string[2]
				{
					fullName,
					"Il2Cpp." + fullName
				};
				string[] array2 = new string[3]
				{
					assemblyHint,
					"Il2Cpp" + assemblyHint,
					assemblyHint + "-firstpass"
				};
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					string name = assembly.GetName().Name;
					string[] array3 = array2;
					foreach (string text in array3)
					{
						if (name != text)
						{
							continue;
						}
						string[] array4 = array;
						foreach (string name2 in array4)
						{
							Type type = assembly.GetType(name2);
							if (type != null)
							{
								_typeCache[fullName] = type;
								return type;
							}
						}
					}
				}
				assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly2 in assemblies)
				{
					string[] array3 = array;
					foreach (string name3 in array3)
					{
						Type type2;
						try
						{
							type2 = assembly2.GetType(name3);
						}
						catch
						{
							continue;
						}
						if (type2 != null)
						{
							_typeCache[fullName] = type2;
							return type2;
						}
					}
				}
				assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly3 in assemblies)
				{
					Type[] types;
					try
					{
						types = assembly3.GetTypes();
					}
					catch (ReflectionTypeLoadException ex)
					{
						types = ex.Types;
					}
					catch
					{
						continue;
					}
					string text2 = fullName;
					int num = fullName.LastIndexOf('.');
					if (num >= 0 && num < fullName.Length - 1)
					{
						text2 = fullName.Substring(num + 1);
					}
					Type[] array5 = types;
					foreach (Type type3 in array5)
					{
						if (!(type3 == null) && (type3.FullName == fullName || type3.FullName == "Il2Cpp." + fullName || (type3.FullName != null && type3.FullName.EndsWith("." + fullName)) || type3.Name == fullName || type3.Name == text2))
						{
							_typeCache[fullName] = type3;
							SafeLog.Info($"Refl.FindType: '{fullName}' resolved via full scan as '{type3.FullName}' in {assembly3.GetName().Name}");
							return type3;
						}
					}
				}
				if (!_loggedAssemblies)
				{
					SafeLog.Warn("Refl.FindType: '" + fullName + "' not found. Loaded assemblies:");
					assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly4 in assemblies)
					{
						SafeLog.Warn("  - " + assembly4.GetName().Name);
					}
					_loggedAssemblies = true;
				}
				return null;
			}
			catch (Exception ex2)
			{
				SafeLog.Error($"Refl.FindType({assemblyHint},{fullName})", ex2);
				return null;
			}
		}

		public static MethodInfo Method(Type t, string name, params Type[] argTypes)
		{
			if (t == null)
			{
				return null;
			}
			try
			{
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
				if (argTypes.Length == 0)
				{
					MethodInfo[] methods = t.GetMethods(bindingAttr);
					foreach (MethodInfo methodInfo in methods)
					{
						if (methodInfo.Name == name)
						{
							return methodInfo;
						}
					}
					return null;
				}
				return t.GetMethod(name, bindingAttr, null, argTypes, null);
			}
			catch (Exception ex)
			{
				SafeLog.Error($"Refl.Method({t.Name}.{name})", ex);
				return null;
			}
		}

		public static FieldInfo Field(Type t, string name)
		{
			if (t == null)
			{
				return null;
			}
			try
			{
				return t.GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			catch (Exception ex)
			{
				SafeLog.Error($"Refl.Field({t.Name}.{name})", ex);
				return null;
			}
		}

		public static object CastToIl2Cpp(object obj, Type targetType)
		{
			if (obj == null || targetType == null)
			{
				return null;
			}
			if (targetType.IsInstanceOfType(obj))
			{
				return obj;
			}
			try
			{
				if (_il2cppCastGeneric == null)
				{
					Type type = FindType("Il2CppInterop.Runtime", "Il2CppInterop.Runtime.InteropTypes.Il2CppObjectBase");
					if (type == null)
					{
						type = obj.GetType();
					}
					while (type != null)
					{
						MethodInfo method = type.GetMethod("Cast", BindingFlags.Instance | BindingFlags.Public);
						if (method != null && method.IsGenericMethodDefinition)
						{
							_il2cppCastGeneric = method;
							break;
						}
						type = type.BaseType;
					}
				}
				if (_il2cppCastGeneric == null)
				{
					return null;
				}
				return _il2cppCastGeneric.MakeGenericMethod(targetType).Invoke(obj, null);
			}
			catch (Exception ex)
			{
				SafeLog.Error("Refl.CastToIl2Cpp(" + targetType.FullName + ")", ex);
				return null;
			}
		}
	}
	internal static class SafeLog
	{
		private static Instance _logger;

		private static readonly LinkedList<string> _ring = new LinkedList<string>();

		private const int RingMax = 200;

		public static IEnumerable<string> Recent => _ring;

		public static void Bind(Instance logger)
		{
			_logger = logger;
		}

		public static void Info(string msg)
		{
			Instance logger = _logger;
			if (logger != null)
			{
				logger.Msg(msg);
			}
			Push("INFO  " + msg);
		}

		public static void Warn(string msg)
		{
			Instance logger = _logger;
			if (logger != null)
			{
				logger.Warning(msg);
			}
			Push("WARN  " + msg);
		}

		public static void Error(string msg, Exception ex = null)
		{
			if (_logger != null)
			{
				if (ex != null)
				{
					_logger.Error($"{msg}: {ex.GetType().Name}: {ex.Message}\n{ex.StackTrace}");
				}
				else
				{
					_logger.Error(msg);
				}
			}
			Push("ERROR " + ((ex != null) ? (msg + ": " + ex.Message) : msg));
		}

		private static void Push(string line)
		{
			_ring.AddLast(line);
			while (_ring.Count > 200)
			{
				_ring.RemoveFirst();
			}
		}
	}
}