using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using TurronishMod.Logger;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ControlDoblaje")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ControlDoblaje")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fa4defe9-2a53-4511-a7a4-e9af13103075")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ControlDoblaje;

public class DoblejeUIMarker : MonoBehaviour
{
}
public class CoroutineHolder : MonoBehaviour
{
	private static CoroutineHolder _inst;

	private static void Ensure()
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Expected O, but got Unknown
		if (!((Object)(object)_inst != (Object)null) || !((Object)(object)((Component)_inst).gameObject != (Object)null))
		{
			GameObject val = new GameObject("_CoroutineHolder");
			Object.DontDestroyOnLoad((Object)(object)val);
			_inst = val.AddComponent<CoroutineHolder>();
		}
	}

	public static void Inicia(IEnumerator r)
	{
		Ensure();
		((MonoBehaviour)_inst).StartCoroutine(r);
	}
}
public static class Layout
{
	public static float FontCabecera = 22f;

	public static float FontEtiqueta = 20f;

	public static float FontDropdown = 20f;

	public static float FontDropItem = 18f;

	public static float FontDescTitulo = 22f;

	public static float FontDescTexto = 18f;

	public static float FontBoton = 18f;

	public static float FontInput = 18f;

	public static float FontChevron = 16f;

	public static float AltoCabecera = 48f;

	public static float AltoFila = 48f;

	public static float AltoFilaGrid = 48f;

	public static float AltoDropdown = 36f;

	public static float AltoBoton = 36f;

	public static float AltoInput = 36f;

	public static float AltoItemPopup = 36f;

	public static float AnchoEtiqueta = 200f;

	public static float AnchoEtiquetaGrid = 160f;

	public static float AnchoDropdownNormal = 400f;

	public static float AnchoDropdownGrid = 380f;

	public static float AnchoDropdownPreset = 320f;

	public static float AnchoBoton = 280f;

	public static float AnchoBotonBorrar = 220f;

	public static float AnchoInput = 300f;

	public static float GridSepWidth = 2f;

	public static void CalibrateFrom(Transform tabRoot)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Expected O, but got Unknown
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)tabRoot == (Object)null)
		{
			return;
		}
		ScrollRect componentInChildren = ((Component)tabRoot).GetComponentInChildren<ScrollRect>(true);
		Transform val = (Transform)(object)((componentInChildren != null) ? componentInChildren.content : null);
		if ((Object)(object)val == (Object)null)
		{
			ControlDoblajePlugin.Log.LogWarning((object)"[Layout] CalibrateFrom: no ScrollRect content");
			return;
		}
		foreach (Transform item in val)
		{
			Transform val2 = item;
			if (((Object)val2).name.StartsWith("*"))
			{
				continue;
			}
			RectTransform component = ((Component)val2).GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				continue;
			}
			float y = component.sizeDelta.y;
			if (y < 20f || y > 200f)
			{
				continue;
			}
			TMP_Text componentInChildren2 = ((Component)val2).GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				float fontSize = componentInChildren2.fontSize;
				FontEtiqueta = Mathf.Round(fontSize * 0.9f);
				FontDropdown = FontEtiqueta;
				FontDropItem = Mathf.Round(fontSize * 0.82f);
				FontCabecera = Mathf.Round(fontSize * 0.9f);
				FontBoton = Mathf.Round(fontSize * 0.78f);
				FontInput = Mathf.Round(fontSize * 0.78f);
				FontDescTitulo = Mathf.Round(fontSize * 1.8f);
				FontDescTexto = Mathf.Round(fontSize * 1.56f);
				FontChevron = Mathf.Round(fontSize * 0.6f);
				AltoFila = Mathf.Clamp(y, 44f, 72f);
				AltoFilaGrid = AltoFila;
				AltoCabecera = AltoFila;
				AltoDropdown = Mathf.Clamp(Mathf.Round(AltoFila * 0.6f), 30f, 44f);
				AltoBoton = AltoDropdown;
				AltoInput = AltoDropdown;
				AltoItemPopup = Mathf.Clamp(Mathf.Round(AltoFila * 0.64f), 32f, 48f);
				ControlDoblajePlugin.Log.LogInfo((object)$"[Layout] Calibrado desde '{((Object)val2).name}': srcH={y} srcFont={fontSize} -> AltoFila={AltoFila} FontLabel={FontEtiqueta}");
			}
			return;
		}
		ControlDoblajePlugin.Log.LogWarning((object)"[Layout] CalibrateFrom: no se encontro fila valida, usando defaults.");
	}
}
[BepInPlugin("com.enadoblaje.control", "ENA Control de Doblaje", "1.1.0")]
public class ControlDoblajePlugin : BaseUnityPlugin
{
	public static Action InstalarAudioScanners;

	public static Action<Harmony> PatchAudioExtra;

	public static Action SceneLoadedAudio;

	public static Func<IEnumerator> AplicarModelosCallback;

	public static Action<bool> WandererRadioMute;

	public static Action ModelosAplicar;

	public static Action ModelosRestaurar;

	public static Action SoundPlayRandom;

	public static Action UIResetarEstado;

	public static Action UIExtrasTurronishReset;

	public static Func<IEnumerator> UIExtrasTurronishInyectar;

	public static Action<GameObject, GameObject, GameObject> UIAttachLogoMonitor;

	public static Action<Harmony> UITryInstalarPatch;

	public static Action<string, string, string, string> UIMostrarAvisoActualizacion;

	public static Action VideoExtrasInicio;

	public static Action VideoExtrasFin;

	private static int _frameNum = 0;

	private static readonly HashSet<string> _carpetasOcultas = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Ambiente" };

	public static Func<HashSet<string>> AudioObtenerPersonajesDeBank;

	public static Action AudioForzarCargaBanks;

	public static ControlDoblajePlugin Instance { get; private set; }

	public static ManualLogSource Log { get; private set; }

	public static string VoicesPath { get; private set; }

	public static string VideoClipsPath { get; private set; }

	public static string ImagesPath { get; private set; }

	public static string MeshPath { get; private set; }

	public static string BanksPath { get; private set; }

	public static string AssetsRoot { get; private set; }

	public static Dictionary<string, bool> PersonajeActivo { get; private set; } = new Dictionary<string, bool>();

	public static List<string> PersonajesDisponibles { get; private set; } = new List<string>();

	public static bool VideoClipsActivo { get; set; } = true;

	public static bool ImagenesActivas { get; set; } = true;

	public static bool ModelosActivos { get; set; } = true;

	public static int VarianteENA { get; set; } = 0;

	public static bool VarianteENAMeanie => VarianteENA == 1;

	public static int VarianteTaxi { get; set; } = 0;

	public static int VarianteYowadama { get; set; } = 0;

	public static bool LogVerboso { get; set; } = false;

	public static bool LogoBtnActivo { get; set; } = true;

	public static bool BuscarActualizaciones { get; set; } = true;

	public static string URLVersion { get; set; } = "";

	public static bool EnTransicion { get; set; } = false;

	public static float VideoClipStartTime { get; set; } = -1f;

