using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Content.Client.LanguageManager;
using Content.Client.LogManager;
using Content.Client.MenuSliderElement;
using Content.Client.Translator;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyCompany("REPO_Translator")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1+aa9cacd6f1b69b6572fa5b6ff37dff99eb6a1bbb")]
[assembly: AssemblyProduct("REPO_Translator")]
[assembly: AssemblyTitle("REPO_Translator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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 REPO_Translator
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "REPO_Translator";

		public const string PLUGIN_NAME = "REPO_Translator";

		public const string PLUGIN_VERSION = "1.1";
	}
}
namespace Content.Client.Translator
{
	public class REPO_Translator_Config
	{
		private readonly ConfigFile _configFile;

		public static ConfigEntry<bool> TranslatorDevModeEnabled;

		public static ConfigEntry<bool> HotReloadEnabled;

		public static ConfigEntry<bool> DevLogEnabled;

		public static ConfigEntry<bool> QuiteModeEnabled;

		public static ConfigEntry<string> TranslatorFileExtansion;

		public static ConfigEntry<string> SelectedTranslate;

		public string SelectedLanguageCode = "EN";

		public REPO_Translator_Config(ConfigFile configFile)
		{
			_configFile = configFile;
		}

		public void RegisterOptions()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			TranslatorDevModeEnabled = _configFile.Bind<bool>("General", "TranslatorDevModeEnabled", false, new ConfigDescription("If enabled, plugin will save new untranslated words in your Translate file (WARNING: Use carefully as ALL lines will be added, some lines do not need to be translated, since they have constantly changing meanings)", (AcceptableValueBase)new AcceptableValueRange<bool>(false, true), Array.Empty<object>()));
			HotReloadEnabled = _configFile.Bind<bool>("General", "HotReload", false, new ConfigDescription("If enabled, plugin will reload selected Translation when you editing translation file.", (AcceptableValueBase)new AcceptableValueRange<bool>(false, true), Array.Empty<object>()));
			DevLogEnabled = _configFile.Bind<bool>("General", "DevLog", false, new ConfigDescription("If enabled, plugin will log all untranslated strings and some dev information.", (AcceptableValueBase)new AcceptableValueRange<bool>(false, true), Array.Empty<object>()));
			QuiteModeEnabled = _configFile.Bind<bool>("General", "QuiteMode", true, new ConfigDescription("If enabled, plugin will log ONLY important information.", (AcceptableValueBase)new AcceptableValueRange<bool>(false, true), Array.Empty<object>()));
			TranslatorFileExtansion = _configFile.Bind<string>("General", "TranslatorFileExtansion", "YML", new ConfigDescription("you can change default file extantion to old(xml). IT WORKS ONLY WITH: YML, XML", (AcceptableValueBase)new AcceptableValueList<string>(new string[2] { "YML", "XML" }), Array.Empty<object>()));
			SelectedTranslate = _configFile.Bind<string>("General", "SelectedTranslate", "EN", new ConfigDescription("Set the name of what translate file you want to use, example: Translate_RU.yml -> RU / Translate_YourLangCode.yml -> YourLangCode", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[HarmonyPatch]
	[BepInPlugin("Great_REPO_Translator", "REPO_Translator", "1.4.0")]
	public class REPO_Translator : BaseUnityPlugin
	{
		public static REPO_Translator PluginInstance;

		public static REPO_Translator_Config ConfigInstance;

		public static Content.Client.LogManager.LogManager _logMan;

		public static Content.Client.LanguageManager.LanguageManager _langMan;

		public static Harmony HarmonyInstance;

		public static TMP_FontAsset PerfectFontCyrillicAsset;

		public static TMP_FontAsset VCROSDFontCyrillicAsset;

		public static TMP_FontAsset TekoRegularAsset;

		public static string TranslateFilePath;

		public static bool OneTimeInit;

		public static Dictionary<string, string> AlreadyTranslatedStrings;

		public static Dictionary<string, string> AlreadyTranslatedCodes;

		public static Dictionary<string, InputKey> tagDictionary = new Dictionary<string, InputKey>();

		public static List<Translate> AllTranslates;

		public static List<Translate> AllChatMessages;

		public static List<DatasetEntry> AllDatasets;

		private FileSystemWatcher _configWatcher;

		private static AssetBundle _languageSliderBundle;

		private static GameObject _languageSliderPrefab;

		private void Awake()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			PluginInstance = this;
			ConfigInstance = new REPO_Translator_Config(((BaseUnityPlugin)this).Config);
			ConfigInstance.RegisterOptions();
			_langMan = Content.Client.LanguageManager.LanguageManager.ManagerInstance ?? new Content.Client.LanguageManager.LanguageManager();
			_langMan.InitializeLanguages();
			_logMan = Content.Client.LogManager.LogManager.ManagerInstance ?? new Content.Client.LogManager.LogManager();
			LoadFonts();
			HarmonyInstance = new Harmony("REPO_Translator");
			HarmonyInstance.PatchAll();
			InitializeTranslator();
			_logMan.TryLog("Loaded!", LogType.Info);
		}

		private static void LoadFonts()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			string text = Path.Combine(Path.GetTempPath(), "PerfectDOSVGA437_CYRILLIC.ttf");
			using (Stream stream = LoadEmbeddedResource("REPO_Translator.Resources.Fonts.PerfectDOSVGA437_CYRILLIC.ttf"))
			{
				using FileStream destination = File.Create(text);
				stream.CopyTo(destination);
			}
			Font val = new Font(text);
			PerfectFontCyrillicAsset = TMP_FontAsset.CreateFontAsset(val);
			string text2 = Path.Combine(Path.GetTempPath(), "VCR_OSD_MONO_CYRILLIC.ttf");
			using (Stream stream2 = LoadEmbeddedResource("REPO_Translator.Resources.Fonts.VCR_OSD_MONO_CYRILLIC.ttf"))
			{
				using FileStream destination2 = File.Create(text2);
				stream2.CopyTo(destination2);
			}
			Font val2 = new Font(text2);
			VCROSDFontCyrillicAsset = TMP_FontAsset.CreateFontAsset(val2);
			string text3 = Path.Combine(Path.GetTempPath(), "TekoRegular.ttf");
			using (Stream stream3 = LoadEmbeddedResource("REPO_Translator.Resources.Fonts.TekoRegular.ttf"))
			{
				using FileStream destination3 = File.Create(text3);
				stream3.CopyTo(destination3);
			}
			Font val3 = new Font(text3);
			TekoRegularAsset = TMP_FontAsset.CreateFontAsset(val3);
		}

		public static Stream LoadEmbeddedResource(string name)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			return executingAssembly.GetManifestResourceStream(name);
		}

