using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Agents;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using CellMenu;
using Clonesoft.Json;
using Clonesoft.Json.Linq;
using Clonesoft.Json.Serialization;
using FluffyUnderware.DevTools.Extensions;
using GameData;
using Gear;
using Globals;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Localization;
using MTFO.API;
using Microsoft.CodeAnalysis;
using Player;
using Skins.Assets;
using Skins.Config;
using Skins.Data;
using Skins.Icons;
using Skins.Interop;
using Skins.Localization;
using Skins.Manifest;
using Skins.Meshes;
using Skins.Patches;
using Skins.Target;
using Skins.Textures;
using Skins.UI;
using Skins.UI.Menu;
using Skins.UI.Utils;
using Skins.Utils;
using Skins.Utils.Ext;
using StbDxtSharp;
using StbImageSharp;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Skins")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Skins")]
[assembly: AssemblyTitle("Skins")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Skins
{
	[HarmonyPatch]
	public class Events
	{
		public static event Action? OnGameDataInitialized;

		public static event Action<Item>? OnGearSpawnComplete;

		public static event Action? OnElevatorStop;

		public static event Action? OnBuilderDone;

		[HarmonyPatch(typeof(GameDataInit), "Initialize")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Postfix__GameDataInit_Initialize()
		{
			Events.OnGameDataInitialized?.Invoke();
		}

		[HarmonyPatch(typeof(Item), "OnGearSpawnComplete")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Postfix__Item_OnGearSpawnComplete(Item __instance)
		{
			Events.OnGearSpawnComplete?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(ItemEquippable), "OnGearSpawnComplete")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Postfix__ItemEquippable_OnGearSpawnComplete(Item __instance)
		{
			Events.OnGearSpawnComplete?.Invoke(__instance);
		}

		[HarmonyPatch(typeof(GS_StopElevatorRide), "Enter")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void Postfix__GS_StopElevatorRide_Enter()
		{
			Events.OnElevatorStop?.Invoke();
		}

		[HarmonyPatch(typeof(Builder), "OnFactoryDone")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void Postfix__Builder_OnFactoryDone()
		{
			Events.OnBuilderDone?.Invoke();
		}
	}
	internal static class Logger
	{
		private static ManualLogSource _mLogSource;

		public static bool Ready => _mLogSource != null;

		public static void Setup()
		{
			_mLogSource = Logger.CreateLogSource("io.takina.gtfo.Skins");
		}

		public static void SetupFromInit(ManualLogSource logSource)
		{
			_mLogSource = logSource;
		}

		private static string Format(object data)
		{
			return data.ToString();
		}

		public static void Debug(object msg)
		{
			if (ConfigMgr.Debug)
			{
				_mLogSource.LogDebug((object)Format(msg));
			}
		}

		public static void Debugf(string fmt, params object[] args)
		{
			if (ConfigMgr.Debug)
			{
				_mLogSource.LogDebug((object)Format(string.Format(fmt, args)));
			}
		}

		public static void Info(object msg)
		{
			_mLogSource.LogInfo((object)Format(msg));
		}

		public static void Infof(string fmt, params object[] args)
		{
			_mLogSource.LogInfo((object)Format(string.Format(fmt, args)));
		}

		public static void Warn(object msg)
		{
			_mLogSource.LogWarning((object)Format(msg));
		}

		public static void Warnf(string fmt, params object[] args)
		{
			_mLogSource.LogWarning((object)Format(string.Format(fmt, args)));
		}

		public static void Error(object msg)
		{
			_mLogSource.LogError((object)Format(msg));
		}

		public static void Errorf(string fmt, params object[] args)
		{
			_mLogSource.LogError((object)Format(string.Format(fmt, args)));
		}

		public static void Fatal(object msg)
		{
			_mLogSource.LogFatal((object)Format(msg));
		}

		public static void Fatalf(string fmt, params object[] args)
		{
			_mLogSource.LogFatal((object)Format(string.Format(fmt, args)));
		}
	}
	[BepInPlugin("io.takina.gtfo.Skins", "Skins", "0.12.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string NAME = "Skins";

		public const string GUID = "io.takina.gtfo.Skins";

		public const string VERSION = "0.12.0";

		internal const string GUID_MTFO = "com.dak.MTFO";

		internal const string GUID_LEGACY_LOBBY = "dev.aurirex.gtfo.legacylobby";

		public static GameObject? PluginObject;

		public static SkinProcess? UnityBehaviourProcess;

		public event Action? OnManagersSetup;

		public override void Load()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			Logger.Setup();
			Logger.Info("Skins [io.takina.gtfo.Skins @ 0.12.0]");
			JObject.Parse("{}");
			ConfigMgr.Process();
			ModData.Initialize();
			if (!PersistentConfig<UserConfig>.Load())
			{
				Logger.Fatal("Failed to load user config, aborting plugin load. Please ensure the config file is valid JSON");
				return;
			}
			Events.OnGameDataInitialized += Loc.InsertToGtfoDB;
			GearDump.Load();
			Application.quitting += Action.op_Implicit((Action)GearDump.FlushNow);
			MeshDump.Load();
			Application.quitting += Action.op_Implicit((Action)MeshDump.FlushNow);
			ShaderRefs.Preload();
			InternalData.Write();
			SkinManager.Initialize().RunSync();
			RegisterIl2CppTypes();
			OnManagersSetup += Initialize;
			Global.OnAllManagersSetup += Action.op_Implicit(this.OnManagersSetup);
			Logger.Info("Patching...");
			ApplyPatches(new Harmony("io.takina.gtfo.Skins"));
			Logger.Info("Finished Patching");
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static void ApplyPatches(Harmony h)
		{
			ApplyPatch<Events>(h);
			ApplyPatch<GearPatches>(h);
			ApplyPatch<GearIconPatches>(h);
			ApplyPatch<GearIcons>(h);
			ApplyPatch<ShellSkinning>(h);
			ApplyPatch<UIManager>(h);
			ApplyPatch<UISettings>(h);
			h.PatchAll(typeof(Loc));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static void ApplyPatchIfLoaded<T>(Harmony h, string guid)
		{
			if (((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey(guid))
			{
				ApplyPatch<T>(h);
				Logger.Info("Applied compat patches for plugin with GUID " + guid + ".");
			}
			else
			{
				Logger.Info("Plugin with GUID " + guid + " not found, skipping compat patches for it.");
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static void ApplyPatch<T>(Harmony h)
		{
			h.PatchAll(typeof(T));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static void RegisterIl2CppTypes()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<RegisterIl2CppAttribute>() != null)
				{
					ClassInjector.RegisterTypeInIl2Cpp(type);
				}
			}
		}

		private void Initialize()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Logger.Debug("Initializing...");
			_ = Loc.CurrentLocale;
			UIManager.Initialize();
			PluginObject = new GameObject("io.takina.gtfo.Skins");
			Object.DontDestroyOnLoad((Object)(object)PluginObject);
			UnityBehaviourProcess = PluginObject.AddComponent<SkinProcess>();
			new GameObject().AddComponent<DevUI>();
		}
	}
	public static class SkinManager
	{
		public static readonly List<InventorySlot> OfflineGearInventorySlots;

		private static readonly Dictionary<int, ManagedGroupTarget> GroupTargets;

		private static readonly Dictionary<int, ManagedMaterialTarget> MaterialTargets;

		private static readonly Dictionary<string, SkinGroup> SkinGroups;

		private static bool _inReload;

		public static bool Initialized { get; private set; }

		public static bool InReload => _inReload;

		public static IEnumerable<SkinGroup> AllGroups => SkinGroups.Values;

		static SkinManager()
		{
			OfflineGearInventorySlots = new List<InventorySlot>
			{
				(InventorySlot)1,
				(InventorySlot)2,
				(InventorySlot)3,
				(InventorySlot)10,
				(InventorySlot)11
			};
			Initialized = false;
			GroupTargets = new Dictionary<int, ManagedGroupTarget>();
			MaterialTargets = new Dictionary<int, ManagedMaterialTarget>();
			SkinGroups = new Dictionary<string, SkinGroup>();
			_inReload = false;
			Events.OnBuilderDone += RegisterPlayerBackpackTargets;
		}

		public static IEnumerator Initialize()
		{
			if (Initialized)
			{
				Logger.Warn("[SkinManager] Already initialized, skipping initialization.");
				yield break;
			}
			Logger.Info("[SkinManager] Started initialization.");
			Stopwatch loadTimer = Stopwatch.StartNew();
			TextureLibrary.ResetStats();
			if (!ConfigMgr.DevEnables(eDevOpts.NoNormalize))
			{
				NormalizeFolder(ModData.SkinsFolder);
				NormalizeFolder(ModData.PerProfileSkinsFolder);
			}
			if (!ConfigMgr.DevEnables(eDevOpts.NoMove))
			{
				MoveSkinGroups(ModData.PerProfileSkinsFolder, ModData.SkinsFolder);
			}
			yield return SkinPackageManager.InstallAll();
			RegisterGroup(SkinGroup.Vanilla);
			yield return LoadSkinsFolder(ModData.SkinsFolder);
			yield return LoadSkinsFolder(ModData.PerProfileSkinsFolder);
			double manifestMs = loadTimer.Elapsed.TotalMilliseconds;
			yield return WaitForTextures();
			Initialized = true;
			string value = (ConfigMgr.DevEnables(eDevOpts.NoCompress) ? "off" : "on");
			string text = (ConfigMgr.DevEnables(eDevOpts.LegacyLoad) ? "legacy (Unity LoadImage/Compress, main thread)" : $"managed pipeline, {TextureLoader.MaxWorkers} workers");
			text += $"; load mode {ConfigMgr.SkinLoadMode}, unload {ConfigMgr.SkinUnloadMode}";
			Logger.Info($"[SkinManager] Initialization complete in {loadTimer.Elapsed.TotalMilliseconds:F0} ms (manifests {manifestMs:F0} ms, textures {loadTimer.Elapsed.TotalMilliseconds - manifestMs:F0} ms wall): {SkinGroups.Count - 1} skin group(s), {TextureLibrary.LoadedCount} texture(s) ({(double)TextureLibrary.BytesRead / 1024.0 / 1024.0:F1} MB on disk, ~{(double)TextureLibrary.EstimatedVramBytes / 1024.0 / 1024.0:F0} MB in VRAM); decode {TextureLibrary.DecodeMs:F0} ms + compress {TextureLibrary.CompressMs:F0} ms (summed across threads), upload {TextureLibrary.UploadMs:F0} ms (main thread); loader: {text}; compression {value}, {TextureLibrary.CompressedCount} compressed");
		}

		private static IEnumerator WaitForTextures()
		{
			int total = TextureLoader.Pending;
			if (total == 0)
			{
				yield break;
			}
			if (_inReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: true);
			}
			while (TextureLoader.Pending > 0)
			{
				TextureLoader.Pump(_inReload ? 8 : 0);
				if (TextureLoader.Pending == 0)
				{
					break;
				}
				if (_inReload)
				{
					int num = total - TextureLoader.Pending;
					DevUI.Instance?.SetCenterDisplayText($"{Loc.T("settings.reloading")}\n<size=24>textures</size>\n<b>{num}/{total}</b>");
					DevUI.Instance?.SetCenterDisplayProgress((float)num / (float)total);
					yield return null;
				}
				else
				{
					Thread.Sleep(1);
				}
			}
			if (_inReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: false);
			}
		}

		private static IEnumerator LoadSkinsFolder(string path)
		{
			if (_inReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: true);
				yield return null;
			}
			List<string> files = FileUtils.FileInEachSubdirectory(path, "manifest.skingroup.json").ToList();
			int fileCount = files.Count;
			int i = 0;
			while (i < fileCount)
			{
				if (UpdateProgress(i, fileCount))
				{
					yield return null;
				}
				string text = files[i];
				Stopwatch stopwatch = Stopwatch.StartNew();
				SkinGroup skinGroup = JsonUtils.DeserializeFromFile<SkinGroup>(text);
				if (skinGroup == null)
				{
					Logger.Warn("[SkinManager] group manifest at '" + text + "' deserialized to null, skipping.");
				}
				else if (skinGroup.Initialize(text))
				{
					RegisterGroup(skinGroup);
					Logger.Info($"[SkinManager] Loaded skin group '{skinGroup.Name}' in {stopwatch.Elapsed.TotalMilliseconds:F0} ms.");
				}
				else
				{
					Logger.Error($"[SkinManager] Failed to initialize skin group '{skinGroup.Name}' at '{text}', skipping.");
				}
				int num = i + 1;
				i = num;
			}
			if (_inReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: false);
			}
			bool UpdateProgress(int current, int total)
			{
				if (!_inReload)
				{
					return false;
				}
				string centerDisplayText = $"{Loc.T("settings.reloading")}\n<size=24>{path}</size>\n<b>{current + 1}/{total}</b>";
				DevUI.Instance?.SetCenterDisplayText(centerDisplayText);
				DevUI.Instance?.SetCenterDisplayProgress((float)current / (float)total);
				return true;
			}
		}

		private static void NormalizeFolder(string path)
		{
			if (!Directory.Exists(path))
			{
				return;
			}
			string[] directories = Directory.GetDirectories(path);
			foreach (string text in directories)
			{
				string text2 = Path.Combine(text, "manifest.skingroup.json");
				if (!File.Exists(text2))
				{
					Logger.Debug("[SkinManager] NormalizeFolder: no manifest found in '" + text + "', skipping.");
					continue;
				}
				SkinGroup skinGroup = JsonUtils.DeserializeFromFile<SkinGroup>(text2);
				if (skinGroup == null || string.IsNullOrEmpty(skinGroup.Guid))
				{
					Logger.Warn("[SkinManager] NormalizeFolder: could not read a valid GUID from '" + text2 + "', skipping.");
					continue;
				}
				string fileName = Path.GetFileName(text);
				if (string.Equals(fileName, skinGroup.Guid, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string text3 = Path.Combine(path, skinGroup.Guid);
				if (Directory.Exists(text3))
				{
					Logger.Warn($"[SkinManager] NormalizeFolder: cannot rename '{fileName}' -> '{skinGroup.Guid}' -- a folder with that name already exists. Skipping.");
					continue;
				}
				try
				{
					Directory.Move(text, text3);
					Logger.Info($"[SkinManager] NormalizeFolder: renamed '{fileName}' -> '{skinGroup.Guid}'");
				}
				catch (Exception ex)
				{
					Logger.Error($"[SkinManager] NormalizeFolder: failed to rename '{fileName}' -> '{skinGroup.Guid}': {ex.Message}");
				}
			}
		}

		internal static void MoveSkinGroups(string from, string to, string callerTag = "AutoMove")
		{
			if (!Directory.Exists(from))
			{
				return;
			}
			string[] directories = Directory.GetDirectories(from);
			foreach (string text in directories)
			{
				string fileName = Path.GetFileName(text);
				string text2 = Path.Combine(to, fileName);
				if (Directory.Exists(text2))
				{
					try
					{
						Directory.Delete(text2, recursive: true);
						Logger.Info($"[SkinManager] {callerTag}: removed old global copy of '{fileName}'.");
					}
					catch (Exception ex)
					{
						Logger.Error($"[SkinManager] {callerTag}: failed to remove existing '{fileName}' from global skins folder, skipping move: {ex.Message}");
						continue;
					}
				}
				try
				{
					FileUtils.MoveDirectory(text, text2);
					Logger.Info("[SkinManager] AutoMove: moved '" + fileName + "' to global skins folder.");
				}
				catch (Exception ex2)
				{
					Logger.Error("[SkinManager] AutoMove: failed to move '" + fileName + "': " + ex2.Message);
				}
			}
		}

		public static void ApplyGroupToTargetsUnder(SkinGroup group, GameObject root, object owner)
		{
			foreach (MeshRenderer componentsInChild in root.GetComponentsInChildren<MeshRenderer>())
			{
				ApplyGroupToRawTarget(group, componentsInChild, owner);
			}
		}

		public static void ReleaseOwner(object owner)
		{
			TextureLibrary.ReleaseOwner(owner);
			MeshLibrary.ReleaseOwner(owner);
		}

		public static void SweepIdle()
		{
			if (ConfigMgr.SkinLoadMode != eSkinLoadMode.Eager)
			{
				float idleSeconds = ((ConfigMgr.SkinUnloadMode == eSkinUnloadMode.Immediate) ? 0f : ((float)ConfigMgr.UnloadIdleSeconds));
				int num = TextureLibrary.SweepIdle(idleSeconds);
				int num2 = MeshLibrary.SweepIdle(idleSeconds);
				if (num + num2 > 0)
				{
					Logger.Info($"[SkinManager] Freed {num} idle texture(s) and {num2} idle mesh(es); resident: {TextureLibrary.ResidentCount} texture(s) (~{(double)TextureLibrary.ResidentVramBytes / 1024.0 / 1024.0:F0} MB), {MeshLibrary.ResidentCount} mesh(es)");
				}
			}
		}

		public static void ApplyGroupToRawTarget(SkinGroup group, MeshRenderer meshRenderer, object owner)
		{
			Material material = ((Renderer)meshRenderer).material;
			MeshFilter component = ((Component)meshRenderer).GetComponent<MeshFilter>();
			string cleanName = NameUtils.GetCleanName(((Object)material).name);
			string text = (((Object)(object)component == (Object)null) ? null : NameUtils.GetCleanName(((Object)component.sharedMesh).name));
			MaterialSnapshot materialSnapshot = MaterialSnapshot.Capture(material);
			Dictionary<string, string> textureNames = materialSnapshot.GetTextureNames();
			materialSnapshot.Release();
			if (text != null && group.TryGetMeshTarget(text, cleanName, out MeshTarget targetOut))
			{
				Mesh val = targetOut.Acquire(owner);
				if ((Object)(object)val != (Object)null)
				{
					component.sharedMesh = val;
				}
			}
			if (!group.TryGetMaterialTarget(cleanName, textureNames, out MaterialTarget targetOut2))
			{
				Logger.Debug($"[ApplyGroupToRawTarget] skin group '{group.Name}' does not have a matching material target for material '{cleanName}' with the required textures.");
				return;
			}
			if (targetOut2.Shader != null && targetOut2.Shader != ((Object)material.shader).name)
			{
				Shader val2 = ShaderRefs.Get(targetOut2.Shader);
				if ((Object)(object)val2 == (Object)null)
				{
					Logger.Warn($"[ManagedMaterialTarget] failed to load shader '{targetOut2.Shader}' for material target '{targetOut2.MaterialNameToMatch}' in skin group '{group.Name}'. Shader will not be substituted.");
				}
				else
				{
					material.shader = val2;
				}
			}
			foreach (var (propertyName, materialProperty2) in targetOut2.Properties)
			{
				materialProperty2?.Apply(material, propertyName, owner);
			}
		}

		public static void UpdateTargetsUnder(GameObject go)
		{
			foreach (ManagedMaterialTarget componentsInChild in go.GetComponentsInChildren<ManagedMaterialTarget>())
			{
				componentsInChild.UpdateMaterial();
			}
		}

		public static void UpdateTargetsUnder(GameObject go, string groupGuid)
		{
			foreach (ManagedMaterialTarget componentsInChild in go.GetComponentsInChildren<ManagedMaterialTarget>())
			{
				componentsInChild.UpdateMaterial(overrideGroup: true, groupGuid);
			}
		}

		public static void UpdateAllTargets()
		{
			foreach (ManagedMaterialTarget value in MaterialTargets.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					value.UpdateMaterial();
				}
			}
		}

		public static void UpdateAllGroups()
		{
			foreach (ManagedGroupTarget value in GroupTargets.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					value.UpdateTargets();
				}
			}
		}

		internal static void RegisterPlayerBackpackTargets()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			BackpackItem val = default(BackpackItem);
			foreach (InventorySlot offlineGearInventorySlot in OfflineGearInventorySlots)
			{
				if (!PlayerBackpackManager.LocalBackpack.TryGetBackpackItem(offlineGearInventorySlot, ref val))
				{
					continue;
				}
				Item component = ((Component)val.Instance).GetComponent<Item>();
				if ((Object)(object)component == (Object)null)
				{
					Logger.Debug("[SkinManager] RegisterPlayerBackpackTargets: no Item component found on backpack item in slot " + $"{offlineGearInventorySlot}, skipping ManagedGroupTarget setup for this item.");
					continue;
				}
				ManagedGroupTarget orAddComponent = ((Component)component).gameObject.GetOrAddComponent<ManagedGroupTarget>();
				if ((Object)(object)orAddComponent == (Object)null)
				{
					Logger.Error("[SkinManager] RegisterPlayerBackpackTargets: failed to add ManagedGroupTarget component to backpack item in slot " + $"{offlineGearInventorySlot}, skipping ManagedGroupTarget setup for this item.");
				}
				else if (!((Object)(object)orAddComponent.BulletWeapon == (Object)null))
				{
					BulletWeapon bulletWeapon = orAddComponent.BulletWeapon;
					if (GearUtils.TryGetOfflineGearId(((ItemEquippable)bulletWeapon).GearIDRange, out var gearId) && ((ItemEquippable)bulletWeapon).ShellCasingData != null)
					{
						ShellSkinning.SetupPoolForGear(gearId, ((ItemEquippable)bulletWeapon).ShellCasingData.ShellCasingType);
					}
				}
			}
		}

		public static IEnumerator Reload()
		{
			if (_inReload)
			{
				Logger.Warn("[SkinManager] Already reloading!");
				yield break;
			}
			_inReload = true;
			try
			{
				GearIcons.BeforeReload();
				Unload();
				yield return Initialize();
				UpdateAllTargets();
				ShellSkinning.RebuildPools();
				GearIcons.OnSkinsReloaded();
			}
			finally
			{
				_inReload = false;
				DevUI.Instance?.SetCenterDisplayActive(active: false);
			}
		}

		public static void Unload()
		{
			if (_inReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: true);
				DevUI.Instance?.SetCenterDisplayText("Unloading Assets...");
			}
			SkinGroups.Clear();
			TextureLoader.CancelAll();
			TextureLibrary.UnloadAll();
			TextureMacro.UnloadAll();
			MeshLibrary.UnloadAll();
			Initialized = false;
			if (_inReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: false);
			}
		}

		public static bool TryGetGroup(string guid, [NotNullWhen(true)] out SkinGroup? group)
		{
			return SkinGroups.TryGetValue(guid, out group);
		}

		public static List<SkinGroup> GetAllMatchingGroups(TargetContext ctx)
		{
			List<SkinGroup> list = new List<SkinGroup>();
			Logger.Debug($"[SkinManager] GetAllMatchingGroups => {ctx}");
			foreach (SkinGroup value in SkinGroups.Values)
			{
				if (value.IsMatch(ctx))
				{
					list.Add(value);
					Logger.Debug($"[SkinManager] GetAllMatchingGroups => MATCH '{value.Name}' ({value.Guid})");
				}
			}
			return list;
		}

		public static SkinGroup? GetCurrentSkinGroupOfGear(uint gearPersistentId)
		{
			if (!GameDataBlockBase<PlayerOfflineGearDataBlock>.HasBlock(gearPersistentId))
			{
				return null;
			}
			if (PersistentConfig<UserConfig>.Instance == null)
			{
				return null;
			}
			if (PersistentConfig<UserConfig>.Instance.CurrentSkinConfig.OfflineGear.TryGetValue(gearPersistentId, out string value))
			{
				if (SkinGroups.TryGetValue(value, out SkinGroup value2))
				{
					return value2;
				}
				PersistentConfig<UserConfig>.Instance.CurrentSkinConfig.OfflineGear[gearPersistentId] = "10chambers.vanilla";
				PersistentConfig<UserConfig>.Save();
			}
			return SkinGroup.Vanilla;
		}

		public static SkinGroup? GetAnyMatchingGroup(TargetContext ctx)
		{
			foreach (SkinGroup value in SkinGroups.Values)
			{
				if (value.IsMatch(ctx))
				{
					return value;
				}
			}
			return null;
		}

		private static bool RegisterGroup(SkinGroup group)
		{
			if (string.IsNullOrEmpty(group.Guid))
			{
				Logger.Error($"Failed to register skin group '{group.Name}' because it has an empty guid.");
				return false;
			}
			if (!SkinGroups.TryAdd(group.Guid, group))
			{
				Logger.Warn($"Unable to register skin group '{group.Name}' ({group.Guid}) because a group with the same guid already exists. Skipping.");
				return false;
			}
			return true;
		}

		internal static void RegisterGroupTarget(ManagedGroupTarget target)
		{
			GroupTargets.Add(((Object)target).GetInstanceID(), target);
		}

		internal static void UnregisterGroupTarget(ManagedGroupTarget target)
		{
			GroupTargets.Remove(((Object)target).GetInstanceID());
		}

		internal static void RegisterMatTarget(ManagedMaterialTarget target)
		{
			MaterialTargets.Add(((Object)target).GetInstanceID(), target);
		}

		internal static void UnregisterMatTarget(ManagedMaterialTarget target)
		{
			MaterialTargets.Remove(((Object)target).GetInstanceID());
		}
	}
	public class SkinPackageManager
	{
		public const string SkinPackageExtension = ".skinspkg";

		public static IEnumerator InstallAll()
		{
			List<string> pkgFiles = FileUtils.FilesWithExtension(ModData.SkinsFolder, ".skinspkg").ToList();
			int pkgFileCount = pkgFiles.Count;
			if (pkgFileCount == 0)
			{
				yield break;
			}
			if (SkinManager.InReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: true);
				yield return null;
			}
			for (int i = 0; i < pkgFileCount; i++)
			{
				string pkgFile = pkgFiles[i];
				if (UpdateProgress(i, pkgFileCount, Path.GetFileName(pkgFile), Loc.T("settings.install.unpack")))
				{
					yield return null;
				}
				if (!Unpack(pkgFile))
				{
					Logger.Error("[SkinPackageManager] InstallAll: failed to unpack package '" + pkgFile + "'.");
					continue;
				}
				if (UpdateProgress(i, pkgFileCount, Path.GetFileName(pkgFile), Loc.T("settings.install.normalize")))
				{
					yield return null;
				}
				StagingNormalize(ModData.SkinsStagingFolder);
				string[] stagingGroups = (Directory.Exists(ModData.SkinsStagingFolder) ? Directory.GetDirectories(ModData.SkinsStagingFolder) : Array.Empty<string>());
				if (stagingGroups.Length == 0)
				{
					Logger.Error("[SkinPackageManager] InstallAll: package '" + Path.GetFileName(pkgFile) + "' contained no valid skin groups after normalization, skipping.");
					continue;
				}
				if (UpdateProgress(i, pkgFileCount, Path.GetFileName(pkgFile), Loc.T("settings.install.move")))
				{
					yield return null;
				}
				SkinManager.MoveSkinGroups(ModData.SkinsStagingFolder, ModData.SkinsFolder);
				Logger.Info($"[SkinPackageManager] InstallAll: successfully installed package '{pkgFile}' with {stagingGroups.Length} skin groups.");
				try
				{
					File.Delete(pkgFile);
				}
				catch (Exception ex)
				{
					Logger.Error("[SkinPackageManager] InstallAll: failed to delete package file '" + pkgFile + "' after installation: " + ex.Message);
				}
			}
			CleanupStagingArea();
			if (SkinManager.InReload)
			{
				DevUI.Instance?.SetCenterDisplayActive(active: false);
			}
			static bool UpdateProgress(int completed, int total, string processing, string message)
			{
				if (!SkinManager.InReload)
				{
					return false;
				}
				string centerDisplayText = $"{Loc.T("settings.installing")}\n<size=24>{processing}</size>\n<b>{completed + 1}/{total}</b>{(string.IsNullOrWhiteSpace(message) ? "" : (" " + message))}";
				DevUI.Instance?.SetCenterDisplayText(centerDisplayText);
				DevUI.Instance?.SetCenterDisplayProgress((float)completed / (float)total);
				return true;
			}
		}

		private static bool SetupStagingArea()
		{
			try
			{
				Directory.CreateDirectory(ModData.SkinsStagingFolder);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("[SkinPackageManager] SetupStagingArea: failed to create staging directory '" + ModData.SkinsStagingFolder + "': " + ex.Message);
				return false;
			}
		}

		private static bool CleanupStagingArea()
		{
			if (!Directory.Exists(ModData.SkinsStagingFolder))
			{
				return true;
			}
			try
			{
				Directory.Delete(ModData.SkinsStagingFolder, recursive: true);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("[SkinPackageManager] CleanupStagingArea: failed to clear staging directory '" + ModData.SkinsStagingFolder + "': " + ex.Message);
				return false;
			}
		}

		private static bool Unpack(string packageFile)
		{
			if (!CleanupStagingArea())
			{
				return false;
			}
			if (!SetupStagingArea())
			{
				return false;
			}
			try
			{
				ZipFile.ExtractToDirectory(packageFile, ModData.SkinsStagingFolder);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("[SkinPackageManager] Unpack: failed to unpack package '" + packageFile + "': " + ex.Message);
				return false;
			}
		}

		private static void StagingNormalize(string folderPath)
		{
			if (!Directory.Exists(folderPath))
			{
				return;
			}
			string[] directories = Directory.GetDirectories(folderPath);
			foreach (string text in directories)
			{
				string text2 = Path.Combine(text, "manifest.skingroup.json");
				if (!File.Exists(text2))
				{
					Logger.Debug("[SkinPackageManager] NormalizeFolder: no manifest found in '" + text + "', skipping.");
					continue;
				}
				SkinGroup skinGroup = JsonUtils.DeserializeFromFile<SkinGroup>(text2);
				if (skinGroup == null || string.IsNullOrEmpty(skinGroup.Guid))
				{
					Logger.Error("[SkinPackageManager] NormalizeFolder: could not read a valid GUID from '" + text2 + "'. Unstaging folder for installation.");
					try
					{
						Directory.Delete(text, recursive: true);
					}
					catch (Exception ex)
					{
						Logger.Error("[SkinPackageManager] NormalizeFolder: failed to delete & unstage folder '" + text + "': " + ex.Message);
					}
					continue;
				}
				string fileName = Path.GetFileName(text);
				if (string.Equals(fileName, skinGroup.Guid, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string text3 = Path.Combine(folderPath, skinGroup.Guid);
				if (Directory.Exists(text3))
				{
					Logger.Error($"[SkinPackageManager] NormalizeFolder: cannot rename '{fileName}' -> '{skinGroup.Guid}' -- a folder with that name already exists. Unstaging folder for installation.");
					try
					{
						Directory.Delete(text, recursive: true);
					}
					catch (Exception ex2)
					{
						Logger.Error("[SkinPackageManager] NormalizeFolder: failed to delete & unstage folder '" + text + "': " + ex2.Message);
					}
					continue;
				}
				try
				{
					Directory.Move(text, text3);
					Logger.Info($"[SkinPackageManager] NormalizeFolder: renamed '{fileName}' -> '{skinGroup.Guid}'");
				}
				catch (Exception ex3)
				{
					Logger.Error($"[SkinPackageManager] NormalizeFolder: failed to rename '{fileName}' -> '{skinGroup.Guid}': {ex3.Message}");
				}
			}
		}
	}
	[RegisterIl2Cpp]
	public class SkinProcess : MonoBehaviour
	{
		private const float DumpDirtyCheckInterval = 30f;

		private const float SweepInterval = 1f;

		private const double TextureUploadBudgetMs = 4.0;

		private float _nextDumpDirtyCheckTime;

		private float _nextSweepTime;

		private void Update()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			TextureLoader.Pump(4.0);
			GearIcons.Pump(4.0);
			GearIconPatches.Tick();
			if (Time.time >= _nextSweepTime)
			{
				SkinManager.SweepIdle();
				_nextSweepTime = Time.time + 1f;
			}
			if (ConfigMgr.EnableHotReloadKey && Input.GetKeyDown(ConfigMgr.HotReloadKey))
			{
				((MonoBehaviour)this).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(SkinManager.Reload()));
			}
			if (Time.time >= _nextDumpDirtyCheckTime)
			{
				GearDump.FlushNow();
				MeshDump.FlushNow();
				_nextDumpDirtyCheckTime = Time.time + 30f;
			}
		}
	}
}
namespace Skins.Utils
{
	public static class FileUtils
	{
		public static IEnumerable<string> FileInEachSubdirectory(string dir, string fileName)
		{
			if (!Directory.Exists(dir))
			{
				yield break;
			}
			foreach (string item in Directory.EnumerateDirectories(dir))
			{
				string text = Path.Combine(item, fileName);
				if (File.Exists(text))
				{
					yield return text;
				}
			}
		}