	public static Dictionary<string, string> NombresUI { get; private set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

	public static Dictionary<string, string> DescripcionesUI { get; private set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

	public static Dictionary<string, string> DescripcionesUI_EN { get; private set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

	public static Dictionary<string, string> KeyOverride { get; private set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

	public static HashSet<string> VirtualPersonajes { get; private set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private static string PersonajesConfigPath => Path.Combine(Path.GetDirectoryName(typeof(ControlDoblajePlugin).Assembly.Location), "personajes_config.json");

	private static string ConfigPath => Path.Combine(Paths.ConfigPath, "ENADoblaje_config.json");

	public static string NombreUIDePersonaje(string carpeta)
	{
		string value;
		return NombresUI.TryGetValue(carpeta, out value) ? value : carpeta;
	}

	public static string DescripcionUIDePersonaje(string carpeta)
	{
		Dictionary<string, string> dictionary = (Traducciones.TextoEspanolActivo ? DescripcionesUI : DescripcionesUI_EN);
		if (!dictionary.TryGetValue(carpeta, out var value) || string.IsNullOrEmpty(value))
		{
			DescripcionesUI.TryGetValue(carpeta, out value);
		}
		if (string.IsNullOrEmpty(value))
		{
			return null;
		}
		return value.Replace("\n\\ ", "\n").Replace("\n\\", "\n");
	}

	public static string KeyDePersonaje(string carpeta)
	{
		string value;
		return KeyOverride.TryGetValue(carpeta, out value) ? value : carpeta;
	}

	private void Update()
	{
		_frameNum++;
		float unscaledDeltaTime = Time.unscaledDeltaTime;
		if (unscaledDeltaTime > 0.1f && _frameNum > 2)
		{
			Log.LogWarning((object)$"[PERF] frame lento #{_frameNum}: {(int)(unscaledDeltaTime * 1000f)}ms (~{(int)(1f / unscaledDeltaTime)}fps)");
		}
	}

	private static string ResolverCarpetaAssets()
	{
		string directoryName = Path.GetDirectoryName(typeof(ControlDoblajePlugin).Assembly.Location);
		string text = Path.Combine(Paths.BepInExRootPath, "Assets");
		string[] array = new string[4]
		{
			directoryName,
			Path.Combine(directoryName, "Assets"),
			text,
			Path.Combine(Path.GetDirectoryName(Application.dataPath), "BepInEx", "Assets")
		};
		string[] array2 = array;
		foreach (string text2 in array2)
		{
			try
			{
				if (File.Exists(Path.Combine(text2, "assets.dat")) || File.Exists(Path.Combine(text2, "audio.dat")) || File.Exists(Path.Combine(text2, "turronish_img.dat")))
				{
					return text2;
				}
			}
			catch
			{
			}
		}
		return text;
	}

	private void Awake()
	{
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		string text = Path.Combine(Paths.BepInExRootPath, "Logs", "Turronish");
		TurronishDiagLogger.Initialize(Log, text, (TLogMode)0);
		TurronishDiagLogger.Verbose = LogVerboso;
		try
		{
			string text2 = (AssetsRoot = ResolverCarpetaAssets());
			Log.LogInfo((object)("[Paths] dataPath='" + Application.dataPath + "' dllDir='" + Path.GetDirectoryName(typeof(ControlDoblajePlugin).Assembly.Location) + "' → bepAssets='" + text2 + "'"));
			AssetPack.Init(text2);
			VoicesPath = Path.Combine(text2, "Voices");
			VideoClipsPath = Path.Combine(text2, "VideoClips");
			ImagesPath = Path.Combine(text2, "Images");
			MeshPath = Path.Combine(text2, "Mesh");
			BanksPath = Path.Combine(text2, "Banks");
			EscanearPersonajes();
			CargarConfig();
			CargarPersonajesConfig();
			Traducciones.CargarDesdeJSON();
			Harmony val = new Harmony("com.enadoblaje.control");
			val.PatchAll();
			UITryInstalarPatch?.Invoke(val);
			PatchAudioExtra?.Invoke(val);
			InstalarAudioScanners?.Invoke();
			SceneManager.sceneLoaded += SceneLoaded_Handler;
			TurronishDiagLogger.Info("[Core]", "Awake completado. sceneLoaded registrado.");
		}
		catch (Exception ex)
		{
			TurronishDiagLogger.Error("[Core]", "EXCEPCION EN AWAKE: " + ex.GetType().Name + " — " + ex.Message + "\n" + ex.StackTrace);
			Log.LogError((object)("[Turronish] EXCEPCION EN AWAKE: " + ex.Message + "\n" + ex.StackTrace));
		}
	}

	private void SceneLoaded_Handler(Scene scene, LoadSceneMode mode)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			SceneLoaded_Impl(scene, mode);
		}
		catch (Exception ex)
		{
			Log.LogError((object)("[Turronish] SceneLoaded exception: " + ex.Message + "\n" + ex.StackTrace));
		}
	}

	private void SceneLoaded_Impl(Scene scene, LoadSceneMode mode)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		Log.LogInfo((object)("[Turronish] sceneLoaded: '" + ((Scene)(ref scene)).name + "'"));
		TurronishDiagLogger.Info("[Core]", $"sceneLoaded: '{((Scene)(ref scene)).name}' mode={mode}");
		EnTransicion = true;
		UIResetarEstado?.Invoke();
		UIExtrasTurronishReset?.Invoke();
		SceneLoadedAudio?.Invoke();
		if (((Scene)(ref scene)).name == "Boot" && PersonajesDisponibles.Count == 0)
		{
			AudioForzarCargaBanks?.Invoke();
			if (AudioObtenerPersonajesDeBank != null)
			{
				EscanearPersonajes();
				CargarPersonajesConfig();
			}
		}
		if (((Scene)(ref scene)).name.IndexOf("Credit", StringComparison.OrdinalIgnoreCase) >= 0 || ((Scene)(ref scene)).name.IndexOf("Ending", StringComparison.OrdinalIgnoreCase) >= 0 || ((Scene)(ref scene)).name.IndexOf("Grey", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			Log.LogInfo((object)("[Credits] Escena detectada: " + ((Scene)(ref scene)).name));
			CreditScanner.Escanear();
		}
		try
		{
			CoroutineHolder.Inicia(InyectarLogoDespues());
		}
		catch (Exception ex)
		{
			Log.LogWarning((object)("[Turronish] CoroutineHolder InyectarLogoDespues: " + ex.Message));
		}
		try
		{
			CoroutineHolder.Inicia(DiagnosticarEscena(((Scene)(ref scene)).name));
		}
		catch (Exception ex2)
		{
			Log.LogWarning((object)("[Turronish] CoroutineHolder DiagnosticarEscena: " + ex2.Message));
		}
		try
		{
			CoroutineHolder.Inicia(EscanearImagenesDespues());
		}
		catch (Exception ex3)
		{
			Log.LogWarning((object)("[Turronish] CoroutineHolder EscanearImagenesDespues: " + ex3.Message));
		}
		if (AplicarModelosCallback != null)
		{
			try
			{
				CoroutineHolder.Inicia(AplicarModelosCallback());
			}
			catch (Exception ex4)
			{
				Log.LogWarning((object)("[Turronish] CoroutineHolder AplicarModelos3DDespues: " + ex4.Message));
			}
		}
		if (((Scene)(ref scene)).name.Equals("Menu", StringComparison.OrdinalIgnoreCase) && UIExtrasTurronishInyectar != null)
		{
			try
			{
				CoroutineHolder.Inicia(UIExtrasTurronishInyectar());
			}
			catch (Exception ex5)
			{
				Log.LogWarning((object)("[Turronish] ExtrasTurronishGestor: " + ex5.Message));
			}
		}
	}

	private IEnumerator EscanearImagenesDespues()
	{
		for (int i = 0; i < 8; i++)
		{
			yield return null;
		}
		EnTransicion = false;
		Log.LogInfo((object)"[IMAGE] Transicion completada — escaneo post-transicion iniciado");
		if (!ImagenesActivas)
		{
			yield break;
		}
		Image[] array = Resources.FindObjectsOfTypeAll<Image>();
		Scene scene;
		foreach (Image img in array)
		{
			if ((Object)(object)img == (Object)null || (Object)(object)img.sprite == (Object)null)
			{
				continue;
			}
			scene = ((Component)img).gameObject.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				Sprite reemplazado = SpriteReemplazador.Reemplazar(img.sprite);
				if ((Object)(object)reemplazado != (Object)(object)img.sprite)
				{
					img.sprite = reemplazado;
				}
			}
		}
		SpriteRenderer[] array2 = Resources.FindObjectsOfTypeAll<SpriteRenderer>();
		foreach (SpriteRenderer sr in array2)
		{
			if ((Object)(object)sr == (Object)null || (Object)(object)sr.sprite == (Object)null)
			{
				continue;
			}
			scene = ((Component)sr).gameObject.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				Sprite reemplazado2 = SpriteReemplazador.Reemplazar(sr.sprite);
				if ((Object)(object)reemplazado2 != (Object)(object)sr.sprite)
				{
					sr.sprite = reemplazado2;
				}
			}
		}
		Log.LogInfo((object)"[IMAGE] Escaneo post-transicion completado");
	}

	private IEnumerator DiagnosticarEscena(string nombreEscena)
	{
		if (LogVerboso)
		{
			for (int i = 0; i < 5; i++)
			{
				yield return null;
			}
			VolcarDiagnostico(nombreEscena, "5f");
			for (int j = 0; j < 85; j++)
			{
				yield return null;
			}
			VolcarDiagnostico(nombreEscena, "90f");
		}
	}

	private void VolcarDiagnostico(string nombreEscena, string etiqueta)
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: 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_0307: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_0397: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Log.LogInfo((object)$"[DIAG] ═══ {etiqueta} post-carga '{nombreEscena}' tScale={Time.timeScale:F2} ═══");
			int num = 0;
			Canvas[] array = Resources.FindObjectsOfTypeAll<Canvas>();
			foreach (Canvas val in array)
			{
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy)
				{
					continue;
				}
				Scene scene = ((Component)val).gameObject.scene;
				object obj;
				if (!((Scene)(ref scene)).IsValid())
				{
					obj = "DDOL";
				}
				else
				{
					scene = ((Component)val).gameObject.scene;
					obj = ((Scene)(ref scene)).name;
				}
				string text = (string)obj;
				Log.LogInfo((object)("[DIAG] Canvas '" + ((Object)((Component)val).gameObject).name + "' [" + text + "] " + $"mode={val.renderMode} sort={val.sortingOrder} root={val.isRootCanvas}"));
				Image[] componentsInChildren = ((Component)val).GetComponentsInChildren<Image>(false);
				foreach (Image val2 in componentsInChildren)
				{
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && !(((Graphic)val2).color.a < 0.5f))
					{
						RectTransform component = ((Component)val2).GetComponent<RectTransform>();
						float num2;
						Rect rect;
						if (!((Object)(object)component != (Object)null))
						{
							num2 = 0f;
						}
						else
						{
							rect = component.rect;
							num2 = ((Rect)(ref rect)).width;
						}
						float num3 = num2;
						float num4;
						if (!((Object)(object)component != (Object)null))
						{
							num4 = 0f;
						}
						else
						{
							rect = component.rect;
							num4 = ((Rect)(ref rect)).height;
						}
						float num5 = num4;
						Log.LogInfo((object)$"[DIAG]   Image '{((Object)((Component)val2).gameObject).name}' color={((Graphic)val2).color} {num3:F0}x{num5:F0}");
					}
				}
				CanvasGroup[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<CanvasGroup>(true);
				foreach (CanvasGroup val3 in componentsInChildren2)
				{
					if (!((Object)(object)val3 == (Object)null) && !(val3.alpha >= 0.99f))
					{
						Log.LogInfo((object)$"[DIAG]   CanvasGroup '{((Object)((Component)val3).gameObject).name}' alpha={val3.alpha:F2}");
					}
				}
				num++;
			}
			if (num == 0)
			{
				Log.LogInfo((object)"[DIAG]   (ningún Canvas activo encontrado)");
			}
			VideoPlayer[] array2 = Resources.FindObjectsOfTypeAll<VideoPlayer>();
			foreach (VideoPlayer val4 in array2)
			{
				if (!((Object)(object)val4 == (Object)null))
				{
					Log.LogInfo((object)($"[DIAG] VP '{((Object)((Component)val4).gameObject).name}' playing={val4.isPlaying} " + $"paused={val4.isPaused} mode={val4.renderMode} active={((Component)val4).gameObject.activeInHierarchy}"));
				}
			}
			Camera[] allCameras = Camera.allCameras;
			foreach (Camera val5 in allCameras)
			{
				if (!((Object)(object)val5 == (Object)null))
				{
					Log.LogInfo((object)($"[DIAG] Cam '{((Object)((Component)val5).gameObject).name}' depth={val5.depth} " + $"clear={val5.clearFlags} enabled={((Behaviour)val5).enabled} mask={val5.cullingMask}"));
				}
			}
			Log.LogInfo((object)"[DIAG] ══════════════════════════════════════════════════");
		}
		catch (Exception ex)
		{
			Log.LogWarning((object)("[DIAG] Error en volcado: " + ex.Message));
		}
	}

	private IEnumerator InyectarLogoDespues()
	{
		yield return null;
		yield return null;
		if (!LogoBtnActivo || (Object)(object)GameObject.Find("_TurronishLogoBtn") != (Object)null)
		{
			yield break;
		}
		GameObject mainMenuGO = GameObject.Find("Main Menu");
		if ((Object)(object)mainMenuGO == (Object)null)
		{
			Log.LogWarning((object)"[Turronish] Logo: 'Main Menu' no encontrado");
			yield break;
		}
		Transform bordersPath = mainMenuGO.transform.Find("Borders (Masked)") ?? mainMenuGO.transform.Find("Content (Masked)/Borders (Masked)") ?? mainMenuGO.transform.Find("Content (Masked)/Borders") ?? mainMenuGO.transform;
		Transform mainPanelT = mainMenuGO.transform.Find("Content (Masked)/Main") ?? mainMenuGO.transform.Find("Main");
		if ((Object)(object)bordersPath == (Object)null)
		{
			Log.LogWarning((object)"[Turronish] Logo: transform raíz nula, abortando");
			yield break;
		}
		Log.LogInfo((object)$"[Turronish] Logo: borders='{((Object)bordersPath).name}' main={(Object)(object)mainPanelT != (Object)null}");
		GameObject plantilla = null;
		Button[] componentsInChildren = mainMenuGO.GetComponentsInChildren<Button>(true);
		foreach (Button btn in componentsInChildren)
		{
			if (!((Object)((Component)btn).gameObject).name.ToLower().Contains("logo") && (Object)(object)((Component)btn).GetComponent<Image>() != (Object)null)
			{
				plantilla = ((Component)btn).gameObject;
				break;
			}
		}
		GameObject btnGO;
		if ((Object)(object)plantilla != (Object)null)
		{
			btnGO = Object.Instantiate<GameObject>(plantilla, bordersPath);
			((Object)btnGO).name = "_TurronishLogoBtn";
			string[] array = new string[3] { "JoelG.ENA4.UI.MainMenuLogo", "JoelG.ENA4.UI.MenuClickScaleVisualFeedback", "JoelG.ENA4.UI.MainMenuBordersAnimator" };
			foreach (string cn in array)
			{
				Component c = btnGO.GetComponent(cn);
				if ((Object)(object)c != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)c);
				}
			}
			EventTrigger[] componentsInChildren2 = btnGO.GetComponentsInChildren<EventTrigger>(true);
			foreach (EventTrigger ev in componentsInChildren2)
			{
				Object.DestroyImmediate((Object)(object)ev);
			}
			TMP_Text[] componentsInChildren3 = btnGO.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text txt in componentsInChildren3)
			{
				txt.SetText("T");
			}
			Image rootImg = btnGO.GetComponent<Image>();
			if ((Object)(object)rootImg != (Object)null)
			{
				((Graphic)rootImg).raycastTarget = true;
			}
			RectTransform rt = btnGO.GetComponent<RectTransform>();
			if ((Object)(object)rt != (Object)null)
			{
				rt.sizeDelta = new Vector2(380f, 220f);
				rt.anchoredPosition = new Vector2(1695f, 745f);
			}
			Log.LogInfo((object)("[Turronish] Clon emoji OK plantilla='" + ((Object)plantilla).name + "'"));
		}
		else
		{
			Log.LogWarning((object)"[Turronish] Logo: no se encontró botón emoji — usando fallback naranja");
			btnGO = new GameObject("_TurronishLogoBtn");
			btnGO.transform.SetParent(bordersPath, false);
			Transform emoji1Fb = bordersPath.Find("Emoji 1");
			if (!((Object)(object)emoji1Fb != (Object)null))
			{
				new Vector2(500f, -80f);
			}
			else
			{
				_ = ((Component)emoji1Fb).GetComponent<RectTransform>().anchoredPosition;
			}
			RectTransform rt2 = btnGO.AddComponent<RectTransform>();
			Vector2 anchorMin = (rt2.anchorMax = Vector2.zero);
			rt2.anchorMin = anchorMin;
			rt2.pivot = new Vector2(0.5f, 0.5f);
			rt2.sizeDelta = new Vector2(380f, 220f);
			rt2.anchoredPosition = new Vector2(1695f, 745f);
			((Graphic)btnGO.AddComponent<Image>()).color = new Color(0.8f, 0.55f, 0.1f, 0.88f);
			GameObject tGO = new GameObject("T");
			tGO.transform.SetParent(btnGO.transform, false);
			RectTransform tRT = tGO.AddComponent<RectTransform>();
			tRT.anchorMin = Vector2.zero;
			tRT.anchorMax = Vector2.one;
			anchorMin = (tRT.offsetMax = Vector2.zero);
			tRT.offsetMin = anchorMin;
			TextMeshProUGUI txt2 = tGO.AddComponent<TextMeshProUGUI>();
			((TMP_Text)txt2).SetText("T");
			((TMP_Text)txt2).fontSize = 40f;
			((Graphic)txt2).color = Color.white;
			((TMP_Text)txt2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)txt2).fontStyle = (FontStyles)1;
		}
		btnGO.layer = LayerMask.NameToLayer("UI");
		string videoPath = VideoExtensions.BuscarArchivo(VideoClipsPath, "vid_Menu_Logo_Turronish");
		if (videoPath != null)
		{
			RenderTexture renderTex = new RenderTexture(512, 296, 0);
			renderTex.Create();
			GameObject vidGO = new GameObject("_VideoDisplay");
			vidGO.transform.SetParent(btnGO.transform, false);
			RectTransform vidRT = vidGO.AddComponent<RectTransform>();
			vidRT.anchorMin = Vector2.zero;
			vidRT.anchorMax = Vector2.one;
			Vector2 anchorMin = (vidRT.offsetMax = Vector2.zero);
			vidRT.offsetMin = anchorMin;
			RawImage rawImg = vidGO.AddComponent<RawImage>();
			rawImg.texture = (Texture)(object)renderTex;
			((Graphic)rawImg).raycastTarget = false;
			VideoPlayer vp = vidGO.AddComponent<VideoPlayer>();
			vp.url = videoPath;
			vp.renderMode = (VideoRenderMode)2;
			vp.targetTexture = renderTex;
			vp.isLooping = true;
			vp.playOnAwake = true;
			vp.Play();
			Image rootImgVP = btnGO.GetComponent<Image>();
			if ((Object)(object)rootImgVP != (Object)null)
			{
				((Graphic)rootImgVP).color = Color.clear;
			}
			CanvasGroup cgLogo = btnGO.GetComponent<CanvasGroup>() ?? btnGO.AddComponent<CanvasGroup>();
			cgLogo.alpha = 0f;
			TMP_Text[] txtsLogo = btnGO.GetComponentsInChildren<TMP_Text>(true);
			vp.prepareCompleted += (EventHandler)delegate
			{
				TMP_Text[] array2 = txtsLogo;
				foreach (TMP_Text val in array2)
				{
					if ((Object)(object)val != (Object)null)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
				cgLogo.alpha = 1f;
				Log.LogInfo((object)"[Turronish] Logo video preparado — botón visible");
			};
			LogoRevealFailsafe fsLogo = btnGO.AddComponent<LogoRevealFailsafe>();
			fsLogo.cg = cgLogo;
			Log.LogInfo((object)"[Turronish] VideoPlayer logo añadido OK (oculto hasta prepare)");
		}
		else
		{
			Log.LogWarning((object)("[Turronish] Video del logo no encontrado en " + VideoClipsPath));
		}
		btnGO.transform.SetSiblingIndex(0);
		if ((Object)(object)mainPanelT != (Object)null)
		{
			GameObject proxy = new GameObject("_LogoVisProxy");
			proxy.transform.SetParent(mainPanelT, false);
			proxy.AddComponent<TurronishLogoProxy>().Init(btnGO);
			Log.LogInfo((object)"[Turronish] Logo: proxy de visibilidad instalado en Main");
		}
		btnGO.AddComponent<TurronishClickBlocker>().Init(btnGO);
		Log.LogInfo((object)("[Turronish] Logo instalado en " + ((Object)bordersPath).name + "."));
	}

	private void EscanearPersonajes()
	{
		PersonajesDisponibles.Clear();
		Log.LogInfo((object)$"[Scan] VoicesPath='{VoicesPath}' existe={Directory.Exists(VoicesPath)}");
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		foreach (string item in AssetPack.ListarSubcarpetas(VoicesPath))
		{
			string fileName = Path.GetFileName(item);
			if (AssetPack.Listar(item, new string[2] { ".wav", ".ogg" }, recurse: true).Count != 0)
			{
				hashSet.Add(fileName);
			}
		}
		if (AudioObtenerPersonajesDeBank != null)
		{
			HashSet<string> hashSet2 = AudioObtenerPersonajesDeBank();
			if (hashSet2 != null)
			{
				foreach (string item2 in hashSet2)
				{
					hashSet.Add(item2);
				}
				if (hashSet2.Count > 0)
				{
					Log.LogInfo((object)$"[Scan] {hashSet2.Count} personajes detectados desde banks");
				}
			}
		}
		foreach (string item3 in hashSet)
		{
			if (_carpetasOcultas.Contains(item3))
			{
				if (!PersonajeActivo.ContainsKey(item3))
				{
					PersonajeActivo[item3] = true;
				}
				continue;
			}
			PersonajesDisponibles.Add(item3);
			if (!PersonajeActivo.ContainsKey(item3))
			{
				PersonajeActivo[item3] = true;
			}
		}
		Log.LogInfo((object)$"[Scan] {PersonajesDisponibles.Count} personajes disponibles");
	}

	private void CargarPersonajesConfig()
	{
		NombresUI.Clear();
		DescripcionesUI.Clear();
		DescripcionesUI_EN.Clear();
		KeyOverride.Clear();
		VirtualPersonajes.Clear();
		string personajesConfigPath = PersonajesConfigPath;
		if (!File.Exists(personajesConfigPath))
		{
			File.WriteAllText(personajesConfigPath, "{\n  \"NombresUI\": {\n    \"Salespersone\": \"ENA Sales\",\n    \"Meanie\": \"ENA Meanie\"\n  },\n  \"KeyOverride\": {\n    \"Witches_Maria\": \"Witches\"\n  },\n  \"Virtual\": [\n    \"ExtraEffects\"\n  ]\n}\n", Encoding.UTF8);
			Log.LogInfo((object)("[PersonajesConfig] Plantilla creada en: " + personajesConfigPath));
			NombresUI["Salespersone"] = "ENA Sales";
			NombresUI["Meanie"] = "ENA Meanie";
			return;
		}
		try
		{
			string json = File.ReadAllText(personajesConfigPath, Encoding.UTF8);
			ParsearSeccionDict(json, "NombresUI", NombresUI);
			ParsearSeccionDict(json, "DescripcionesUI", DescripcionesUI);
			ParsearSeccionDict(json, "DescripcionesUI_EN", DescripcionesUI_EN);
			ParsearSeccionDict(json, "KeyOverride", KeyOverride);
			ParsearSeccionArray(json, "Virtual", VirtualPersonajes);
			foreach (string virtualPersonaje in VirtualPersonajes)
			{
				string path = Path.Combine(VoicesPath, virtualPersonaje);
				if (Directory.Exists(path) && Directory.GetFiles(path, "*.wav").Length != 0)
				{
					if (!PersonajesDisponibles.Contains(virtualPersonaje))
					{
						PersonajesDisponibles.Add(virtualPersonaje);
					}
					if (!PersonajeActivo.ContainsKey(virtualPersonaje))
					{
						PersonajeActivo[virtualPersonaje] = true;
					}
				}
			}
			foreach (string key in KeyOverride.Keys)
			{
				string path2 = Path.Combine(VoicesPath, key);
				if (Directory.Exists(path2) && Directory.GetFiles(path2, "*.wav").Length != 0)
				{
					if (!PersonajesDisponibles.Contains(key))
					{
						PersonajesDisponibles.Add(key);
					}
					if (!PersonajeActivo.ContainsKey(key))
					{
						PersonajeActivo[key] = true;
					}
				}
			}
			Log.LogInfo((object)$"[PersonajesConfig] UI={NombresUI.Count} KeyOverride={KeyOverride.Count} Virtual={VirtualPersonajes.Count}");
		}
		catch (Exception ex)
		{
			Log.LogError((object)("[PersonajesConfig] Error: " + ex.Message));
		}
		Traducciones.AgregarNombresUIAIgnorar();
	}

	private static void ParsearSeccionDict(string json, string seccion, Dictionary<string, string> dest)
	{
		int num = json.IndexOf("\"" + seccion + "\"", StringComparison.Ordinal);
		if (num < 0)
		{
			return;
		}
		int num2 = json.IndexOf('{', num);
		if (num2 < 0)
		{
			return;
		}
		int i = num2 + 1;
		int num3 = 1;
		while (i < json.Length && num3 > 0)
		{
			for (; i < json.Length && json[i] != '"' && json[i] != '{' && json[i] != '}'; i++)
			{
			}
			if (i >= json.Length)
			{
				break;
			}
			if (json[i] == '{')
			{
				num3++;
				i++;
				continue;
			}
			if (json[i] == '}')
			{
				num3--;
				i++;
				continue;
			}
			string text = LeerStrJSON(json, ref i);
			for (; i < json.Length && json[i] != ':'; i++)
			{
			}
			for (i++; i < json.Length && json[i] != '"'; i++)
			{
			}
			string text2 = LeerStrJSON(json, ref i);
			if (text != null && text2 != null)
			{
				dest[text] = text2;
			}
			for (; i < json.Length && json[i] != ',' && json[i] != '}'; i++)
			{
			}
			if (i < json.Length && json[i] == ',')
			{
				i++;
			}
		}
	}

	private static void ParsearSeccionArray(string json, string seccion, HashSet<string> dest)
	{
		int num = json.IndexOf("\"" + seccion + "\"", StringComparison.Ordinal);
		if (num < 0)
		{
			return;
		}
		int num2 = json.IndexOf('[', num);
		if (num2 < 0)
		{
			return;
		}
		int i = num2 + 1;
		while (i < json.Length && json[i] != ']')
		{
			for (; i < json.Length && json[i] != '"' && json[i] != ']'; i++)
			{
			}
			if (i >= json.Length || json[i] == ']')
			{
				break;
			}
			string text = LeerStrJSON(json, ref i);
			if (text != null)
			{
				dest.Add(text);
			}
			for (; i < json.Length && json[i] != ',' && json[i] != ']'; i++)
			{
			}
			if (i < json.Length && json[i] == ',')
			{
				i++;
			}
		}
	}

	private static string LeerStrJSON(string txt, ref int i)
	{
		if (i >= txt.Length || txt[i] != '"')
		{
			return null;
		}
		i++;
		StringBuilder stringBuilder = new StringBuilder();
		while (i < txt.Length)
		{
			char c = txt[i++];
			if (c == '"')
			{
				break;
			}
			if (c == '\\' && i < txt.Length)
			{
				char c2 = txt[i++];
				if (c2 == 'n')
				{
					stringBuilder.Append('\n');
				}
				else
				{
					stringBuilder.Append(c2);
				}
			}
			else
			{
				stringBuilder.Append(c);
			}
		}
		return stringBuilder.ToString();
	}

	private void CargarConfig()
	{
		if (!File.Exists(ConfigPath))
		{
			return;
		}
		try
		{
			string[] array = File.ReadAllLines(ConfigPath);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num <= 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num).Trim();
				string text3 = text.Substring(num + 1).Trim();
				switch (text2)
				{
				case "_textoEspanol":
					Traducciones.TextoEspanolActivo = text3 == "true";
					break;
				case "_buscarActualizaciones":
					BuscarActualizaciones = text3 == "true";
					break;
				case "_urlVersion":
					URLVersion = text3;
					break;
				case "_videoClips":
					VideoClipsActivo = text3 == "true";
					break;
				case "_imagenes":
					ImagenesActivas = text3 == "true";
					break;
				case "_modelos":
					ModelosActivos = text3 == "true";
					break;
				case "_varianteENA":
				{
					if (int.TryParse(text3, out var result3))
					{
						VarianteENA = result3;
					}
					break;
				}
				case "_varianteENAMeanie":
					VarianteENA = ((text3 == "true") ? 1 : 0);
					break;
				case "_varianteTaxi":
				{
					if (int.TryParse(text3, out var result2))
					{
						VarianteTaxi = result2;
					}
					break;
				}
				case "_varianteYowadama":
				{
					if (int.TryParse(text3, out var result))
					{
						VarianteYowadama = result;
					}
					break;
				}
				case "_logoBtnActivo":
					LogoBtnActivo = text3 == "true";
					break;
				default:
					PersonajeActivo[text2] = text3 == "true";
					break;
				}
			}
		}
		catch (Exception ex)
		{
			Log.LogError((object)("Error cargando config: " + ex.Message));
		}
	}

	public static void GuardarConfig()
	{
		try
		{
			List<string> list = new List<string>
			{
				"_textoEspanol=" + Traducciones.TextoEspanolActivo.ToString().ToLower(),
				"_videoClips=" + VideoClipsActivo.ToString().ToLower(),
				"_imagenes=" + ImagenesActivas.ToString().ToLower(),
				"_modelos=" + ModelosActivos.ToString().ToLower(),
				$"_varianteENA={VarianteENA}",
				$"_varianteTaxi={VarianteTaxi}",
				$"_varianteYowadama={VarianteYowadama}",
				"_logoBtnActivo=" + LogoBtnActivo.ToString().ToLower(),
				"_buscarActualizaciones=" + BuscarActualizaciones.ToString().ToLower(),
				"_urlVersion=" + URLVersion
			};
			list.AddRange(PersonajeActivo.Select((KeyValuePair<string, bool> p) => p.Key + "=" + p.Value.ToString().ToLower()));
			File.WriteAllLines(ConfigPath, list);
		}
		catch (Exception ex)
		{
			Log.LogError((object)("Error guardando config: " + ex.Message));
		}
	}
}
public static class PresetManager
{
	public class Preset
	{
		public string Nombre;