		private static void WatchConfigFile()
		{
			if (!REPO_Translator_Config.HotReloadEnabled.Value)
			{
				_logMan.TryLog("Hot Reload Disabled, startup denied", LogType.Info);
				return;
			}
			string translateFilePath = TranslateFilePath;
			string translatePath = GetTranslatePath();
			PluginInstance._configWatcher = new FileSystemWatcher(translateFilePath)
			{
				NotifyFilter = NotifyFilters.LastWrite
			};
			_logMan.TryLog("Setuping file watcher in: " + translateFilePath, LogType.Info);
			_logMan.TryLog("Watching file: Translate_" + _langMan.GetSelectedLanguage() + GetTranslateExtantion(), LogType.Info);
			PluginInstance._configWatcher.Filter = "Translate_" + _langMan.GetSelectedLanguage() + GetTranslateExtantion();
			PluginInstance._configWatcher.Changed += OnConfigFileChanged;
			PluginInstance._configWatcher.Created += OnConfigFileChanged;
			PluginInstance._configWatcher.Renamed += OnConfigFileChanged;
			PluginInstance._configWatcher.EnableRaisingEvents = true;
		}

		private static void OnConfigFileChanged(object sender, FileSystemEventArgs e)
		{
			_logMan.TryLog("Config file changed: " + e.FullPath + ", reloading...", LogType.Info);
			ReloadTranslations();
		}

		public static void ReloadTranslations()
		{
			try
			{
				LoadTranslationsFromFile();
				UpdateAllTextMeshProObjects();
				WatchConfigFile();
				_logMan.TryLog("Translations successfully reloaded.", LogType.Info);
			}
			catch (Exception arg)
			{
				_logMan.TryLog($"Error reloading translations: {arg}", LogType.Error);
			}
		}

		private static void UpdateAllTextMeshProObjects()
		{
			TMP_Text[] array = Object.FindObjectsOfType<TMP_Text>();
			foreach (TMP_Text textObject in array)
			{
				if ((Object)(object)textObject != (Object)null)
				{
					string text = AlreadyTranslatedStrings.FirstOrDefault((KeyValuePair<string, string> pair) => pair.Value == textObject.text).Key;
					string selectedLanguage = _langMan.GetSelectedLanguage();
					if (text != null && AlreadyTranslatedCodes[text] != selectedLanguage)
					{
						AlreadyTranslatedStrings.Remove(text);
						AlreadyTranslatedCodes.Remove(text);
						UpdateTextMeshProText(textObject, ref text);
						textObject.text = text;
					}
					else
					{
						string text2 = textObject.text;
						UpdateTextMeshProText(textObject, ref text2);
						textObject.text = text2;
					}
				}
			}
		}

