using System;
using System.Collections;
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 System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SimTranslation")]
[assembly: AssemblyTitle("SimTranslation")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 SimTranslation
{
	[BepInPlugin("Omniscye.SimTranslation", "SimTranslation", "1.0")]
	public class SimTranslation : BaseUnityPlugin
	{
		internal static SimTranslation Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}
namespace Empress.Simlishizer
{
	[BepInPlugin("empress.repo.simlishizer", "Simlishizer", "1.1.1")]
	public class Simlishizer : BaseUnityPlugin
	{
		internal class SimlishState : MonoBehaviour
		{
			public string lastIn;

			public string lastOut;
		}

		internal static class Core
		{
			private static readonly Regex TagRx = new Regex("<[^>]*>", RegexOptions.Compiled);

			private static readonly Regex WordRx = new Regex("\\b[\\p{L}][\\p{L}\\p{Mn}\\p{Pd}']*\\b", RegexOptions.Compiled);

			private static readonly Regex SimlishHintRx = new Regex("\\b(sul\\s?sul|dag\\s?dag|nooboo|voo?hoo|yibs|whippna|glooby|frabbit)\\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);

			private static readonly Dictionary<string, string> VowelSubs = new Dictionary<string, string>
			{
				{ "ea", "ee" },
				{ "ee", "ii" },
				{ "oo", "uu" },
				{ "ou", "oo" },
				{ "ai", "ay" },
				{ "au", "oo" },
				{ "oi", "oy" },
				{ "ie", "ee" },
				{ "ei", "ee" }
			};

			private static readonly Dictionary<string, string> Common = new Dictionary<string, string>
			{
				{ "play", "plumbob" },
				{ "start", "sul sul" },
				{ "exit", "dag dag" },
				{ "confirm", "voohoo" },
				{ "ok", "okie-dokie" },
				{ "yes", "yibs" },
				{ "no", "naybo" },
				{ "pause", "glooby" },
				{ "resume", "frabbit" },
				{ "loading", "whippna choba" },
				{ "settings", "zowie" },
				{ "options", "zowie" },
				{ "warning", "zo hungwah" },
				{ "error", "hoo baa" },
				{ "player", "sim" },
				{ "you", "duh" },
				{ "health", "nooboo" },
				{ "ammo", "zizzle" },
				{ "score", "zooba" }
			};

			private static readonly (string Key, string Value)[] ConsonantSubs = new(string, string)[5]
			{
				("th", "d"),
				("ch", "sh"),
				("ph", "f"),
				("ck", "k"),
				("qu", "kw")
			};

			private static readonly string[] SimlishParticles = new string[6] { "  sul!", "  dag dag!", "  nooboo!", "  yibs!", "  zowie!", "  voohoo!" };

			public static string StripTags(string s)
			{
				return TagRx.Replace(s ?? string.Empty, "");
			}

			private static bool LooksSimlish(string s)
			{
				return SimlishHintRx.IsMatch(s);
			}

			public static SimlishState GetStateFor(Component comp)
			{
				GameObject gameObject = comp.gameObject;
				SimlishState simlishState = gameObject.GetComponent<SimlishState>();
				if (!Object.op_Implicit((Object)(object)simlishState))
				{
					simlishState = gameObject.AddComponent<SimlishState>();
				}
				return simlishState;
			}

			public static string ToSimlishIfNeeded(Component comp, string raw, bool treatAsTMP)
			{
				if (!Enabled.Value)
				{
					return raw;
				}
				if ((Object)(object)comp == (Object)null)
				{
					return raw;
				}
				if (ProcessTMPOnly.Value && !treatAsTMP)
				{
					return raw;
				}
				SimlishState stateFor = GetStateFor(comp);
				if (stateFor.lastIn == raw)
				{
					return stateFor.lastOut ?? raw;
				}
				string text = StripTags(raw);
				if (text.Length < MinLength.Value)
				{
					stateFor.lastIn = raw;
					stateFor.lastOut = raw;
					return raw;
				}
				try
				{
					if (!string.IsNullOrEmpty(ExclusionsRegex.Value) && Regex.IsMatch(text, ExclusionsRegex.Value))
					{
						stateFor.lastIn = raw;
						stateFor.lastOut = raw;
						return raw;
					}
					if (SkipIfLooksSimlish.Value && LooksSimlish(text))
					{
						stateFor.lastIn = raw;
						stateFor.lastOut = raw;
						return raw;
					}
					string text2 = (RespectRichTags.Value ? MapPreservingTags(raw) : MapPlain(text));
					stateFor.lastIn = raw;
					stateFor.lastOut = text2;
					return text2;
				}
				catch (Exception arg)
				{
					Log.LogWarning((object)$"Simlish transform failed: {arg}");
					stateFor.lastIn = raw;
					stateFor.lastOut = raw;
					return raw;
				}
			}

			private static string MapPreservingTags(string s)
			{
				StringBuilder stringBuilder = new StringBuilder();
				int num = 0;
				foreach (Match item in TagRx.Matches(s))
				{
					if (item.Index > num)
					{
						stringBuilder.Append(MapPlain(s.Substring(num, item.Index - num)));
					}
					stringBuilder.Append(item.Value);
					num = item.Index + item.Length;
				}
				if (num < s.Length)
				{
					stringBuilder.Append(MapPlain(s.Substring(num)));
				}
				return stringBuilder.ToString();
			}

			private static string MapPlain(string s)
			{
				bool addFlavor = AddFlavorParticles.Value;
				int flavorEvery = Math.Max(FlavorEveryNWords.Value, 2);
				int wordCount = 0;
				return WordRx.Replace(s, delegate(Match match)
				{
					string value = match.Value;
					wordCount++;
					string text = MapWordToSimlish(value);
					if (addFlavor && wordCount % flavorEvery == 0)
					{
						text += SimlishParticles[Random.Range(0, SimlishParticles.Length)];
					}
					return text;
				});
			}

			private static string MapWordToSimlish(string word)
			{
				if (string.IsNullOrEmpty(word))
				{
					return word;
				}
				string text = word;
				string text2 = "";
				string text3 = "";
				Match match = Regex.Match(text, "^[\\p{Pd}']+");
				if (match.Success)
				{
					text2 = match.Value;
					text = text.Substring(text2.Length);
				}
				Match match2 = Regex.Match(text, "[\\p{Pd}']+$");
				if (match2.Success)
				{
					text3 = match2.Value;
					text = text.Substring(0, text.Length - match2.Length);
				}
				if (text.Length == 0)
				{
					return word;
				}
				bool flag = text.ToUpperInvariant() == text;
				bool flag2 = char.IsUpper(text[0]) && (text.Length == 1 || text.Substring(1).ToLowerInvariant() == text.Substring(1));
				text = ((!Common.TryGetValue(text.ToLowerInvariant(), out string value)) ? Phonetic(text) : value);
				if (flag)
				{
					text = text.ToUpperInvariant();
				}
				else if (flag2 && text.Length > 0)
				{
					text = char.ToUpperInvariant(text[0]) + text.Substring(1);
				}
				return text2 + text + text3;
			}

			private static string Phonetic(string s)
			{
				string text = s.ToLowerInvariant();
				foreach (KeyValuePair<string, string> vowelSub in VowelSubs)
				{
					text = text.Replace(vowelSub.Key, vowelSub.Value);
				}
				(string, string)[] consonantSubs = ConsonantSubs;
				for (int i = 0; i < consonantSubs.Length; i++)
				{
					(string, string) tuple = consonantSubs[i];
					text = Regex.Replace(text, tuple.Item1, tuple.Item2);
				}
				text = Regex.Replace(text, "([bcdfghjklmnpqrstvwxyz])(?=[bcdfghjklmnpqrstvwxyz])", "$1a");
				text = Regex.Replace(text, "([aeiou])([bcdfghjklmnpqrstvwxyz])\\b", (Match m) => m.Groups[1].Value + m.Groups[2].Value + "a");
				StringBuilder stringBuilder = new StringBuilder(text.Length + 8);
				for (int j = 0; j < text.Length; j++)
				{
					char c = text[j];
					stringBuilder.Append(c);
					if (IsVowel(c) && j + 1 < text.Length && IsConsonant(text[j + 1]))
					{
						if ((j & 3) == 1)
						{
							stringBuilder.Append("oo");
						}
						else if ((j & 3) == 2)
						{
							stringBuilder.Append("ah");
						}
					}
				}
				string input = stringBuilder.ToString();
				input = Regex.Replace(input, "([aeiou])\\1{2,}", "$1$1");
				input = Regex.Replace(input, "([a]{2,})", "a");
				return Regex.Replace(input, "([o]{3,})", "oo");
			}

			private static bool IsVowel(char c)
			{
				return "aeiou".IndexOf(c) >= 0;
			}

			private static bool IsConsonant(char c)
			{
				return c >= 'a' && c <= 'z' && !IsVowel(c);
			}
		}

		internal static class Patches
		{
			public static class TMPText_set_text
			{
				public static void Prefix(TMP_Text __instance, ref string value)
				{
					if (value != null)
					{
						value = Core.ToSimlishIfNeeded((Component)(object)__instance, value, treatAsTMP: true);
					}
				}
			}

			[HarmonyPatch(typeof(TMP_Text))]
			public static class TMPText_SetText_StringLike
			{
				[CompilerGenerated]
				private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
				{
					private int <>1__state;

					private MethodBase <>2__current;

					private int <>l__initialThreadId;

					private List<MethodInfo>.Enumerator <>s__1;

					private MethodInfo <m>5__2;

					private ParameterInfo[] <ps>5__3;

					MethodBase IEnumerator<MethodBase>.Current
					{
						[DebuggerHidden]
						get
						{
							return <>2__current;
						}
					}

					object IEnumerator.Current
					{
						[DebuggerHidden]
						get
						{
							return <>2__current;
						}
					}

					[DebuggerHidden]
					public <TargetMethods>d__0(int <>1__state)
					{
						this.<>1__state = <>1__state;
						<>l__initialThreadId = Environment.CurrentManagedThreadId;
					}

					[DebuggerHidden]
					void IDisposable.Dispose()
					{
						int num = <>1__state;
						if (num == -3 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally1();
							}
						}
						<>s__1 = default(List<MethodInfo>.Enumerator);
						<m>5__2 = null;
						<ps>5__3 = null;
						<>1__state = -2;
					}

					private bool MoveNext()
					{
						try
						{
							int num = <>1__state;
							if (num != 0)
							{
								if (num != 1)
								{
									return false;
								}
								<>1__state = -3;
								goto IL_00db;
							}
							<>1__state = -1;
							<>s__1 = AccessTools.GetDeclaredMethods(typeof(TMP_Text)).GetEnumerator();
							<>1__state = -3;
							goto IL_00ea;
							IL_00db:
							<ps>5__3 = null;
							<m>5__2 = null;
							goto IL_00ea;
							IL_00ea:
							do
							{
								if (<>s__1.MoveNext())
								{
									<m>5__2 = <>s__1.Current;
									continue;
								}
								<>m__Finally1();
								<>s__1 = default(List<MethodInfo>.Enumerator);
								return false;
							}
							while (<m>5__2.Name != "SetText");
							<ps>5__3 = <m>5__2.GetParameters();
							if (<ps>5__3.Length >= 1 && <ps>5__3[0].ParameterType == typeof(string))
							{
								<>2__current = <m>5__2;
								<>1__state = 1;
								return true;
							}
							goto IL_00db;
						}
						catch
						{
							//try-fault
							((IDisposable)this).Dispose();
							throw;
						}
					}

					bool IEnumerator.MoveNext()
					{
						//ILSpy generated this explicit interface implementation from .override directive in MoveNext
						return this.MoveNext();
					}

					private void <>m__Finally1()
					{
						<>1__state = -1;
						((IDisposable)<>s__1).Dispose();
					}

					[DebuggerHidden]
					void IEnumerator.Reset()
					{
						throw new NotSupportedException();
					}

					[DebuggerHidden]
					IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
					{
						if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
						{
							<>1__state = 0;
							return this;
						}
						return new <TargetMethods>d__0(0);
					}

					[DebuggerHidden]
					IEnumerator IEnumerable.GetEnumerator()
					{
						return ((IEnumerable<MethodBase>)this).GetEnumerator();
					}
				}

				[IteratorStateMachine(typeof(<TargetMethods>d__0))]
				private static IEnumerable<MethodBase> TargetMethods()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <TargetMethods>d__0(-2);
				}

				private static void Prefix(TMP_Text __instance, ref string __0)
				{
					if (__0 != null)
					{
						__0 = Core.ToSimlishIfNeeded((Component)(object)__instance, __0, treatAsTMP: true);
					}
				}
			}

			[HarmonyPatch(typeof(TMP_Text))]
			public static class TMPText_SetText_SBLike
			{
				[CompilerGenerated]
				private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
				{
					private int <>1__state;

					private MethodBase <>2__current;

					private int <>l__initialThreadId;

					private List<MethodInfo>.Enumerator <>s__1;

					private MethodInfo <m>5__2;

					private ParameterInfo[] <ps>5__3;

					MethodBase IEnumerator<MethodBase>.Current
					{
						[DebuggerHidden]
						get
						{
							return <>2__current;
						}
					}

					object IEnumerator.Current
					{
						[DebuggerHidden]
						get
						{
							return <>2__current;
						}
					}

					[DebuggerHidden]
					public <TargetMethods>d__0(int <>1__state)
					{
						this.<>1__state = <>1__state;
						<>l__initialThreadId = Environment.CurrentManagedThreadId;
					}

					[DebuggerHidden]
					void IDisposable.Dispose()
					{
						int num = <>1__state;
						if (num == -3 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally1();
							}
						}
						<>s__1 = default(List<MethodInfo>.Enumerator);
						<m>5__2 = null;
						<ps>5__3 = null;
						<>1__state = -2;
					}

					private bool MoveNext()
					{
						try
						{
							int num = <>1__state;
							if (num != 0)
							{
								if (num != 1)
								{
									return false;
								}
								<>1__state = -3;
								goto IL_00db;
							}
							<>1__state = -1;
							<>s__1 = AccessTools.GetDeclaredMethods(typeof(TMP_Text)).GetEnumerator();
							<>1__state = -3;
							goto IL_00ea;
							IL_00db:
							<ps>5__3 = null;
							<m>5__2 = null;
							goto IL_00ea;
							IL_00ea:
							do
							{
								if (<>s__1.MoveNext())
								{
									<m>5__2 = <>s__1.Current;
									continue;
								}
								<>m__Finally1();
								<>s__1 = default(List<MethodInfo>.Enumerator);
								return false;
							}
							while (<m>5__2.Name != "SetText");
							<ps>5__3 = <m>5__2.GetParameters();
							if (<ps>5__3.Length >= 1 && <ps>5__3[0].ParameterType == typeof(StringBuilder))
							{
								<>2__current = <m>5__2;
								<>1__state = 1;
								return true;
							}
							goto IL_00db;
						}
						catch
						{
							//try-fault
							((IDisposable)this).Dispose();
							throw;
						}
					}

					bool IEnumerator.MoveNext()
					{
						//ILSpy generated this explicit interface implementation from .override directive in MoveNext
						return this.MoveNext();
					}

					private void <>m__Finally1()
					{
						<>1__state = -1;
						((IDisposable)<>s__1).Dispose();
					}

					[DebuggerHidden]
					void IEnumerator.Reset()
					{
						throw new NotSupportedException();
					}

					[DebuggerHidden]
					IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
					{
						if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
						{
							<>1__state = 0;
							return this;
						}
						return new <TargetMethods>d__0(0);
					}

					[DebuggerHidden]
					IEnumerator IEnumerable.GetEnumerator()
					{
						return ((IEnumerable<MethodBase>)this).GetEnumerator();
					}
				}

				[IteratorStateMachine(typeof(<TargetMethods>d__0))]
				private static IEnumerable<MethodBase> TargetMethods()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <TargetMethods>d__0(-2);
				}

				private static void Prefix(TMP_Text __instance, StringBuilder __0)
				{
					if (__0 != null)
					{
						string value = Core.ToSimlishIfNeeded((Component)(object)__instance, __0.ToString(), treatAsTMP: true);
						__0.Length = 0;
						__0.Append(value);
					}
				}
			}

			public static class LegacyText_set_text
			{
				public static void Prefix(Text __instance, ref string value)
				{
					if (value != null)
					{
						value = Core.ToSimlishIfNeeded((Component)(object)__instance, value, treatAsTMP: false);
					}
				}
			}
		}

		public const string PluginGuid = "empress.repo.simlishizer";

		public const string PluginName = "Simlishizer";

		public const string PluginVersion = "1.1.1";

		internal static ManualLogSource Log;

		internal static Harmony Harmony;

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<int> MinLength;

		internal static ConfigEntry<string> ExclusionsRegex;

		internal static ConfigEntry<bool> ProcessTMPOnly;

		internal static ConfigEntry<bool> RespectRichTags;

		internal static ConfigEntry<bool> AddFlavorParticles;

		internal static ConfigEntry<int> FlavorEveryNWords;

		internal static ConfigEntry<bool> SkipIfLooksSimlish;

		internal static ConfigEntry<bool> PatchLegacyUGUIText;

		private void Awake()
		{
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master on/off.");
			MinLength = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MinLength", 3, "Minimum raw segment length to process.");
			ExclusionsRegex = ((BaseUnityPlugin)this).Config.Bind<string>("General", "ExclusionsRegex", "^\\s*$", "Regex tested against tag-stripped text; matching text is skipped.");
			ProcessTMPOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Safety", "ProcessTMPOnly", true, "Only process TMPro components (recommended).");
			RespectRichTags = ((BaseUnityPlugin)this).Config.Bind<bool>("Safety", "RespectRichTags", true, "Keep <...> segments intact.");
			AddFlavorParticles = ((BaseUnityPlugin)this).Config.Bind<bool>("Style", "AddFlavorParticles", true, "Occasionally insert small Simlish particles.");
			FlavorEveryNWords = ((BaseUnityPlugin)this).Config.Bind<int>("Style", "FlavorEveryNWords", 8, "Insert a particle roughly every N words.");
			SkipIfLooksSimlish = ((BaseUnityPlugin)this).Config.Bind<bool>("Style", "SkipIfLooksSimlish", true, "Avoid double-processing if text already looks Simlish.");
			PatchLegacyUGUIText = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "PatchLegacyUGUIText", true, "Also patch UnityEngine.UI.Text.text setter.");
			Harmony = new Harmony("empress.repo.simlishizer");
			TryPatch(typeof(TMP_Text).GetProperty("text")?.GetSetMethod(nonPublic: true), typeof(Patches.TMPText_set_text));
			Harmony.CreateClassProcessor(typeof(Patches.TMPText_SetText_StringLike)).Patch();
			Harmony.CreateClassProcessor(typeof(Patches.TMPText_SetText_SBLike)).Patch();
			if (PatchLegacyUGUIText.Value)
			{
				TryPatch(typeof(Text).GetProperty("text")?.GetSetMethod(nonPublic: true), typeof(Patches.LegacyText_set_text));
			}
			Log.LogInfo((object)("Simlishizer 1.1.1 loaded. TMP text + SetText patched; LegacyText " + (PatchLegacyUGUIText.Value ? "ON" : "OFF") + "."));
		}

		private void OnDestroy()
		{
			try
			{
				Harmony harmony = Harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
		}

		private static void TryPatch(MethodBase target, Type patchType)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (target == null)
			{
				Log.LogWarning((object)("Target missing for " + patchType.Name + ", skipping."));
				return;
			}
			object obj = Harmony;
			obj = target;
			obj = (object)((!(AccessTools.Method(patchType, "Prefix", (Type[])null, (Type[])null) != null)) ? ((HarmonyMethod)null) : new HarmonyMethod(patchType, "Prefix", (Type[])null));
			obj = (object)((!(AccessTools.Method(patchType, "Postfix", (Type[])null, (Type[])null) != null)) ? ((HarmonyMethod)null) : new HarmonyMethod(patchType, "Postfix", (Type[])null));
			((Harmony)obj).Patch((MethodBase)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogDebug((object)("Patched: " + target.DeclaringType?.FullName + "." + target.Name));
		}
	}
}