		public bool TextoEspanol;

		public bool VideoClips;

		public bool Imagenes;

		public bool Modelos3D;

		public Dictionary<string, bool> AudioPersonajes;

		public Preset(string n, bool te, bool vc, bool im, bool m3d, Dictionary<string, bool> a)
		{
			Nombre = n;
			TextoEspanol = te;
			VideoClips = vc;
			Imagenes = im;
			Modelos3D = m3d;
			AudioPersonajes = new Dictionary<string, bool>(a);
		}
	}

	private static string PresetsPath => Path.Combine(Paths.ConfigPath, "ENADoblaje_presets.json");

	public static List<Preset> Presets { get; private set; } = new List<Preset>();

	public static void Cargar()
	{
		Presets.Clear();
		if (!File.Exists(PresetsPath))
		{
			return;
		}
		try
		{
			string text = File.ReadAllText(PresetsPath, Encoding.UTF8);
			int i;
			for (i = 0; i < text.Length && text[i] != '['; i++)
			{
			}
			if (i >= text.Length)
			{
				return;
			}
			i++;
			while (i < text.Length)
			{
				for (; i < text.Length && text[i] != '{' && text[i] != ']'; i++)
				{
				}
				if (i >= text.Length || text[i] == ']')
				{
					break;
				}
				string text2 = null;
				bool te = true;
				bool vc = true;
				bool im = true;
				bool m3d = true;
				Dictionary<string, bool> dictionary = new Dictionary<string, bool>();
				int num = 1;
				i++;
				bool flag = false;
				while (i < text.Length && num > 0)
				{
					for (; i < text.Length && text[i] != '"' && text[i] != '{' && text[i] != '}'; i++)
					{
					}
					if (i >= text.Length)
					{
						break;
					}
					if (text[i] == '{')
					{
						num++;
						flag = true;
						i++;
						continue;
					}
					if (text[i] == '}')
					{
						num--;
						flag = false;
						i++;
						continue;
					}
					string text3 = LeerStr(text, ref i);
					for (; i < text.Length && text[i] != ':'; i++)
					{
					}
					for (i++; i < text.Length && (text[i] == ' ' || text[i] == '\t' || text[i] == '\n' || text[i] == '\r'); i++)
					{
					}
					if (i >= text.Length)
					{
						break;
					}
					if (text[i] == '{')
					{
						num++;
						flag = true;
						i++;
						continue;
					}
					if (text[i] == '"')
					{
						string text4 = LeerStr(text, ref i);
						if (text3 == "nombre")
						{
							text2 = text4;
						}
					}
					else
					{
						int j;
						for (j = i; j < text.Length && text[j] != ',' && text[j] != '}' && text[j] != '\n'; j++)
						{
						}
						string text5 = text.Substring(i, j - i).Trim();
						i = j;
						switch (text3)
						{
						case "textoEspanol":
							te = text5 == "true";
							break;
						case "videoClips":
							vc = text5 == "true";
							break;
						case "imagenes":
							im = text5 == "true";
							break;
						case "modelos3D":
							m3d = text5 == "true";
							break;
						default:
							if (flag)
							{
								dictionary[text3] = text5 == "true";
							}
							break;
						}
					}
					for (; i < text.Length && text[i] != '"' && text[i] != '{' && text[i] != '}'; i++)
					{
					}
				}
				if (text2 != null)
				{
					Presets.Add(new Preset(text2, te, vc, im, m3d, dictionary));
				}
			}
		}
		catch (Exception ex)
		{
			ControlDoblajePlugin.Log.LogError((object)("[Presets] Error: " + ex.Message));
		}
	}