		private static void UpdateTextMeshProText(TMP_Text textObject, ref string text, bool setText = true)
		{
			if ((Object)(object)textObject == (Object)null || string.IsNullOrEmpty(text) || (Object)(object)textObject.transform.root == (Object)null || _langMan == null)
			{
				return;
			}
			string name = ((Object)((Component)textObject.transform.root).gameObject).name;
			if (name == "UniverseLibCanvas" || name == "ExplorerCanvas" || int.TryParse(text, out var _))
			{
				return;
			}
			UpdateFontIfNeeded(textObject);
			if (AlreadyTranslatedStrings.TryGetValue(text, out var value))
			{
				if (setText && textObject.text != value)
				{
					textObject.SetText(value, true);
				}
				else
				{
					text = value;
				}
				return;
			}
			string exportText = text;
			Translate translate = AllTranslates?.Find((Translate t) => DisplayReplaceTags(t.key) == exportText.Trim());
			if (translate != null)
			{
				exportText = (translate.trim ? DisplayReplaceTags(translate.translate).Trim() : DisplayReplaceTags(translate.translate));
				AlreadyTranslatedStrings[text] = exportText;
				AlreadyTranslatedCodes[text] = _langMan.GetSelectedLanguage();
				ApplyTranslateSettings(textObject, translate);
			}
			else
			{
				List<Translate> list = AllTranslates?.Where((Translate t) => exportText.Contains(DisplayReplaceTags(t.key)) && t.part).ToList();
				if (list != null && list.Count > 0)
				{
					foreach (Translate item2 in list)
					{
						string text2 = (item2.trim ? item2.translate.Trim() : item2.translate);
						exportText = exportText.Replace(item2.key, item2.newLine ? (text2 + "<br>") : text2);
					}
					AlreadyTranslatedStrings[text] = exportText;
					AlreadyTranslatedCodes[text] = _langMan.GetSelectedLanguage();
					ApplyTranslateSettings(textObject, list.Last());
				}
				else if (!IsMessageUnwanted(exportText) && !exportText.Any(char.IsDigit))
				{
					string value2;
					if (REPO_Translator_Config.TranslatorDevModeEnabled.Value)
					{
						Translate item = new Translate
						{
							key = exportText,
							translate = exportText,
							size = textObject.fontSize
						};
						AllTranslates.Add(item);
						SaveTranslateData(AllTranslates);
					}
					else if (!AlreadyTranslatedStrings.TryGetValue(exportText, out value2))
					{
						_logMan.TryLog("WARNING: Untranslated Key: [" + exportText.Trim() + "]", LogType.Warning);
					}
				}
			}
			if ((Object)(object)StatsUI.instance != (Object)null && ((TMP_Text)StatsUI.instance.textNumbers).lineSpacing != ((TMP_Text)StatsUI.instance.Text).lineSpacing)
			{
				((TMP_Text)StatsUI.instance.textNumbers).lineSpacing = ((TMP_Text)StatsUI.instance.Text).lineSpacing;
			}
			if (setText)
			{
				textObject.SetText(exportText, true);
			}
			else
			{
				text = exportText;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ChatManager), "PossessChat")]
		public static bool ChatManager_PossessChat(ChatManager __instance, PossessChatID _possessChatID, ref string message, float typingSpeed, Color _possessColor, float _messageDelay, bool sendInTaxmanChat, int sendInTaxmanChatEmojiInt, UnityEvent eventExecutionAfterMessageIsDone)
		{
			string exportMessage = message;
			List<Translate> allChatMessages = AllChatMessages;
			if (allChatMessages != null && allChatMessages.Count > 0)
			{
				Translate translate = AllChatMessages.Find((Translate t) => DisplayReplaceTags(t.key) == exportMessage.Trim());
				List<Translate> list = AllChatMessages?.Where((Translate t) => exportMessage.Contains(DisplayReplaceTags(t.key)) && t.part).ToList();
				if (translate != null)
				{
					exportMessage = translate.translate;
				}
				else if (list != null && list.Any())
				{
					foreach (Translate item in list)
					{
						string text = (item.trim ? item.translate.Trim() : item.translate);
						exportMessage = exportMessage.Replace(item.key, item.newLine ? (text + "<br>") : text);
					}
				}
			}
			message = exportMessage;
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StatsUI), "Fetch")]
		public static bool StatsUI_Fetch(StatsUI __instance)
		{
			Dictionary<string, int> dictionary = StatsManager.instance.FetchPlayerUpgrades(PlayerController.instance.playerSteamID);
			if (__instance.playerUpgrades != null && __instance.playerUpgrades.Count == dictionary.Count && !__instance.playerUpgrades.Except(dictionary).Any())
			{
				return false;
			}
			__instance.playerUpgrades = StatsManager.instance.FetchPlayerUpgrades(PlayerController.instance.playerSteamID);
			((TMP_Text)__instance.Text).text = "";
			((TMP_Text)__instance.textNumbers).text = "";
			((Behaviour)__instance.upgradesHeader).enabled = false;
			__instance.scanlineObject.SetActive(false);
			foreach (KeyValuePair<string, int> playerUpgrade in __instance.playerUpgrades)
			{
				if (playerUpgrade.Value > 0)
				{
					string text = playerUpgrade.Key.ToUpper();
					if (!string.IsNullOrEmpty(((TMP_Text)__instance.Text).text))
					{
						TextMeshProUGUI text2 = __instance.Text;
						((TMP_Text)text2).text = ((TMP_Text)text2).text + "\n";
					}
					TextMeshProUGUI text3 = __instance.Text;
					((TMP_Text)text3).text = ((TMP_Text)text3).text + text;
					if (!string.IsNullOrEmpty(((TMP_Text)__instance.textNumbers).text))
					{
						TextMeshProUGUI textNumbers = __instance.textNumbers;
						((TMP_Text)textNumbers).text = ((TMP_Text)textNumbers).text + "\n";
					}
					TextMeshProUGUI textNumbers2 = __instance.textNumbers;
					((TMP_Text)textNumbers2).text = ((TMP_Text)textNumbers2).text + $"<b>{playerUpgrade.Value}</b>";
				}
			}
			if (!string.IsNullOrEmpty(((TMP_Text)__instance.Text).text))
			{
				((Behaviour)__instance.upgradesHeader).enabled = true;
				__instance.scanlineObject.SetActive(true);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(TextMeshProUGUI), "OnEnable")]
		public static bool OV_TextMeshProUGUI_OnEnable(TextMeshProUGUI __instance)
		{
			if ((Object)(object)__instance != (Object)null && AllTranslates != null)
			{
				string text = ((TMP_Text)__instance).text;
				UpdateTextMeshProText((TMP_Text)(object)__instance, ref text);
			}
			else if (AllTranslates == null)
			{
				_logMan.TryLog("AllTranslates is null!", LogType.Error);
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static bool OV_TMP_Text_text(TMP_Text __instance, ref string value)
		{
			if ((Object)(object)__instance != (Object)null)
			{
				UpdateTextMeshProText(__instance, ref value, setText: false);
			}
			return true;
		}

		public static bool IsMessageUnwanted(string message)
		{
			string text = Regex.Replace(message, "<.*?>", "").Trim();
			bool flag = Regex.IsMatch(text, "\\p{L}");
			bool flag2 = Regex.IsMatch(text, "^[\\d\\p{P}\\p{S}\\s]+$");
			bool flag3 = text.Contains("$");
			return !flag || flag2 || flag3;
		}

		public static string GetTranslatePath()
		{
			return TranslateFilePath + "\\Translate_" + _langMan.GetSelectedLanguage() + GetTranslateExtantion();
		}

		public static string GetTranslateExtantion()
		{
			return (REPO_Translator_Config.TranslatorFileExtansion.Value == "YML") ? ".yml" : ".xml";
		}

		public static List<Translate> GetTranslateData(bool ChatMessages = false)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			try
			{
				if (_langMan.GetSelectedLanguage() == "EN")
				{
					return new List<Translate>();
				}
				string translatePath = GetTranslatePath();
				string translateExtantion = GetTranslateExtantion();
				List<Translate> list = null;
				if (translateExtantion == ".yml")
				{
					string text = File.ReadAllText(translatePath);
					IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
					TranslationDataFile translationDataFile = val.Deserialize<TranslationDataFile>(text);
					list = translationDataFile.translations;
				}
				else
				{
					if (!(translateExtantion == ".xml"))
					{
						throw new Exception("Unsupported file extension: " + translateExtantion);
					}
					XmlSerializer xmlSerializer = new XmlSerializer(typeof(List<Translate>));
					using StreamReader textReader = new StreamReader(translatePath);
					list = (List<Translate>)xmlSerializer.Deserialize(textReader);
				}
				list.RemoveAll(delegate(Translate item)
				{
					bool flag = string.IsNullOrWhiteSpace(item.key) || string.IsNullOrWhiteSpace(item.translate);
					if (flag)
					{
						Console.WriteLine("Warning: skipped translation with missing 'key' or 'translate'");
					}
					return flag;
				});
				if (ChatMessages)
				{
					list = list.Where((Translate t) => t.ChatMessage).ToList();
				}
				return list;
			}
			catch (Exception ex)
			{
				Console.WriteLine("Error loading Translation file: " + ex.Message);
				return new List<Translate>();
			}
		}

		public static List<DatasetEntry> GetDatasetEntries()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			try
			{
				if (_langMan.GetSelectedLanguage() == "EN")
				{
					return new List<DatasetEntry>();
				}
				string translatePath = GetTranslatePath();
				string translateExtantion = GetTranslateExtantion();
				List<DatasetEntry> list = new List<DatasetEntry>();
				if (translateExtantion == ".yml")
				{
					string text = File.ReadAllText(translatePath);
					IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
					TranslationDataFile translationDataFile = val.Deserialize<TranslationDataFile>(text);
					list = translationDataFile.datasets;
					list.RemoveAll(delegate(DatasetEntry item)
					{
						bool flag = string.IsNullOrWhiteSpace(item.key) || item.translations.Count == 0;
						if (flag)
						{
							Console.WriteLine("Warning: skipped dataset with missing 'key' or 'translations'");
						}
						return flag;
					});
					return list;
				}
				throw new Exception("Unsupported file extension: " + translateExtantion);
			}
			catch (Exception ex)
			{
				Console.WriteLine("Error loading Datasets from file: " + ex.Message);
				return new List<DatasetEntry>();
			}
		}

		public static void SaveTranslateData(List<Translate> translations)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			try
			{
				string translatePath = GetTranslatePath();
				string translateExtantion = GetTranslateExtantion();
				TranslationDataFile translationDataFile = new TranslationDataFile
				{
					translations = translations,
					datasets = AllDatasets
				};
				if (translateExtantion == ".yml")
				{
					ISerializer val = ((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
					string contents = val.Serialize((object)translationDataFile);
					File.WriteAllText(GetTranslatePath(), contents);
					return;
				}
				if (translateExtantion == ".xml")
				{
					TextWriter textWriter = new StreamWriter(GetTranslatePath());
					new XmlSerializer(typeof(List<Translate>)).Serialize(textWriter, translations);
					textWriter.Close();
					return;
				}
				throw new Exception("Unsupported file extension: " + translateExtantion);
			}
			catch (Exception ex)
			{
				Console.WriteLine("Error saving Translation YAML: " + ex.Message);
			}
		}

		public static string DisplayReplaceTags(string _text)
		{
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			if (_text == null || (Object)(object)InputManager.instance == (Object)null || tagDictionary == null || tagDictionary.Count == 0)
			{
				return _text;
			}
			string text = _text;
			foreach (KeyValuePair<string, InputKey> item in tagDictionary)
			{
				if (item.Key == "[move]" && text.Contains(item.Key))
				{
					string text2 = DisplayTextReplace(InputManager.instance.GetMovementKeyString((MovementDirection)0).Split('/')[^1].ToUpper());
					string text3 = DisplayTextReplace(InputManager.instance.GetMovementKeyString((MovementDirection)2).Split('/')[^1].ToUpper());
					string text4 = DisplayTextReplace(InputManager.instance.GetMovementKeyString((MovementDirection)1).Split('/')[^1].ToUpper());
					string text5 = DisplayTextReplace(InputManager.instance.GetMovementKeyString((MovementDirection)3).Split('/')[^1].ToUpper());
					text = text.Replace(item.Key, "<u><b>" + text2 + text3 + text4 + text5 + "</b></u>");
				}
				else if (text.Contains(item.Key))
				{
					string keyString = InputManager.instance.GetKeyString(item.Value);
					string text6 = DisplayTextReplace(keyString.Split('/')[^1].ToUpper());
					if (keyString.Contains("scroll/y"))
					{
						text6 = DisplayTextReplace(keyString);
					}
					text = text.Replace(item.Key, "<u><b>" + text6 + "</b></u>");
				}
			}
			return text;
		}

		public static string DisplayTextReplace(string text)
		{
			switch (text)
			{
			case "CTRL":
				return "CONTROL";
			case "LEFTSHIFT":
				return "LEFT SHIFT";
			case "LEFTBUTTON":
				return "MOUSE LEFT";
			case "RIGHTBUTTON":
				return "MOUSE RIGHT";
			case "MIDDLEBUTTON":
				return "MOUSE MIDDLE";
			default:
				if (text.Contains("scroll/y"))
				{
					return "MOUSE SCROLL";
				}
				return text;
			}
		}

		public static void LoadTranslationsFromFile()
		{
			if (!File.Exists(GetTranslatePath()))
			{
				AllTranslates = new List<Translate>();
				if (REPO_Translator_Config.TranslatorDevModeEnabled.Value)
				{
					SaveTranslateData(AllTranslates);
				}
				else
				{
					_logMan.TryLog("I can't find translations file, maybe... You don't correct install me? Check instruction on: https://github.com/Rinary1/GreatREPOTranslator", LogType.Error);
				}
			}
			else
			{
				AllTranslates = GetTranslateData();
				AllChatMessages = GetTranslateData(ChatMessages: true);
				AllDatasets = GetDatasetEntries();
			}
		}

		public List<string> GetAllAvailableTranslations()
		{
			string searchPattern = "Translate_*" + GetTranslateExtantion();
			if (!Directory.Exists(TranslateFilePath))
			{
				TranslateFilePath = Path.GetDirectoryName(((BaseUnityPlugin)PluginInstance).Info.Location);
			}
			string[] files = Directory.GetFiles(TranslateFilePath, searchPattern);
			return (from f in files
				select Path.GetFileNameWithoutExtension(f) into name
				where name.StartsWith("Translate_")
				select name.Replace("Translate_", "")).ToList();
		}

		public int GetAvailableTranslationsCount()
		{
			return GetAllAvailableTranslations().Count;
		}

		[HarmonyPatch(typeof(MenuPageSettingsPage), "Start")]
		[HarmonyPostfix]
		private static void MenuPageSettings_StartHook(MenuPageSettingsPage __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.settingType != 1)
			{
				return;
			}
			MenuPage component = ((Component)__instance).GetComponent<MenuPage>();
			if ((Object)(object)component == (Object)null)
			{
				_logMan.TryLog("Page not founded", LogType.Error);
				return;
			}
			Transform val = FindDeepChild(((Component)component).transform, "Scroller");
			if ((Object)(object)val == (Object)null)
			{
				_logMan.TryLog("Scroller not found inside page", LogType.Error);
				return;
			}
			if ((Object)(object)_languageSliderBundle == (Object)null || (Object)(object)_languageSliderPrefab == (Object)null)
			{
				_logMan.TryLog("Loading AssetBundle and prefab for the first time...", LogType.Info);
				Stream stream = LoadEmbeddedResource("REPO_Translator.Resources.prefab.unity3d");
				string text = Path.Combine(Path.GetTempPath(), "prefab.unity3d");
				if (!File.Exists(text))
				{
					using FileStream destination = File.Create(text);
					stream.CopyTo(destination);
				}
				_languageSliderBundle = AssetBundle.LoadFromFile(text);
				if ((Object)(object)_languageSliderBundle == (Object)null)
				{
					_logMan.TryLog("Failed to load AssetBundle.", LogType.Error);
					return;
				}
				_languageSliderPrefab = _languageSliderBundle.LoadAsset<GameObject>("LanguageSlider");
				if ((Object)(object)_languageSliderPrefab == (Object)null)
				{
					_logMan.TryLog("Failed to load prefab 'LanguageSlider' from bundle.", LogType.Error);
					return;
				}
			}
			GameObject val2 = Object.Instantiate<GameObject>(_languageSliderPrefab, val, false);
			Vector3 localPosition = val2.transform.localPosition;
			localPosition.x = 3.7f;
			val2.transform.localPosition = localPosition;
			InsertAndShiftByY(val, val2, 4);
			_logMan.TryLog("Language slider added to Gameplay settings", LogType.Info);
			val2.AddComponent<MenuSliderLanguage>();
		}

		private static void InsertAndShiftByY(Transform parent, GameObject newObj, int insertIndex)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)parent == (Object)null || (Object)(object)newObj == (Object)null)
			{
				return;
			}
			if (parent.childCount <= insertIndex)
			{
				_logMan.TryLog("Insert index out of range", LogType.Error);
				return;
			}
			Transform child = parent.GetChild(insertIndex);
			Vector3 localPosition = child.localPosition;
			Vector3 val = ((insertIndex > 0) ? parent.GetChild(insertIndex + 1).localPosition : localPosition);
			float num = localPosition.y - val.y;
			Transform transform = newObj.transform;
			Vector3 localPosition2 = transform.localPosition;
			localPosition2.y = localPosition.y;
			transform.SetParent(parent, false);
			transform.localPosition = localPosition2;
			transform.SetSiblingIndex(insertIndex);
			for (int i = insertIndex + 1; i < parent.childCount; i++)
			{
				Transform child2 = parent.GetChild(i);
				Vector3 localPosition3 = child2.localPosition;
				localPosition3.y -= num;
				child2.localPosition = localPosition3;
			}
		}

		public static Transform FindDeepChild(Transform parent, string name)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (((Object)val).name == name)
				{
					return val;
				}
				Transform val2 = FindDeepChild(val, name);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}

		private static void UpdateFontIfNeeded(TMP_Text textObject)
		{
			string name = ((Object)textObject.font).name;
			if (name.Contains("Perfect") && (Object)(object)textObject.font != (Object)(object)PerfectFontCyrillicAsset)
			{
				textObject.font = PerfectFontCyrillicAsset;
			}
			else if (name.Contains("VCR OSD") && (Object)(object)textObject.font != (Object)(object)VCROSDFontCyrillicAsset)
			{
				textObject.font = VCROSDFontCyrillicAsset;
			}
			else if (name.Contains("Teko") && (Object)(object)textObject.font != (Object)(object)TekoRegularAsset)
			{
				textObject.font = TekoRegularAsset;
			}
		}

		private static void ApplyTranslateSettings(TMP_Text textObject, Translate translate)
		{
			if (translate.size != 0f)
			{
				textObject.fontSize = translate.size;
				textObject.lineSpacing = ((translate.lineSpacing != 0f) ? translate.lineSpacing : textObject.lineSpacing);
				textObject.enableAutoSizing = false;
			}
			else
			{
				textObject.fontSizeMax = textObject.fontSize;
				textObject.fontSizeMin = translate.autoSizingFontMin;
				textObject.lineSpacing = ((translate.lineSpacing != 0f) ? translate.lineSpacing : textObject.lineSpacing);
				textObject.enableAutoSizing = translate.autoSizing;
			}
		}

		public void InitializeTranslator()
		{
			if (_langMan == null)
			{
				_logMan.TryLog("Language Manager not founded! NULL: Disabling Translator!", LogType.Fatal);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else if (_langMan.GetSelectedLanguage() == null)
			{
				_logMan.TryLog("Selected Language not founded! NULL: Disabling Translator!", LogType.Fatal);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else if (!OneTimeInit)
			{
				_logMan.TryLog("Selected Translate: " + _langMan.GetSelectedLanguage(), LogType.Info);
				_logMan.TryLog($"DEVMODE Translate Enabled?: {REPO_Translator_Config.TranslatorDevModeEnabled.Value}", LogType.Info);
				TranslateFilePath = Path.GetDirectoryName(((BaseUnityPlugin)PluginInstance).Info.Location);
				_logMan.TryLog("TranslateFilePath: " + GetTranslatePath(), LogType.Info);
				if (REPO_Translator_Config.TranslatorDevModeEnabled.Value)
				{
					_logMan.TryLog("WARNING: YOU HAVE ENABLED DEVMODE TRANSLATOR, DO NOT EDIT THE TRANSLATE FILE BEFORE TURNING OFF THE GAME!!!!", LogType.Warning);
				}
				AlreadyTranslatedStrings = new Dictionary<string, string>();
				AlreadyTranslatedCodes = new Dictionary<string, string>();
				LoadTranslationsFromFile();
				OneTimeInit = true;
				WatchConfigFile();
				tagDictionary.Add("[move]", (InputKey)0);
				tagDictionary.Add("[jump]", (InputKey)1);
				tagDictionary.Add("[grab]", (InputKey)10);
				tagDictionary.Add("[grab2]", (InputKey)11);
				tagDictionary.Add("[sprint]", (InputKey)15);
				tagDictionary.Add("[crouch]", (InputKey)12);
				tagDictionary.Add("[map]", (InputKey)8);
				tagDictionary.Add("[inventory1]", (InputKey)19);
				tagDictionary.Add("[inventory2]", (InputKey)20);
				tagDictionary.Add("[inventory3]", (InputKey)21);
				tagDictionary.Add("[tumble]", (InputKey)14);
				tagDictionary.Add("[interact]", (InputKey)2);
				tagDictionary.Add("[push]", (InputKey)4);
				tagDictionary.Add("[pull]", (InputKey)5);
				tagDictionary.Add("[chat]", (InputKey)7);
			}
		}
	}
	public class TranslationDataFile
	{
		public List<Translate> translations { get; set; } = new List<Translate>();


		public List<DatasetEntry> datasets { get; set; } = new List<DatasetEntry>();

	}
	public abstract class TranslationEntry
	{
		public string type { get; set; }
	}
	public class Translate : TranslationEntry
	{
		[XmlAttribute]
		public string key { get; set; } = "";


		[XmlAttribute]
		public string translate { get; set; } = "";


		[XmlAttribute]
		public float size { get; set; } = 0f;


		[XmlAttribute]
		public float lineSpacing { get; set; } = 0f;


		[XmlAttribute]
		public bool autoSizing { get; set; } = true;


		[XmlAttribute]
		public float autoSizingFontMin { get; set; } = 0f;


		[XmlAttribute]
		public bool part { get; set; } = false;


		[XmlAttribute]
		public bool trim { get; set; } = false;


		[XmlAttribute]
		public bool newLine { get; set; } = false;


		[XmlAttribute]
		public bool ChatMessage { get; set; } = false;


		public Translate()
		{
			base.type = "Translation";
		}
	}
	public class DatasetEntry : TranslationEntry
	{
		public string key { get; set; } = "";


		public List<string> translations { get; set; } = new List<string>();


		public DatasetEntry()
		{
			base.type = "Dataset";
		}
	}
}
namespace Content.Client.MenuSliderElement
{
	public class MenuSliderLanguage : MonoBehaviour
	{
		private MenuSlider? menuSlider;