		public static IEnumerable<string> FilesWithExtensionRecursive(string dir, string extension)
		{
			if (!Directory.Exists(dir))
			{
				yield break;
			}
			string text = (extension.StartsWith(".") ? extension : ("." + extension));
			foreach (string item in Directory.EnumerateFiles(dir, "*" + text, SearchOption.AllDirectories))
			{
				yield return item;
			}
		}

		public static IEnumerable<string> FilesWithExtension(string dir, string extension)
		{
			if (!Directory.Exists(dir) || string.IsNullOrWhiteSpace(extension))
			{
				yield break;
			}
			string text = (extension.StartsWith(".") ? extension : ("." + extension));
			foreach (string item in Directory.EnumerateFiles(dir, "*" + text, SearchOption.TopDirectoryOnly))
			{
				yield return item;
			}
		}

		public static void MoveFile(string sourcePath, string destPath, bool overwrite = false)
		{
			if (!File.Exists(sourcePath))
			{
				Logger.Warn("[FileUtils] Source file does not exist: " + sourcePath);
				return;
			}
			if (File.Exists(destPath))
			{
				if (!overwrite)
				{
					Logger.Warn("[FileUtils] Destination file already exists: " + destPath);
					return;
				}
				File.Delete(destPath);
			}
			File.Copy(sourcePath, destPath);
			File.Delete(sourcePath);
		}