	public static void Guardar()
	{
		try
		{
			StringBuilder stringBuilder = new StringBuilder("[");
			for (int i = 0; i < Presets.Count; i++)
			{
				Preset preset = Presets[i];
				stringBuilder.Append("\n  {\"nombre\":\"" + Esc(preset.Nombre) + "\",\"textoEspanol\":" + (preset.TextoEspanol ? "true" : "false") + ",\"videoClips\":" + (preset.VideoClips ? "true" : "false") + ",\"imagenes\":" + (preset.Imagenes ? "true" : "false") + ",\"modelos3D\":" + (preset.Modelos3D ? "true" : "false") + ",\"audio\":{");
				List<string> list = preset.AudioPersonajes.Keys.ToList();
				for (int j = 0; j < list.Count; j++)
				{
					stringBuilder.Append("\"" + Esc(list[j]) + "\":" + (preset.AudioPersonajes[list[j]] ? "true" : "false") + ((j < list.Count - 1) ? "," : ""));
				}
				stringBuilder.Append("}}" + ((i < Presets.Count - 1) ? "," : ""));
			}
			stringBuilder.Append("\n]");
			File.WriteAllText(PresetsPath, stringBuilder.ToString(), Encoding.UTF8);
		}
		catch (Exception ex)
		{
			ControlDoblajePlugin.Log.LogError((object)("[Presets] Error guardando: " + ex.Message));
		}
	}

	public static void AgregarPresetActual(string nombre)
	{
		Presets.RemoveAll((Preset p) => p.Nombre.Equals(nombre, StringComparison.OrdinalIgnoreCase));
		Presets.Add(new Preset(nombre, Traducciones.TextoEspanolActivo, ControlDoblajePlugin.VideoClipsActivo, ControlDoblajePlugin.ImagenesActivas, ControlDoblajePlugin.ModelosActivos, new Dictionary<string, bool>(ControlDoblajePlugin.PersonajeActivo)));
		Guardar();
	}

	public static void AplicarPreset(Preset p)
	{
		Traducciones.TextoEspanolActivo = p.TextoEspanol;
		ControlDoblajePlugin.VideoClipsActivo = p.VideoClips;
		ControlDoblajePlugin.ImagenesActivas = p.Imagenes;
		ControlDoblajePlugin.ModelosActivos = p.Modelos3D;
		foreach (KeyValuePair<string, bool> audioPersonaje in p.AudioPersonajes)
		{
			ControlDoblajePlugin.PersonajeActivo[audioPersonaje.Key] = audioPersonaje.Value;
		}
		ControlDoblajePlugin.GuardarConfig();
	}

	public static void EliminarPreset(string nombre)
	{
		Presets.RemoveAll((Preset p) => p.Nombre.Equals(nombre, StringComparison.OrdinalIgnoreCase));
		Guardar();
	}

	private static string LeerStr(string txt, ref int i)
	{
		if (i >= txt.Length || txt[i] != '"')
		{
			return "";
		}
		i++;
		StringBuilder stringBuilder = new StringBuilder();
		while (i < txt.Length)
		{
			char c = txt[i++];
			if (c == '"')
			{
				break;
			}
			if (c == '\\' && i < txt.Length)
			{
				char c2 = txt[i++];
				switch (c2)
				{
				case 'n':
					stringBuilder.Append('\n');
					break;
				case '"':
					stringBuilder.Append('"');
					break;
				default:
					stringBuilder.Append(c2);
					break;
				}
			}
			else
			{
				stringBuilder.Append(c);
			}
		}
		return stringBuilder.ToString();
	}

	private static string Esc(string s)
	{
		return s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n");
	}
}
public class SpriteRendererScanner : MonoBehaviour
{
	private float _timer = 0f;

	private const float INTERVAL = 2f;

	private static SpriteRendererScanner _instancia;

	private void Awake()
	{
		_instancia = this;
	}

	private void Update()
	{
		if (!ControlDoblajePlugin.ImagenesActivas)
		{
			return;
		}
		_timer -= Time.unscaledDeltaTime;
		if (_timer > 0f)
		{
			return;
		}
		_timer = 2f;
		try
		{
			EscanearAhora();
		}
		catch
		{
		}
	}

	public static void EscanearConReintentos()
	{
		if ((Object)(object)_instancia != (Object)null)
		{
			((MonoBehaviour)_instancia).StartCoroutine(_instancia.ReintentarScan());
		}
	}

	private IEnumerator ReintentarScan()
	{
		for (int i = 0; i < 20; i++)
		{
			yield return (object)new WaitForSecondsRealtime(0.2f);
			try
			{
				EscanearAhora();
			}
			catch
			{
			}
		}
	}

	public static void EscanearAhora()
	{
		if (ControlDoblajePlugin.ImagenesActivas)
		{
			EscanearSpriteRenderers();
			EscanearImageComponents();
		}
	}

	private static void EscanearSpriteRenderers()
	{
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		SpriteRenderer[] array = Object.FindObjectsOfType<SpriteRenderer>();
		Vector2 val3 = default(Vector2);
		foreach (SpriteRenderer val in array)
		{
			if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null || ((Object)val.sprite).name.StartsWith("_replaced_"))
			{
				continue;
			}
			string name = ((Object)val.sprite).name;
			string text = ImageExtensions.BuscarArchivo(ControlDoblajePlugin.ImagesPath, name);
			if (text != null)
			{
				Texture2D val2 = TexturaCache.Obtener(text);
				if (!((Object)(object)val2 == (Object)null))
				{
					float x = val.sprite.pivot.x;
					Rect rect = val.sprite.rect;
					float num = x / Mathf.Max(((Rect)(ref rect)).width, 1f);
					float y = val.sprite.pivot.y;
					rect = val.sprite.rect;
					((Vector2)(ref val3))..ctor(num, y / Mathf.Max(((Rect)(ref rect)).height, 1f));
					Sprite val4 = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), val3, val.sprite.pixelsPerUnit);
					((Object)val4).name = "_replaced_" + name;
					val.sprite = val4;
					ImageTracker.Registrar(name);
					ControlDoblajePlugin.Log.LogInfo((object)("[IMAGE] SpriteRenderer reemplazado: " + name));
				}
			}
		}
	}

	private static void EscanearImageComponents()
	{
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
		Image[] array = Object.FindObjectsOfType<Image>();
		Vector2 val3 = default(Vector2);
		foreach (Image val in array)
		{
			if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null)
			{
				continue;
			}
			string name = ((Object)val.sprite).name;
			if (name.StartsWith("_replaced_"))
			{
				continue;
			}
			string text = ImageExtensions.BuscarArchivo(ControlDoblajePlugin.ImagesPath, name);
			if (text == null)
			{
				if (name.IndexOf("Item", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Acquired", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("sp_UI", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Ina", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					ManualLogSource log = ControlDoblajePlugin.Log;
					string[] obj = new string[6]
					{
						"[IMAGE_SCAN] Image sin reemplazo: ",
						name,
						" go=",
						((Object)((Component)val).gameObject).name,
						" parent=",
						null
					};
					Transform parent = ((Component)val).transform.parent;
					obj[5] = ((parent != null) ? ((Object)((Component)parent).gameObject).name : null) ?? "null";
					log.LogInfo((object)string.Concat(obj));
				}
				continue;
			}
			Texture2D val2 = TexturaCache.Obtener(text);
			if (!((Object)(object)val2 == (Object)null))
			{
				float x = val.sprite.pivot.x;
				Rect rect = val.sprite.rect;
				float num = x / Mathf.Max(((Rect)(ref rect)).width, 1f);
				float y = val.sprite.pivot.y;
				rect = val.sprite.rect;
				((Vector2)(ref val3))..ctor(num, y / Mathf.Max(((Rect)(ref rect)).height, 1f));
				Sprite val4 = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), val3, val.sprite.pixelsPerUnit);
				((Object)val4).name = "_replaced_" + name;
				val.sprite = val4;
				ImageTracker.Registrar(name);
				ControlDoblajePlugin.Log.LogInfo((object)("[IMAGE] Image reemplazado: " + name));
			}
		}
	}
}
public static class VideoClipTracker
{
	private static readonly HashSet<string> Logueados = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	public static void Registrar(string nombre)
	{
		if (!string.IsNullOrEmpty(nombre))
		{
			ControlDoblajePlugin.VideoClipStartTime = Time.realtimeSinceStartup;
			if (Logueados.Add(nombre))
			{
				ControlDoblajePlugin.Log.LogInfo((object)("[VIDEOCLIP] " + nombre));
			}
		}
	}
}
public static class ImageTracker
{
	private static readonly HashSet<string> Logueados = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	public static void Registrar(string nombre)
	{
		if (!string.IsNullOrEmpty(nombre) && Logueados.Add(nombre))
		{
			ControlDoblajePlugin.Log.LogInfo((object)("[IMAGE] " + nombre));
		}
	}
}
public static class CreditScanner
{
	public static void Escanear()
	{
		Assembly assembly = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly2 in assemblies)
		{
			if (assembly2.GetName().Name == "JoelG.ENA4")
			{
				assembly = assembly2;
				break;
			}
		}
		if (assembly == null)
		{
			return;
		}
		ControlDoblajePlugin.Log.LogInfo((object)"[Credits] === TIPOS CON 'CREDIT' ===");
		Type[] types = assembly.GetTypes();
		foreach (Type type in types)
		{
			string text = type.FullName ?? "";
			if (text.IndexOf("Credit", StringComparison.OrdinalIgnoreCase).Equals(-1) && text.IndexOf("Roll", StringComparison.OrdinalIgnoreCase).Equals(-1))
			{
				continue;
			}
			ControlDoblajePlugin.Log.LogInfo((object)("[Credits] TIPO: " + text));
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				ControlDoblajePlugin.Log.LogInfo((object)("[Credits]   -> " + methodInfo.Name + "(" + string.Join(", ", Array.ConvertAll(methodInfo.GetParameters(), (ParameterInfo p) => p.ParameterType.Name + " " + p.Name)) + ")"));
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				ControlDoblajePlugin.Log.LogInfo((object)("[Credits]   field: " + fieldInfo.FieldType.Name + " " + fieldInfo.Name));
			}
		}
	}
}
public static class VideoExtensions
{
	public static readonly string[] Lista = new string[4] { ".mp4", ".webm", ".ogv", ".mov" };

	public static string BuscarArchivo(string carpeta, string nombreSinExt)
	{
		string[] lista = Lista;
		foreach (string text in lista)
		{
			string text2 = Path.Combine(carpeta, nombreSinExt + text);
			if (File.Exists(text2))
			{
				return text2;
			}
		}
		string assetsRoot = ControlDoblajePlugin.AssetsRoot;
		if (AssetPack.Flattened && !string.IsNullOrEmpty(assetsRoot) && !string.Equals(carpeta, assetsRoot, StringComparison.OrdinalIgnoreCase))
		{
			string[] lista2 = Lista;
			foreach (string text3 in lista2)
			{
				string text4 = Path.Combine(assetsRoot, nombreSinExt + text3);
				if (File.Exists(text4))
				{
					return text4;
				}
			}
		}
		return null;
	}
}
public class TurronishFixedPosition : MonoBehaviour
{
	private Vector3 _worldPos;

	private Quaternion _worldRot;

	private Vector3 _worldScale;