		public UnityEvent? langEvent;

		private int currentLangCount = 0;

		private static Content.Client.Translator.REPO_Translator _Translator = Content.Client.Translator.REPO_Translator.PluginInstance;

		private static Content.Client.LanguageManager.LanguageManager _langMan = Content.Client.Translator.REPO_Translator._langMan;

		private static Content.Client.LogManager.LogManager _logMan = Content.Client.Translator.REPO_Translator._logMan;

		private static REPO_Translator_Config _config = Content.Client.Translator.REPO_Translator.ConfigInstance;

		public void Start()
		{
			menuSlider = ((Component)this).GetComponent<MenuSlider>();
			SetOptions();
		}

		private void Update()
		{
			if ((Object)(object)menuSlider == (Object)null)
			{
				return;
			}
			if (currentLangCount != _Translator.GetAvailableTranslationsCount())
			{
				SetOptions();
				return;
			}
			if (_langMan == null || _langMan.Languages == null || _langMan.Languages.Count == 0)
			{
				_langMan = Content.Client.LanguageManager.LanguageManager.ManagerInstance ?? new Content.Client.LanguageManager.LanguageManager();
				_langMan.InitializeLanguages();
				if (_langMan.Languages == null || _langMan.Languages.Count == 0)
				{
					return;
				}
			}
			else if (_langMan.GetSelectedLanguage() == null)
			{
				Debug.LogError((object)"Selected Language not founded! NULL: Disabling Translator!");
				return;
			}
			string customOptionText = menuSlider.customOptions[menuSlider.currentValue].customOptionText;
			if (!string.IsNullOrEmpty(customOptionText) && _langMan.GetSelectedLanguage() != customOptionText)
			{
				_config.SelectedLanguageCode = customOptionText;
				REPO_Translator_Config.SelectedTranslate.Value = customOptionText;
				_langMan.SaveLanguage();
				Content.Client.Translator.REPO_Translator.ReloadTranslations();
			}
		}