		public static void MoveDirectory(string sourceDir, string destDir, bool overwrite = false)
		{
			if (!Directory.Exists(sourceDir))
			{
				Logger.Warn("[FileUtils] Source directory does not exist: " + sourceDir);
				return;
			}
			if (Directory.Exists(destDir))
			{
				if (!overwrite)
				{
					Logger.Warn("[FileUtils] Destination directory already exists: " + destDir);
					return;
				}
				Directory.Delete(destDir, recursive: true);
			}
			Directory.CreateDirectory(destDir);
			foreach (string item in Directory.EnumerateFiles(sourceDir))
			{
				string destFileName = Path.Combine(destDir, Path.GetFileName(item));
				File.Copy(item, destFileName);
				File.Delete(item);
			}
			foreach (string item2 in Directory.EnumerateDirectories(sourceDir))
			{
				string destDir2 = Path.Combine(destDir, Path.GetFileName(item2));
				MoveDirectory(item2, destDir2, overwrite);
			}
			Directory.Delete(sourceDir);
		}
	}
	public static class GearUtils
	{
		private const string GearIdPattern = "^OfflineGear_ID_(\\d+)$";

		private static readonly Regex GearIdRe = new Regex("^OfflineGear_ID_(\\d+)$", RegexOptions.Compiled);