	public void Init(Vector3 pos, Quaternion rot, Vector3 scale)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		_worldPos = pos;
		_worldRot = rot;
		_worldScale = scale;
	}

	public void Init(Vector3 pos)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		Init(pos, ((Component)this).transform.rotation, ((Component)this).transform.lossyScale);
	}

	private void LateUpdate()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: 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_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.position = _worldPos;
		((Component)this).transform.rotation = _worldRot;
		Transform parent = ((Component)this).transform.parent;
		if ((Object)(object)parent != (Object)null)
		{
			Vector3 lossyScale = parent.lossyScale;
			((Component)this).transform.localScale = new Vector3((lossyScale.x != 0f) ? (_worldScale.x / lossyScale.x) : 1f, (lossyScale.y != 0f) ? (_worldScale.y / lossyScale.y) : 1f, (lossyScale.z != 0f) ? (_worldScale.z / lossyScale.z) : 1f);
		}
	}
}
public class TurronishLogoProxy : MonoBehaviour
{
	private GameObject _btn;

	private float _readyAt;

	private Transform _mainPanel;

	public void Init(GameObject btn)
	{
		_btn = btn;
		_btn.SetActive(false);
		_readyAt = Time.realtimeSinceStartup + 1.5f;
		_mainPanel = ((Component)this).transform.parent;
	}

	private void OnDisable()
	{
		if ((Object)(object)_btn != (Object)null)
		{
			_btn.SetActive(false);
		}
	}

	private void Update()
	{
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Expected O, but got Unknown
		if ((Object)(object)_btn == (Object)null)
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
		else
		{
			if (Time.realtimeSinceStartup < _readyAt)
			{
				return;
			}
			bool flag = (Object)(object)_mainPanel != (Object)null && ((Component)_mainPanel).gameObject.activeInHierarchy;
			bool flag2 = false;
			if (flag && (Object)(object)_mainPanel.parent != (Object)null)
			{
				foreach (Transform item in _mainPanel.parent)
				{
					Transform val = item;
					if (!((Object)(object)val == (Object)(object)_mainPanel) && ((Component)val).gameObject.activeInHierarchy)
					{
						string name = ((Object)((Component)val).gameObject).name;
						if (name.IndexOf("Settings", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Options", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Extras", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Credits", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Supporter", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Turronish", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							flag2 = true;
							break;
						}
					}
				}
			}
			bool flag3 = ControlDoblajePlugin.LogoBtnActivo && flag && !flag2;
			if (flag3 != _btn.activeSelf)
			{
				_btn.SetActive(flag3);
			}
		}
	}
}
public class TurronishClickBlocker : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerClickHandler, IPointerExitHandler
{
	private GameObject _clon;

	public void Init(GameObject clon)
	{
		_clon = clon;
	}

	public void OnPointerDown(PointerEventData e)
	{
		((AbstractEventData)e).Use();
		TurronishScaleTween.ScaleTo(_clon, 1.15f, 0.07f);
	}

	public void OnPointerClick(PointerEventData e)
	{
		((AbstractEventData)e).Use();
		TurronishScaleTween.ScaleTo(_clon, 1f, 0.12f);
		ControlDoblajePlugin.SoundPlayRandom?.Invoke();
		ControlDoblajePlugin.Log.LogInfo((object)"[Turronish] ¡Click!");
	}

	public void OnPointerExit(PointerEventData e)
	{
		TurronishScaleTween.ScaleTo(_clon, 1f, 0.08f);
	}
}
public class TurronishScaleTween : MonoBehaviour
{
	private float _target = 1f;

	private float _speed = 0.08f;

	private bool _running = false;

	public static void ScaleTo(GameObject go, float target, float duration)
	{
		if (!((Object)(object)go == (Object)null))
		{
			TurronishScaleTween component = go.GetComponent<TurronishScaleTween>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			TurronishScaleTween turronishScaleTween = go.AddComponent<TurronishScaleTween>();
			turronishScaleTween._target = target;
			turronishScaleTween._speed = Mathf.Max(duration, 0.001f);
			turronishScaleTween._running = true;
		}
	}

	private void Update()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		if (_running)
		{
			float num = 1f - Mathf.Pow(0.001f, Time.unscaledDeltaTime / _speed);
			((Component)this).transform.localScale = Vector3.Lerp(((Component)this).transform.localScale, Vector3.one * _target, num);
			if (Vector3.Distance(((Component)this).transform.localScale, Vector3.one * _target) < 0.001f)
			{
				((Component)this).transform.localScale = Vector3.one * _target;
				_running = false;
				Object.Destroy((Object)(object)this);
			}
		}
	}
}
public static class Localizacion
{
	private class DatosIdioma
	{
		public string Nombre;

		public Dictionary<string, string> Nativo;

		public Dictionary<string, string> NativoCI;

		public Dictionary<string, string> Inverso;

		public HashSet<string> Valores;
	}

	public static string IdiomaTextos = "es";

	private static readonly Dictionary<string, DatosIdioma> _idiomas = new Dictionary<string, DatosIdioma>(StringComparer.Ordinal);

	public static IEnumerable<string> IdiomasDisponibles => _idiomas.Keys;

	public static bool EsPassthroughActual => EsPassthrough(IdiomaTextos);

	private static DatosIdioma Actual
	{
		get
		{
			DatosIdioma value;
			return _idiomas.TryGetValue(IdiomaTextos, out value) ? value : null;
		}
	}

	public static Dictionary<string, string> MapaActual => Actual?.Nativo;

	public static Dictionary<string, string> MapaActualCI => Actual?.NativoCI;

	public static Dictionary<string, string> MapaInversoActual => Actual?.Inverso;

	public static HashSet<string> ValoresActual => Actual?.Valores;

	public static event Action OnIdiomaChanged;

	public static void NotificarCambio()
	{
		Localizacion.OnIdiomaChanged?.Invoke();
	}

	public static string NombreDe(string idioma)
	{
		DatosIdioma value;
		return _idiomas.TryGetValue(idioma, out value) ? value.Nombre : idioma;
	}

	public static bool EsPassthrough(string idioma)
	{
		DatosIdioma value;
		return idioma == "en" || !_idiomas.TryGetValue(idioma, out value) || value.Nativo == null;
	}

	public static void RegistrarIdioma(string id, string nombre, Dictionary<string, string> nativo)
	{
		DatosIdioma datosIdioma = new DatosIdioma
		{
			Nombre = nombre
		};
		if (nativo != null)
		{
			datosIdioma.Nativo = nativo;
			datosIdioma.NativoCI = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			datosIdioma.Inverso = new Dictionary<string, string>(StringComparer.Ordinal);
			datosIdioma.Valores = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, string> item in nativo)
			{
				if (!datosIdioma.NativoCI.ContainsKey(item.Key))
				{
					datosIdioma.NativoCI[item.Key] = item.Value;
				}
				if (!datosIdioma.Inverso.ContainsKey(item.Value))
				{
					datosIdioma.Inverso[item.Value] = item.Key;
				}
				datosIdioma.Valores.Add(item.Value);
			}
		}
		_idiomas[id] = datosIdioma;
	}

	public static string AIngles(string texto)
	{
		if (string.IsNullOrEmpty(texto))
		{
			return texto;
		}
		foreach (KeyValuePair<string, DatosIdioma> idioma in _idiomas)
		{
			Dictionary<string, string> inverso = idioma.Value.Inverso;
			if (inverso != null && inverso.TryGetValue(texto, out var value))
			{
				return value;
			}
		}
		return texto;
	}

	public static string ArchivoIdioma(string carpetaAbs, string baseName, string ext)
	{
		string text = Path.Combine(carpetaAbs, baseName + "." + IdiomaTextos + ext);
		if (AssetPack.Existe(text))
		{
			return text;
		}
		return Path.Combine(carpetaAbs, baseName + ext);
	}
}
public static class ReporteLogs
{
	private class ReporteLogsRunner : MonoBehaviour
	{
	}

	public const string WEBHOOK_URL = "https://discord.com/api/webhooks/1523378344593195068/UEEu2qgv28_tkajjRrgdbdOOPBLukNjtsss6fxvfKRajpI8-e5CdnWC-PMNSGym3i01u";

	private const long MAX_LOG_BYTES = 900000L;

	private static ReporteLogsRunner _runner;

	public static bool Enviando { get; private set; }

	public static bool Configurado => !string.IsNullOrEmpty("https://discord.com/api/webhooks/1523378344593195068/UEEu2qgv28_tkajjRrgdbdOOPBLukNjtsss6fxvfKRajpI8-e5CdnWC-PMNSGym3i01u") && !"https://discord.com/api/webhooks/1523378344593195068/UEEu2qgv28_tkajjRrgdbdOOPBLukNjtsss6fxvfKRajpI8-e5CdnWC-PMNSGym3i01u".StartsWith("REEMPLAZAR");

	private static string BepInExDir => Paths.BepInExRootPath;

	private static string ArchivoDiagMasReciente()
	{
		try
		{
			string path = Path.Combine(BepInExDir, "Logs", "Turronish");
			if (!Directory.Exists(path))
			{
				return null;
			}
			string result = null;
			DateTime dateTime = DateTime.MinValue;
			string[] files = Directory.GetFiles(path, "turronish_*.txt");
			foreach (string text in files)
			{
				DateTime lastWriteTime = File.GetLastWriteTime(text);
				if (lastWriteTime > dateTime)
				{
					dateTime = lastWriteTime;
					result = text;
				}
			}
			return result;
		}
		catch
		{
			return null;
		}
	}

	private static string LeerCola(string path, long maxBytes)
	{
		try
		{
			if (string.IsNullOrEmpty(path) || !File.Exists(path))
			{
				return "(no encontrado)";
			}
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
			long num = Math.Max(0L, fileStream.Length - maxBytes);
			fileStream.Seek(num, SeekOrigin.Begin);
			using StreamReader streamReader = new StreamReader(fileStream, Encoding.UTF8);
			string text = streamReader.ReadToEnd();
			if (num > 0)
			{
				text = $"...(recortado; últimos {maxBytes / 1024} KB)...\n" + text;
			}
			return text;
		}
		catch (Exception ex)
		{
			return "(error leyendo: " + ex.Message + ")";
		}
	}

	private static byte[] ConstruirReporte(string nota, string discord, bool incluirLogOutput, out string nombre)
	{
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.AppendLine("=== Reporte Turronish ===");
		stringBuilder.AppendLine("Fecha: " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
		stringBuilder.AppendLine("OS: " + SystemInfo.operatingSystem);
		stringBuilder.AppendLine("Idioma textos: " + Localizacion.IdiomaTextos);
		stringBuilder.AppendLine("Discord: " + (string.IsNullOrWhiteSpace(discord) ? "(no indicado)" : discord.Trim()));
		stringBuilder.AppendLine("Nota: " + (string.IsNullOrWhiteSpace(nota) ? "(sin nota)" : nota.Trim()));
		stringBuilder.AppendLine();
		string text = ArchivoDiagMasReciente();
		stringBuilder.AppendLine("--- " + ((text != null) ? Path.GetFileName(text) : "turronish log (no encontrado)") + " ---");
		stringBuilder.AppendLine(LeerCola(text, 900000L));
		if (incluirLogOutput)
		{
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("--- LogOutput.log ---");
			stringBuilder.AppendLine(LeerCola(Path.Combine(BepInExDir, "LogOutput.log"), 900000L));
		}
		nombre = "turronish_report_" + DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".txt";
		return Encoding.UTF8.GetBytes(stringBuilder.ToString());
	}

	private static ReporteLogsRunner Runner()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		if ((Object)(object)_runner == (Object)null)
		{
			GameObject val = new GameObject("_TurronishReporteRunner");
			Object.DontDestroyOnLoad((Object)(object)val);
			_runner = val.AddComponent<ReporteLogsRunner>();
		}
		return _runner;
	}

	public static void Enviar(string nota, string discord, bool incluirLogOutput, Action<bool, string> onResult)
	{
		if (Enviando)
		{
			onResult?.Invoke(arg1: false, "Ya se está enviando...");
			return;
		}
		if (!Configurado)
		{
			onResult?.Invoke(arg1: false, "Webhook no configurado.");
			return;
		}
		try
		{
			((MonoBehaviour)Runner()).StartCoroutine(EnviarCo(nota, discord, incluirLogOutput, onResult));
		}
		catch (Exception ex)
		{
			onResult?.Invoke(arg1: false, "No se pudo iniciar el envío: " + ex.Message);
		}
	}

	private static IEnumerator EnviarCo(string nota, string discord, bool incluirLogOutput, Action<bool, string> onResult)
	{
		Enviando = true;
		byte[] archivo = null;
		string nombre = "report.txt";
		string errArmado = null;
		try
		{
			archivo = ConstruirReporte(nota, discord, incluirLogOutput, out nombre);
		}
		catch (Exception ex)
		{
			Exception e = ex;
			errArmado = e.Message;
		}
		if (errArmado != null)
		{
			Enviando = false;
			onResult?.Invoke(arg1: false, "Error armando reporte: " + errArmado);
			yield break;
		}
		string contenido = "Nuevo reporte" + (string.IsNullOrWhiteSpace(discord) ? "" : (" de " + discord.Trim())) + (string.IsNullOrWhiteSpace(nota) ? "" : (": " + ((nota.Trim().Length > 180) ? nota.Trim().Substring(0, 180) : nota.Trim())));
		List<IMultipartFormSection> form = new List<IMultipartFormSection>
		{
			(IMultipartFormSection)new MultipartFormDataSection("payload_json", "{\"content\":" + JsonEscape(contenido) + "}"),
			(IMultipartFormSection)new MultipartFormFileSection("files[0]", archivo, nombre, "text/plain")
		};
		UnityWebRequest req = UnityWebRequest.Post("https://discord.com/api/webhooks/1523378344593195068/UEEu2qgv28_tkajjRrgdbdOOPBLukNjtsss6fxvfKRajpI8-e5CdnWC-PMNSGym3i01u", form);
		try
		{
			yield return req.SendWebRequest();
			bool ok = (int)req.result == 1;
			Enviando = false;
			if (ok)
			{
				ControlDoblajePlugin.Log.LogInfo((object)"[ReporteLogs] enviado OK");
				onResult?.Invoke(arg1: true, "¡Reporte enviado! Gracias.");
			}
			else
			{
				ControlDoblajePlugin.Log.LogWarning((object)$"[ReporteLogs] fallo: {req.error} (HTTP {req.responseCode})");
				onResult?.Invoke(arg1: false, "Fallo al enviar: " + (req.error ?? ("HTTP " + req.responseCode)));
			}
		}
		finally
		{
			((IDisposable)req)?.Dispose();
		}
	}