		private void SetOptions()
		{
			if ((Object)(object)menuSlider == (Object)null)
			{
				return;
			}
			menuSlider.customOptions.Clear();
			menuSlider.hasCustomOptions = true;
			menuSlider.hasCustomValues = true;
			if (_langMan == null)
			{
				_langMan = Content.Client.LanguageManager.LanguageManager.ManagerInstance ?? new Content.Client.LanguageManager.LanguageManager();
				_langMan.InitializeLanguages();
			}
			string selectedLanguage = _langMan.GetSelectedLanguage();
			int num = 0;
			List<string> allAvailableTranslations = _Translator.GetAllAvailableTranslations();
			_logMan.TryLog($"Found {allAvailableTranslations.Count} translations.", LogType.Info);
			for (int i = 0; i < allAvailableTranslations.Count; i++)
			{
				string text = allAvailableTranslations[i];
				int num2 = i;
				menuSlider.CustomOptionAdd(text, langEvent);
				menuSlider.customOptions[i].customValueInt = i;
				_logMan.TryLog("Add translate to tab: " + text, LogType.Info);
				if (text.Equals(selectedLanguage, StringComparison.OrdinalIgnoreCase))
				{
					num = i;
					_logMan.TryLog("Finded selected language code: " + text, LogType.Info);
				}
			}
			if (num >= 0 && menuSlider.customOptions.Count > 1)
			{
				float bar = (float)num / (float)(menuSlider.customOptions.Count - 1);
				menuSlider.SetBar(bar);
				menuSlider.SetBarScaleInstant();
				menuSlider.UpdateSegmentTextAndValue();
			}
			currentLangCount = allAvailableTranslations.Count;
		}
	}
}
namespace Content.Client.LogManager
{
	public class LogManager
	{
		public static ManualLogSource LogInstance = Logger.CreateLogSource("Great Repo Translator");