		public static uint? ExtractOfflineGearId(string? gearPartId)
		{
			if (gearPartId == null)
			{
				return null;
			}
			Match match = GearIdRe.Match(gearPartId);
			if (!match.Success)
			{
				return null;
			}
			if (uint.TryParse(match.Groups[1].Value, out var result))
			{
				return result;
			}
			return null;
		}

		public static bool TryGetOfflineGearId(BackpackItem item, out uint gearId)
		{
			if (item.GearIDRange != null)
			{
				return TryGetOfflineGearId(item.GearIDRange, out gearId);
			}
			gearId = 0u;
			return false;
		}

		public static bool TryGetOfflineGearId(ItemEquippable item, out uint gearId)
		{
			if (item.GearIDRange != null)
			{
				return TryGetOfflineGearId(item.GearIDRange, out gearId);
			}
			gearId = 0u;
			return false;
		}

		public static bool TryGetOfflineGearId(GearIDRange idRange, out uint gearId)
		{
			uint? num = ExtractOfflineGearId(idRange.PlayfabItemInstanceId);
			if (num.HasValue)
			{
				gearId = num.Value;
				return true;
			}
			gearId = 0u;
			return false;
		}

		public static bool TryGetShellType(GearIDRange? idRange, out ShellTypes type)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			type = (ShellTypes)0;
			if (idRange == null)
			{
				return false;
			}
			uint compID = idRange.GetCompID((eGearComponent)7);
			if (!GameDataBlockBase<WeaponShellCasingDataBlock>.HasBlock(compID))
			{
				return false;
			}
			WeaponShellCasingDataBlock block = GameDataBlockBase<WeaponShellCasingDataBlock>.GetBlock(compID);
			type = (ShellTypes)(int)block.ShellCasingType;
			return true;
		}