	private static string JsonEscape(string s)
	{
		if (s == null)
		{
			return "\"\"";
		}
		StringBuilder stringBuilder = new StringBuilder("\"");
		foreach (char c in s)
		{
			switch (c)
			{
			case '"':
				stringBuilder.Append("\\\"");
				continue;
			case '\\':
				stringBuilder.Append("\\\\");
				continue;
			case '\n':
				stringBuilder.Append("\\n");
				continue;
			case '\r':
				stringBuilder.Append("\\r");
				continue;
			case '\t':
				stringBuilder.Append("\\t");
				continue;
			}
			if (c < ' ')
			{
				int num = c;
				stringBuilder.Append("\\u" + num.ToString("x4"));
			}
			else
			{
				stringBuilder.Append(c);
			}
		}
		stringBuilder.Append("\"");
		return stringBuilder.ToString();
	}
}
public static class ActualizacionChecker
{
	private static bool _lanzado;

	public static void LanzarUnaVez()
	{
		if (_lanzado)
		{
			return;
		}
		_lanzado = true;
		if (!ControlDoblajePlugin.BuscarActualizaciones)
		{
			ControlDoblajePlugin.Log.LogInfo((object)"[Actualiz] desactivado por config.");
			return;
		}
		string uRLVersion = ControlDoblajePlugin.URLVersion;
		if (string.IsNullOrEmpty(uRLVersion) || (!uRLVersion.StartsWith("http") && !uRLVersion.StartsWith("file:")))
		{
			ControlDoblajePlugin.Log.LogInfo((object)"[Actualiz] sin URL configurada — no se consulta.");
			return;
		}
		if (Traducciones.VersionTraduccionLocal == "0")
		{
			ControlDoblajePlugin.Log.LogWarning((object)"[Actualiz] traducciones.json sin '__version_traduccion__' — se omite el chequeo.");
			return;
		}
		try
		{
			CoroutineHolder.Inicia(ChequeoCo(uRLVersion));
		}
		catch (Exception ex)
		{
			ControlDoblajePlugin.Log.LogWarning((object)("[Actualiz] no se pudo lanzar: " + ex.Message));
		}
	}

	private static IEnumerator ChequeoCo(string url)
	{
		UnityWebRequest req = UnityWebRequest.Get(url);
		try
		{
			req.timeout = 10;
			yield return req.SendWebRequest();
			if ((int)req.result != 1)
			{
				ControlDoblajePlugin.Log.LogInfo((object)("[Actualiz] sin respuesta (" + req.error + ") — se ignora."));
				yield break;
			}
			string json = ((req.downloadHandler != null) ? req.downloadHandler.text : null);
			if (string.IsNullOrEmpty(json))
			{
				yield break;
			}
			string remota = ExtraerCampo(json, "version");
			string urlDesc = ExtraerCampo(json, "url");
			string changelog = ExtraerCampo(json, "changelog");
			string local = Traducciones.VersionTraduccionLocal;
			if (string.IsNullOrEmpty(remota))
			{
				ControlDoblajePlugin.Log.LogInfo((object)"[Actualiz] JSON sin 'version' — se ignora.");
				yield break;
			}
			int cmp = CompararVersiones(remota, local);
			ControlDoblajePlugin.Log.LogInfo((object)$"[Actualiz] local='{local}' remota='{remota}' cmp={cmp}");
			if (cmp <= 0)
			{
				yield break;
			}
			Action<string, string, string, string> hook = ControlDoblajePlugin.UIMostrarAvisoActualizacion;
			if (hook != null)
			{
				try
				{
					hook(local, remota, urlDesc ?? "", changelog ?? "");
				}
				catch (Exception ex)
				{
					Exception ex2 = ex;
					ControlDoblajePlugin.Log.LogWarning((object)("[Actualiz] hook de UI falló: " + ex2.Message));
				}
			}
			else
			{
				ControlDoblajePlugin.Log.LogWarning((object)"[Actualiz] hay update pero la UI no registró el hook.");
			}
		}
		finally
		{
			((IDisposable)req)?.Dispose();
		}
	}

	private static string ExtraerCampo(string json, string campo)
	{
		if (string.IsNullOrEmpty(json))
		{
			return null;
		}
		int num = json.IndexOf("\"" + campo + "\"", StringComparison.Ordinal);
		if (num < 0)
		{
			return null;
		}
		int num2 = json.IndexOf(':', num + campo.Length + 2);
		if (num2 < 0)
		{
			return null;
		}
		int i;
		for (i = num2 + 1; i < json.Length && char.IsWhiteSpace(json[i]); i++)
		{
		}
		if (i >= json.Length || json[i] != '"')
		{
			return null;
		}
		i++;
		StringBuilder stringBuilder = new StringBuilder();
		while (i < json.Length)
		{
			char c = json[i++];
			if (c == '\\' && i < json.Length)
			{
				char c2 = json[i++];
				switch (c2)
				{
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case '/':
					stringBuilder.Append('/');
					break;
				default:
					stringBuilder.Append(c2);
					break;
				case 'r':
					break;
				}
			}
			else
			{
				if (c == '"')
				{
					break;
				}
				stringBuilder.Append(c);
			}
		}
		return stringBuilder.ToString().Trim();
	}

	public static int CompararVersiones(string a, string b)
	{
		int[] array = Parsear(a);
		int[] array2 = Parsear(b);
		if (array == null || array2 == null)
		{
			return (!string.Equals(a?.Trim(), b?.Trim(), StringComparison.OrdinalIgnoreCase)) ? string.Compare(a?.Trim(), b?.Trim(), StringComparison.OrdinalIgnoreCase) : 0;
		}
		int num = Math.Max(array.Length, array2.Length);
		for (int i = 0; i < num; i++)
		{
			int num2 = ((i < array.Length) ? array[i] : 0);
			int num3 = ((i < array2.Length) ? array2[i] : 0);
			if (num2 != num3)
			{
				return (num2 > num3) ? 1 : (-1);
			}
		}
		return 0;
	}

	private static int[] Parsear(string v)
	{
		if (string.IsNullOrEmpty(v))
		{
			return null;
		}
		v = v.Trim();
		if (v.Length > 0 && (v[0] == 'v' || v[0] == 'V'))
		{
			v = v.Substring(1);
		}
		string[] array = v.Split(new char[1] { '.' });
		int[] array2 = new int[array.Length];
		for (int i = 0; i < array.Length; i++)
		{
			if (!int.TryParse(array[i].Trim(), out array2[i]))
			{
				return null;
			}
		}
		return array2;
	}
}
public static class Traducciones
{
	private static readonly Dictionary<string, string> Cache = new Dictionary<string, string>(StringComparer.Ordinal);

	private static readonly HashSet<string> YaLogueados = new HashSet<string>(StringComparer.Ordinal);

	private static readonly Dictionary<string, string> EstiloAPersonaje = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
	{
		{ "Dratula", "Dratula" },
		{ "SuspiciousMan", "SuspiciousMan" }
	};

	public const string VERSION_KEY = "__version_traduccion__";

	public static Action OnIdiomaChanged;

	private static readonly HashSet<string> IgnorarLog = new HashSet<string>(StringComparer.Ordinal)
	{
		"Doblaje", "Preajustes", "Borrar", "Guardar", "Idioma general", "Textos", "IDIOMA GENERAL", "TRADUCCION VISUAL", "AUDIO POR PERSONAJE", "Español",
		"Original", "Inglés", "-- Ninguno --", "-- None --", "Dratula", "SuspiciousMan", "TheBus", "Wanderer", "Todo Español", "Todo Original",
		"Todo English", "Todo Spanish", "Presets", "Delete", "Save", "General language", "Texts", "GENERAL LANGUAGE", "VISUAL TRANSLATION", "AUDIO PER CHARACTER",
		"Spanish", "English", "All Spanish", "All English", "VideoClips", "Video Clips", "Imágenes", "Images", "Turronish", "Nombre del preajuste...",
		"Preset name...", "CoralGlasses", "Froggy", "Meanie", "Mitu", "Phindol", "PurgeKiosk", "Receptionist", "Salespersone", "Taxi",
		"TimothyRundle", "Witches", "ENA Sales", "ENA Meanie", "Coral Glasses", "Purge Kiosk", "Suspicious Man", "The Bus", "Timothy Rundle"
	};

	private static string _dumpSinTrad;

	public static bool TextoEspanolActivo
	{
		get
		{
			return Localizacion.IdiomaTextos == "es";
		}
		set
		{
			Localizacion.IdiomaTextos = (value ? "es" : "en");
		}
	}

	public static Dictionary<string, string> Mapa => Localizacion.MapaActual;

	private static Dictionary<string, string> MapaInverso => Localizacion.MapaInversoActual;

	private static HashSet<string> ValoresTraducidos => Localizacion.ValoresActual;

	public static string JSONPath
	{
		get
		{
			string text = Path.Combine(Path.GetDirectoryName(typeof(Traducciones).Assembly.Location), "traducciones.json");
			if (File.Exists(text))
			{
				return text;
			}
			return Path.Combine(Paths.ConfigPath, "traducciones.json");
		}
	}

	public static string VersionTraduccionLocal { get; private set; } = "0";

	public static void CargarDesdeJSON()
	{
		if (!File.Exists(JSONPath))
		{
			ControlDoblajePlugin.Log.LogWarning((object)("[Traducciones] No se encontro: " + JSONPath));
			return;
		}
		try
		{
			string text = File.ReadAllText(JSONPath, Encoding.UTF8);
			int num = text.IndexOf("\"traducciones\"");
			if (num < 0)
			{
				return;
			}
			num = text.IndexOf('{', num);
			if (num < 0)
			{
				return;
			}
			int i = num + 1;
			int num2 = 0;
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			while (i < text.Length)
			{
				for (; i < text.Length && text[i] != '"' && text[i] != '}'; i++)
				{
				}
				if (i >= text.Length || text[i] == '}')
				{
					break;
				}
				string text2 = LeerStringJSON(text, ref i);
				if (text2 == null)
				{
					break;
				}
				for (; i < text.Length && text[i] != ':'; i++)
				{
				}
				for (i++; i < text.Length && text[i] != '"'; i++)
				{
				}
				string text3 = LeerStringJSON(text, ref i);
				if (text3 == null)
				{
					break;
				}
				if (text2 == "__version_traduccion__")
				{
					VersionTraduccionLocal = text3.Trim();
				}
				else if (!text2.StartsWith("---") && !text2.StartsWith("//") && text3.Length > 0)
				{
					string key = text2.Replace("\r\n", "\n");
					string value = text3.Replace("\r\n", "\n");
					dictionary[key] = value;
					num2++;
				}
				for (; i < text.Length && text[i] != ',' && text[i] != '}'; i++)
				{
				}
				if (i < text.Length && text[i] == ',')
				{
					i++;
				}
			}
			Localizacion.RegistrarIdioma("en", "English", null);
			Localizacion.RegistrarIdioma("es", "Español", dictionary);
			Cache.Clear();
			YaLogueados.Clear();
			ControlDoblajePlugin.Log.LogInfo((object)$"[Traducciones] {num2} entradas cargadas (idioma actual: {Localizacion.IdiomaTextos}).");
		}
		catch (Exception ex)
		{
			ControlDoblajePlugin.Log.LogError((object)("[Traducciones] Error: " + ex.Message));
		}
	}