		public static LogManager ManagerInstance { get; internal set; }

		private void Awake()
		{
			ManagerInstance = this;
		}

		public bool TryLog(string? message, LogType type)
		{
			if (message == null)
			{
				return false;
			}
			try
			{
				Log(message, type);
				return true;
			}
			catch (ArgumentException ex)
			{
				LogInstance.LogError((object)ex.Message);
				return false;
			}
		}

		public void Log(string message, LogType type)
		{
			switch (type)
			{
			case LogType.Debug:
				if (REPO_Translator_Config.DevLogEnabled.Value)
				{
					LogInstance.LogDebug((object)message);
				}
				break;
			case LogType.Warning:
				if (REPO_Translator_Config.DevLogEnabled.Value)
				{
					LogInstance.LogWarning((object)message);
				}
				break;
			case LogType.Error:
				if (!REPO_Translator_Config.QuiteModeEnabled.Value)
				{
					LogInstance.LogError((object)message);
				}
				break;
			case LogType.Fatal:
				LogInstance.LogFatal((object)message);
				break;
			case LogType.Info:
				if (!REPO_Translator_Config.QuiteModeEnabled.Value)
				{
					LogInstance.LogInfo((object)message);
				}
				break;
			case LogType.Regular:
				if (!REPO_Translator_Config.QuiteModeEnabled.Value)
				{
					LogInstance.LogMessage((object)message);
				}
				break;
			default:
				throw new ArgumentException("AH! I DON'T KNOW WHY YOU LOG NON AVAILABLE TYPE!");
			}
		}
	}
	public enum LogType
	{
		Debug,
		Warning,
		Error,
		Fatal,
		Info,
		Regular
	}
}
namespace Content.Client.LanguageManager
{
	public class LanguageManager
	{
		public static string DefaultLanguageCode = "EN";