		public static bool TryGetShellTypePrefab(ShellTypes type, [NotNullWhen(true)] out GameObject? prefab)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected I4, but got Unknown
			WeaponShellManager current = WeaponShellManager.Current;
			prefab = (GameObject?)((type - 1) switch
			{
				0 => current.m_shell_9mm_prefab, 
				1 => current.m_shell_45_ACP_prefab, 
				2 => current.m_shell_338_prefab, 
				3 => current.m_shell_12_Gauge_prefab, 
				_ => null, 
			});
			return (Object)(object)prefab != (Object)null;
		}
	}
	public static class GuiUtils
	{
		public static void SetItemColor(CM_Item item, Color spriteColor, Color textColorAll)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			Color spriteColorOut = default(Color);
			((Color)(ref spriteColorOut))..ctor(spriteColor.r, spriteColor.g, spriteColor.b, item.m_spriteAlphaOut);
			Color spriteColorOver = default(Color);
			((Color)(ref spriteColorOver))..ctor(spriteColor.r, spriteColor.g, spriteColor.b, item.m_spriteAlphaOver);
			Color val = default(Color);
			((Color)(ref val))..ctor(textColorAll.r, textColorAll.g, textColorAll.b, item.m_textAlphaOut);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(textColorAll.r, textColorAll.g, textColorAll.b, item.m_textAlphaOver);
			item.m_spriteColorOrg = spriteColor;
			item.m_spriteColorOut = spriteColorOut;
			item.m_spriteColorOver = spriteColorOver;
			if (item.m_texts != null)
			{
				for (int i = 0; i < ((Il2CppArrayBase<TextMeshPro>)(object)item.m_texts).Count; i++)
				{
					((Il2CppArrayBase<Color>)(object)item.m_textColorOrg)[i] = textColorAll;
					((Il2CppArrayBase<Color>)(object)item.m_textColorOut)[i] = val;
					((Il2CppArrayBase<Color>)(object)item.m_textColorOver)[i] = val2;
				}
			}
			item.OnHoverOut();
		}

		public static void FixLobbyScrollItem(CM_LobbyScrollItem item, float? newX = null, float? newY = null, float leftLineThickness = 12f, float lineThickness = 4f)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = ((Il2CppObjectBase)((Component)item).transform).TryCast<RectTransform>();
			RectTransform component = ((Component)CustomExtensions.FindChildRecursive((Transform)(object)obj, "StretchLineT", true)).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)CustomExtensions.FindChildRecursive((Transform)(object)obj, "StretchLineB", true)).GetComponent<RectTransform>();
			RectTransform component3 = ((Component)CustomExtensions.FindChildRecursive((Transform)(object)obj, "StretchLineL", true)).GetComponent<RectTransform>();
			RectTransform component4 = ((Component)CustomExtensions.FindChildRecursive((Transform)(object)obj, "StretchLineR", true)).GetComponent<RectTransform>();
			RectTransform component5 = ((Component)((Transform)component).parent).GetComponent<RectTransform>();
			RectTransform component6 = ((Component)CustomExtensions.FindChildRecursive((Transform)(object)component5, "Background", true)).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(newX ?? component5.sizeDelta.x, newY ?? component5.sizeDelta.y);
			component5.sizeDelta = val;
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = Vector2.one;
			component6.offsetMin = Vector2.zero;
			component6.offsetMax = Vector2.zero;
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.offsetMin = new Vector2(0f, 0f - lineThickness);
			component.offsetMax = new Vector2(0f, 0f);
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 0f);
			component2.offsetMin = new Vector2(0f, 0f - lineThickness);
			component2.offsetMax = new Vector2(0f, 0f);
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(0f, 1f);
			component3.offsetMin = new Vector2(0f, 0f);
			component3.offsetMax = new Vector2(leftLineThickness, 0f);
			component4.anchorMin = new Vector2(1f, 0f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.offsetMin = new Vector2(0f, 0f);
			component4.offsetMax = new Vector2(lineThickness, 0f);
			foreach (UI_SpriteResizer componentsInChild in ((Component)item).GetComponentsInChildren<UI_SpriteResizer>())
			{
				if (Object.op_Implicit((Object)(object)componentsInChild))
				{
					componentsInChild.Resize();
				}
			}
			((CM_Item)item).m_collider.size = val;
		}
	}
	public static class JsonUtils
	{
		public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
		{
			ContractResolver = (IContractResolver)(object)new SkinsContractResolver()
		};

		public static T? Deserialize<T>(string json)
		{
			return JsonConvert.DeserializeObject<T>(json, Settings);
		}

		public static T? DeserializeFromFile<T>(string path)
		{
			if (!File.Exists(path))
			{
				Logger.Warn("[JsonUtils] File not found: '" + path + "'");
				return default(T);
			}
			return Deserialize<T>(File.ReadAllText(path));
		}
	}
	public class SkinsContractResolver : DefaultContractResolver
	{
		protected override JsonConverter? ResolveContractConverter(Type objectType)
		{
			if (objectType == typeof(IMaterialProperty))
			{
				return (JsonConverter?)(object)new MaterialPropertyConverter();
			}
			return ((DefaultContractResolver)this).ResolveContractConverter(objectType);
		}
	}
	[RegisterIl2Cpp]
	public class LifecycleHook : MonoBehaviour
	{
		public event Action? OnStarted;

		public event Action? OnEnabled;

		public event Action? OnDisabled;

		public event Action? OnDestroyed;

		private void Start()
		{
			this.OnStarted?.Invoke();
		}

		private void OnEnable()
		{
			this.OnEnabled?.Invoke();
		}

		private void OnDisable()
		{
			this.OnDisabled?.Invoke();
		}

		private void OnDestroy()
		{
			this.OnDestroyed?.Invoke();
		}
	}
	public class LocaleUtils
	{
		public static readonly Dictionary<string, string> LocaleKeyToDisplayName = new Dictionary<string, string>
		{
			{ "en", "English" },
			{ "fr", "Français" },
			{ "de", "Deutsch" },
			{ "es", "Español" },
			{ "it", "Italiano" },
			{ "ja", "日本語" },
			{ "ko", "한국어" },
			{ "pt-BR", "Português (Brasil)" },
			{ "ru", "Русский" },
			{ "pl", "Polski" },
			{ "zh-Hans", "简体中文" },
			{ "zh-Hant", "繁體中文" }
		};

		public static string LocaleKeyFromEnum(Language key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected I4, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			return (key - 1) switch
			{
				0 => "en", 
				1 => "fr", 
				3 => "de", 
				4 => "es", 
				2 => "it", 
				8 => "ja", 
				9 => "ko", 
				6 => "pt-BR", 
				5 => "ru", 
				7 => "pl", 
				11 => "zh-Hans", 
				10 => "zh-Hant", 
				_ => throw new ArgumentOutOfRangeException("key", key, null), 
			};
		}

		public static void SetTranslation(TextDataBlock db, string locale, string text)
		{
			switch (locale)
			{
			case "en":
				db.English = text;
				break;
			case "fr":
				db.French = LanguageData.op_Implicit(text);
				break;
			case "de":
				db.German = LanguageData.op_Implicit(text);
				break;
			case "es":
				db.Spanish = LanguageData.op_Implicit(text);
				break;
			case "it":
				db.Italian = LanguageData.op_Implicit(text);
				break;
			case "ja":
				db.Japanese = LanguageData.op_Implicit(text);
				break;
			case "ko":
				db.Korean = LanguageData.op_Implicit(text);
				break;
			case "pt-BR":
				db.Portuguese_Brazil = LanguageData.op_Implicit(text);
				break;
			case "ru":
				db.Russian = LanguageData.op_Implicit(text);
				break;
			case "pl":
				db.Polish = LanguageData.op_Implicit(text);
				break;
			case "zh-Hans":
				db.Chinese_Simplified = LanguageData.op_Implicit(text);
				break;
			case "zh-Hant":
				db.Chinese_Traditional = LanguageData.op_Implicit(text);
				break;
			}
		}

		public static uint GetSlotGearSelectTextDbId(InventorySlot slot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected I4, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			switch (slot - 1)
			{
			default:
				if ((int)slot == 10)
				{
					return 490u;
				}
				return 0u;
			case 0:
				return 487u;
			case 1:
				return 488u;
			case 2:
				return 489u;
			}
		}

		public static string GetSlotGearSelectLocalizedText(InventorySlot slot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Text.Get(GetSlotGearSelectTextDbId(slot));
		}
	}
	public static class LogDumper
	{
		private static readonly Dictionary<string, StreamWriter> LogStreams = new Dictionary<string, StreamWriter>();

		private static readonly Dictionary<string, HashSet<int>> LoggedIds = new Dictionary<string, HashSet<int>>();

		public static void Dump(string name, string content, bool append = false)
		{
			if (!LogStreams.TryGetValue(name, out StreamWriter value))
			{
				value = new StreamWriter(Path.Combine(ModData.DumpFolder, name + ".log"), append);
				LogStreams[name] = value;
				LoggedIds[name] = new HashSet<int>();
			}
			value.WriteLine(content);
			value.Flush();
		}

		public static void DumpUnique(string name, int id, string content, bool append = false)
		{
			if (!LogStreams.TryGetValue(name, out StreamWriter value))
			{
				value = new StreamWriter(Path.Combine(ModData.DumpFolder, name + ".log"), append);
				LogStreams[name] = value;
				LoggedIds[name] = new HashSet<int>();
			}
			if (!LoggedIds[name].Contains(id))
			{
				value.WriteLine(content);
				value.Flush();
				LoggedIds[name].Add(id);
			}
		}
	}
	public static class NameUtils
	{
		private static readonly Regex CleanPattern = new Regex("\\s*(?:\\(Clone\\)|\\(Instance\\)|Instance).*$", RegexOptions.Compiled);

		public static string GetCleanName(string name)
		{
			return CleanPattern.Replace(name, "");
		}
	}
	public static class PluginUtils
	{
		public static bool IsPluginLoaded(string pluginGuid)
		{
			return ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey(pluginGuid);
		}
	}
	public static class TextureUtils
	{
		public static Texture2D CreateBlankWhiteTexture()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, Color.white);
			val.Apply();
			return val;
		}

		public static Texture2D CreateBlankTexture(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_0017: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, color);
			val.Apply();
			return val;
		}

		public static Sprite SpriteFromRenderTexture(RenderTexture rt)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0038: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(((Texture)rt).width, ((Texture)rt).height, (TextureFormat)4, false);
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = rt;
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)rt).width, (float)((Texture)rt).height), 0, 0);
			val.Apply();
			RenderTexture.active = active;
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		public static Sprite SpriteFromTexture2D(Texture2D tex)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			float num = ((Texture)tex).width;
			float num2 = ((Texture)tex).height;
			return Sprite.Create(tex, new Rect(0f, 0f, num, num2), new Vector2(0.5f, 0.5f));
		}

		public static TextureOptions InferOptionsFromSlot(string slot)
		{
			return new TextureOptions(slot switch
			{
				"_BumpMap" => true, 
				"_MetallicGlossMap" => true, 
				"_AOCurveTex" => true, 
				"_SpecGlossMap" => true, 
				"_HeightMap" => true, 
				"_DistortionTex" => true, 
				"_DistortionSignal" => true, 
				_ => false, 
			}, PersistentConfig<UserConfig>.Instance?.PluginConfig.EnableMipMaps ?? false);
		}
	}
	public class TMPUtils
	{
		public static bool CreateTMP(string name, Transform? parent, [NotNullWhen(true)] out TextMeshPro? tp)
		{
			//IL_0058: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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)
			WatermarkGuiLayer watermarkLayer = GuiManager.WatermarkLayer;
			object obj;
			if (watermarkLayer == null)
			{
				obj = null;
			}
			else
			{
				PUI_Watermark watermark = watermarkLayer.m_watermark;
				obj = ((watermark != null) ? watermark.m_fpsText : null);
			}
			TextMeshPro val = (TextMeshPro)obj;
			if ((Object)(object)parent == (Object)null || (Object)(object)val == (Object)null)
			{
				tp = null;
				return false;
			}
			tp = Object.Instantiate<TextMeshPro>(val, parent, false);
			((Object)tp).name = name;
			((TMP_Text)tp).rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			((TMP_Text)tp).rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			((TMP_Text)tp).rectTransform.pivot = new Vector2(1f, 0f);
			((TMP_Text)tp).rectTransform.anchoredPosition3D = new Vector3(0f, 2f, 0f);
			((Transform)((TMP_Text)tp).rectTransform).localRotation = Quaternion.Euler(0f, 0f, 0f);
			((TMP_Text)tp).enableAutoSizing = false;
			((TMP_Text)tp).overflowMode = (TextOverflowModes)0;
			((TMP_Text)tp).alignment = (TextAlignmentOptions)513;
			((TMP_Text)tp).fontSize = 16f;
			return true;
		}

		public static bool CreateTMPUGUI(string name, Transform? parent, [NotNullWhen(true)] out TextMeshProUGUI? tp)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			WatermarkGuiLayer watermarkLayer = GuiManager.WatermarkLayer;
			object obj;
			if (watermarkLayer == null)
			{
				obj = null;
			}
			else
			{
				PUI_Watermark watermark = watermarkLayer.m_watermark;
				obj = ((watermark != null) ? watermark.m_fpsText : null);
			}
			TextMeshPro val = (TextMeshPro)obj;
			GameObject val2 = new GameObject();
			val2.transform.SetParent(parent, false);
			tp = val2.AddComponent<TextMeshProUGUI>();
			((Object)tp).name = name;
			((TMP_Text)tp).rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			((TMP_Text)tp).rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			((TMP_Text)tp).rectTransform.pivot = new Vector2(0.5f, 0.5f);
			((TMP_Text)tp).rectTransform.anchoredPosition3D = new Vector3(0f, 0f, 0f);
			((Transform)((TMP_Text)tp).rectTransform).localRotation = Quaternion.Euler(0f, 0f, 0f);
			((TMP_Text)tp).enableAutoSizing = false;
			((TMP_Text)tp).overflowMode = (TextOverflowModes)0;
			((TMP_Text)tp).alignment = (TextAlignmentOptions)514;
			((TMP_Text)tp).fontSize = 16f;
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)tp).font = ((TMP_Text)val).font;
				((TMP_Text)tp).fontSharedMaterial = ((TMP_Text)val).fontSharedMaterial;
			}
			return true;
		}
	}
}
namespace Skins.Utils.Ext
{
	public static class BackpackExtensions
	{
		public static TargetContext GetContextForSlot(this PlayerBackpack bkpk, InventorySlot slot)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			TargetContext targetContext = new TargetContext();
			BackpackItem item = default(BackpackItem);
			if ((slot - 1 <= 2 || (int)slot == 10) && bkpk.TryGetBackpackItem(slot, ref item) && GearUtils.TryGetOfflineGearId(item, out var gearId))
			{
				targetContext.OfflineGearId = gearId;
			}
			return targetContext;
		}
	}
	public static class ComponentExtensions
	{
		public static T? AddComponentIfMissing<T>(this GameObject obj) where T : Component
		{
			if (!((Object)(object)obj.GetComponent<T>() == (Object)null))
			{
				return default(T);
			}
			return obj.AddComponent<T>();
		}

		public static T GetOrAddComponent<T>(this GameObject obj) where T : Component
		{
			T val = obj.GetComponent<T>();
			if ((Object)(object)val == (Object)null)
			{
				val = obj.AddComponent<T>();
			}
			return val;
		}

		public static T? GetComponentSafe<T>(this GameObject? obj) where T : Component
		{
			if ((Object)(object)obj == (Object)null)
			{
				return default(T);
			}
			return obj.GetComponent<T>();
		}

		public static T? GetComponentSafe<T>(this Component? obj) where T : Component
		{
			if ((Object)(object)obj == (Object)null)
			{
				return default(T);
			}
			return obj.GetComponent<T>();
		}
	}
	public static class EnumeratorExtensions
	{
		public static void RunSync(this IEnumerator enumerator)
		{
			Stack<IEnumerator> stack = new Stack<IEnumerator>();
			stack.Push(enumerator);
			while (stack.Count > 0)
			{
				IEnumerator enumerator2 = stack.Peek();
				if (enumerator2.MoveNext())
				{
					if (enumerator2.Current is IEnumerator item)
					{
						stack.Push(item);
					}
				}
				else
				{
					stack.Pop();
				}
			}
		}
	}
}
namespace Skins.UI
{
	[RegisterIl2Cpp]
	public class DevUI : MonoBehaviour
	{
		private static readonly Vector2 ReferenceResolution = new Vector2(2560f, 1440f);

		private Canvas _canvas;

		private CanvasScaler _canvasScaler;

		private GameObject _centerContainer;

		private Image _centerContainerImage;

		private TMP_Text _centerDisplayTxt;

		private Image _progressBarFill;

		private RectTransform _progressBarFillRt;

		public static DevUI? Instance { get; private set; } = null;