	public static void RefrescarTextosActivos()
	{
		if (!TextoEspanolActivo)
		{
			return;
		}
		try
		{
			TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val in array)
			{
				if ((Object)(object)val == (Object)null || EsDeNuestraUI((Component)(object)val) || (Object)(object)((Component)val).GetComponentInParent<TMP_InputField>() != (Object)null)
				{
					continue;
				}
				string text = ((TMP_Text)val).text;
				if (!string.IsNullOrEmpty(text))
				{
					Cache.Remove(text);
					string text2 = Aplicar(text);
					if (text2 != text)
					{
						((TMP_Text)val).SetText(text2);
					}
				}
			}
		}
		catch (Exception ex)
		{
			ControlDoblajePlugin.Log.LogWarning((object)("[RefrescarTextos] " + ex.Message));
		}
	}

	private static void RefrescarDropdownsNativos()
	{
		try
		{
			int num = 0;
			TMP_Dropdown[] array = Resources.FindObjectsOfTypeAll<TMP_Dropdown>();
			foreach (TMP_Dropdown val in array)
			{
				if ((Object)(object)val == (Object)null || EsDeNuestraUI((Component)(object)val))
				{
					continue;
				}
				try
				{
					try
					{
						val.RefreshShownValue();
					}
					catch
					{
					}
					TMP_Text captionText = val.captionText;
					List<OptionData> options = val.options;
					if ((Object)(object)captionText != (Object)null && options != null && val.value >= 0 && val.value < options.Count)
					{
						string text = Aplicar(Localizacion.AIngles(options[val.value].text));
						if (captionText.text != text)
						{
							captionText.SetText(text);
							num++;
						}
					}
				}
				catch
				{
				}
			}
			if (num > 0)
			{
				ControlDoblajePlugin.Log.LogInfo((object)$"[DDNativos] {num} caption(s) forzados a idioma '{Localizacion.IdiomaTextos}'.");
			}
		}
		catch
		{
		}
	}

	public static void DesactivarYRevertir()
	{
		Dictionary<string, string> mapaInverso = MapaInverso;
		TextoEspanolActivo = false;
		Cache.Clear();
		TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
		foreach (TextMeshProUGUI val in array)
		{
			if (!((Object)(object)val == (Object)null) && !EsDeNuestraUI((Component)(object)val) && !((Object)(object)((Component)val).GetComponentInParent<TMP_InputField>() != (Object)null))
			{
				string text = ((TMP_Text)val).text;
				if (!string.IsNullOrEmpty(text) && mapaInverso != null && mapaInverso.TryGetValue(text, out var value))
				{
					((TMP_Text)val).SetText(value);
				}
			}
		}
		RefrescarDropdownsNativos();
		OnIdiomaChanged?.Invoke();
		Localizacion.NotificarCambio();
	}

	public static void ActivarYAplicar()
	{
		TextoEspanolActivo = true;
		Cache.Clear();
		TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
		foreach (TextMeshProUGUI val in array)
		{
			if ((Object)(object)val == (Object)null || EsDeNuestraUI((Component)(object)val) || (Object)(object)((Component)val).GetComponentInParent<TMP_InputField>() != (Object)null)
			{
				continue;
			}
			string text = ((TMP_Text)val).text;
			if (!string.IsNullOrEmpty(text))
			{
				string text2 = Aplicar(text);
				if (text2 != text)
				{
					((TMP_Text)val).SetText(text2);
				}
			}
		}
		RefrescarDropdownsNativos();
		OnIdiomaChanged?.Invoke();
		Localizacion.NotificarCambio();
	}

	public static bool EsDeNuestraUI(Component c)
	{
		if ((Object)(object)c == (Object)null)
		{
			return false;
		}
		Transform val = c.transform;
		while ((Object)(object)val != (Object)null)
		{
			if ((Object)(object)((Component)val).GetComponent<DoblejeUIMarker>() != (Object)null)
			{
				return true;
			}
			val = val.parent;
		}
		return false;
	}

	private static string LeerStringJSON(string texto, ref int i)
	{
		if (i >= texto.Length || texto[i] != '"')
		{
			return null;
		}
		i++;
		StringBuilder stringBuilder = new StringBuilder();
		while (i < texto.Length)
		{
			char c = texto[i++];
			if (c == '"')
			{
				break;
			}
			if (c == '\\' && i < texto.Length)
			{
				char c2 = texto[i++];
				switch (c2)
				{
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'u':
					if (i + 4 <= texto.Length)
					{
						stringBuilder.Append((char)Convert.ToInt32(texto.Substring(i, 4), 16));
						i += 4;
					}
					break;
				default:
					stringBuilder.Append(c2);
					break;
				}
			}
			else
			{
				stringBuilder.Append(c);
			}
		}
		return stringBuilder.ToString();
	}

	public static void AgregarNombresUIAIgnorar()
	{
		foreach (string value in ControlDoblajePlugin.NombresUI.Values)
		{
			IgnorarLog.Add(value);
		}
		foreach (string personajesDisponible in ControlDoblajePlugin.PersonajesDisponibles)
		{
			IgnorarLog.Add(personajesDisponible);
		}
	}

	public static void InvalidarCache(string texto)
	{
		Cache.Remove(texto);
	}

	private static bool EsTodoMayusculas(string s)
	{
		bool result = false;
		foreach (char c in s)
		{
			if (char.IsLetter(c))
			{
				result = true;
				if (char.IsLower(c))
				{
					return false;
				}
			}
		}
		return result;
	}

	private static bool BuscarTrad(string s, out string trad)
	{
		trad = null;
		if (string.IsNullOrEmpty(s))
		{
			return false;
		}
		Dictionary<string, string> mapa = Mapa;
		if (mapa == null)
		{
			return false;
		}
		if (mapa.TryGetValue(s, out trad))
		{
			return true;
		}
		string text = s.Replace('’', '\'').Replace('‘', '\'').Replace('“', '"')
			.Replace('”', '"');
		if ((object)text != s && mapa.TryGetValue(text, out trad))
		{
			return true;
		}
		Dictionary<string, string> mapaActualCI = Localizacion.MapaActualCI;
		if (mapaActualCI != null && (mapaActualCI.TryGetValue(s, out trad) || mapaActualCI.TryGetValue(text, out trad)))
		{
			if (EsTodoMayusculas(s))
			{
				trad = trad.ToUpperInvariant();
			}
			return true;
		}
		trad = null;
		return false;
	}

	public static string Aplicar(string texto)
	{
		if (string.IsNullOrEmpty(texto) || Localizacion.EsPassthroughActual)
		{
			return texto;
		}
		if (Cache.TryGetValue(texto, out var value))
		{
			return value;
		}
		string text = texto.Replace("\r\n", "\n");
		if (ValoresTraducidos.Contains(text))
		{
			Cache[texto] = texto;
			return texto;
		}
		if (BuscarTrad(text, out var trad))
		{
			Cache[texto] = trad;
			return trad;
		}
		string text2 = text.Replace('’', '\'').Replace('‘', '\'').Replace('“', '"')
			.Replace('”', '"');
		if ((object)text2 != text && Mapa.TryGetValue(text2, out var value2))
		{
			Cache[texto] = value2;
			return value2;
		}
		string text3 = text.Trim();
		if (text3.Length != text.Length)
		{
			if (BuscarTrad(text3, out var trad2))
			{
				Cache[texto] = trad2;
				return trad2;
			}
			string text4 = text3.Replace('’', '\'').Replace('‘', '\'').Replace('“', '"')
				.Replace('”', '"');
			if ((object)text4 != text3 && Mapa.TryGetValue(text4, out var value3))
			{
				Cache[texto] = value3;
				return value3;
			}
		}
		string text5 = AplicarPatronLastSaved(text);
		if (text5 != null)
		{
			Cache[texto] = text5;
			return text5;
		}
		string text6 = AplicarPatronTimeAgo(text);
		if (text6 != null)
		{
			Cache[texto] = text6;
			return text6;
		}
		if (Enumerable.Contains(text, '\n'))
		{
			string[] array = text.Split(new char[1] { '\n' });
			bool flag = false;
			bool flag2 = true;
			for (int i = 0; i < array.Length; i++)
			{
				if (string.IsNullOrEmpty(array[i]))
				{
					continue;
				}
				string text7 = array[i];
				if (ValoresTraducidos.Contains(text7))
				{
					flag = true;
					continue;
				}
				if (BuscarTrad(text7, out var trad3))
				{
					array[i] = trad3;
					flag = true;
					continue;
				}
				string text8 = text7.Replace('’', '\'').Replace('‘', '\'').Replace('“', '"')
					.Replace('”', '"');
				if ((object)text8 != text7 && Mapa.TryGetValue(text8, out var value4))
				{
					array[i] = value4;
					flag = true;
					continue;
				}
				string text9 = text7.Trim();
				if (text9.Length != text7.Length)
				{
					if (BuscarTrad(text9, out var trad4))
					{
						array[i] = trad4;
						flag = true;
						continue;
					}
					string text10 = text9.Replace('’', '\'').Replace('‘', '\'');
					if ((object)text10 != text9 && Mapa.TryGetValue(text10, out var value5))
					{
						array[i] = value5;
						flag = true;
						continue;
					}
				}
				string text11 = TraducirTiempoRelativo(text9);
				if (text11 != null && text11 != text9)
				{
					array[i] = text7.Replace(text9, text11);
					flag = true;
					continue;
				}
				Match match = Regex.Match(text9, "^(?<pre>(?:<[^<>]+>)+)?(?<core>[^<>]+?)(?<post>(?:<[^<>]+>)+)?$");
				if (match.Success)
				{
					string text12 = match.Groups["core"].Value.Trim();
					if (text12.Length > 0 && text12.Length != text9.Length)
					{
						if (!BuscarTrad(text12, out var trad5))
						{
							trad5 = TraducirTiempoRelativo(text12);
						}
						if (trad5 != null && trad5 != text12)
						{
							array[i] = text7.Replace(text12, trad5);
							flag = true;
							continue;
						}
					}
				}
				flag2 = false;
			}
			if (flag)
			{
				string text13 = string.Join("\n", array);
				if (flag2)
				{
					Cache[texto] = text13;
				}
				return text13;
			}
		}
		string text14 = text.Trim();
		if (!DebeIgnorar(text14) && !YaLogueados.Contains(text14))
		{
			ControlDoblajePlugin.Log.LogInfo((object)("SIN_TRADUCIR: [" + texto + "]"));
			YaLogueados.Add(text14);
			VolcarSinTraducir(texto);
		}
		if (!EsTextoAleatorio(text14))
		{
			Cache[texto] = texto;
		}
		return texto;
	}

	private static void VolcarSinTraducir(string texto)
	{
		try
		{
			if (_dumpSinTrad == null)
			{
				_dumpSinTrad = Path.Combine(Paths.ConfigPath, "sin_traducir_dump.jsonl");
			}
			string text = "\"" + texto.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r")
				.Replace("\n", "\\n")
				.Replace("\t", "\\t") + "\"";
			File.AppendAllText(_dumpSinTrad, text + "\n", Encoding.UTF8);
		}
		catch
		{
		}
	}

	private static string AplicarPatronLastSaved(string norm)
	{
		if (!norm.StartsWith("Last Saved: ", StringComparison.Ordinal))
		{
			return null;
		}
		string parte = norm.Substring("Last Saved: ".Length).Trim();
		string text = TraducirTiempoRelativo(parte);
		if (text == null)
		{
			return null;
		}
		return "Último guardado: " + text;
	}

	private static string AplicarPatronTimeAgo(string norm)
	{
		string text = TraducirTiempoRelativo(norm);
		return (text != null && text != norm) ? text : null;
	}

	private static string TraducirTiempoRelativo(string parte)
	{
		if (Mapa.TryGetValue(parte, out var value))
		{
			return value;
		}
		string key = parte.Replace('’', '\'').Replace('‘', '\'');
		if (Mapa.TryGetValue(key, out var value2))
		{
			return value2;
		}
		string text = parte.ToLowerInvariant();
		if (text == "less than a minute ago")
		{
			return "Hace menos de un minuto";
		}
		if (text == "just now" || text == "a moment ago")
		{
			return "Ahora mismo";
		}
		switch (text)
		{
		case "1 minute ago":
			return "Hace 1 minuto";
		case "1 hour ago":
			return "Hace 1 hora";
		case "1 day ago":
			return "Hace 1 día";
		default:
		{
			Match match = Regex.Match(text, "^(\\d+)\\s+(minute|hour|day|week)s?\\s+ago$");
			if (match.Success)
			{
				string value3 = match.Groups[1].Value;
				switch (match.Groups[2].Value)
				{
				case "minute":
					return "Hace " + value3 + " minutos";
				case "hour":
					return "Hace " + value3 + " horas";
				case "day":
					return "Hace " + value3 + " días";
				case "week":
					return "Hace " + value3 + " semanas";
				}
			}
			return null;
		}
		}
	}

	private static string PersonajeDueno(string texto)
	{
		if (!texto.StartsWith("<style="))
		{
			return null;
		}
		int num = texto.IndexOf('>', 7);
		if (num < 0)
		{
			return null;
		}
		string value;
		return EstiloAPersonaje.TryGetValue(texto.Substring(7, num - 7), out value) ? value : null;
	}

	public static bool EsTextoAleatorio(string s)
	{
		if (string.IsNullOrEmpty(s))
		{
			return false;
		}
		if (s.Length <= 10 && s[0] == '¢')
		{
			return true;
		}
		int num = 0;
		int num2 = 0;
		foreach (char c in s)
		{
			if (!char.IsWhiteSpace(c))
			{
				num++;
				if (c >= 'ɐ' && c <= 'ʯ')
				{
					num2++;
				}
			}
		}
		return num > 0 && num2 * 2 > num;
	}

	private static bool DebeIgnorar(string trim)
	{
		if (trim.Length <= 3 || IgnorarLog.Contains(trim))
		{
			return true;
		}
		if (EsTextoAleatorio(trim))
		{
			return true;
		}
		if (trim.Contains("<alpha=") || trim.StartsWith("USB_LP_") || trim.Contains("<sprite="))
		{
			return true;
		}
		if (trim.Length <= 8 && (char.IsDigit(trim[0]) || trim[0] == '-'))
		{
			return true;
		}
		if (Enumerable.Contains(trim, '%') || (trim.StartsWith("v") && Enumerable.Contains(trim, '.')))
		{
			return true;
		}
		if (Enumerable.Contains(trim, 'ó') || Enumerable.Contains(trim, 'á') || Enumerable.Contains(trim, 'é') || Enumerable.Contains(trim, 'í') || Enumerable.Contains(trim, 'ú') || Enumerable.Contains(trim, 'ñ') || Enumerable.Contains(trim, '¿') || Enumerable.Contains(trim, '¡') || Enumerable.Contains(trim, 'Ú') || Enumerable.Contains(trim, 'à'))
		{
			return true;
		}
		if (trim.StartsWith("ÚLtimo guardado:") || trim.StartsWith("Hace ") || trim.StartsWith("Ahora mismo") || trim.StartsWith("Hace menos de"))
		{
			return true;
		}
		if (Enumerable.Contains(trim, '\n'))
		{
			int num = trim.Split(new char[1] { '\n' }).Length;
			bool flag = trim.Contains("<style=") || trim.Contains("<color=") || trim.Contains("<u>") || trim.Contains("<size=") || trim.Contains("<align=") || trim.Contains("<i>");
			if (num >= 5 && !flag)
			{
				return true;
			}
		}
		return false;
	}
}
public static class ImageExtensions
{
	public static readonly string[] Lista = new string[3] { ".png", ".jpg", ".jpeg" };