		public Dictionary<string, string> Languages = new Dictionary<string, string>();

		private static REPO_Translator_Config _config = Content.Client.Translator.REPO_Translator.ConfigInstance;

		private static Content.Client.LogManager.LogManager _logMan = Content.Client.Translator.REPO_Translator._logMan;

		public static LanguageManager ManagerInstance { get; internal set; }

		private void Awake()
		{
			ManagerInstance = this;
			Debug.Log((object)"[Translator Init] LanguageManager Initialized");
			InitializeLanguages();
			LoadLanguage();
		}

		public void InitializeLanguages()
		{
			Debug.Log((object)$"[Translator Init] PluginInstance: {Content.Client.Translator.REPO_Translator.PluginInstance}");
			List<string> allAvailableTranslations = Content.Client.Translator.REPO_Translator.PluginInstance.GetAllAvailableTranslations();
			if (allAvailableTranslations == null)
			{
				Debug.LogError((object)"[Translator Init] GetAllAvailableTranslations() returned null!");
				return;
			}
			if (Languages == null)
			{
				Debug.LogError((object)"[Translator Init] Languages dictionary is null!");
				return;
			}
			foreach (string item in allAvailableTranslations)
			{
				try
				{
					CultureInfo cultureInfo = new CultureInfo(item);
					Languages.Add(item, cultureInfo.EnglishName);
				}
				catch (CultureNotFoundException)
				{
					_logMan.TryLog("Language '" + item + "' not founded as real.", LogType.Error);
				}
			}
		}