		private void Awake()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance != (Object)null)
			{
				Logger.Warn("[DevUI] Instance already exists, destroying new instance.");
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).name = "io.takina.gtfo.Skins.DevUI";
			_canvas = ((Component)this).gameObject.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 1000;
			_canvasScaler = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			_canvasScaler.uiScaleMode = (ScaleMode)1;
			_canvasScaler.referenceResolution = ReferenceResolution;
			_canvasScaler.m_MatchWidthOrHeight = 1f;
			CreateElements();
		}

		public void SetCenterDisplayActive(bool active)
		{
			if (!((Object)(object)_centerContainer == (Object)null))
			{
				_centerContainer.SetActive(active);
			}
		}

		public void SetCenterDisplayText(string text)
		{
			if (!((Object)(object)_centerDisplayTxt == (Object)null))
			{
				_centerDisplayTxt.text = text;
			}
		}

		public void SetCenterDisplayProgress(float progress)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			if (!((Object)(object)_progressBarFill == (Object)null))
			{
				RectTransform progressBarFillRt = _progressBarFillRt;
				progressBarFillRt.anchorMin = Vector2.zero;
				progressBarFillRt.anchorMax = new Vector2(Mathf.Clamp01(progress), 1f);
				progressBarFillRt.offsetMin = Vector2.zero;
				progressBarFillRt.offsetMax = Vector2.zero;
			}
		}

		private void CreateElements()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			_centerContainer = new GameObject("CenterTextDisplay Container");
			_centerContainer.transform.SetParent(((Component)this).gameObject.transform, false);
			RectTransform obj = _centerContainer.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0.33f);
			obj.anchorMax = new Vector2(1f, 0.66f);
			obj.anchoredPosition = Vector2.zero;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			_centerContainerImage = _centerContainer.AddComponent<Image>();
			((Graphic)_centerContainerImage).color = new Color(0f, 0f, 0f, 0.95f);
			if (TMPUtils.CreateTMPUGUI("io.takina.gtfo.Skins.CenterTextDisplay", _centerContainer.transform, out TextMeshProUGUI tp))
			{
				((TMP_Text)tp).enableAutoSizing = true;
				((TMP_Text)tp).m_maxFontSize = 100f;
				((TMP_Text)tp).m_minFontSize = 32f;
				((Graphic)tp).color = UIManager.AccentColor;
				((TMP_Text)tp).rectTransform.sizeDelta = new Vector2(ReferenceResolution.x, ReferenceResolution.y / 3f);
				_centerDisplayTxt = (TMP_Text)(object)tp;
			}
			GameObject val = new GameObject("ProgressBar Background");
			val.transform.SetParent(_centerContainer.transform, false);
			RectTransform obj2 = val.AddComponent<RectTransform>();
			obj2.anchorMin = new Vector2(0f, 0f);
			obj2.anchorMax = new Vector2(1f, 0f);
			obj2.pivot = new Vector2(0.5f, 0f);
			obj2.anchoredPosition = Vector2.zero;
			obj2.sizeDelta = new Vector2(0f, 8f);
			((Graphic)val.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.15f);
			GameObject val2 = new GameObject("ProgressBar Fill");
			val2.transform.SetParent(val.transform, false);
			_progressBarFillRt = val2.AddComponent<RectTransform>();
			_progressBarFillRt.anchorMin = Vector2.zero;
			_progressBarFillRt.anchorMax = Vector2.one;
			_progressBarFillRt.offsetMin = Vector2.zero;
			_progressBarFillRt.offsetMax = Vector2.zero;
			_progressBarFill = val2.AddComponent<Image>();
			((Graphic)_progressBarFill).color = UIManager.AccentColor;
			_progressBarFill.type = (Type)3;
			_progressBarFill.fillMethod = (FillMethod)0;
			_progressBarFill.fillAmount = 0f;
			_centerContainer.SetActive(false);
		}
	}
	[HarmonyPatch]
	public class UIManager
	{
		public static readonly Color AccentColor = Color32.op_Implicit(new Color32((byte)137, (byte)180, (byte)250, byte.MaxValue));

		private static readonly Action<int> OnOfflineGearShowSkinSelectPopup = OpenOfflineGearSkinSelect;

		public static readonly List<InventorySlot> GearSlots = new List<InventorySlot>
		{
			(InventorySlot)1,
			(InventorySlot)2,
			(InventorySlot)3,
			(InventorySlot)10
		};

		private static Sprite? _pluginIcon = null;

		public static void Initialize()
		{
			Text.UpdateAllTexts();
			Texture2D val = TextureLibrary.Load(Path.Combine(ModData.PluginFolder, "icon.png"), default(TextureOptions), managed: false);
			if ((Object)(object)val != (Object)null)
			{
				_pluginIcon = TextureUtils.SpriteFromTexture2D(val);
			}
		}

		private static void OpenOfflineGearSkinSelect(int _)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			PlayerBackpack localBackpack = PlayerBackpackManager.LocalBackpack;
			SelectionPopupMenu selectionPopupMenu = new SelectionPopupMenu();
			BackpackItem val = default(BackpackItem);
			foreach (InventorySlot gearSlot in GearSlots)
			{
				Logger.Debug($"[UIManager.OpenOfflineGearSkinSelect] Setting up skin select for slot {gearSlot}");
				SelectionPopupHeader header = new SelectionPopupHeader(LocaleUtils.GetSlotGearSelectLocalizedText(gearSlot))
				{
					SetActiveConfirmText = "<color=orange>" + Loc.T("gear.select.clickAgain") + "</color>",
					IsActiveText = "<color=green>" + Loc.T("gear.select.active") + "</color>"
				};
				TargetContext ctx = localBackpack.GetContextForSlot(gearSlot);
				BackpackItem bkpkItem = (localBackpack.TryGetBackpackItem(gearSlot, ref val) ? val : null);
				SelectionPopupHeader selectionPopupHeader = header;
				UserConfig? instance = PersistentConfig<UserConfig>.Instance;
				selectionPopupHeader.ActiveItemID = ((instance != null && instance.CurrentSkinConfig.OfflineGear.TryGetValue(ctx.OfflineGearId.GetValueOrDefault(), out string value)) ? value : "10chambers.vanilla");
				AddGroup(SkinGroup.Vanilla);
				foreach (SkinGroup allMatchingGroup in SkinManager.GetAllMatchingGroups(ctx))
				{
					AddGroup(allMatchingGroup);
				}
				if (header.Items.Any((ISelectionPopupItem it) => it.ID == header.ActiveItemID))
				{
					header.LastSelectedItemID = header.ActiveItemID;
				}
				selectionPopupMenu.AddHeader(header);
				void AddGroup(SkinGroup group)
				{
					SkinSelectionPopupItem obj = new SkinSelectionPopupItem
					{
						DisplayName = group.Name.Resolve(),
						ID = group.Guid,
						SubTitle = group.Author.Resolve(),
						Description = group.Description?.Resolve(),
						setActiveAction = OnOfflineGearSkinSelected,
						upperTextCustomization = AuthorTextDecoration,
						subtitleTextCustomization = DescriptionTextDecoration,
						Context = ctx
					};
					BackpackItem obj2 = bkpkItem;
					object obj3;
					if (obj2 == null)
					{
						obj3 = null;
					}
					else
					{
						Item instance2 = obj2.Instance;
						obj3 = ((instance2 != null) ? ((Component)instance2).gameObject : null);
					}
					if (obj3 == null)
					{
						obj3 = null;
					}
					obj.ApplicationTarget = (GameObject?)obj3;
					BackpackItem obj4 = bkpkItem;
					obj.GearID = ((obj4 != null) ? obj4.GearIDRange : null);
					obj.SkinGUID = group.Guid;
					obj.IsVanilla = group.Guid == SkinGroup.Vanilla.Guid;
					SkinSelectionPopupItem item = obj;
					if ((Object)(object)_pluginIcon != (Object)null)
					{
						item.SpriteLarge = _pluginIcon;
						item.SpriteSmall = _pluginIcon;
					}
					if (GearIcons.Enabled)
					{
						BackpackItem obj5 = bkpkItem;
						if (((obj5 != null) ? obj5.GearIDRange : null) != null)
						{
							GearIcons.Request(bkpkItem.GearIDRange, group, delegate(Sprite sprite)
							{
								item.SetSprites(sprite, sprite);
							});
						}
					}
					header.AddItem(item);
				}
			}
			selectionPopupMenu.Show();
		}

		private static void OnOfflineGearSkinSelected(ISelectionPopupItem item)
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (!(item is SkinSelectionPopupItem skinSelectionPopupItem))
			{
				Logger.Warn("[UIManager] OnSkinSelected called with non-skin item.");
				return;
			}
			TargetContext context = skinSelectionPopupItem.Context;
			if (!context.OfflineGearId.HasValue)
			{
				Logger.Warn("[UIManager] Selected skin for item with no offline gear id - context: " + context);
				return;
			}
			string text = (skinSelectionPopupItem.IsVanilla ? "10chambers.vanilla" : skinSelectionPopupItem.SkinGUID);
			if (PersistentConfig<UserConfig>.Instance != null)
			{
				if (PersistentConfig<UserConfig>.Instance.CurrentSkinConfig.OfflineGear.TryGetValue(context.OfflineGearId.Value, out string value) && value == text)
				{
					return;
				}
				PersistentConfig<UserConfig>.Instance.CurrentSkinConfig.OfflineGear[context.OfflineGearId.Value] = text;
				PersistentConfig<UserConfig>.Save();
			}
			else
			{
				Logger.Warn("[UIManager] Cannot save skin selection because UserConfig.Instance is null.");
			}
			if ((Object)(object)skinSelectionPopupItem.ApplicationTarget != (Object)null)
			{
				ItemEquippable component = skinSelectionPopupItem.ApplicationTarget.GetComponent<ItemEquippable>();
				if ((Object)(object)component != (Object)null)
				{
					WeaponShellCasingDataBlock shellCasingData = component.ShellCasingData;
					ShellTypes? val = ((shellCasingData != null) ? new ShellTypes?(shellCasingData.ShellCasingType) : ((ShellTypes?)null));
					if (val.HasValue)
					{
						ShellSkinning.SetupPoolForGear(context.OfflineGearId.Value, val.Value);
					}
				}
				SkinManager.UpdateTargetsUnder(skinSelectionPopupItem.ApplicationTarget);
			}
			GearIconPatches.RegenerateIcons(skinSelectionPopupItem.GearID);
		}

		private static string AuthorTextDecoration(ISelectionPopupItem item, string text)
		{
			return text;
		}

		private static string DescriptionTextDecoration(ISelectionPopupItem item, string text)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return "<" + ColorExt.ToHtml(AccentColor) + ">" + text + "</color>";
		}

		[HarmonyPatch(typeof(CM_PlayerLobbyBar), "SetupFromPage")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		[HarmonyPriority(700)]
		private static void AddLobbyBarSelectSkinEntryPoint(CM_PlayerLobbyBar __instance)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)__instance.m_weaponsHeaderText.transform).GetComponent<RectTransform>();
			CM_LobbyScrollItem val = Object.Instantiate<CM_LobbyScrollItem>(__instance.m_clothesButton, ((Component)__instance.m_clothesButton).transform.parent, true);
			((RectTransformComp)val).Setup();
			((Object)((Component)val).gameObject).name = "Skins Select Button";
			((CM_Item)val).SetOnBtnPressCallback(Action<int>.op_Implicit(OnOfflineGearShowSkinSelectPopup));
			RectTransform val2 = ((Il2CppObjectBase)((Component)val).transform).TryCast<RectTransform>();
			if ((Object)(object)val2 != (Object)null && (Object)(object)component != (Object)null)
			{
				Vector2 anchoredPosition = val2.anchoredPosition;
				anchoredPosition.y = component.anchoredPosition.y + 15f;
				val2.anchoredPosition = anchoredPosition;
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(1f, 0.5f);
				val2.anchorMax = val3;
				val2.anchorMin = val3;
				((Transform)val2).Translate(new Vector3(32f, 0f, 0f));
				if (PluginUtils.IsPluginLoaded("dev.aurirex.gtfo.legacylobby"))
				{
					((Transform)val2).Translate(new Vector3(83f, 160f, 0f));
				}
				GuiUtils.FixLobbyScrollItem(val, val2.sizeDelta.x * 0.4f);
				GuiUtils.SetItemColor((CM_Item)(object)val, AccentColor, Color.white);
			}
			Loc.TrySetExistingTMP((Component)(object)val, "ui.skinsButton");
			GameStateCache.LobbyBar2LobbyScrollItem.Save((Component)(object)__instance, val);
		}

		[HarmonyPatch(typeof(CM_PlayerLobbyBar), "PrepareForIntro")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Postfix__LobbyBar_PrepareForIntro(CM_PlayerLobbyBar __instance)
		{
			CM_LobbyScrollItem val = GameStateCache.LobbyBar2LobbyScrollItem.Get((Component)(object)__instance);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(CM_PlayerLobbyBar), "SpawnPlayerModel")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Postfix__LobbyBar_SpawnPlayerModel(CM_PlayerLobbyBar __instance)
		{
			CM_LobbyScrollItem val = GameStateCache.LobbyBar2LobbyScrollItem.Get((Component)(object)__instance);
			if ((Object)(object)val != (Object)null && (Object)(object)__instance.m_player != (Object)null && __instance.m_player.IsLocal)
			{
				CoroutineManager.BlinkIn((CM_Item)(object)val, 1.2f, (Transform)null);
			}
		}

		[HarmonyPatch(typeof(CM_PlayerLobbyBar), "ShowWeaponSelectionPopup")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void AddWeaponSelectSkinEntryPoint(CM_PlayerLobbyBar __instance)
		{
		}

		[HarmonyPatch(typeof(CM_PageSettings), "Setup")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		[HarmonyPriority(700)]
		private static void AddHotReloadButton(CM_PageSettings __instance)
		{
			Logger.Warn("Uhh... maybe TheArchive should find a better way to store offset, because I hate to have to take VeryHigh priority ;)");
		}

		private static void OnPageMenuSettingReloadSkins(int _)
		{
			ReloadSkins();
		}

		public static void ReloadSkins()
		{
			if ((Object)(object)Plugin.UnityBehaviourProcess == (Object)null)
			{
				Logger.Error("[UIManager] Cannot reload skins because UnityBehaviourProcess is null.");
			}
			else
			{
				((MonoBehaviour)Plugin.UnityBehaviourProcess).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(SkinManager.Reload()));
			}
		}

		private static void OnPageMenuSettingOpenGlobalSkinsFolder(int _)
		{
			OpenGlobalSkinsFolder();
		}

		public static void OpenGlobalSkinsFolder()
		{
			Process.Start(new ProcessStartInfo
			{
				FileName = "explorer.exe",
				Arguments = ModData.SkinsFolder,
				UseShellExecute = true
			});
		}
	}
	public sealed class BoolHandle
	{
		private readonly Action<bool> _refresh;

		internal BoolHandle(Action<bool> refresh)
		{
			_refresh = refresh;
		}

		public void Refresh(bool value)
		{
			_refresh(value);
		}
	}
	public sealed class TextHandle
	{
		private readonly TextMeshPro _tmp;

		public TMP_Text TMP => (TMP_Text)(object)_tmp;

		internal TextHandle(TextMeshPro tmp)
		{
			_tmp = tmp;
		}

		public void SetVisible(bool visible)
		{
			if ((Object)(object)_tmp != (Object)null)
			{
				((Component)_tmp).gameObject.SetActive(visible);
			}
		}

		public void SetText(string text)
		{
			TextMeshPro tmp = _tmp;
			if (tmp != null)
			{
				((TMP_Text)tmp).SetText(text, true);
			}
		}
	}
	public sealed class EnumHandle<T>
	{
		private readonly Action<T> _refresh;

		internal EnumHandle(Action<T> refresh)
		{
			_refresh = refresh;
		}

		public void Refresh(T value)
		{
			_refresh(value);
		}
	}
	[HarmonyPatch]
	public class UISettings
	{
		private static class Layout
		{
			internal const float WindowX = 420f;

			internal const float WindowY = -200f;

			internal const float WindowWidth = 1020f;

			internal const float WindowHeight = 900f;

			internal const float ItemPadding = 5f;

			internal const float ControlW = 550f;

			internal const float ControlH = 50f;

			internal const float ControlOfsX = 250f;

			internal const float ControlOfsY = -25f;

			internal static readonly Vector3 WidgetAnchorPosition = new Vector3(-325f, 0f, 0f);
		}

		private static CM_PageSettings? _pageInstance;

		private static CM_ScrollWindow? _settingsWindow;

		private static CM_ScrollWindow? _popupWindow;

		private static GameObject? _settingsItemPrefab;

		private static Coroutine? _hideMessageCoroutine;

		public static TextHandle? ThMessageBox { get; private set; }

		public static LifecycleHook? SettingsWindowLifecycle { get; private set; }

		[HarmonyPatch(typeof(CM_PageSettings), "Setup")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		[HarmonyPriority(800)]
		private static void SetupSettingsPage(CM_PageSettings __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			_pageInstance = __instance;
			_settingsItemPrefab = __instance.m_settingsItemPrefab;
			_popupWindow = __instance.m_popupWindow;
			CM_Item val = __instance.CreateSingleButton(__instance.m_subMenuButtonPrefab, Loc.ID("settings.page.skins"));
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GuiUtils.SetItemColor(val, UIManager.AccentColor, UIManager.AccentColor);
			CM_ScrollWindow val2 = ((Il2CppObjectBase)((GuiLayer)((CM_PageBase)__instance).m_guiLayer).AddRectComp(__instance.m_scrollwindowPrefab, (GuiAnchor)1, new Vector2(420f, -200f), (Transform)(object)((CM_PageBase)__instance).m_movingContentHolder)).TryCast<CM_ScrollWindow>();
			if (!((Object)(object)val2 == (Object)null))
			{
				val2.Setup(((Component)__instance).transform);
				((RectTransformComp)val2).SetSize(new Vector2(1020f, 900f));
				((RectTransformComp)val2).SetVisible(false);
				if (((Il2CppArrayBase<CM_ScrollWindowHeader>)(object)val2.m_headers).Count > 0)
				{
					Loc.AttachToTMP((Component)(object)((Il2CppArrayBase<CM_ScrollWindowHeader>)(object)val2.m_headers)[0], "settings.page.skins");
				}
				((Component)val2).gameObject.AddComponent<LifecycleHook>();
				__instance.m_allSettingsWindows.Add(val2);
				_settingsWindow = val2;
				PopulateSettings(__instance, val2);
				val.OnBtnPressCallback += Action<int>.op_Implicit((Action<int>)OnSkinsSettingsButtonPressed);
			}
		}

		private static void PopulateSettings(CM_PageSettings instance, CM_ScrollWindow window)
		{
			List<iScrollWindowContent> val = new List<iScrollWindowContent>();
			AddHeader(instance, window, val, "settings.page.general.header");
			AddBoolToggle(instance, window, val, "settings.mipmaps", "settings.mipmaps.desc", () => PersistentConfig<UserConfig>.Instance?.PluginConfig.EnableMipMaps ?? true, delegate(bool enableMipMaps)
			{
				if (PersistentConfig<UserConfig>.Instance != null)
				{
					OnSettingsMipMapChanged();
					PersistentConfig<UserConfig>.Instance.PluginConfig.EnableMipMaps = enableMipMaps;
					PersistentConfig<UserConfig>.Save();
				}
			});
			AddHeader(instance, window, val, "settings.page.manage.header");
			AddButton(instance, window, val, "settings.page.manage.reload.label", "settings.page.manage.reload.desc", "settings.page.manage.reload.button", OnSettingsSkinReload);
			AddButton(instance, window, val, "settings.page.manage.globalSkinsFolder.label", "settings.page.manage.globalSkinsFolder.desc", "settings.page.manage.globalSkinsFolder.button", OnSettingsOpenSkinsFolder);
			AddButton(instance, window, val, "settings.page.manage.updateAllMatTargets.label", "settings.page.manage.updateAllMatTargets.desc", "settings.page.manage.updateAllMatTargets.button", OnSettingsUpdateAllGroupTargets);
			AddButton(instance, window, val, "settings.page.manage.reloadSkinsSettings.label", "settings.page.manage.reloadSkinsSettings.desc", "settings.page.manage.reloadSkinsSettings.button", OnSettingsReloadSkinsSettings);
			AddHeader(instance, window, val, "settings.page.info.header");
			AddTextDisplay(instance, window, val, "settings.page.info.version.label", "v0.12.0");
			ThMessageBox = AddTextRegion(instance, window, val, "settings.page.info.credits.label");
			window.SetContentItems(val, 5f);
			if ((Object)(object)SettingsWindowLifecycle != (Object)null)
			{
				SettingsWindowLifecycle.OnEnabled += OnSettingsPageEnabled;
				SettingsWindowLifecycle.OnDisabled += OnSettingsPageDisabled;
			}
		}

		private static void OnSettingsMipMapChanged()
		{
			if (ThMessageBox != null)
			{
				ShowInfoMessage("settings.page.info.reloadToTakeEffect");
			}
		}

		private static void OnSettingsOpenSkinsFolder()
		{
			if (ThMessageBox != null)
			{
				ShowInfoMessage("settings.page.info.reloadToTakeEffect");
				UIManager.OpenGlobalSkinsFolder();
			}
		}

		private static void OnSettingsSkinReload()
		{
			if (ThMessageBox != null)
			{
				HideInfoMessage();
				UIManager.ReloadSkins();
			}
		}

		private static void OnSettingsUpdateAllGroupTargets()
		{
			SkinManager.UpdateAllGroups();
			ShowInfoMessage("settings.page.info.allTargetsUpdated", 5f);
		}

		private static void OnSettingsReloadSkinsSettings()
		{
			PersistentConfig<UserConfig>.Load();
			SkinManager.UpdateAllGroups();
			ShowInfoMessage("settings.page.info.skinsSettingsReloaded", 5f);
		}

		private static void OnSettingsPageEnabled()
		{
		}

		private static void OnSettingsPageDisabled()
		{
			HideInfoMessage();
		}

		private static void ShowInfoMessage(string textKey)
		{
			if (ThMessageBox != null)
			{
				ThMessageBox.SetVisible(visible: true);
				ThMessageBox.SetText(Loc.T(textKey));
				ThMessageBox.TMP.alignment = (TextAlignmentOptions)514;
				if (_hideMessageCoroutine != null)
				{
					CoroutineManager.StopCoroutine(_hideMessageCoroutine);
					_hideMessageCoroutine = null;
				}
			}
		}

		private static void ShowInfoMessage(string textKey, float autoHideTimeout)
		{
			if (ThMessageBox != null)
			{
				ShowInfoMessage(textKey);
				_hideMessageCoroutine = CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(AutoHideInfoMessage(autoHideTimeout)), (Action)null);
			}
		}

		private static IEnumerator AutoHideInfoMessage(float timeout)
		{
			yield return (object)new WaitForSeconds(timeout);
			HideInfoMessage();
			_hideMessageCoroutine = null;
		}

		private static void HideInfoMessage()
		{
			if (ThMessageBox != null)
			{
				ThMessageBox.SetText("");
				ThMessageBox.SetVisible(visible: false);
			}
		}

		private static CM_SettingsItem? CreateSettingsItem(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, Color? titleColor = null)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_settingsItemPrefab == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(_settingsItemPrefab, ((Component)window).transform);
			CM_SettingsItem component = val.GetComponent<CM_SettingsItem>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			((CM_Item)component).TextMeshRoot = ((Component)instance).transform;
			Transform obj = val.transform.Find("Title/TitleText");
			TextMeshPro val2 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshPro>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				if (titleColor.HasValue)
				{
					((Graphic)val2).color = titleColor.Value;
				}
				Loc.AttachToTMP((Component)(object)val2, labelKey);
			}
			else
			{
				((CM_Item)component).SetText(Loc.T(labelKey));
			}
			((RectTransformComp)component).ForcePopupLayer(true, (GameObject)null);
			iScrollWindowContent val3 = ((Il2CppObjectBase)component).TryCast<iScrollWindowContent>();
			if (val3 != null)
			{
				items.Add(val3);
			}
			else
			{
				Logger.Warn("[UISettings] CM_SettingsItem → iScrollWindowContent cast failed for '" + labelKey + "'");
			}
			return component;
		}

		private static (CM_Item button, TextMeshPro? label) SetupControlButton(CM_SettingsItem item, GameObject widgetPrefab)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(widgetPrefab, item.m_inputAlign, false);
			CM_Item val = obj.AddComponent<CM_Item>();
			((RectTransformComp)val).RectTrans.anchoredPosition3D = Layout.WidgetAnchorPosition;
			BoxCollider2D component = obj.GetComponent<BoxCollider2D>();
			if ((Object)(object)component != (Object)null)
			{
				component.size = new Vector2(550f, 50f);
				((Collider2D)component).offset = new Vector2(250f, -25f);
			}
			TextMeshPro componentInChildren = obj.GetComponentInChildren<TextMeshPro>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).fontStyle = (FontStyles)(((TMP_Text)componentInChildren).fontStyle | 0x10);
				((TMP_Text)componentInChildren).alignment = (TextAlignmentOptions)4097;
			}
			return (button: val, label: componentInChildren);
		}

		private static CM_Item? SetupEnumButton(CM_SettingsItem item, out GameObject popupItemPrefab, out Transform? popupAnchor)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(item.m_enumDropdownInputPrefab, item.m_inputAlign);
			CM_SettingsEnumDropdownButton component = obj.GetComponent<CM_SettingsEnumDropdownButton>();
			CM_Item val = obj.AddComponent<CM_Item>();
			((RectTransformComp)val).Setup();
			popupItemPrefab = component.m_popupItemPrefab;
			popupAnchor = component.m_popupWindowAlign;
			BoxCollider2D component2 = obj.GetComponent<BoxCollider2D>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.size = new Vector2(550f, 50f);
				((Collider2D)component2).offset = new Vector2(250f, -25f);
			}
			((Behaviour)component).enabled = false;
			if ((Object)(object)_popupWindow != (Object)null)
			{
				component.m_popupWindow = _popupWindow;
			}
			Object.Destroy((Object)(object)component);
			return val;
		}

		private static void SetTooltip(CM_Item item, string headerKey, string? bodyKey = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			item.TooltipInfo = new TooltipInfo
			{
				PositionType = (TooltipPositionType)0,
				TooltipHeader = Loc.T(headerKey),
				TooltipText = ((bodyKey == null) ? "" : Loc.T(bodyKey)),
				UseTooptip = true
			};
			TooltipInfoLocalizer tooltipInfoLocalizer = ((Component)item).gameObject.AddComponent<TooltipInfoLocalizer>();
			if ((Object)(object)tooltipInfoLocalizer != (Object)null)
			{
				tooltipInfoLocalizer.Setup(headerKey, bodyKey);
			}
		}

		private static void AddHeader(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, Color? color = null, float heightMultiplier = 1.5f, float? fontSize = null)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			CM_SettingsItem val = CreateSettingsItem(instance, window, items, labelKey, color);
			if (!((Object)(object)val == (Object)null))
			{
				RectTransform val2 = ((Component)val).gameObject.GetComponent<RectTransform>() ?? ((Il2CppObjectBase)((Component)val).transform).TryCast<RectTransform>();
				if ((Object)(object)val2 != (Object)null)
				{
					val2.sizeDelta = new Vector2(val2.sizeDelta.x, val2.sizeDelta.y * heightMultiplier);
				}
				((Renderer)val.m_background).enabled = false;
				Transform obj = ((Component)val).transform.Find("Title/TitleText");
				TextMeshPro val3 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshPro>() : null);
				if ((Object)(object)val3 != (Object)null)
				{
					RectTransform rectTransform = ((TMP_Text)val3).rectTransform;
					rectTransform.anchorMin = Vector2.zero;
					rectTransform.anchorMax = new Vector2(1f, 0.6f);
					rectTransform.offsetMin = new Vector2(10f, 0f);
					rectTransform.offsetMax = new Vector2(0f, 0f);
					((TMP_Text)val3).alignment = (TextAlignmentOptions)1025;
					((TMP_Text)val3).fontSizeMax = fontSize ?? (((TMP_Text)val3).fontSizeMax * heightMultiplier);
				}
				BoxCollider2D component = ((Component)val).gameObject.GetComponent<BoxCollider2D>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = false;
				}
			}
		}

		private static BoolHandle? AddBoolToggle(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, string? descriptionKey, Func<bool> getter, Action<bool> setter)
		{
			CM_SettingsItem val = CreateSettingsItem(instance, window, items, labelKey);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			CM_SettingsToggleButton componentInChildren = ((Component)val).GetComponentInChildren<CM_SettingsToggleButton>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				ObjectExt.Destroy((Object)(object)componentInChildren);
			}
			(CM_Item, TextMeshPro) tuple = SetupControlButton(val, val.m_toggleInputPrefab);
			CM_Item item = tuple.Item1;
			TextMeshPro label = tuple.Item2;
			Collider2D componentInChildren2 = ((Component)item).GetComponentInChildren<Collider2D>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				((Behaviour)componentInChildren2).enabled = false;
			}
			Refresh(getter());
			if (descriptionKey != null)
			{
				SetTooltip((CM_Item)(object)val, labelKey, descriptionKey);
			}
			((CM_Item)(object)val).SetEvents(delegate
			{
				bool flag = !getter();
				setter(flag);
				Refresh(flag);
			});
			return new BoolHandle(Refresh);
			void Refresh(bool flag)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)label == (Object)null))
				{
					((TMP_Text)label).SetText(Loc.T(flag ? "ui.on" : "ui.off"), true);
					((Graphic)label).color = (flag ? Color.green : Color.red);
				}
			}
		}

		private static void AddButton(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, string? descriptionKey, string buttonTextKey, Action onClick)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			CM_SettingsItem val = CreateSettingsItem(instance, window, items, labelKey);
			if (!((Object)(object)val == (Object)null))
			{
				(CM_Item button, TextMeshPro? label) tuple = SetupControlButton(val, val.m_toggleInputPrefab);
				CM_Item item = tuple.button;
				TextMeshPro item2 = tuple.label;
				Collider2D componentInChildren = ((Component)item).GetComponentInChildren<Collider2D>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Behaviour)componentInChildren).enabled = false;
				}
				if ((Object)(object)item2 != (Object)null)
				{
					((TMP_Text)item2).SetText(Loc.T(buttonTextKey), true);
					Loc.AttachToTMP((Component)(object)item2, buttonTextKey);
					((TMP_Text)item2).fontStyle = (FontStyles)(((TMP_Text)item2).fontStyle | 4);
					((Graphic)item2).color = UIManager.AccentColor;
				}
				if (descriptionKey != null)
				{
					SetTooltip((CM_Item)(object)val, labelKey, descriptionKey);
				}
				((CM_Item)(object)val).SetEvents(delegate
				{
					onClick();
				});
			}
		}

		private static TextHandle? AddTextDisplay(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, string initialText = "")
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			CM_SettingsItem val = CreateSettingsItem(instance, window, items, labelKey);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(val.m_toggleInputPrefab, val.m_inputAlign);
			CM_Item component = obj.GetComponent<CM_Item>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			BoxCollider2D component2 = obj.GetComponent<BoxCollider2D>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			RectTransform component3 = obj.GetComponent<RectTransform>();
			if ((Object)(object)component3 != (Object)null)
			{
				component3.anchoredPosition3D = Layout.WidgetAnchorPosition;
			}
			TextMeshPro componentInChildren = obj.GetComponentInChildren<TextMeshPro>();
			if (componentInChildren != null)
			{
				((TMP_Text)componentInChildren).SetText(initialText, true);
			}
			if (!((Object)(object)componentInChildren != (Object)null))
			{
				return null;
			}
			return new TextHandle(componentInChildren);
		}

		private static TextHandle? AddTextRegion(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, Color? color = null, float heightMultiplier = 2f, float? fontSize = null)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			CM_SettingsItem val = CreateSettingsItem(instance, window, items, labelKey, color);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			RectTransform val2 = ((Component)val).gameObject.GetComponent<RectTransform>() ?? ((Il2CppObjectBase)((Component)val).transform).TryCast<RectTransform>();
			if ((Object)(object)val2 != (Object)null)
			{
				val2.sizeDelta = new Vector2(val2.sizeDelta.x, val2.sizeDelta.y * heightMultiplier);
			}
			((Renderer)val.m_background).enabled = false;
			Transform obj = ((Component)val).transform.Find("Title/TitleText");
			TextMeshPro val3 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshPro>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				RectTransform rectTransform = ((TMP_Text)val3).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = new Vector2(1f, 1f);
				rectTransform.offsetMin = new Vector2(10f, 0f);
				rectTransform.offsetMax = new Vector2(0f, 0f);
				((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			}
			BoxCollider2D component = ((Component)val).gameObject.GetComponent<BoxCollider2D>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			if (!((Object)(object)val3 != (Object)null))
			{
				return null;
			}
			return new TextHandle(val3);
		}

		private static EnumHandle<T>? AddEnumDropdown<T>(CM_PageSettings instance, CM_ScrollWindow window, List<iScrollWindowContent> items, string labelKey, string? descriptionKey, Func<T> getter, Action<T> setter, IReadOnlyList<(string label, T value)> options) where T : notnull
		{
			CM_SettingsItem val = CreateSettingsItem(instance, window, items, labelKey);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject popupItemPrefab;
			Transform popupAnchor;
			CM_Item button = SetupEnumButton(val, out popupItemPrefab, out popupAnchor);
			if ((Object)(object)button == (Object)null)
			{
				return null;
			}
			Refresh(getter());
			if (descriptionKey != null)
			{
				SetTooltip((CM_Item)(object)val, labelKey, descriptionKey);
			}
			((CM_Item)(object)val).SetEvents(delegate
			{
				ShowEnumPopup(getter, setter, options, button, popupItemPrefab, popupAnchor, Refresh);
			});
			return new EnumHandle<T>(Refresh);
			void Refresh(T y)
			{
				string text = y.ToString() ?? "";
				foreach (var option in options)
				{
					if (EqualityComparer<T>.Default.Equals(option.value, y))
					{
						(text, _) = option;
						break;
					}
				}
				button.SetText(text);
			}
		}

		private static void ShowEnumPopup<T>(Func<T> getter, Action<T> setter, IReadOnlyList<(string label, T value)> options, CM_Item button, GameObject popupItemPrefab, Transform? popupAnchor, Action<T> refreshButton) where T : notnull
		{
			//IL_00c6: Unknown result type (might be d