	public static string BuscarArchivo(string carpeta, string nombreSinExt)
	{
		string[] lista = Lista;
		foreach (string text in lista)
		{
			string text2 = Path.Combine(carpeta, nombreSinExt + text);
			if (AssetPack.Existe(text2))
			{
				return text2;
			}
		}
		int num = nombreSinExt.LastIndexOf('_');
		if (num > 0)
		{
			string text3 = nombreSinExt.Substring(num + 1);
			if (text3.Length > 0 && text3.All(char.IsDigit))
			{
				string text4 = nombreSinExt.Substring(0, num);
				string[] lista2 = Lista;
				foreach (string text5 in lista2)
				{
					string text6 = Path.Combine(carpeta, text4 + text5);
					if (AssetPack.Existe(text6))
					{
						return text6;
					}
				}
			}
		}
		return null;
	}
}
public static class OfuscadorAssets
{
	private static readonly byte[] Magic = new byte[4] { 84, 82, 78, 49 };

	private static readonly byte[] Key = Encoding.ASCII.GetBytes("TurronishDoblaje_2026_Blix");

	public static byte[] Desofuscar(byte[] datos)
	{
		if (datos == null || datos.Length < Magic.Length)
		{
			return datos;
		}
		for (int i = 0; i < Magic.Length; i++)
		{
			if (datos[i] != Magic[i])
			{
				return datos;
			}
		}
		int num = datos.Length - Magic.Length;
		byte[] array = new byte[num];
		for (int j = 0; j < num; j++)
		{
			array[j] = (byte)(datos[j + Magic.Length] ^ Key[j % Key.Length]);
		}
		return array;
	}
}
public class LogoRevealFailsafe : MonoBehaviour
{
	public CanvasGroup cg;

	private float _t;

	private void Update()
	{
		if ((Object)(object)cg == (Object)null || cg.alpha >= 1f)
		{
			((Behaviour)this).enabled = false;
			return;
		}
		_t += Time.unscaledDeltaTime;
		if (_t > 6f)
		{
			cg.alpha = 1f;
			((Behaviour)this).enabled = false;
		}
	}
}
public static class AssetPack
{
	private static readonly byte[] Magic = new byte[4] { 84, 80, 65, 75 };

	internal const uint HDR_EXT_A = 1114401144u;

	internal const uint HDR_EXT_B = 1247901184u;

	private static readonly byte[] Key = Encoding.ASCII.GetBytes("TurronishDoblaje_2026_Blix");

	private static string _root;

	private static bool _cargado;

	private static bool _flattened;

	private static readonly List<string> _packs = new List<string>();

	private static readonly List<FileStream> _packStreams = new List<FileStream>();

	private static readonly List<object> _packLocks = new List<object>();

	private static readonly Dictionary<string, long[]> _index = new Dictionary<string, long[]>(StringComparer.OrdinalIgnoreCase);

	private static readonly HashSet<string> _dirsPack = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private static byte[] _keyExp;

	public static bool Flattened => _flattened;

	private static void DesXor(byte[] buf, int len)
	{
		if (_keyExp == null)
		{
			_keyExp = new byte[Key.Length * 16];
			for (int i = 0; i < _keyExp.Length; i++)
			{
				_keyExp[i] = Key[i % Key.Length];
			}
		}
		int num = _keyExp.Length;
		int num2;
		for (int j = 0; j < len; j += num2)
		{
			num2 = num;
			if (j + num2 > len)
			{
				num2 = len - j;
			}
			for (int k = 0; k < num2; k++)
			{
				buf[j + k] ^= _keyExp[k];
			}
		}
	}

	private static string Norm(string rel)
	{
		return rel.Replace('/', '\\').TrimStart(new char[1] { '\\' });
	}

	public static void Init(string assetsRoot)
	{
		_root = assetsRoot;
		_cargado = false;
		_index.Clear();
		_packs.Clear();
		_dirsPack.Clear();
		foreach (FileStream packStream in _packStreams)
		{
			try
			{
				packStream.Dispose();
			}
			catch
			{
			}
		}
		_packStreams.Clear();
		_packLocks.Clear();
		string[] array = new string[3] { "assets.dat", "audio.dat", "turronish_img.dat" };
		foreach (string path in array)
		{
			string text = Path.Combine(assetsRoot, path);
			if (File.Exists(text))
			{
				CargarPack(text);
			}
		}
		_cargado = _index.Count > 0;
		_flattened = _cargado && !Directory.Exists(Path.Combine(assetsRoot, "VideoClips"));
		if (_cargado)
		{
			ControlDoblajePlugin.Log.LogInfo((object)($"[AssetPack] {_packs.Count} .dat cargado(s): {_index.Count} entradas" + (_flattened ? " · layout APLANADO (sueltos en raíz)" : "")));
		}
		else
		{
			ControlDoblajePlugin.Log.LogInfo((object)"[AssetPack] sin .dat — archivos sueltos (disco)");
		}
	}

	private static void CargarPack(string packPath)
	{
		try
		{
			int count = _packs.Count;
			using (FileStream input = File.OpenRead(packPath))
			{
				using BinaryReader binaryReader = new BinaryReader(input);
				byte[] array = binaryReader.ReadBytes(4);
				for (int i = 0; i < 4; i++)
				{
					if (i >= array.Length || array[i] != Magic[i])
					{
						ControlDoblajePlugin.Log.LogWarning((object)("[AssetPack] " + Path.GetFileName(packPath) + ": magic inválida — ignorado"));
						return;
					}
				}
				binaryReader.ReadInt32();
				int num = binaryReader.ReadInt32();
				for (int j = 0; j < num; j++)
				{
					int count2 = binaryReader.ReadInt16();
					string rel = Encoding.UTF8.GetString(binaryReader.ReadBytes(count2));
					long num2 = binaryReader.ReadInt64();
					int num3 = binaryReader.ReadInt32();
					string text = Norm(rel);
					_index[text] = new long[3] { count, num2, num3 };
					int num4 = text.LastIndexOf('\\');
					while (num4 > 0)
					{
						string text2 = text.Substring(0, num4);
						if (!_dirsPack.Add(text2))
						{
							break;
						}
						num4 = text2.LastIndexOf('\\');
					}
				}
			}
			_packs.Add(packPath);
			_packStreams.Add(new FileStream(packPath, FileMode.Open, FileAccess.Read, FileShare.Read));
			_packLocks.Add(new object());
		}
		catch (Exception ex)
		{
			ControlDoblajePlugin.Log.LogError((object)("[AssetPack] error cargando " + Path.GetFileName(packPath) + ": " + ex.Message));
		}
	}

	private static string Rel(string abs)
	{
		if (_root == null || abs == null || !abs.StartsWith(_root, StringComparison.OrdinalIgnoreCase))
		{
			return null;
		}
		return Norm(abs.Substring(_root.Length));
	}

	public static bool EstaEnPack(string abs)
	{
		if (!_cargado)
		{
			return false;
		}
		string text = Rel(abs);
		return text != null && _index.ContainsKey(text);
	}

	public static bool CarpetaExiste(string absFolder)
	{
		if (Directory.Exists(absFolder))
		{
			return true;
		}
		if (!_cargado)
		{
			return false;
		}
		string text = Rel(absFolder);
		if (text == null)
		{
			return false;
		}
		return _dirsPack.Contains(text.TrimEnd(new char[1] { '\\' }));
	}

	private static string FlatPath(string abs)
	{
		if (!_flattened || _root == null || string.IsNullOrEmpty(abs))
		{
			return null;
		}
		string text = Path.Combine(_root, Path.GetFileName(abs));
		return string.Equals(text, abs, StringComparison.OrdinalIgnoreCase) ? null : text;
	}

	public static bool Existe(string abs)
	{
		if (EstaEnPack(abs) || File.Exists(abs))
		{
			return true;
		}
		string text = FlatPath(abs);
		return text != null && File.Exists(text);
	}

	public static List<string> ListarArchivos(string absFolder, string ext)
	{
		List<string> list = new List<string>();
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		if (Directory.Exists(absFolder))
		{
			string[] files = Directory.GetFiles(absFolder, "*" + ext, SearchOption.TopDirectoryOnly);
			foreach (string text in files)
			{
				list.Add(text);
				hashSet.Add(Path.GetFileName(text));
			}
		}
		if (_cargado)
		{
			string text2 = Rel(absFolder);
			if (text2 != null)
			{
				string text3 = text2.TrimEnd(new char[1] { '\\' }) + "\\";
				foreach (string key in _index.Keys)
				{
					if (key.StartsWith(text3, StringComparison.OrdinalIgnoreCase) && key.EndsWith(ext, StringComparison.OrdinalIgnoreCase))
					{
						string text4 = key.Substring(text3.Length);
						if (text4.IndexOf('\\') < 0 && !hashSet.Contains(text4))
						{
							list.Add(Path.Combine(_root, key));
						}
					}
				}
			}
		}
		return list;
	}

	public static byte[] LeerBytes(string abs)
	{
		if (_cargado)
		{
			string text = Rel(abs);
			if (text != null && _index.TryGetValue(text, out var value))
			{
				try
				{
					int index = (int)value[0];
					int num = (int)value[2];
					byte[] array = new byte[num];
					lock (_packLocks[index])
					{
						FileStream fileStream = _packStreams[index];
						fileStream.Seek(value[1], SeekOrigin.Begin);
						int num2;
						for (int i = 0; i < num; i += num2)
						{
							num2 = fileStream.Read(array, i, num - i);
							if (num2 <= 0)
							{
								break;
							}
						}
					}
					DesXor(array, num);
					return array;
				}
				catch (Exception ex)
				{
					ControlDoblajePlugin.Log.LogError((object)("[AssetPack] error leyendo " + text + ": " + ex.Message));
				}
			}
		}
		string path = abs;
		if (!File.Exists(path))
		{
			string text2 = FlatPath(abs);
			if (text2 != null && File.Exists(text2))
			{
				path = text2;
			}
		}
		return OfuscadorAssets.Desofuscar(File.ReadAllBytes(path));
	}

	public static string LeerTexto(string abs)
	{
		return Encoding.UTF8.GetString(LeerBytes(abs));
	}

	public static string[] LeerLineas(string abs)
	{
		if (!Existe(abs))
		{
			return new string[0];
		}
		string text = LeerTexto(abs);
		if (text.Length > 0 && text[0] == '\ufeff')
		{
			text = text.Substring(1);
		}
		return text.Replace("\r\n", "\n").Replace("\r", "\n").Split(new char[1] { '\n' });
	}

	public static List<string> Listar(string absFolder, string[] exts, bool recurse)
	{
		HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		List<string> res = new List<string>();
		try
		{
			if (Directory.Exists(absFolder))
			{
				string[] files = Directory.GetFiles(absFolder, "*", recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
				foreach (string f in files)
				{
					if (exts == null || Array.Exists(exts, (string x) => f.EndsWith(x, StringComparison.OrdinalIgnoreCase)))
					{
						Add(f);
					}
				}
			}
		}
		catch
		{
		}
		if (_cargado)
		{
			string text = Rel(absFolder);
			if (text != null)
			{
				text = text.TrimEnd(new char[1] { '\\' }) + "\\";
			}
			if (text != null)
			{
				foreach (KeyValuePair<string, long[]> kv in _index)
				{
					if (kv.Key.StartsWith(text, StringComparison.OrdinalIgnoreCase) && (recurse || kv.Key.IndexOf('\\', text.Length) < 0) && (exts == null || Array.Exists(exts, (string x) => kv.Key.EndsWith(x, StringComparison.OrdinalIgnoreCase))))
					{
						Add(Path.Combine(_root, kv.Key));
					}
				}
			}
		}
		return res;
		void Add(string abs)
		{
			if (set.Add(abs))
			{
				res.Add(abs);
			}
		}
	}

	public static List<string> ListarSubcarpetas(string absFolder)
	{
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		List<string> list = new List<string>();
		try
		{
			if (Directory.Exists(absFolder))
			{
				string[] directories = Directory.GetDirectories(absFolder);
				foreach (string item in directories)
				{
					if (hashSet.Add(item))