		public string GetSelectedLanguage()
		{
			if (!string.IsNullOrEmpty(_config.SelectedLanguageCode))
			{
				return REPO_Translator_Config.SelectedTranslate.Value;
			}
			_logMan.TryLog("SELECTED LANGUAGE NOT FOUNDED, RETURNED EN", LogType.Error);
			return "EN";
		}

		public void LoadLanguage()
		{
			try
			{
				string value = REPO_Translator_Config.SelectedTranslate.Value;
				if (string.IsNullOrEmpty(value))
				{
					_logMan.TryLog("Loaded language is null or empty, falling back to EN.", LogType.Error);
					REPO_Translator_Config.SelectedTranslate.Value = "EN";
				}
			}
			catch (Exception ex)
			{
				_logMan.TryLog("Failed to load language: " + ex.Message, LogType.Error);
				SaveLanguage();
			}
		}

		public void SaveLanguage()
		{
			REPO_Translator_Config.SelectedTranslate.Value = _config.SelectedLanguageCode;
		}
	}
}
namespace Content.Client.ChatManagerTranslate
{
	public class ChatManagerTranslate
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(ChatManager), "TumbleInterruption")]
		public static bool ChatManager_TumbleInterruption(ChatManager __instance)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			List<DatasetEntry> allDatasets = Content.Client.Translator.REPO_Translator.AllDatasets;
			DatasetEntry datasetEntry = allDatasets.Find((DatasetEntry t) => t.key == "TumbleInterruption");
			if (datasetEntry != null)
			{
				if (!(__instance.activePossessionTimer > 0f))
				{
					__instance.PossessionReset();
					if (Object.op_Implicit((Object)(object)__instance.playerAvatar) && __instance.playerAvatar.voiceChatFetched && __instance.playerAvatar.voiceChat.ttsVoice.isSpeaking)
					{
						List<string> translations = datasetEntry.translations;
						int index = Random.Range(0, translations.Count);
						string text = translations[index];
						__instance.PossessChatScheduleStart(3);
						__instance.PossessChat((PossessChatID)2, text, 1f, Color.red, 0f, false, 0, (UnityEvent)null);
						__instance.PossessChatScheduleEnd();
						return false;
					}
					return true;
				}
				return true;
			}
			return true;
		}
	}
}