using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using ItemSpawnerEnhanced.Api;
using ItemSpawnerEnhanced.Core;
using ItemSpawnerEnhanced.Localization;
using ItemSpawnerEnhanced.UI;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.UI;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ItemSpawnerEnhanced")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+868a403036ec2b476d1ba1a4dba1c5a0bb24d6c5")]
[assembly: AssemblyProduct("ItemSpawnerEnhanced")]
[assembly: AssemblyTitle("ItemSpawnerEnhanced")]
[assembly: AssemblyVersion("1.3.0.0")]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ItemSpawnerEnhanced
{
	internal sealed class FavoriteStore
	{
		private readonly ConfigEntry<string> _entry;

		private readonly ManualLogSource _logger;

		private HashSet<string> _itemNames;

		public FavoriteStore(ConfigEntry<string> entry, ManualLogSource logger)
		{
			_entry = entry;
			_logger = logger;
			_itemNames = Deserialize(entry.Value);
		}

		public bool IsFavorite(string itemName)
		{
			return _itemNames.Contains(itemName);
		}

		public bool TryToggle(string itemName, out bool isFavorite)
		{
			HashSet<string> hashSet = new HashSet<string>(_itemNames, StringComparer.Ordinal);
			isFavorite = !hashSet.Remove(itemName);
			if (isFavorite)
			{
				hashSet.Add(itemName);
			}
			string value = FavoriteItemCodec.Serialize(hashSet);
			string value2 = _entry.Value;
			try
			{
				_entry.Value = value;
			}
			catch (Exception arg)
			{
				try
				{
					_entry.Value = value2;
				}
				catch
				{
				}
				isFavorite = _itemNames.Contains(itemName);
				_logger.LogError((object)$"Failed to save favorite items: {arg}");
				return false;
			}
			_itemNames = hashSet;
			return true;
		}

		private HashSet<string> Deserialize(string serialized)
		{
			try
			{
				return FavoriteItemCodec.Deserialize(serialized);
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("Favorite item configuration is invalid and will be ignored: " + ex.Message));
				return new HashSet<string>(StringComparer.Ordinal);
			}
		}
	}
	internal sealed class GameItemCatalog
	{
		private readonly ManualLogSource _logger;

		private readonly Func<bool> _showAllItems;

		private readonly Func<string, bool> _isFavorite;

		private SearchIndex<GameItemRecord> _index = new SearchIndex<GameItemRecord>(Array.Empty<(GameItemRecord, IEnumerable<SearchAliasValue>)>());

		private Item[] _sourceItems = Array.Empty<Item>();

		private bool _sourceShowAllItems;

		public IReadOnlyList<GameItemRecord> Items { get; private set; } = Array.Empty<GameItemRecord>();

		public GameItemCatalog(ManualLogSource logger, Func<bool> showAllItems, Func<string, bool> isFavorite)
		{
			_logger = logger;
			_showAllItems = showAllItems;
			_isFavorite = isFavorite;
		}

		public bool IsCurrent()
		{
			if (((DatabaseAsset<ItemDatabase, Item>)(object)SingletonAsset<ItemDatabase>.Instance).Objects.Where((Item item) => (Object)(object)item != (Object)null).ToArray().SequenceEqual(_sourceItems))
			{
				return _showAllItems() == _sourceShowAllItems;
			}
			return false;
		}

		public void RebuildItems()
		{
			IEnumerator enumerator = RebuildItemsIncrementally(double.MaxValue);
			while (enumerator.MoveNext())
			{
			}
		}

		public IEnumerator RebuildItemsIncrementally(double timeBudgetMilliseconds)
		{
			if (timeBudgetMilliseconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("timeBudgetMilliseconds");
			}
			Item[] sourceItems = ((DatabaseAsset<ItemDatabase, Item>)(object)SingletonAsset<ItemDatabase>.Instance).Objects.Where((Item item) => (Object)(object)item != (Object)null).ToArray();
			bool showAllItems = _showAllItems();
			List<GameItemRecord> items = new List<GameItemRecord>(sourceItems.Length);
			long timestamp = Stopwatch.GetTimestamp();
			for (int index = 0; index < sourceItems.Length; index++)
			{
				Item val = sourceItems[index];
				if (VanillaItemVisibility.IsVisible(((Object)val).name, showAllItems, _isFavorite(((Object)val).name)))
				{
					string fallback = val.UIData?.itemName ?? ((Object)val).name;
					items.Add(new GameItemRecord(val, SafeLocalizedName(val, fallback), ItemCategoryResolver.Resolve(val)));
				}
				if (index + 1 < sourceItems.Length && ElapsedMilliseconds(timestamp) >= timeBudgetMilliseconds)
				{
					yield return null;
					timestamp = Stopwatch.GetTimestamp();
				}
			}
			Items = items.ToArray();
			_sourceItems = sourceItems;
			_sourceShowAllItems = showAllItems;
			_index = new SearchIndex<GameItemRecord>(Array.Empty<(GameItemRecord, IEnumerable<SearchAliasValue>)>());
		}

		public IEnumerator RebuildSearchIndexIncrementally(double timeBudgetMilliseconds)
		{
			if (timeBudgetMilliseconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("timeBudgetMilliseconds");
			}
			string languageCode = GameLanguage.CurrentCode;
			IReadOnlyList<ISearchAliasProvider> readOnlyList = SearchAliasRegistry.Snapshot();
			List<ISearchAliasProvider> activeProviders = new List<ISearchAliasProvider>(readOnlyList.Count);
			foreach (ISearchAliasProvider item2 in readOnlyList)
			{
				try
				{
					if (item2.SupportsLanguage(languageCode))
					{
						activeProviders.Add(item2);
					}
				}
				catch (Exception arg)
				{
					_logger.LogError((object)$"Search alias provider '{item2.Id}' failed while checking language '{languageCode}': {arg}");
				}
			}
			SearchIndex<GameItemRecord>.Builder indexBuilder = new SearchIndex<GameItemRecord>.Builder();
			long timestamp = Stopwatch.GetTimestamp();
			for (int itemIndex = 0; itemIndex < Items.Count; itemIndex++)
			{
				GameItemRecord gameItemRecord = Items[itemIndex];
				Item item = gameItemRecord.Item;
				string text = item.UIData?.itemName ?? ((Object)item).name;
				string text2 = SafeEnglishName(text);
				SearchAliasContext context = new SearchAliasContext(((Object)item).name, text, gameItemRecord.DisplayName, text2, languageCode);
				List<SearchAliasValue> list = new List<SearchAliasValue>
				{
					new SearchAliasValue(gameItemRecord.DisplayName, SearchAliasPriority.Display),
					new SearchAliasValue(text2, SearchAliasPriority.English),
					new SearchAliasValue(((Object)item).name, SearchAliasPriority.Internal),
					new SearchAliasValue(text, SearchAliasPriority.Internal)
				};
				foreach (ISearchAliasProvider item3 in activeProviders)
				{
					try
					{
						list.AddRange(from alias in item3.GetAliases(context)
							where !string.IsNullOrWhiteSpace(alias)
							select new SearchAliasValue(alias, SearchAliasPriority.Provider));
					}
					catch (Exception arg2)
					{
						_logger.LogError((object)$"Search alias provider '{item3.Id}' failed for '{((Object)item).name}': {arg2}");
					}
				}
				indexBuilder.Add(gameItemRecord, list);
				if (itemIndex + 1 < Items.Count && ElapsedMilliseconds(timestamp) >= timeBudgetMilliseconds)
				{
					yield return null;
					timestamp = Stopwatch.GetTimestamp();
				}
			}
			_index = indexBuilder.Build();
		}

		public IReadOnlyList<GameItemRecord> Search(string query)
		{
			return _index.Search(query);
		}

		private static string SafeLocalizedName(Item item, string fallback)
		{
			try
			{
				string name = item.GetName();
				return IsUsable(name) ? name : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		private static string SafeEnglishName(string rawName)
		{
			try
			{
				string text = LocalizedText.GetText(LocalizedText.GetNameIndex(rawName), (Language)0);
				return IsUsable(text) ? text : rawName;
			}
			catch
			{
				return rawName;
			}
		}

		private static bool IsUsable(string? value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return !value.StartsWith("LOC:", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static double ElapsedMilliseconds(long started)
		{
			return (double)(Stopwatch.GetTimestamp() - started) * 1000.0 / (double)Stopwatch.Frequency;
		}
	}
	internal sealed class GameItemRecord
	{
		public Item Item { get; }

		public string DisplayName { get; }

		public ItemFilterTag Tags { get; }

		public GameItemRecord(Item item, string displayName, ItemFilterTag tags)
		{
			Item = item;
			DisplayName = displayName;
			Tags = tags;
		}
	}
	internal sealed class ItemBrowserSession
	{
		public ItemFilterTag SelectedTags { get; set; }
	}
	internal static class ItemCategoryResolver
	{
		public static ItemFilterTag Resolve(Item item)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			ItemFilterTag itemFilterTag = VanillaItemCategories.Resolve(((Object)item).name);
			if (((Enum)item.itemTags).HasFlag((Enum)(object)(ItemTags)1))
			{
				itemFilterTag |= ItemFilterTag.Mystical;
			}
			bool flag = ((Component)item).GetComponentsInChildren<Action_Consume>(true).Length != 0;
			bool flag2 = ((Component)item).GetComponentsInChildren<Action_ModifyStatus>(true).Any((Action_ModifyStatus action) => (int)action.statusType == 1);
			bool flag3 = ((Component)item).GetComponentsInChildren<Action_RestoreHunger>(true).Length != 0;
			bool flag4 = ((Enum)item.itemTags).HasFlag((Enum)(object)(ItemTags)2) || ((Enum)item.itemTags).HasFlag((Enum)(object)(ItemTags)4) || ((Enum)item.itemTags).HasFlag((Enum)(object)(ItemTags)8);
			itemFilterTag = ItemCategoryPolicy.ApplyConsumptionTags(itemFilterTag, flag, flag4 || flag3 || (flag && flag2));
			itemFilterTag = ItemCategoryPolicy.NormalizeConsumableTag(itemFilterTag);
			itemFilterTag = ItemCategoryPolicy.NormalizeEquipmentTag(itemFilterTag);
			if (itemFilterTag == ItemFilterTag.None)
			{
				itemFilterTag = ItemFilterTag.Other;
			}
			return itemFilterTag;
		}
	}
	internal sealed class ItemSpawnerController : IDisposable
	{
		private readonly ManualLogSource _logger;

		private readonly ModConfig _settings;

		private readonly FavoriteStore _favorites;

		private readonly ItemSpawnerInput _input;

		private readonly ItemBrowserSession _browserSession = new ItemBrowserSession();

		private ItemSpawnerWindow? _window;

		public ItemSpawnerController(ModConfig settings, ManualLogSource logger)
		{
			_logger = logger;
			_settings = settings;
			_favorites = new FavoriteStore(settings.FavoriteItemNamesEntry, logger);
			_input = new ItemSpawnerInput(settings, logger);
		}

		public void Attach()
		{
			if ((Object)(object)_window != (Object)null)
			{
				return;
			}
			try
			{
				_window = ItemSpawnerWindow.Create(_logger, _settings, _favorites, _browserSession);
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Failed to create item spawner UI: {arg}");
			}
		}

		public void Tick()
		{
			ItemSpawnerInputSnapshot input = _input.ReadSnapshot();
			if ((Object)(object)_window == (Object)null)
			{
				return;
			}
			if (input.ControllerToggle)
			{
				if (_window.IsOpen || CanOpenWithController())
				{
					_window.ToggleWindow(WindowInputSource.Controller);
				}
			}
			else if (input.KeyboardToggle)
			{
				_window.ToggleWindow(WindowInputSource.Keyboard);
			}
			else if (_window.IsOpen)
			{
				_window.HandleControllerInput(input);
			}
		}

		public void Dispose()
		{
			if ((Object)(object)_window != (Object)null)
			{
				_window.Shutdown();
				Object.Destroy((Object)(object)((Component)_window).gameObject);
			}
			_window = null;
			_input.Dispose();
		}

		private static bool CanOpenWithController()
		{
			GUIManager instance = GUIManager.instance;
			if (Time.timeScale > 0f && (Object)(object)instance != (Object)null && !instance.windowBlockingInput)
			{
				return !instance.wheelActive;
			}
			return false;
		}
	}
	internal readonly struct ItemSpawnerInputSnapshot
	{
		public bool KeyboardToggle { get; }

		public bool ControllerToggle { get; }

		public Vector2 Navigation { get; }

		public bool ConfirmPressed { get; }

		public bool ConfirmHeld { get; }

		public bool ConfirmReleased { get; }

		public bool CancelPressed { get; }

		public bool FavoritePressed { get; }

		public bool PreviousTargetPressed { get; }

		public bool NextTargetPressed { get; }

		public bool MouseActivity { get; }

		public bool ControllerActivity
		{
			get
			{
				//IL_0009: 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)
				if (!ControllerToggle)
				{
					Vector2 navigation = Navigation;
					if (!(((Vector2)(ref navigation)).sqrMagnitude >= 0.25f) && !ConfirmPressed && !CancelPressed && !FavoritePressed && !PreviousTargetPressed)
					{
						return NextTargetPressed;
					}
				}
				return true;
			}
		}

		public ItemSpawnerInputSnapshot(bool keyboardToggle, bool controllerToggle, Vector2 navigation, bool confirmPressed, bool confirmHeld, bool confirmReleased, bool cancelPressed, bool favoritePressed, bool previousTargetPressed, bool nextTargetPressed, bool mouseActivity)
		{
			//IL_000f: 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)
			KeyboardToggle = keyboardToggle;
			ControllerToggle = controllerToggle;
			Navigation = navigation;
			ConfirmPressed = confirmPressed;
			ConfirmHeld = confirmHeld;
			ConfirmReleased = confirmReleased;
			CancelPressed = cancelPressed;
			FavoritePressed = favoritePressed;
			PreviousTargetPressed = previousTargetPressed;
			NextTargetPressed = nextTargetPressed;
			MouseActivity = mouseActivity;
		}
	}
	internal sealed class ItemSpawnerInput : IDisposable
	{
		private readonly ModConfig _config;

		private readonly ManualLogSource _logger;

		private InputAction? _controllerToggleAction;

		private string _bindingSignature = string.Empty;

		public ItemSpawnerInput(ModConfig config, ManualLogSource logger)
		{
			_config = config;
			_logger = logger;
		}

		public ItemSpawnerInputSnapshot ReadSnapshot()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_00af: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			EnsureActions();
			Gamepad current = Gamepad.current;
			Mouse current2 = Mouse.current;
			Vector2 navigation = ((current == null) ? Vector2.zero : Vector2.ClampMagnitude(((InputControl<Vector2>)(object)current.leftStick).ReadValue() + ((InputControl<Vector2>)(object)current.dpad).ReadValue(), 1f));
			int num;
			if (current2 != null)
			{
				Vector2 val = ((InputControl<Vector2>)(object)((Pointer)current2).delta).ReadValue();
				if (!(((Vector2)(ref val)).sqrMagnitude > 0.25f) && !current2.leftButton.wasPressedThisFrame && !current2.rightButton.wasPressedThisFrame && !current2.middleButton.wasPressedThisFrame)
				{
					val = ((InputControl<Vector2>)(object)current2.scroll).ReadValue();
					num = ((((Vector2)(ref val)).sqrMagnitude > 0.01f) ? 1 : 0);
				}
				else
				{
					num = 1;
				}
			}
			else
			{
				num = 0;
			}
			bool mouseActivity = (byte)num != 0;
			KeyCode toggleKey = _config.ToggleKey;
			bool keyboardToggle = (int)toggleKey != 0 && Input.GetKeyDown(toggleKey);
			InputAction? controllerToggleAction = _controllerToggleAction;
			return new ItemSpawnerInputSnapshot(keyboardToggle, controllerToggleAction != null && controllerToggleAction.WasPressedThisFrame(), navigation, current != null && current.buttonSouth.wasPressedThisFrame, current != null && current.buttonSouth.isPressed, current != null && current.buttonSouth.wasReleasedThisFrame, Input.GetKeyDown((KeyCode)27) || (current != null && current.buttonEast.wasPressedThisFrame), current != null && current.buttonWest.wasPressedThisFrame, current != null && current.leftShoulder.wasPressedThisFrame, current != null && current.rightShoulder.wasPressedThisFrame, mouseActivity);
		}

		public void Dispose()
		{
			DisposeAction();
			_bindingSignature = string.Empty;
		}

		private void EnsureActions()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_009b: 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_00ab: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			string text = ControllerBindingRules.NormalizeBindingPath(_config.ControllerChordModifierPath.Value);
			string text2 = ControllerBindingRules.NormalizeBindingPath(_config.ControllerTogglePath.Value);
			string text3 = text + "\n" + text2;
			if (text3 == _bindingSignature)
			{
				return;
			}
			DisposeAction();
			_bindingSignature = text3;
			if (text2.Length == 0)
			{
				return;
			}
			try
			{
				_controllerToggleAction = new InputAction("ItemSpawnerEnhanced Controller Toggle", (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
				if (text.Length == 0)
				{
					InputActionSetupExtensions.AddBinding(_controllerToggleAction, text2, (string)null, (string)null, (string)null);
				}
				else
				{
					CompositeSyntax val = InputActionSetupExtensions.AddCompositeBinding(_controllerToggleAction, "OneModifier", (string)null, (string)null);
					val = ((CompositeSyntax)(ref val)).With("modifier", text, (string)null, (string)null);
					((CompositeSyntax)(ref val)).With("binding", text2, (string)null, (string)null);
				}
				_controllerToggleAction.Enable();
			}
			catch (Exception ex)
			{
				DisposeAction();
				_logger.LogWarning((object)("Controller window binding is invalid and has been disabled: " + ex.Message));
			}
		}

		private void DisposeAction()
		{
			if (_controllerToggleAction != null)
			{
				_controllerToggleAction.Disable();
				_controllerToggleAction.Dispose();
				_controllerToggleAction = null;
			}
		}
	}
	internal sealed class ModConfig
	{
		private static readonly string[] ControllerPathOptions = new string[18]
		{
			"<Gamepad>/select", "<Gamepad>/start", "<Gamepad>/leftShoulder", "<Gamepad>/rightShoulder", "<Gamepad>/buttonSouth", "<Gamepad>/buttonEast", "<Gamepad>/buttonWest", "<Gamepad>/buttonNorth", "<Gamepad>/leftTrigger", "<Gamepad>/rightTrigger",
			"<Gamepad>/leftStickPress", "<Gamepad>/rightStickPress", "<Gamepad>/dpad/up", "<Gamepad>/dpad/down", "<Gamepad>/dpad/left", "<Gamepad>/dpad/right", "None", ""
		};

		private readonly ConfigEntry<KeyCode> _toggleKey;

		private readonly ConfigEntry<bool> _showAllItems;

		private readonly ConfigEntry<bool> _singleTagSelection;

		private readonly ConfigEntry<TagMatchMode> _tagMatchMode;

		private readonly ConfigEntry<string> _favoriteItemNames;

		public KeyCode ToggleKey => _toggleKey.Value;

		public ConfigEntry<string> ControllerChordModifierPath { get; }

		public ConfigEntry<string> ControllerTogglePath { get; }

		public bool ShowAllItems => _showAllItems.Value;

		public bool SingleTagSelection => _singleTagSelection.Value;

		public TagMatchMode TagMatchMode => _tagMatchMode.Value;

		public ConfigEntry<bool> SingleTagSelectionEntry => _singleTagSelection;

		public ConfigEntry<TagMatchMode> TagMatchModeEntry => _tagMatchMode;

		public ConfigEntry<string> FavoriteItemNamesEntry => _favoriteItemNames;

		public ModConfig(ConfigFile config)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			_toggleKey = config.Bind<KeyCode>("General", "ToggleKey", (KeyCode)286, "The keyboard key used to open and close the item spawner.");
			ControllerChordModifierPath = config.Bind<string>("Controls", "ControllerChordModifierPath", "<Gamepad>/select", new ConfigDescription("Controller button held as the optional modifier for the item spawner shortcut. Default: <Gamepad>/select (Xbox View / PlayStation Share). Leave empty or set to None for a single-button shortcut.", (AcceptableValueBase)(object)new AcceptableValueList<string>(ControllerPathOptions), Array.Empty<object>()));
			ControllerTogglePath = config.Bind<string>("Controls", "ControllerTogglePath", "<Gamepad>/rightTrigger", new ConfigDescription("Controller button pressed with the optional modifier to open or close the item spawner. Default: <Gamepad>/rightTrigger (Xbox RT / PlayStation R2). Leave empty or set to None to disable.", (AcceptableValueBase)(object)new AcceptableValueList<string>(ControllerPathOptions), Array.Empty<object>()));
			_showAllItems = config.Bind<bool>("Catalog", "ShowAllItems", false, "Show every item prefab registered by PEAK, including unused, test, cheat, and internal duplicate items.");
			_singleTagSelection = config.Bind<bool>("Filtering", "SingleTagSelection", true, "Allow only one selected filter tag at a time. Selecting another tag clears the current selection.");
			_tagMatchMode = config.Bind<TagMatchMode>("Filtering", "TagMatchMode", TagMatchMode.And, "How selected tags are combined. And requires every selected tag; Or requires any selected tag.");
			_favoriteItemNames = config.Bind<string>("Favorites", "ItemNames", "[]", "Favorite item prefab names stored as a JSON array. Manage these in the item spawner UI.");
		}
	}
	internal static class PatchInstaller
	{
		public static bool Install(Harmony harmony, ManualLogSource logger)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(GUIManager), "Start", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(PatchCallbacks), "GuiManagerStartPostfix", (Type[])null, (Type[])null);
				if (methodInfo == null || methodInfo2 == null)
				{
					return false;
				}
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch (Exception arg)
			{
				logger.LogError((object)$"Failed to patch GUIManager.Start: {arg}");
				return false;
			}
		}
	}
	internal static class PatchCallbacks
	{
		public static void GuiManagerStartPostfix()
		{
			Plugin.Instance?.Attach();
		}
	}
	internal sealed class PlayerTargetService
	{
		private static readonly MethodInfo? SpawnItemMethod = AccessTools.Method(typeof(CharacterItems), "SpawnItemInHand", new Type[1] { typeof(string) }, (Type[])null);

		private readonly ManualLogSource _logger;

		public PlayerTargetService(ManualLogSource logger)
		{
			_logger = logger;
		}

		public PlayerTargetSnapshot Capture()
		{
			Character[] playerCharacters = GetPlayerCharacters();
			Character specCharacter = MainCameraMovement.specCharacter;
			List<PlayerTarget> list = new List<PlayerTarget>(playerCharacters.Length);
			TargetCandidate[] array = new TargetCandidate[playerCharacters.Length];
			for (int i = 0; i < playerCharacters.Length; i++)
			{
				Character val = playerCharacters[i];
				int actorId = GetActorId(val);
				bool canReceiveItem = CanReceiveItem(val);
				bool isLocal = (Object)(object)val == (Object)(object)Character.localCharacter;
				bool isSpectated = (Object)(object)val == (Object)(object)specCharacter;
				bool isSelectable = IsSelectable(actorId, canReceiveItem);
				array[i] = new TargetCandidate(actorId, isLocal, isSpectated, isSelectable, canReceiveItem);
				if (actorId > 0)
				{
					list.Add(new PlayerTarget(actorId, val.characterName, isLocal, isSpectated, isSelectable));
				}
			}
			PlayerTarget[] targets = list.OrderByDescending((PlayerTarget target) => target.IsLocal).ThenBy<PlayerTarget, string>((PlayerTarget target) => target.Name, StringComparer.OrdinalIgnoreCase).ToArray();
			return new PlayerTargetSnapshot(playerCharacters, array, targets);
		}

		public bool TrySpawn(Item item, int? manualActorId, out string errorKey)
		{
			if (!PhotonNetwork.IsConnected)
			{
				errorKey = "notConnected";
				return false;
			}
			Character val = Capture().Resolve(manualActorId);
			if ((Object)(object)val == (Object)null)
			{
				errorKey = "noTarget";
				return false;
			}
			try
			{
				if (SpawnItemMethod == null)
				{
					throw new MissingMethodException(typeof(CharacterItems).FullName, "SpawnItemInHand");
				}
				SpawnItemMethod.Invoke(val.refs.items, new object[1] { ((Object)item).name });
				_logger.LogInfo((object)("Spawned '" + ((Object)item).name + "' for '" + val.characterName + "'."));
				errorKey = string.Empty;
				return true;
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Failed to spawn '{((Object)item).name}': {arg}");
				errorKey = "spawnFailed";
				return false;
			}
		}

		private static bool IsPlayerCharacter(Character? character)
		{
			if ((Object)(object)character != (Object)null)
			{
				return !character.isBot;
			}
			return false;
		}

		private static Character[] GetPlayerCharacters()
		{
			return PlayerHandler.GetAllPlayerCharacters().Where(IsPlayerCharacter).ToArray();
		}

		private static bool CanReceiveItem(Character? character)
		{
			if (IsPlayerCharacter(character) && character.refs != null)
			{
				return (Object)(object)character.refs.items != (Object)null;
			}
			return false;
		}

		private static bool IsSelectable(int actorId, bool canReceiveItem)
		{
			return actorId > 0 && canReceiveItem;
		}

		private static int GetActorId(Character character)
		{
			try
			{
				PhotonView photonView = ((MonoBehaviourPun)character).photonView;
				return (photonView != null) ? photonView.OwnerActorNr : (-1);
			}
			catch
			{
				return -1;
			}
		}
	}
	internal sealed class PlayerTargetSnapshot
	{
		private readonly Character[] _characters;

		private readonly TargetCandidate[] _candidates;

		public IReadOnlyList<PlayerTarget> Targets { get; }

		public PlayerTargetSnapshot(Character[] characters, TargetCandidate[] candidates, IReadOnlyList<PlayerTarget> targets)
		{
			_characters = characters;
			_candidates = candidates;
			Targets = targets;
		}

		public Character? Resolve(int? manualActorId)
		{
			int? num = TargetResolver.ResolveIndex(_candidates, manualActorId);
			if (!num.HasValue)
			{
				return null;
			}
			return _characters[num.Value];
		}
	}
	internal readonly struct PlayerTarget
	{
		public int ActorId { get; }

		public string Name { get; }

		public bool IsLocal { get; }

		public bool IsSpectated { get; }

		public bool IsSelectable { get; }

		public PlayerTarget(int actorId, string name, bool isLocal, bool isSpectated, bool isSelectable)
		{
			ActorId = actorId;
			Name = name;
			IsLocal = isLocal;
			IsSpectated = isSpectated;
			IsSelectable = isSelectable;
		}
	}
	[BepInPlugin("com.github.lllei.ItemSpawnerEnhanced", "ItemSpawnerEnhanced", "1.3.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.github.lllei.ItemSpawnerEnhanced";

		public const string PluginName = "ItemSpawnerEnhanced";

		private Harmony? _harmony;

		private ItemSpawnerController? _controller;

		internal static Plugin? Instance { get; private set; }

		private void Awake()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			Instance = this;
			ModConfig settings = new ModConfig(((BaseUnityPlugin)this).Config);
			_controller = new ItemSpawnerController(settings, ((BaseUnityPlugin)this).Logger);
			_harmony = new Harmony("com.github.lllei.ItemSpawnerEnhanced");
			if (!PatchInstaller.Install(_harmony, ((BaseUnityPlugin)this).Logger))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Item spawner UI is disabled because GUIManager.Start could not be patched.");
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"ItemSpawnerEnhanced 1.3.0 loaded for PEAK 2.1.a baseline.");
		}

		private void Update()
		{
			_controller?.Tick();
		}

		internal void Attach()
		{
			_controller?.Attach();
		}

		private void OnDestroy()
		{
			_controller?.Dispose();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			RuntimeUiAssets.Release();
			Instance = null;
		}
	}
	internal static class BuildInfo
	{
		internal const string Version = "1.3.0";
	}
}
namespace ItemSpawnerEnhanced.UI
{
	internal sealed class ControlInteractionState : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerDownHandler, IPointerUpHandler
	{
		public bool Focused { get; private set; }

		public bool Hovered { get; private set; }

		public bool Pressed { get; private set; }

		public event Action? Changed;

		public void SetFocused(bool focused)
		{
			if (Focused != focused)
			{
				Focused = focused;
				this.Changed?.Invoke();
			}
		}

		public void SetControllerPressed(bool pressed)
		{
			if (Pressed != pressed)
			{
				Pressed = pressed;
				this.Changed?.Invoke();
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			Hovered = true;
			this.Changed?.Invoke();
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			Hovered = false;
			Pressed = false;
			this.Changed?.Invoke();
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				Pressed = true;
				this.Changed?.Invoke();
			}
		}

		public void OnPointerUp(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				Pressed = false;
				this.Changed?.Invoke();
				if ((Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)this).gameObject)
				{
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				}
			}
		}

		private void OnDisable()
		{
			Focused = false;
			Hovered = false;
			Pressed = false;
			this.Changed?.Invoke();
		}
	}
	internal sealed class ActionButtonVisual
	{
		private readonly Button _button;

		private readonly Image _background;

		private readonly Graphic _foreground;

		private readonly Image _focusFrame;

		private readonly ControlInteractionState _interaction;

		private bool _enabled = true;

		public Button Button => _button;

		public bool Enabled => _enabled;

		public ActionButtonVisual(Button button, Image background, Graphic foreground)
		{
			_button = button;
			_background = background;
			_foreground = foreground;
			_focusFrame = RuntimeUiFactory.CreateFocusFrame(((Component)button).transform);
			_interaction = ((Component)button).gameObject.AddComponent<ControlInteractionState>();
			_interaction.Changed += Render;
			((Selectable)_button).transition = (Transition)0;
			Render();
		}

		public void SetEnabled(bool enabled)
		{
			_enabled = enabled;
			((Selectable)_button).interactable = enabled;
			Render();
		}

		public void SetFocused(bool focused)
		{
			_interaction.SetFocused(focused && _enabled);
		}

		public void SetControllerPressed(bool pressed)
		{
			_interaction.SetControllerPressed(pressed && _enabled);
		}

		private void Render()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			ControlVisualState controlVisualState = ControllerVisualState.ForAction(_enabled, _interaction.Focused, _interaction.Hovered, _interaction.Pressed);
			((Graphic)_background).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Background);
			_foreground.color = (Color)(_enabled ? RuntimeUiFactory.ResolvePalette(controlVisualState.Foreground) : new Color(RuntimeUiFactory.TextMuted.r, RuntimeUiFactory.TextMuted.g, RuntimeUiFactory.TextMuted.b, 0.35f));
			((Component)_focusFrame).gameObject.SetActive(controlVisualState.ShowFocus);
		}
	}
	internal sealed class ControllerFocusCoordinator
	{
		private const float NavigationDeadZone = 0.55f;

		private const float InitialRepeatDelay = 0.35f;

		private const float RepeatInterval = 0.1f;

		private readonly ItemSpawnerView _view;

		private readonly Action _close;

		private ControllerFocusLocation _focus;

		private ControllerFocusLocation _lastFocus;

		private ControllerFocusLocation _lastTagFocus;

		private ControllerFocusLocation _lastItemFocus;

		private ControllerNavigationDirection? _heldDirection;

		private float _nextNavigationAt;

		private TagToggle? _pressedTag;

		private ItemTile? _pressedTile;

		private bool _tagClearPressed;

		private bool _controllerMode;

		private bool _windowOpen;

		public ControllerFocusCoordinator(ItemSpawnerView view, Action close)
		{
			_view = view;
			_close = close;
		}

		public void OpenWithController()
		{
			_windowOpen = true;
			_controllerMode = true;
			_heldDirection = null;
			ClearEventSystemSelection();
			RestoreFocus(preferFirstItem: true);
		}

		public void OpenWithoutController()
		{
			_windowOpen = true;
			_controllerMode = false;
			_heldDirection = null;
			ClearFocusVisual(_focus);
		}

		public void Close()
		{
			ReleasePressedControl();
			if (_view.TargetDropdown.Dropdown.IsExpanded)
			{
				_view.TargetDropdown.Dropdown.Hide();
			}
			_view.TargetDropdown.SetExpanded(expanded: false);
			ClearFocusVisual(_focus);
			ClearDropdownOptionFocus();
			_view.HideTooltip();
			_windowOpen = false;
			_controllerMode = false;
			_heldDirection = null;
			if ((Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject != (Object)null && EventSystem.current.currentSelectedGameObject.transform.IsChildOf(_view.Root.transform))
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
		}

		public void Tick(ItemSpawnerInputSnapshot input)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!_windowOpen)
			{
				return;
			}
			SyncDropdownState();
			if (input.MouseActivity)
			{
				SetControllerMode(controllerMode: false);
			}
			if (input.ControllerActivity)
			{
				SetControllerMode(controllerMode: true);
			}
			ValidateFocus();
			if (input.CancelPressed)
			{
				if (_view.TargetDropdown.Expanded)
				{
					CollapseDropdown();
				}
				else
				{
					_close();
				}
			}
			else
			{
				if (!_controllerMode)
				{
					return;
				}
				if (input.ConfirmPressed)
				{
					ClearEventSystemSelection();
				}
				ControllerNavigationDirection? direction = ReadDirection(input.Navigation);
				if (ShouldNavigate(direction))
				{
					Move(direction.Value);
				}
				if (!_view.TargetDropdown.Expanded)
				{
					if (input.PreviousTargetPressed)
					{
						SwitchRegion(-1);
					}
					if (input.NextTargetPressed)
					{
						SwitchRegion(1);
					}
					if (input.FavoritePressed)
					{
						ToggleFocusedFavorite();
					}
				}
				if (input.ConfirmPressed)
				{
					ActivateFocusedControl();
				}
				if (input.ConfirmReleased || !input.ConfirmHeld)
				{
					ReleasePressedControl();
				}
			}
		}

		private void SetControllerMode(bool controllerMode)
		{
			if (_controllerMode != controllerMode)
			{
				_controllerMode = controllerMode;
				if (controllerMode)
				{
					ClearEventSystemSelection();
					RestoreFocus(preferFirstItem: false);
					return;
				}
				ReleasePressedControl();
				ClearFocusVisual(_focus);
				ClearDropdownOptionFocus();
				_view.HideTooltip();
			}
		}

		private void RestoreFocus(bool preferFirstItem)
		{
			if (_focus.Kind != ControllerFocusKind.None)
			{
				ApplyFocus(_focus, remember: false);
				return;
			}
			if (!preferFirstItem && _lastFocus.Kind != ControllerFocusKind.None)
			{
				ApplyFocus(_lastFocus, remember: false);
				return;
			}
			IReadOnlyList<ItemTile> visibleTiles = _view.VisibleTiles;
			ApplyFocus((visibleTiles.Count > 0) ? ControllerFocusLocation.ForItem(0, ((Object)visibleTiles[0].Record.Item).name) : ControllerFocusLocation.PendingFirstItem(), remember: false);
		}

		private void ValidateFocus()
		{
			if (!_controllerMode)
			{
				return;
			}
			switch (_focus.Kind)
			{
			case ControllerFocusKind.Item:
			{
				IReadOnlyList<ItemTile> visibleTiles = _view.VisibleTiles;
				if (visibleTiles.Count == 0)
				{
					ClearFocusVisual(_focus);
					_view.HideTooltip();
					break;
				}
				int num = FindFocusedItemIndex(visibleTiles);
				if (num >= 0)
				{
					if (num != _focus.Index)
					{
						_focus = ControllerFocusLocation.ForItem(num, _focus.ItemName);
					}
				}
				else
				{
					int index = ControllerNavigation.ResolveFallbackIndex(_focus.Index, visibleTiles.Count);
					ApplyFocus(ControllerFocusLocation.ForItem(index, ((Object)visibleTiles[index].Record.Item).name), remember: true);
				}
				break;
			}
			case ControllerFocusKind.ClearTags:
				if (!_view.TagClear.Enabled)
				{
					ApplyFocus(ControllerFocusLocation.ForTag(_view.TagToggles.Count - 1), remember: true);
				}
				break;
			case ControllerFocusKind.DropdownOption:
				if (!_view.TargetDropdown.Expanded)
				{
					ApplyFocus(ControllerFocusLocation.Target(), remember: true);
				}
				break;
			case ControllerFocusKind.None:
				RestoreFocus(preferFirstItem: true);
				break;
			case ControllerFocusKind.Target:
			case ControllerFocusKind.Tag:
				break;
			}
		}

		private bool ShouldNavigate(ControllerNavigationDirection? direction)
		{
			if (!direction.HasValue)
			{
				_heldDirection = null;
				return false;
			}
			float unscaledTime = Time.unscaledTime;
			if (_heldDirection != direction)
			{
				_heldDirection = direction;
				_nextNavigationAt = unscaledTime + 0.35f;
				return true;
			}
			if (unscaledTime < _nextNavigationAt)
			{
				return false;
			}
			_nextNavigationAt = unscaledTime + 0.1f;
			return true;
		}

		private void Move(ControllerNavigationDirection direction)
		{
			if (_view.TargetDropdown.Expanded)
			{
				switch (direction)
				{
				case ControllerNavigationDirection.Up:
					MoveDropdownOption(-1);
					break;
				case ControllerNavigationDirection.Down:
					MoveDropdownOption(1);
					break;
				}
				return;
			}
			switch (_focus.Kind)
			{
			case ControllerFocusKind.Target:
				if (direction == ControllerNavigationDirection.Down)
				{
					FocusNearestTag(GetHorizontalCenter(((Component)_view.TargetDropdown.Dropdown).transform));
				}
				break;
			case ControllerFocusKind.Tag:
				MoveFromTag(direction);
				break;
			case ControllerFocusKind.ClearTags:
				MoveFromClearTags(direction);
				break;
			case ControllerFocusKind.Item:
				MoveFromItem(direction);
				break;
			default:
				RestoreFocus(preferFirstItem: true);
				break;
			}
		}

		private void MoveFromTag(ControllerNavigationDirection direction)
		{
			int num = Math.Clamp(_focus.Index, 0, _view.TagToggles.Count - 1);
			switch (direction)
			{
			case ControllerNavigationDirection.Left:
				if (num > 0)
				{
					ApplyFocus(ControllerFocusLocation.ForTag(num - 1), remember: true);
				}
				break;
			case ControllerNavigationDirection.Right:
				if (num + 1 < _view.TagToggles.Count)
				{
					ApplyFocus(ControllerFocusLocation.ForTag(num + 1), remember: true);
				}
				else if (_view.TagClear.Enabled)
				{
					ApplyFocus(ControllerFocusLocation.ClearTags(), remember: true);
				}
				break;
			case ControllerNavigationDirection.Up:
				ApplyFocus(ControllerFocusLocation.Target(), remember: true);
				break;
			case ControllerNavigationDirection.Down:
				FocusNearestItem(GetHorizontalCenter(((Component)_view.TagToggles[num].Toggle).transform));
				break;
			}
		}

		private void MoveFromClearTags(ControllerNavigationDirection direction)
		{
			switch (direction)
			{
			case ControllerNavigationDirection.Left:
				ApplyFocus(ControllerFocusLocation.ForTag(_view.TagToggles.Count - 1), remember: true);
				break;
			case ControllerNavigationDirection.Up:
				ApplyFocus(ControllerFocusLocation.Target(), remember: true);
				break;
			case ControllerNavigationDirection.Down:
				FocusNearestItem(GetHorizontalCenter(((Component)_view.TagClear.Button).transform));
				break;
			case ControllerNavigationDirection.Right:
				break;
			}
		}

		private void MoveFromItem(ControllerNavigationDirection direction)
		{
			IReadOnlyList<ItemTile> visibleTiles = _view.VisibleTiles;
			int num = FindFocusedItemIndex(visibleTiles);
			if (num < 0)
			{
				return;
			}
			int num2 = CalculateColumnCount();
			if (direction == ControllerNavigationDirection.Up && num < num2)
			{
				FocusNearestTag(GetHorizontalCenter((Transform)(object)visibleTiles[num].RectTransform));
				return;
			}
			int num3 = ControllerNavigation.MoveInGrid(num, visibleTiles.Count, num2, direction);
			if (num3 != num)
			{
				ApplyFocus(ControllerFocusLocation.ForItem(num3, ((Object)visibleTiles[num3].Record.Item).name), remember: true);
			}
		}

		private void FocusNearestTag(float horizontalPosition)
		{
			List<float> list = _view.TagToggles.Select((TagToggle tag) => GetHorizontalCenter(((Component)tag.Toggle).transform)).ToList();
			if (_view.TagClear.Enabled)
			{
				list.Add(GetHorizontalCenter(((Component)_view.TagClear.Button).transform));
			}
			int num = ControllerNavigation.FindNearest(horizontalPosition, list);
			if (num >= 0)
			{
				ApplyFocus((num < _view.TagToggles.Count) ? ControllerFocusLocation.ForTag(num) : ControllerFocusLocation.ClearTags(), remember: true);
			}
		}

		private void FocusNearestItem(float horizontalPosition)
		{
			IReadOnlyList<ItemTile> visibleTiles = _view.VisibleTiles;
			if (visibleTiles.Count != 0)
			{
				int count = Math.Min(CalculateColumnCount(), visibleTiles.Count);
				float[] candidates = (from tile in visibleTiles.Take(count)
					select GetHorizontalCenter((Transform)(object)tile.RectTransform)).ToArray();
				int index = ControllerNavigation.FindNearest(horizontalPosition, candidates);
				ApplyFocus(ControllerFocusLocation.ForItem(index, ((Object)visibleTiles[index].Record.Item).name), remember: true);
			}
		}

		private void ActivateFocusedControl()
		{
			switch (_focus.Kind)
			{
			case ControllerFocusKind.Target:
				ExpandDropdown();
				break;
			case ControllerFocusKind.Tag:
				if (_focus.Index >= 0 && _focus.Index < _view.TagToggles.Count)
				{
					TagToggle tagToggle = _view.TagToggles[_focus.Index];
					tagToggle.SetControllerPressed(pressed: true);
					_pressedTag = tagToggle;
					tagToggle.Toggle.isOn = !tagToggle.Toggle.isOn;
				}
				break;
			case ControllerFocusKind.ClearTags:
				if (_view.TagClear.Enabled)
				{
					_view.TagClear.SetControllerPressed(pressed: true);
					_tagClearPressed = true;
					((UnityEvent)_view.TagClear.Button.onClick).Invoke();
					ValidateFocus();
				}
				break;
			case ControllerFocusKind.Item:
			{
				ItemTile itemTile = ResolveFocusedItem();
				if (itemTile != null && itemTile.CanSpawn)
				{
					itemTile.BeginControllerSubmit();
					_pressedTile = itemTile;
				}
				break;
			}
			case ControllerFocusKind.DropdownOption:
				SelectDropdownOption();
				break;
			}
		}

		private void ReleasePressedControl()
		{
			if (_pressedTag != null)
			{
				_pressedTag.SetControllerPressed(pressed: false);
			}
			if (_tagClearPressed)
			{
				_view.TagClear.SetControllerPressed(pressed: false);
			}
			if (_pressedTile != null && (Object)(object)_pressedTile.GameObject != (Object)null)
			{
				_pressedTile.EndControllerSubmit();
			}
			_pressedTag = null;
			_pressedTile = null;
			_tagClearPressed = false;
		}

		private void ToggleFocusedFavorite()
		{
			ItemTile? itemTile = ResolveFocusedItem();
			if (itemTile != null && itemTile.TryToggleFavorite())
			{
				ValidateFocus();
			}
		}

		private void SwitchRegion(int direction)
		{
			bool[] availableRegions = new bool[3]
			{
				_view.TargetDropdown.Enabled,
				_view.TagToggles.Count > 0,
				_view.VisibleTiles.Count > 0
			};
			int num;
			switch (_focus.Kind)
			{
			case ControllerFocusKind.Target:
			case ControllerFocusKind.DropdownOption:
				num = 0;
				break;
			case ControllerFocusKind.Tag:
			case ControllerFocusKind.ClearTags:
				num = 1;
				break;
			case ControllerFocusKind.Item:
				num = 2;
				break;
			default:
				num = 2;
				break;
			}
			int num2 = num;
			int num3 = ControllerNavigation.MoveRegion(num2, direction, availableRegions);
			if (num3 >= 0 && num3 != num2)
			{
				switch (num3)
				{
				case 0:
					ApplyFocus(ControllerFocusLocation.Target(), remember: true);
					break;
				case 1:
					RestoreTagRegionFocus();
					break;
				case 2:
					RestoreItemRegionFocus();
					break;
				}
			}
		}

		private void RestoreTagRegionFocus()
		{
			if (_lastTagFocus.Kind == ControllerFocusKind.ClearTags && _view.TagClear.Enabled)
			{
				ApplyFocus(_lastTagFocus, remember: true);
				return;
			}
			int index = ((_lastTagFocus.Kind == ControllerFocusKind.Tag) ? Math.Clamp(_lastTagFocus.Index, 0, _view.TagToggles.Count - 1) : 0);
			ApplyFocus(ControllerFocusLocation.ForTag(index), remember: true);
		}

		private void RestoreItemRegionFocus()
		{
			IReadOnlyList<ItemTile> visibleTiles = _view.VisibleTiles;
			if (visibleTiles.Count != 0)
			{
				int num = FindItemIndex(visibleTiles, _lastItemFocus);
				if (num < 0)
				{
					num = ControllerNavigation.ResolveFallbackIndex(_lastItemFocus.Index, visibleTiles.Count);
				}
				ApplyFocus(ControllerFocusLocation.ForItem(num, ((Object)visibleTiles[num].Record.Item).name), remember: true);
			}
		}

		private void ExpandDropdown()
		{
			TMP_Dropdown dropdown = _view.TargetDropdown.Dropdown;
			if (((UIBehaviour)dropdown).IsActive() && ((Selectable)dropdown).IsInteractable())
			{
				dropdown.Show();
				if ((Object)(object)EventSystem.current != (Object)null)
				{
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				}
				Canvas.ForceUpdateCanvases();
				_view.TargetDropdown.SetExpanded(dropdown.IsExpanded);
				if (dropdown.IsExpanded)
				{
					int index = Math.Clamp(dropdown.value, 0, Math.Max(0, dropdown.options.Count - 1));
					ApplyFocus(ControllerFocusLocation.DropdownOption(index), remember: false);
				}
			}
		}

		private void CollapseDropdown()
		{
			_view.TargetDropdown.Dropdown.Hide();
			_view.TargetDropdown.SetExpanded(expanded: false);
			ClearDropdownOptionFocus();
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
			ApplyFocus(ControllerFocusLocation.Target(), remember: true);
		}

		private void MoveDropdownOption(int delta)
		{
			IReadOnlyList<DropdownOptionVisual> visibleOptions = _view.TargetDropdown.GetVisibleOptions();
			if (visibleOptions.Count != 0)
			{
				int num = Math.Clamp(_focus.Index + delta, 0, visibleOptions.Count - 1);
				if (num != _focus.Index)
				{
					ApplyFocus(ControllerFocusLocation.DropdownOption(num), remember: false);
				}
			}
		}

		private void SelectDropdownOption()
		{
			TMP_Dropdown dropdown = _view.TargetDropdown.Dropdown;
			if (_focus.Index >= 0 && _focus.Index < dropdown.options.Count)
			{
				dropdown.value = _focus.Index;
			}
			CollapseDropdown();
		}

		private void SyncDropdownState()
		{
			bool isExpanded = _view.TargetDropdown.Dropdown.IsExpanded;
			if (isExpanded != _view.TargetDropdown.Expanded)
			{
				_view.TargetDropdown.SetExpanded(isExpanded);
				if (!isExpanded && _focus.Kind == ControllerFocusKind.DropdownOption)
				{
					ApplyFocus(ControllerFocusLocation.Target(), remember: true);
				}
			}
		}

		private void ApplyFocus(ControllerFocusLocation next, bool remember)
		{
			ReleasePressedControl();
			ClearFocusVisual(_focus);
			ClearDropdownOptionFocus();
			_view.HideTooltip();
			_focus = next;
			ControllerFocusKind kind = next.Kind;
			if ((uint)(kind - 2) <= 1u)
			{
				_lastTagFocus = next;
			}
			else if (next.Kind == ControllerFocusKind.Item)
			{
				_lastItemFocus = next;
			}
			if (remember && next.Kind != ControllerFocusKind.DropdownOption)
			{
				_lastFocus = next;
			}
			if (_controllerMode)
			{
				SetFocusVisual(next);
			}
		}

		private void SetFocusVisual(ControllerFocusLocation location)
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			switch (location.Kind)
			{
			case ControllerFocusKind.Target:
				_view.TargetDropdown.SetFocused(focused: true);
				break;
			case ControllerFocusKind.Tag:
				if (location.Index >= 0 && location.Index < _view.TagToggles.Count)
				{
					_view.TagToggles[location.Index].SetFocused(focused: true);
				}
				break;
			case ControllerFocusKind.ClearTags:
				if (_view.TagClear.Enabled)
				{
					_view.TagClear.SetFocused(focused: true);
				}
				break;
			case ControllerFocusKind.Item:
			{
				ItemTile itemTile = ResolveFocusedItem();
				if (itemTile != null)
				{
					itemTile.SetFocused(focused: true);
					EnsureItemVisible(itemTile);
					if (itemTile.HasTruncatedName())
					{
						_view.ShowControllerTooltip(itemTile);
					}
				}
				break;
			}
			case ControllerFocusKind.DropdownOption:
			{
				IReadOnlyList<DropdownOptionVisual> visibleOptions = _view.TargetDropdown.GetVisibleOptions();
				if (location.Index >= 0 && location.Index < visibleOptions.Count)
				{
					visibleOptions[location.Index].SetFocused(focused: true);
					ScrollRect componentInParent = ((Component)visibleOptions[location.Index]).GetComponentInParent<ScrollRect>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						EnsureVisible(componentInParent, (RectTransform)((Component)visibleOptions[location.Index]).transform);
					}
				}
				break;
			}
			}
		}

		private void ClearFocusVisual(ControllerFocusLocation location)
		{
			switch (location.Kind)
			{
			case ControllerFocusKind.Target:
				_view.TargetDropdown.SetFocused(focused: false);
				break;
			case ControllerFocusKind.Tag:
				if (location.Index >= 0 && location.Index < _view.TagToggles.Count)
				{
					_view.TagToggles[location.Index].SetFocused(focused: false);
				}
				break;
			case ControllerFocusKind.ClearTags:
				_view.TagClear.SetFocused(focused: false);
				break;
			case ControllerFocusKind.Item:
				ResolveFocusedItem()?.SetFocused(focused: false);
				break;
			}
		}

		private void ClearDropdownOptionFocus()
		{
			foreach (DropdownOptionVisual visibleOption in _view.TargetDropdown.GetVisibleOptions())
			{
				visibleOption.SetFocused(focused: false);
			}
		}

		private ItemTile? ResolveFocusedItem()
		{
			IReadOnlyList<ItemTile> visibleTiles = _view.VisibleTiles;
			int num = FindFocusedItemIndex(visibleTiles);
			if (num < 0)
			{
				return null;
			}
			return visibleTiles[num];
		}

		private int FindFocusedItemIndex(IReadOnlyList<ItemTile> tiles)
		{
			return FindItemIndex(tiles, _focus);
		}

		private static int FindItemIndex(IReadOnlyList<ItemTile> tiles, ControllerFocusLocation location)
		{
			if (!string.IsNullOrEmpty(location.ItemName))
			{
				if (location.Index >= 0 && location.Index < tiles.Count && string.Equals(((Object)tiles[location.Index].Record.Item).name, location.ItemName, StringComparison.Ordinal))
				{
					return location.Index;
				}
				for (int i = 0; i < tiles.Count; i++)
				{
					if (string.Equals(((Object)tiles[i].Record.Item).name, location.ItemName, StringComparison.Ordinal))
					{
						return i;
					}
				}
			}
			return -1;
		}

		private int CalculateColumnCount()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Canvas.ForceUpdateCanvases();
			GridLayoutGroup component = ((Component)_view.ItemContent).GetComponent<GridLayoutGroup>();
			Rect rect = _view.ItemContent.rect;
			float num = ((Rect)(ref rect)).width - (float)((LayoutGroup)component).padding.horizontal;
			return Math.Max(1, Mathf.FloorToInt((num + component.spacing.x) / (component.cellSize.x + component.spacing.x)));
		}

		private void EnsureItemVisible(ItemTile tile)
		{
			EnsureVisible(_view.ItemScroll, tile.RectTransform);
		}

		private static void EnsureVisible(ScrollRect scroll, RectTransform target)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			Canvas.ForceUpdateCanvases();
			RectTransform viewport = scroll.viewport;
			RectTransform content = scroll.content;
			Bounds val = RectTransformUtility.CalculateRelativeRectTransformBounds((Transform)(object)viewport, (Transform)(object)target);
			float num = content.anchoredPosition.y;
			float y = ((Bounds)(ref val)).min.y;
			Rect rect = viewport.rect;
			if (y < ((Rect)(ref rect)).yMin)
			{
				float num2 = num;
				rect = viewport.rect;
				num = num2 + (((Rect)(ref rect)).yMin - ((Bounds)(ref val)).min.y);
			}
			else
			{
				float y2 = ((Bounds)(ref val)).max.y;
				rect = viewport.rect;
				if (y2 > ((Rect)(ref rect)).yMax)
				{
					float num3 = num;
					float y3 = ((Bounds)(ref val)).max.y;
					rect = viewport.rect;
					num = num3 - (y3 - ((Rect)(ref rect)).yMax);
				}
			}
			rect = content.rect;
			float height = ((Rect)(ref rect)).height;
			rect = viewport.rect;
			float num4 = Math.Max(0f, height - ((Rect)(ref rect)).height);
			content.anchoredPosition = new Vector2(content.anchoredPosition.x, Mathf.Clamp(num, 0f, num4));
		}

		private static float GetHorizontalCenter(Transform transform)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val == null)
			{
				return transform.position.x;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array);
			return (array[0].x + array[2].x) * 0.5f;
		}

		private static ControllerNavigationDirection? ReadDirection(Vector2 navigation)
		{
			//IL_0018: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector2)(ref navigation)).sqrMagnitude < 0.3025f)
			{
				return null;
			}
			if (Mathf.Abs(navigation.x) > Mathf.Abs(navigation.y))
			{
				return (!(navigation.x < 0f)) ? ControllerNavigationDirection.Right : ControllerNavigationDirection.Left;
			}
			return (navigation.y < 0f) ? ControllerNavigationDirection.Down : ControllerNavigationDirection.Up;
		}

		private void ClearEventSystemSelection()
		{
			if (!((Object)(object)EventSystem.current == (Object)null) && !((Object)(object)EventSystem.current.currentSelectedGameObject == (Object)null) && EventSystem.current.currentSelectedGameObject.transform.IsChildOf(_view.Root.transform))
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
		}
	}
	internal enum ControllerFocusKind
	{
		None,
		Target,
		Tag,
		ClearTags,
		Item,
		DropdownOption
	}
	internal readonly struct ControllerFocusLocation
	{
		public ControllerFocusKind Kind { get; }

		public int Index { get; }

		public string? ItemName { get; }

		private ControllerFocusLocation(ControllerFocusKind kind, int index, string? itemName)
		{
			Kind = kind;
			Index = index;
			ItemName = itemName;
		}

		public static ControllerFocusLocation Target()
		{
			return new ControllerFocusLocation(ControllerFocusKind.Target, 0, null);
		}

		public static ControllerFocusLocation ForTag(int index)
		{
			return new ControllerFocusLocation(ControllerFocusKind.Tag, index, null);
		}

		public static ControllerFocusLocation ClearTags()
		{
			return new ControllerFocusLocation(ControllerFocusKind.ClearTags, 0, null);
		}

		public static ControllerFocusLocation ForItem(int index, string? itemName)
		{
			return new ControllerFocusLocation(ControllerFocusKind.Item, index, itemName);
		}

		public static ControllerFocusLocation PendingFirstItem()
		{
			return ForItem(0, null);
		}

		public static ControllerFocusLocation DropdownOption(int index)
		{
			return new ControllerFocusLocation(ControllerFocusKind.DropdownOption, index, null);
		}
	}
	internal static class ItemBrowserControlFactory
	{
		public static TagToggle CreateTagToggle(Transform parent, TMP_FontAsset font, ItemFilterTag tag)
		{
			//IL_008a: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = RuntimeUiFactory.CreateRect(tag.ToString(), parent, typeof(Image), typeof(Toggle), typeof(LayoutElement));
			LayoutElement component = ((Component)val).GetComponent<LayoutElement>();
			component.minHeight = 52f;
			component.flexibleWidth = 1f;
			Image component2 = ((Component)val).GetComponent<Image>();
			RuntimeUiFactory.ApplyRoundedCorners(component2);
			Toggle component3 = ((Component)val).GetComponent<Toggle>();
			((Selectable)component3).targetGraphic = (Graphic)(object)component2;
			component3.graphic = null;
			TextMeshProUGUI val2 = RuntimeUiFactory.CreateText("Label", (Transform)(object)val, font, 17f, RuntimeUiFactory.TextPrimary, (TextAlignmentOptions)514);
			((TMP_Text)val2).maxVisibleLines = 2;
			RawImage val3 = null;
			if (tag == ItemFilterTag.Favorite)
			{
				RectTransform obj = RuntimeUiFactory.CreateRect("Heart", (Transform)(object)val, typeof(RawImage));
				obj.anchorMin = new Vector2(0f, 0.5f);
				obj.anchorMax = new Vector2(0f, 0.5f);
				obj.pivot = new Vector2(0f, 0.5f);
				obj.anchoredPosition = new Vector2(11f, 0f);
				obj.sizeDelta = new Vector2(18f, 18f);
				val3 = ((Component)obj).GetComponent<RawImage>();
				val3.texture = (Texture)(object)RuntimeUiAssets.HeartTexture;
				((Graphic)val3).color = RuntimeUiFactory.TextPrimary;
				((Graphic)val3).raycastTarget = false;
				RuntimeUiFactory.Stretch(((TMP_Text)val2).rectTransform, 28f, 5f, 2f, 2f);
			}
			else
			{
				RuntimeUiFactory.Stretch(((TMP_Text)val2).rectTransform, 5f, 5f, 2f, 2f);
			}
			TagToggle tagToggle = new TagToggle(tag, component3, component2, (TMP_Text)(object)val2, val3);
			tagToggle.SetActive(active: false);
			return tagToggle;
		}

		public static ItemNameTooltip CreateItemTooltip(RectTransform parent, TMP_FontAsset font)
		{
			//IL_002a: 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_007f: 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)
			RectTransform val = RuntimeUiFactory.CreateRect("ItemTooltip", (Transform)(object)parent, typeof(Image));
			val.anchorMin = new Vector2(0.5f, 0.5f);
			val.anchorMax = new Vector2(0.5f, 0.5f);
			val.pivot = new Vector2(0f, 1f);
			Image component = ((Component)val).GetComponent<Image>();
			RuntimeUiFactory.ApplyRoundedCorners(component);
			((Graphic)component).color = new Color(0.27f, 0.29f, 0.3f, 0.98f);
			((Graphic)component).raycastTarget = false;
			TextMeshProUGUI val2 = RuntimeUiFactory.CreateText("Label", (Transform)(object)val, font, 20f, RuntimeUiFactory.TextPrimary, (TextAlignmentOptions)4097);
			((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
			RuntimeUiFactory.Stretch(((TMP_Text)val2).rectTransform, 12f, 12f, 8f, 8f);
			ItemNameTooltip itemNameTooltip = ((Component)parent).gameObject.AddComponent<ItemNameTooltip>();
			itemNameTooltip.Configure(parent, val, val2);
			return itemNameTooltip;
		}

		public static ItemTile CreateItemTile(Transform parent, TMP_FontAsset font, GameItemRecord record, UnityAction onClick, UnityAction onFavorite, bool isFavorite, ItemNameTooltip tooltip)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: 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_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = RuntimeUiFactory.CreateRect(((Object)record.Item).name, parent, typeof(Image), typeof(Button));
			Image component = ((Component)val).GetComponent<Image>();
			RuntimeUiFactory.ApplyRoundedCorners(component);
			((Graphic)component).color = RuntimeUiFactory.Surface;
			Button component2 = ((Component)val).GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((Selectable)component2).colors = RuntimeUiFactory.CreateButtonColors();
			ItemSpawnTrigger itemSpawnTrigger = ((Component)val).gameObject.AddComponent<ItemSpawnTrigger>();
			itemSpawnTrigger.Configure(component2, onClick);
			RectTransform obj = RuntimeUiFactory.CreateRect("Icon", (Transform)(object)val, typeof(RawImage));
			obj.anchorMin = new Vector2(0.5f, 1f);
			obj.anchorMax = new Vector2(0.5f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = new Vector2(0f, -10f);
			obj.sizeDelta = new Vector2(96f, 96f);
			RawImage component3 = ((Component)obj).GetComponent<RawImage>();
			component3.texture = (Texture)(object)record.Item.UIData?.icon;
			((Graphic)component3).raycastTarget = false;
			TextMeshProUGUI val2 = RuntimeUiFactory.CreateText("Name", (Transform)(object)val, font, 19f, RuntimeUiFactory.TextPrimary, (TextAlignmentOptions)514);
			((TMP_Text)val2).text = record.DisplayName;
			((TMP_Text)val2).maxVisibleLines = 2;
			((TMP_Text)val2).rectTransform.anchorMin = new Vector2(0f, 0f);
			((TMP_Text)val2).rectTransform.anchorMax = new Vector2(1f, 0f);
			((TMP_Text)val2).rectTransform.pivot = new Vector2(0.5f, 0f);
			((TMP_Text)val2).rectTransform.anchoredPosition = new Vector2(0f, 6f);
			((TMP_Text)val2).rectTransform.sizeDelta = new Vector2(-14f, 38f);
			RectTransform val3 = RuntimeUiFactory.CreateRect("Favorite", (Transform)(object)val);
			val3.anchorMin = new Vector2(1f, 1f);
			val3.anchorMax = new Vector2(1f, 1f);
			val3.pivot = new Vector2(1f, 1f);
			val3.anchoredPosition = new Vector2(-6f, -6f);
			val3.sizeDelta = new Vector2(32f, 32f);
			RectTransform obj2 = RuntimeUiFactory.CreateRect("Heart", (Transform)(object)val3, typeof(RawImage));
			RuntimeUiFactory.Stretch(obj2, 3f, 3f, 3f, 3f);
			RawImage component4 = ((Component)obj2).GetComponent<RawImage>();
			component4.texture = (Texture)(object)RuntimeUiAssets.HeartTexture;
			((Graphic)component4).color = RuntimeUiFactory.Favorite;
			((Graphic)component4).raycastTarget = false;
			((Component)val3).gameObject.SetActive(isFavorite);
			ItemFavoriteTrigger itemFavoriteTrigger = ((Component)val).gameObject.AddComponent<ItemFavoriteTrigger>();
			itemFavoriteTrigger.Configure(onFavorite);
			((Component)val).gameObject.AddComponent<ItemNameTooltipTrigger>().Configure(tooltip, record.DisplayName);
			return new ItemTile(record, ((Component)val).gameObject, component2, component, (TMP_Text)(object)val2, component3, ((Component)val3).gameObject, itemFavoriteTrigger, itemSpawnTrigger);
		}
	}
	internal sealed class ItemBrowserController
	{
		private const double CatalogWorkBudgetMilliseconds = 1.25;

		private const double TileWorkBudgetMilliseconds = 1.25;

		private const int MaximumItemsPerFrame = 2;

		private const double SearchIndexWorkBudgetMilliseconds = 1.25;

		private readonly ManualLogSource _logger;

		private readonly ModConfig _settings;

		private readonly FavoriteStore _favorites;

		private readonly ItemBrowserSession _session;

		private readonly ItemSpawnerView _view;

		private readonly PlayerTargetController _targetController;

		private readonly Func<string, string> _localize;

		private readonly GameItemCatalog _catalog;

		private readonly RefreshState _refresh = new RefreshState();

		private int _aliasProviderVersion;

		private float _nextRebuildAttempt;

		public bool IsRebuilding => _refresh.IsRebuilding;

		public bool HasPendingRefresh => _refresh.Pending != RefreshRequirement.None;

		public bool HasPendingCatalogRefresh => (_refresh.Pending & RefreshRequirement.Catalog) != 0;

		public bool AliasProvidersChanged => _aliasProviderVersion != SearchAliasRegistry.Version;

		public ItemBrowserController(ManualLogSource logger, ModConfig settings, FavoriteStore favorites, ItemBrowserSession session, ItemSpawnerView view, PlayerTargetController targetController, Func<string, string> localize)
		{
			_logger = logger;
			_settings = settings;
			_favorites = favorites;
			_session = session;
			_view = view;
			_targetController = targetController;
			_localize = localize;
			_catalog = new GameItemCatalog(logger, () => settings.ShowAllItems, favorites.IsFavorite);
		}

		public bool CanAttemptRebuild(float currentTime)
		{
			return currentTime >= _nextRebuildAttempt;
		}

		public bool IsCatalogCurrent()
		{
			return _catalog.IsCurrent();
		}

		public void InitializeView()
		{
			if (_settings.SingleTagSelection)
			{
				_session.SelectedTags = ItemTagSelection.NormalizeSingle(_session.SelectedTags);
			}
			_view.SetSelectedTags(_session.SelectedTags);
		}

		public void RequestRefresh(RefreshRequirement requirement)
		{
			_refresh.Request(requirement);
		}

		public void AbortRebuild()
		{
			_refresh.Abort();
		}

		public IEnumerator RebuildRequiredIncrementally()
		{
			_view.SetFavoriteEnabled(enabled: false);
			_view.SetStatus("...", isError: false);
			if ((_refresh.Pending & RefreshRequirement.Catalog) != RefreshRequirement.None)
			{
				_refresh.Begin(RebuildPhase.Catalog);
				yield return RebuildCatalogIncrementally();
				if ((_refresh.Pending & RefreshRequirement.Catalog) != RefreshRequirement.None)
				{
					CompleteRebuild(failed: true);
					yield break;
				}
				yield return null;
				if (_targetController.Refresh(force: true))
				{
					RefreshStatus();
				}
			}
			if ((_refresh.Pending & RefreshRequirement.SearchIndex) != RefreshRequirement.None)
			{
				_refresh.Begin(RebuildPhase.SearchIndex);
				yield return RebuildSearchIndexIncrementally();
				if ((_refresh.Pending & RefreshRequirement.SearchIndex) != RefreshRequirement.None)
				{
					CompleteRebuild(failed: true);
					yield break;
				}
			}
			CompleteRebuild(failed: false);
			ApplySearch(_view.SearchText);
		}

		public void ApplySearch(string query)
		{
			if (!IsRebuilding && (_refresh.Pending & RefreshRequirement.SearchIndex) == 0)
			{
				IReadOnlyList<GameItemRecord> results = (from record in _catalog.Search(query)
					where ItemFilterMatcher.Matches(record.Tags, _favorites.IsFavorite(((Object)record.Item).name), _session.SelectedTags, _settings.TagMatchMode)
					select record).ToArray();
				_view.ShowSearchResults(results);
				RefreshStatus();
			}
		}

		public void SetTag(ItemFilterTag tag, bool selected)
		{
			_session.SelectedTags = ItemTagSelection.Update(_session.SelectedTags, tag, selected, _settings.SingleTagSelection);
			_view.SetSelectedTags(_session.SelectedTags);
			ApplySearch(_view.SearchText);
		}

		public void ApplyTagSelectionMode()
		{
			if (_settings.SingleTagSelection)
			{
				ItemFilterTag itemFilterTag = ItemTagSelection.NormalizeSingle(_session.SelectedTags);
				if (itemFilterTag != _session.SelectedTags)
				{
					_session.SelectedTags = itemFilterTag;
					_view.SetSelectedTags(itemFilterTag);
					ApplySearch(_view.SearchText);
				}
			}
		}

		public void ClearTags()
		{
			if (_session.SelectedTags != ItemFilterTag.None)
			{
				_session.SelectedTags = ItemFilterTag.None;
				_view.SetSelectedTags(ItemFilterTag.None);
				ApplySearch(_view.SearchText);
			}
		}

		public void RefreshStatus()
		{
			if (IsRebuilding)
			{
				_view.SetStatus("...", isError: false);
			}
			else if (!_targetController.CanSpawn && _view.VisibleItemCount > 0)
			{
				SetStatus(_targetController.ErrorKey, isError: true);
			}
			else
			{
				SetStatus((_view.VisibleItemCount == 0) ? "noItems" : string.Empty, isError: false);
			}
		}

		private IEnumerator RebuildCatalogIncrementally()
		{
			_view.ClearItems();
			IEnumerator rebuildItems = _catalog.RebuildItemsIncrementally(1.25);
			while (true)
			{
				bool flag;
				try
				{
					flag = rebuildItems.MoveNext();
				}
				catch (Exception arg)
				{
					_logger.LogError((object)$"Failed to rebuild the item catalog: {arg}");
					yield break;
				}
				if (!flag)
				{
					break;
				}
				yield return rebuildItems.Current;
			}
			Stopwatch tileBatch = Stopwatch.StartNew();
			int num = 0;
			for (int index = 0; index < _catalog.Items.Count; index++)
			{
				GameItemRecord captured;
				GameItemRecord gameItemRecord = (captured = _catalog.Items[index]);
				try
				{
					_view.AddItem(gameItemRecord, (UnityAction)delegate
					{
						Spawn(captured);
					}, (UnityAction)delegate
					{
						ToggleFavorite(captured);
					}, _favorites.IsFavorite(((Object)gameItemRecord.Item).name));
				}
				catch (Exception arg2)
				{
					_logger.LogError((object)$"Failed to create the item tile for '{((Object)gameItemRecord.Item).name}': {arg2}");
				}
				num++;
				if (index + 1 < _catalog.Items.Count && (num >= 2 || tileBatch.Elapsed.TotalMilliseconds >= 1.25))
				{
					yield return null;
					tileBatch.Restart();
					num = 0;
				}
			}
			_refresh.Complete(RebuildPhase.Catalog);
		}

		private IEnumerator RebuildSearchIndexIncrementally()
		{
			int providerVersion = SearchAliasRegistry.Version;
			IEnumerator rebuild = _catalog.RebuildSearchIndexIncrementally(1.25);
			while (true)
			{
				bool flag;
				try
				{
					flag = rebuild.MoveNext();
				}
				catch (Exception arg)
				{
					_logger.LogError((object)$"Failed to build the item search index: {arg}");
					yield break;
				}
				if (!flag)
				{
					break;
				}
				yield return rebuild.Current;
			}
			_refresh.Complete(RebuildPhase.SearchIndex);
			_aliasProviderVersion = providerVersion;
		}

		private void CompleteRebuild(bool failed)
		{
			_refresh.Finish();
			_nextRebuildAttempt = (failed ? (Time.unscaledTime + 2f) : 0f);
			_view.SetFavoriteEnabled(!failed);
			if (failed)
			{
				_view.SetStatus("...", isError: true);
			}
		}

		private void ToggleFavorite(GameItemRecord record)
		{
			if (!_favorites.TryToggle(((Object)record.Item).name, out var isFavorite))
			{
				SetStatus("favoriteSaveFailed", isError: true);
				return;
			}
			_view.SetFavorite(record, isFavorite);
			if (!isFavorite && !_settings.ShowAllItems && VanillaItemVisibility.IsDefaultHidden(((Object)record.Item).name))
			{
				RequestRefresh(RefreshRequirement.Catalog);
			}
			else
			{
				ApplySearch(_view.SearchText);
			}
		}

		private void Spawn(GameItemRecord record)
		{
			if (_targetController.TrySpawn(record.Item, out string errorKey))
			{
				SetStatus(string.Empty, isError: false);
			}
			else
			{
				SetStatus(errorKey, isError: true);
			}
		}

		private void SetStatus(string key, bool isError)
		{
			_view.SetStatus(string.IsNullOrEmpty(key) ? string.Empty : _localize(key), isError);
		}
	}
	internal sealed class ItemFavoriteTrigger : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		private UnityAction? _onFavorite;

		public bool InteractionEnabled { get; set; }

		public void Configure(UnityAction onFavorite)
		{
			_onFavorite = onFavorite;
		}

		public bool TryInvoke()
		{
			if (!InteractionEnabled)
			{
				return false;
			}
			UnityAction? onFavorite = _onFavorite;
			if (onFavorite != null)
			{
				onFavorite.Invoke();
			}
			return _onFavorite != null;
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 1)
			{
				TryInvoke();
			}
		}
	}
	internal sealed class ItemNameTooltip : MonoBehaviour
	{
		private const float ShowDelaySeconds = 0.2f;

		private const float MaxTextWidth = 380f;

		private const float HorizontalPadding = 24f;

		private const float VerticalPadding = 16f;

		private const float PointerOffset = 18f;

		private const float EdgeMargin = 8f;

		private RectTransform _bounds;

		private RectTransform _visual;

		private TextMeshProUGUI _label;

		private object? _owner;

		private RectTransform? _anchor;

		private string _text = string.Empty;

		private Vector2 _screenPosition;

		private float _showAt;

		private bool _visible;

		public void Configure(RectTransform bounds, RectTransform visual, TextMeshProUGUI label)
		{
			_bounds = bounds;
			_visual = visual;
			_label = label;
			((Component)_visual).gameObject.SetActive(false);
		}

		public void Begin(ItemNameTooltipTrigger owner, string text, Vector2 screenPosition)
		{
			//IL_000f: 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)
			_owner = owner;
			_text = text;
			_screenPosition = screenPosition;
			_anchor = null;
			_showAt = Time.unscaledTime + 0.2f;
			_visible = false;
			((Component)_visual).gameObject.SetActive(false);
		}

		public void BeginAnchored(object owner, string text, RectTransform anchor)
		{
			_owner = owner;
			_text = text;
			_anchor = anchor;
			_showAt = Time.unscaledTime + 0.2f;
			_visible = false;
			((Component)_visual).gameObject.SetActive(false);
		}

		public void Move(ItemNameTooltipTrigger owner, Vector2 screenPosition)
		{
			//IL_000b: 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)
			if (_owner == owner)
			{
				_screenPosition = screenPosition;
				if (_visible)
				{
					PositionVisual();
				}
			}
		}

		public void End(ItemNameTooltipTrigger owner)
		{
			if (_owner == owner)
			{
				Hide();
			}
		}

		public void Hide()
		{
			_owner = null;
			_anchor = null;
			_text = string.Empty;
			_visible = false;
			if ((Object)(object)_visual != (Object)null)
			{
				((Component)_visual).gameObject.SetActive(false);
			}
		}

		private void Update()
		{
			if (_owner != null && !_visible && !(Time.unscaledTime < _showAt))
			{
				Show();
			}
		}

		private void Show()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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)
			if (!string.IsNullOrWhiteSpace(_text))
			{
				((TMP_Text)_label).text = _text;
				Vector2 preferredValues = ((TMP_Text)_label).GetPreferredValues(_text, 380f, 0f);
				float num = Mathf.Min(380f, Mathf.Ceil(preferredValues.x));
				preferredValues = ((TMP_Text)_label).GetPreferredValues(_text, num, 0f);
				_visual.sizeDelta = new Vector2(num + 24f, Mathf.Ceil(preferredValues.y) + 16f);
				((Transform)_visual).SetAsLastSibling();
				((Component)_visual).gameObject.SetActive(true);
				_visible = true;
				if ((Object)(object)_anchor != (Object)null)
				{
					PositionAnchoredVisual();
				}
				else
				{
					PositionVisual();
				}
			}
		}

		private void PositionVisual()
		{
			//IL_0007: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			if (RectTransformUtility.ScreenPointToLocalPointInRectangle(_bounds, _screenPosition, (Camera)null, ref val))
			{
				Rect rect = _bounds.rect;
				Vector2 sizeDelta = _visual.sizeDelta;
				float num = val.x + 18f;
				float num2 = val.y - 18f;
				if (num + sizeDelta.x > ((Rect)(ref rect)).xMax - 8f)
				{
					num = val.x - sizeDelta.x - 18f;
				}
				if (num2 - sizeDelta.y < ((Rect)(ref rect)).yMin + 8f)
				{
					num2 = val.y + sizeDelta.y + 18f;
				}
				num = Mathf.Clamp(num, ((Rect)(ref rect)).xMin + 8f, ((Rect)(ref rect)).xMax - sizeDelta.x - 8f);
				num2 = Mathf.Clamp(num2, ((Rect)(ref rect)).yMin + sizeDelta.y + 8f, ((Rect)(ref rect)).yMax - 8f);
				_visual.anchoredPosition = new Vector2(num, num2);
			}
		}

		private void PositionAnchoredVisual()
		{
			//IL_0033: 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)
			//IL_003d: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_anchor == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				_anchor.GetWorldCorners(array);
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = ((Transform)_bounds).InverseTransformPoint(array[i]);
				}
				Rect rect = _bounds.rect;
				Vector2 sizeDelta = _visual.sizeDelta;
				float x = array[0].x;
				float x2 = array[2].x;
				float y = array[0].y;
				float y2 = array[2].y;
				float num = (x + x2 - sizeDelta.x) * 0.5f;
				float num2 = y2 + 18f + sizeDelta.y;
				if (num2 > ((Rect)(ref rect)).yMax - 8f)
				{
					num2 = y - 18f;
				}
				num = Mathf.Clamp(num, ((Rect)(ref rect)).xMin + 8f, ((Rect)(ref rect)).xMax - sizeDelta.x - 8f);
				num2 = Mathf.Clamp(num2, ((Rect)(ref rect)).yMin + sizeDelta.y + 8f, ((Rect)(ref rect)).yMax - 8f);
				_visual.anchoredPosition = new Vector2(num, num2);
			}
		}

		private void OnDisable()
		{
			Hide();
		}
	}
	internal sealed class ItemNameTooltipTrigger : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerMoveHandler, IPointerExitHandler
	{
		private ItemNameTooltip _tooltip;

		private string _text = string.Empty;

		public void Configure(ItemNameTooltip tooltip, string text)
		{
			_tooltip = tooltip;
			_text = text;
		}

		public void SetText(string text)
		{
			_text = text;
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_tooltip.Begin(this, _text, eventData.position);
		}

		public void OnPointerMove(PointerEventData eventData)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			_tooltip.Move(this, eventData.position);
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_tooltip.End(this);
		}

		private void OnDisable()
		{
			if ((Object)(object)_tooltip != (Object)null)
			{
				_tooltip.End(this);
			}
		}
	}
	internal sealed class ItemSpawnerView
	{
		private readonly TMP_FontAsset _font;

		private readonly CanvasGroup _canvasGroup;

		private readonly TMP_InputField _search;

		private readonly TargetDropdownVisual _targetDropdown;

		private readonly TextMeshProUGUI _title;

		private readonly TextMeshProUGUI _status;

		private readonly RectTransform _itemContent;

		private readonly Button _close;

		private readonly Button _searchClear;

		private readonly ActionButtonVisual _tagClear;

		private readonly ItemNameTooltipTrigger _tagClearTooltip;

		private readonly ItemNameTooltip _tooltip;

		private readonly IReadOnlyList<TagToggle> _tagToggles;

		private readonly ScrollRect _itemScroll;

		private readonly List<ItemTile> _tiles = new List<ItemTile>();

		private readonly List<ItemTile> _visibleTiles = new List<ItemTile>();

		private readonly Dictionary<GameItemRecord, ItemTile> _tileByRecord = new Dictionary<GameItemRecord, ItemTile>();

		private bool? _spawnEnabled;

		private int _visibleItemCount;

		public GameObject Root { get; }

		public Selectable SearchSelectable => (Selectable)(object)_search;

		public string SearchText => _search.text;

		public int VisibleItemCount => _visibleItemCount;

		internal TargetDropdownVisual TargetDropdown => _targetDropdown;

		internal IReadOnlyList<TagToggle> TagToggles => _tagToggles;

		internal ActionButtonVisual TagClear => _tagClear;

		internal ScrollRect ItemScroll => _itemScroll;

		internal RectTransform ItemContent => _itemContent;

		internal IReadOnlyList<ItemTile> VisibleTiles => _visibleTiles;

		private ItemSpawnerView(GameObject root, TMP_FontAsset font, CanvasGroup canvasGroup, TextMeshProUGUI title, TMP_InputField search, TargetDropdownVisual targetDropdown, TextMeshProUGUI status, RectTransform itemContent, Button close, Button searchClear, ActionButtonVisual tagClear, ItemNameTooltipTrigger tagClearTooltip, ItemNameTooltip tooltip, IReadOnlyList<TagToggle> tagToggles, ScrollRect itemScroll)
		{
			Root = root;
			_font = font;
			_canvasGroup = canvasGroup;
			_title = title;
			_search = search;
			_targetDropdown = targetDropdown;
			_status = status;
			_itemContent = itemContent;
			_close = close;
			_searchClear = searchClear;
			_tagClear = tagClear;
			_tagClearTooltip = tagClearTooltip;
			_tooltip = tooltip;
			_tagToggles = tagToggles;
			_itemScroll = itemScroll;
		}

		internal void ShowControllerTooltip(ItemTile tile)
		{
			_tooltip.BeginAnchored(tile, tile.Record.DisplayName, tile.RectTransform);
		}

		internal void HideTooltip()
		{
			_tooltip.Hide();
		}

		public static ItemSpawnerView Create()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ItemSpawnerEnhancedUI", new Type[5]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(CanvasGroup),
				typeof(GraphicRaycaster)
			});
			try
			{
				RectTransform component = val.GetComponent<RectTransform>();
				RuntimeUiFactory.Stretch(component);
				Canvas component2 = val.GetComponent<Canvas>();
				component2.renderMode = (RenderMode)0;
				component2.sortingOrder = 250;
				CanvasScaler component3 = val.GetComponent<CanvasScaler>();
				component3.uiScaleMode = (ScaleMode)1;
				component3.referenceResolution = new Vector2(1920f, 1080f);
				component3.screenMatchMode = (ScreenMatchMode)0;
				component3.matchWidthOrHeight = 0.5f;
				ItemSpawnerViewReferences itemSpawnerViewReferences = ItemSpawnerViewBuilder.Build(component);
				return new ItemSpawnerView(val, itemSpawnerViewReferences.Font, val.GetComponent<CanvasGroup>(), itemSpawnerViewReferences.Title, itemSpawnerViewReferences.Search, itemSpawnerViewReferences.TargetDropdown, itemSpawnerViewReferences.Status, itemSpawnerViewReferences.ItemContent, itemSpawnerViewReferences.Close, itemSpawnerViewReferences.SearchClear, itemSpawnerViewReferences.TagClear, itemSpawnerViewReferences.TagClearTooltip, itemSpawnerViewReferences.Tooltip, itemSpawnerViewReferences.TagToggles, itemSpawnerViewReferences.ItemScroll);
			}
			catch
			{
				val.SetActive(false);
				Object.Destroy((Object)(object)val);
				throw;
			}
		}

		public void Bind(UnityAction close, UnityAction<string> searchChanged, UnityAction<int> targetChanged, Action<ItemFilterTag, bool> tagChanged, UnityAction clearTags)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			((UnityEvent)_close.onClick).AddListener(close);
			((UnityEvent<string>)(object)_search.onValueChanged).AddListener((UnityAction<string>)delegate(string query)
			{
				UpdateSearchClearButton();
				searchChanged.Invoke(query);
			});
			((UnityEvent)_searchClear.onClick).AddListener((UnityAction)delegate
			{
				_search.SetTextWithoutNotify(string.Empty);
				UpdateSearchClearButton();
				searchChanged.Invoke(string.Empty);
				_search.ActivateInputField();
			});
			((UnityEvent)_tagClear.Button.onClick).AddListener((UnityAction)delegate
			{
				_tooltip.Hide();
				clearTags.Invoke();
			});
			((UnityEvent<int>)(object)_targetDropdown.Dropdown.onValueChanged).AddListener(targetChanged);
			foreach (TagToggle tagToggle in _tagToggles)
			{
				TagToggle captured = tagToggle;
				((UnityEvent<bool>)(object)captured.Toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool selected)
				{
					captured.SetActive(selected);
					tagChanged(captured.Tag, selected);
					UpdateTagClearButton();
				});
			}
		}

		public void SetLocalizedChrome(string title, string searchPlaceholder, string clearTagsTooltip, Func<ItemFilterTag, string> tagLabel)
		{
			((TMP_Text)_title).text = title;
			Graphic placeholder = _search.placeholder;
			TMP_Text val = (TMP_Text)(object)((placeholder is TMP_Text) ? placeholder : null);
			if (val != null)
			{
				val.text = searchPlaceholder;
			}
			_tagClearTooltip.SetText(clearTagsTooltip);
			foreach (TagToggle tagToggle in _tagToggles)
			{
				string text = tagLabel(tagToggle.Tag);
				tagToggle.Label.text = text;
			}
		}

		public void ActivateSearch()
		{
			_search.ActivateInputField();
		}

		public void DeactivateSearch()
		{
			_search.DeactivateInputField(false);
		}

		public void SetVisible(bool visible)
		{
			_canvasGroup.alpha = (visible ? 1 : 0);
			_canvasGroup.interactable = visible;
			_canvasGroup.blocksRaycasts = visible;
		}

		public void ClearItems()
		{
			_tooltip.Hide();
			foreach (ItemTile tile in _tiles)
			{
				tile.GameObject.SetActive(false);
				Object.Destroy((Object)(object)tile.GameObject);
			}
			_tiles.Clear();
			_visibleTiles.Clear();
			_tileByRecord.Clear();
			_visibleItemCount = 0;
			_spawnEnabled = null;
		}

		public void AddItem(GameItemRecord record, UnityAction spawn, UnityAction toggleFavorite, bool isFavorite)
		{
			ItemTile itemTile = ItemBrowserControlFactory.CreateItemTile((Transform)(object)_itemContent, _font, record, spawn, toggleFavorite, isFavorite, _tooltip);
			itemTile.SetSpawnEnabled(enabled: false);
			_tiles.Add(itemTile);
			_visibleTiles.Add(itemTile);
			_tileByRecord.Add(record, itemTile);
			_visibleItemCount++;
		}

		public void SetFavorite(GameItemRecord record, bool isFavorite)
		{
			if (_tileByRecord.TryGetValue(record, out ItemTile value))
			{
				value.SetFavorite(isFavorite);
			}
		}

		public void SetFavoriteEnabled(bool enabled)
		{
			foreach (ItemTile tile in _tiles)
			{
				tile.FavoriteTrigger.InteractionEnabled = enabled;
			}
		}

		public void SetSelectedTags(ItemFilterTag selectedTags)
		{
			foreach (TagToggle tagToggle in _tagToggles)
			{
				bool flag = (selectedTags & tagToggle.Tag) != 0;
				tagToggle.Toggle.SetIsOnWithoutNotify(flag);
				tagToggle.SetActive(flag);
			}
			UpdateTagClearButton();
		}

		private void UpdateSearchClearButton()
		{
			((Component)_searchClear).gameObject.SetActive(!string.IsNullOrEmpty(_search.text));
		}

		private void UpdateTagClearButton()
		{
			bool enabled = _tagToggles.Any((TagToggle tagToggle) => tagToggle.Toggle.isOn);
			_tagClear.SetEnabled(enabled);
		}

		public void ShowSearchResults(IReadOnlyList<GameItemRecord> results)
		{
			_tooltip.Hide();
			HashSet<GameItemRecord> hashSet = new HashSet<GameItemRecord>(results);
			foreach (ItemTile tile in _tiles)
			{
				bool flag = hashSet.Contains(tile.Record);
				if (tile.GameObject.activeSelf != flag)
				{
					tile.GameObject.SetActive(flag);
				}
			}
			int num = 0;
			_visibleTiles.Clear();
			for (int i = 0; i < results.Count; i++)
			{
				if (_tileByRecord.TryGetValue(results[i], out ItemTile value))
				{
					if (value.GameObject.transform.GetSiblingIndex() != i)
					{
						value.GameObject.transform.SetSiblingIndex(i);
					}
					_visibleTiles.Add(value);
					num++;
				}
			}
			_visibleItemCount = num;
		}

		public void SetTargets(IReadOnlyList<string> labels, int selectedIndex)
		{
			TMP_Dropdown dropdown = _targetDropdown.Dropdown;
			dropdown.ClearOptions();
			dropdown.AddOptions(((IEnumerable<string>)labels).Select((Func<string, OptionData>)((string label) => new OptionData(label))).ToList());
			dropdown.SetValueWithoutNotify(Math.Max(0, selectedIndex));
			dropdown.RefreshShownValue();
			_targetDropdown.SetEnabled(labels.Count > 0);
		}

		public void SetSpawnEnabled(bool enabled, bool force = false)
		{
			if (!force && _spawnEnabled == enabled)
			{
				return;
			}
			_spawnEnabled = enabled;
			foreach (ItemTile tile in _tiles)
			{
				tile.SetSpawnEnabled(enabled);
			}
		}

		public void SetStatus(string text, bool isError)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_status).text = text;
			((Graphic)_status).color = (isError ? RuntimeUiFactory.Error : RuntimeUiFactory.TextMuted);
		}
	}
	internal static class ItemSpawnerViewBuilder
	{
		public static ItemSpawnerViewReferences Build(RectTransform root)
		{
			//IL_004e: 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_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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: 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_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: 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)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Expected O, but got Unknown
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_051f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			TMP_FontAsset font = ResolveFont();
			RectTransform obj = RuntimeUiFactory.CreateRect("Dim", (Transform)(object)root, typeof(Image));
			RuntimeUiFactory.Stretch(obj);
			((Graphic)((Component)obj).GetComponent<Image>()).color = RuntimeUiFactory.Backdrop;
			RectTransform val = RuntimeUiFactory.CreateRect("Panel", (Transform)(object)root, typeof(Image));
			val.anchorMin = new Vector2(0.5f, 0.5f);
			val.anchorMax = new Vector2(0.5f, 0.5f);
			val.pivot = new Vector2(0.5f, 0.5f);
			val.sizeDelta = new Vector2(1250f, 900f);
			Image component = ((Component)val).GetComponent<Image>();
			RuntimeUiFactory.ApplyRoundedCorners(component);
			((Graphic)component).color = RuntimeUiFactory.Panel;
			TextMeshProUGUI val2 = RuntimeUiFactory.CreateText("Title", (Transform)(object)val, font, 31f, RuntimeUiFactory.TextPrimary, (TextAlignmentOptions)4097);
			((TMP_Text)val2).rectTransform.anchorMin = new Vector2(0f, 1f);
			((TMP_Text)val2).rectTransform.anchorMax = new Vector2(1f, 1f);
			((TMP_Text)val2).rectTransform.pivot = new Vector2(0.5f, 1f);
			((TMP_Text)val2).rectTransform.anchoredPosition = new Vector2(0f, -18f);
			((TMP_Text)val2).rectTransform.sizeDelta = new Vector2(-120f, 48f);
			Button val3 = RuntimeUiFactory.CreateTextButton("Close", (Transform)(object)val, font, "X");
			RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(1f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(1f, 1f);
			component2.anchoredPosition = new Vector2(-16f, -16f);
			component2.sizeDelta = new Vector2(44f, 44f);
			RectTransform obj2 = RuntimeUiFactory.CreateRect("Toolbar", (Transform)(object)val, typeof(HorizontalLayoutGroup));
			obj2.anchorMin = new Vector2(0.5f, 1f);
			obj2.anchorMax = new Vector2(0.5f, 1f);
			obj2.pivot = new Vector2(0.5f, 1f);
			obj2.anchoredPosition = new Vector2(0f, -78f);
			obj2.sizeDelta = new Vector2(1120f, 52f);
			HorizontalLayoutGroup component3 = ((Component)obj2).GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 12f;
			((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = true;
			TMP_InputField val4 = RuntimeUiFactory.CreateInputField((Transform)(object)obj2, font);
			Button searchClear = RuntimeUiFactory.CreateSearchClearButton(((Component)val4).transform);
			TargetDropdownVisual targetDropdown = RuntimeUiFactory.CreateDropdown((Transform)(object)obj2, font);
			RectTransform tagBar = RuntimeUiFactory.CreateRect("Tags", (Transform)(object)val, typeof(HorizontalLayoutGroup));
			tagBar.anchorMin = new Vector2(0.5f, 1f);
			tagBar.anchorMax = new Vector2(0.5f, 1f);
			tagBar.pivot = new Vector2(0.5f, 1f);
			tagBar.anchoredPosition = new Vector2(0f, -148f);
			tagBar.sizeDelta = new Vector2(1120f, 52f);
			HorizontalLayoutGroup component4 = ((Component)tagBar).GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = true;
			TagToggle[] tagToggles = new ItemFilterTag[7]
			{
				ItemFilterTag.Favorite,
				ItemFilterTag.Food,
				ItemFilterTag.Consumable,
				ItemFilterTag.Equipment,
				ItemFilterTag.Deployable,
				ItemFilterTag.Mystical,
				ItemFilterTag.Other
			}.Select((ItemFilterTag tag) => ItemBrowserControlFactory.CreateTagToggle((Transform)(object)tagBar, font, tag)).ToArray();
			(Button Button, RawImage Icon) tuple = RuntimeUiFactory.CreateFilterClearButton((Transform)(object)val);
			Button item = tuple.Button;
			RawImage item2 = tuple.Icon;
			ActionButtonVisual tagClear = new ActionButtonVisual(item, (Image)((Selectable)item).targetGraphic, (Graphic)(object)item2);
			RectTransform component5 = ((Component)item).GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0.5f, 1f);
			component5.anchorMax = new Vector2(0.5f, 1f);
			component5.pivot = new Vector2(0f, 1f);
			component5.anchoredPosition = new Vector2(568f, -148f);
			component5.sizeDelta = new Vector2(44f, 52f);
			TextMeshProUGUI val5 = RuntimeUiFactory.CreateText("Status", (Transform)(object)val, font, 18f, RuntimeUiFactory.TextMuted, (TextAlignmentOptions)4097);
			((TMP_Text)val5).rectTransform.anchorMin = new Vector2(0f, 1f);
			((TMP_Text)val5).rectTransform.anchorMax = new Vector2(1f, 1f);
			((TMP_Text)val5).rectTransform.pivot = new Vector2(0.5f, 1f);
			((TMP_Text)val5).rectTransform.anchoredPosition = new Vector2(0f, -201f);
			((TMP_Text)val5).rectTransform.sizeDelta = new Vector2(-56f, 18f);
			(ScrollRect Scroll, RectTransform Content) tuple2 = RuntimeUiFactory.CreateItemScroll((Transform)(object)val);
			ScrollRect item3 = tuple2.Scroll;
			RectTransform item4 = tuple2.Content;
			RectTransform component6 = ((Component)item3).GetComponent<RectTransform>();
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = Vector2.one;
			component6.offsetMin = new Vector2(24f, 24f);
			component6.offsetMax = new Vector2(-24f, -221f);
			ItemNameTooltip tooltip = ItemBrowserControlFactory.CreateItemTooltip(val, font);
			ItemNameTooltipTrigger itemNameTooltipTrigger = ((Component)item).gameObject.AddComponent<ItemNameTooltipTrigger>();
			itemNameTooltipTrigger.Configure(tooltip, string.Empty);
			return new ItemSpawnerViewReferences(font, val2, val4, targetDropdown, val5, item4, val3, searchClear, tagClear, itemNameTooltipTrigger, tooltip, tagToggles, item3);
		}

		private static TMP_FontAsset ResolveFont()
		{
			if ((Object)(object)FontFallbackSwapper.instance != (Object)null && (Object)(object)FontFallbackSwapper.instance.mainBaseFont != (Object)null)
			{
				return FontFallbackSwapper.instance.mainBaseFont;
			}
			TMP_FontAsset? obj = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset candidate) => ((Object)candidate).name == "DarumaDropOne-Regular SDF")) ?? Resources.FindObjectsOfTypeAll<TMP_FontAsset>().FirstOrDefault();
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("No TextMeshPro font asset is available.");
			}
			return obj;
		}
	}
	internal readonly struct ItemSpawnerViewReferences
	{
		public TMP_FontAsset Font { get; }

		public TextMeshProUGUI Title { get; }

		public TMP_InputField Search { get; }

		public TargetDropdownVisual TargetDropdown { get; }

		public TextMeshProUGUI Status { get; }

		public RectTransform ItemContent { get; }

		public Button Close { get; }

		public Button SearchClear { get; }

		public ActionButtonVisual TagClear { get; }

		public ItemNameTooltipTrigger TagClearTooltip { get; }

		public ItemNameTooltip Tooltip { get; }

		public IReadOnlyList<TagToggle> TagToggles { get; }

		public ScrollRect ItemScroll { get; }

		public ItemSpawnerViewReferences(TMP_FontAsset font, TextMeshProUGUI title, TMP_InputField search, TargetDropdownVisual targetDropdown, TextMeshProUGUI status, RectTransform itemContent, Button close, Button searchClear, ActionButtonVisual tagClear, ItemNameTooltipTrigger tagClearTooltip, ItemNameTooltip tooltip, IReadOnlyList<TagToggle> tagToggles, ScrollRect itemScroll)
		{
			Font = font;
			Title = title;
			Search = search;
			TargetDropdown = targetDropdown;
			Status = status;
			ItemContent = itemContent;
			Close = close;
			SearchClear = searchClear;
			TagClear = tagClear;
			TagClearTooltip = tagClearTooltip;
			Tooltip = tooltip;
			TagToggles = tagToggles;
			ItemScroll = itemScroll;
		}
	}
	internal sealed class ItemSpawnerWindow : MenuWindow
	{
		private static readonly MethodInfo OpenMethod = AccessTools.Method(typeof(MenuWindow), "Open", (Type[])null, (Type[])null);

		private static readonly MethodInfo CloseMethod = AccessTools.Method(typeof(MenuWindow), "Close", (Type[])null, (Type[])null);

		private ManualLogSource _logger;

		private ModConfig _settings;

		private LocalizationCatalog _localization;

		private PlayerTargetController _targetController;

		private ItemSpawnerView _view;

		private ItemBrowserController _browser;

		private ControllerFocusCoordinator _controllerFocus;

		private Coroutine? _rebuildRoutine;

		private Coroutine? _warmUpRoutine;

		private bool _shutdown;

		private WindowInputSource _openInputSource;

		public override bool openOnStart => false;

		public override bool selectOnOpen => false;

		public override Selectable objectToSelectOnOpen => _view.SearchSelectable;

		public override bool closeOnPause => true;

		public override bool closeOnUICancel => false;

		public override bool blocksPlayerInput => true;

		public override bool showCursorWhileOpen => true;

		public override bool autoHideOnClose => true;

		public override GameObject panel => ((Component)this).gameObject;

		public bool IsOpen => ((MenuWindow)this).isOpen;

		public static ItemSpawnerWindow Create(ManualLogSource logger, ModConfig settings, FavoriteStore favorites, ItemBrowserSession browserSession)
		{
			ItemSpawnerView itemSpawnerView = ItemSpawnerView.Create();
			ItemSpawnerWindow itemSpawnerWindow = null;
			try
			{
				itemSpawnerWindow = itemSpawnerView.Root.AddComponent<ItemSpawnerWindow>();
				itemSpawnerWindow.Configure(logger, settings, favorites, browserSession, itemSpawnerView);
				return itemSpawnerWindow;
			}
			catch
			{
				itemSpawnerWindow?.Shutdown();
				itemSpawnerView.Root.SetActive(false);
				Object.Destroy((Object)(object)itemSpawnerView.Root);
				throw;
			}
		}

		public void ToggleWindow(WindowInputSource inputSource)
		{
			try
			{
				if (!((MenuWindow)this).isOpen)
				{
					_openInputSource = inputSource;
				}
				(((MenuWindow)this).isOpen ? CloseMethod : OpenMethod).Invoke(this, null);
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Failed to toggle item spawner window: {arg}");
			}
		}

		public void HandleControllerInput(ItemSpawnerInputSnapshot input)
		{
			_controllerFocus.Tick(input);
		}

		public void Shutdown()
		{
			if (!_shutdown)
			{
				_shutdown = true;
				if (_controllerFocus != null)
				{
					_controllerFocus.Close();
				}
				StopBackgroundWarmUp();
				StopRebuild();
				LocalizedText.OnLangugageChanged = (Action)Delegate.Remove(LocalizedText.OnLangugageChanged, new Action(OnLanguageChanged));
				if (_settings != null)
				{
					_settings.SingleTagSelectionEntry.SettingChanged -= OnSingleTagSelectionChanged;
					_settings.TagMatchModeEntry.SettingChanged -= OnTagMatchModeChanged;
				}
			}
		}

		protected override void Start()
		{
			((MenuWindow)this).Start();
			if (!_shutdown)
			{
				_view.SetVisible(visible: false);
				((MenuWindow)this).panel.SetActive(true);
				_warmUpRoutine = ((MonoBehaviour)this).StartCoroutine(WarmUpInBackground());
			}
		}

		protected override void Update()
		{
			((MenuWindow)this).Update();
			if (!((MenuWindow)this).isOpen)
			{
				return;
			}
			if (_browser.AliasProvidersChanged)
			{
				_browser.RequestRefresh(RefreshRequirement.SearchIndex);
			}
			if (_browser.IsRebuilding)
			{
				return;
			}
			if (_browser.HasPendingRefresh && _browser.CanAttemptRebuild(Time.unscaledTime))
			{
				BeginRequiredRebuild();
			}
			else if (_targetController.IsRefreshDue(Time.unscaledTime))
			{
				if (!_browser.IsCatalogCurrent())
				{
					_browser.RequestRefresh(RefreshRequirement.Catalog);
					BeginRequiredRebuild();
				}
				else if (_targetController.Refresh(force: false))
				{
					_browser.RefreshStatus();
				}
			}
		}

		protected override void OnOpen()
		{
			StopBackgroundWarmUp();
			_view.SetVisible(visible: true);
			((MenuWindow)this).OnOpen();
			bool flag = _browser.HasPendingCatalogRefresh || _browser.IsCatalogCurrent();
			if (!_browser.HasPendingCatalogRefresh && !flag)
			{
				_browser.RequestRefresh(RefreshRequirement.Catalog);
			}
			if (_browser.AliasProvidersChanged)
			{
				_browser.RequestRefresh(RefreshRequirement.SearchIndex);
			}
			if (_browser.HasPendingRefresh)
			{
				BeginRequiredRebuild();
			}
			else
			{
				_targetController.Refresh(force: true);
				_browser.ApplySearch(_view.SearchText);
			}
			if (_openInputSource == WindowInputSource.Controller)
			{
				_view.DeactivateSearch();
				_controllerFocus.OpenWithController();
			}
			else
			{
				_controllerFocus.OpenWithoutController();
				_view.ActivateSearch();
			}
		}

		protected override void OnClose()
		{
			StopRebuild();
			_controllerFocus.Close();
			_view.DeactivateSearch();
			_view.SetVisible(visible: false);
			((MenuWindow)this).OnClose();
		}

		private void Configure(ManualLogSource logger, ModConfig settings, FavoriteStore favorites, ItemBrowserSession browserSession, ItemSpawnerView view)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00bf: Expected O, but got Unknown
			_logger = logger;
			_settings = settings;
			_view = view;
			_localization = new LocalizationCatalog(Assembly.GetExecutingAssembly());
			_targetController = new PlayerTargetController(new PlayerTargetService(logger), view, Localize);
			_browser = new ItemBrowserController(logger, settings, favorites, browserSession, view, _targetController, Localize);
			_view.Bind((UnityAction)delegate
			{
				ToggleWindow(WindowInputSource.Keyboard);
			}, _browser.ApplySearch, OnTargetChanged, _browser.SetTag, new UnityAction(_browser.ClearTags));
			_controllerFocus = new ControllerFocusCoordinator(_view, delegate
			{
				ToggleWindow(WindowInputSource.Controller);
			});
			_browser.InitializeView();
			ApplyLocalizedChrome();
			LocalizedText.OnLangugageChanged = (Action)Delegate.Combine(LocalizedText.OnLangugageChanged, new Action(OnLanguageChanged));
			_settings.SingleTagSelectionEntry.SettingChanged += OnSingleTagSelectionChanged;
			_settings.TagMatchModeEntry.SettingChanged += OnTagMatchModeChanged;
		}

		private void BeginRequiredRebuild()
		{
			if (_rebuildRoutine == null && !_browser.IsRebuilding && _browser.HasPendingRefresh)
			{
				_rebuildRoutine = ((MonoBehaviour)this).StartCoroutine(RunRequiredRebuild());
			}
		}

		private IEnumerator WarmUpInBackground()
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			yield return null;
			yield return _browser.RebuildRequiredIncrementally();
			_warmUpRoutine = null;
			stopwatch.Stop();
			_logger.LogInfo((object)($"[Perf:UIWarmUp] Full background warm-up completed in {stopwatch.Elapsed.TotalMilliseconds:F2} ms; " + $"items={_view.VisibleItemCount}."));
			((MenuWindow)this).panel.SetActive(false);
		}

		private void StopBackgroundWarmUp()
		{
			if (_warmUpRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_warmUpRoutine);
				_warmUpRoutine = null;
				if (_browser != null)
				{
					_browser.AbortRebuild();
				}
			}
		}

		private IEnumerator RunRequiredRebuild()
		{
			yield return null;
			yield return _browser.RebuildRequiredIncrementally();
			_rebuildRoutine = null;
		}

		private void StopRebuild()
		{
			if (_rebuildRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_rebuildRoutine);
			}
			_rebuildRoutine = null;
			if (_browser != null)
			{
				_browser.AbortRebuild();
			}
		}

		private void OnTargetChanged(int index)
		{
			if (_targetController.Select(index))
			{
				_browser.RefreshStatus();
			}
		}

		private void OnTagMatchModeChanged(object? sender, EventArgs eventArgs)
		{
			if (((MenuWindow)this).isOpen)
			{
				_browser.ApplySearch(_view.SearchText);
			}
		}

		private void OnSingleTagSelectionChanged(object? sender, EventArgs eventArgs)
		{
			_browser.ApplyTagSelectionMode();
		}

		private void OnLanguageChanged()
		{
			_browser.RequestRefresh(RefreshRequirement.Catalog);
			_targetController.InvalidateLabels();
			ApplyLocalizedChrome();
			if (_warmUpRoutine != null)
			{
				StopBackgroundWarmUp();
				_warmUpRoutine = ((MonoBehaviour)this).StartCoroutine(WarmUpInBackground());
			}
			else if (((MenuWindow)this).isOpen)
			{
				StopRebuild();
				BeginRequiredRebuild();
			}
		}

		private void ApplyLocalizedChrome()
		{
			_view.SetLocalizedChrome(Localize("title"), Localize("searchPlaceholder"), Localize("clearTagsTooltip"), (ItemFilterTag tag) => Localize(tag switch
			{
				ItemFilterTag.Favorite => "tagFavorite", 
				ItemFilterTag.Food => "tagFood", 
				ItemFilterTag.Consumable => "tagConsumable", 
				ItemFilterTag.Equipment => "tagEquipment", 
				ItemFilterTag.Deployable => "tagDeployable", 
				ItemFilterTag.Mystical => "tagMystical", 
				ItemFilterTag.Other => "tagOther", 
				_ => throw new ArgumentOutOfRangeException("tag", tag, null), 
			}));
		}

		private string Localize(string key)
		{
			return _localization.Get(GameLanguage.CurrentCode, key);
		}

		private void OnDestroy()
		{
			Shutdown();
			MenuWindow.AllActiveWindows.Remove((MenuWindow)(object)this);
		}
	}
	internal enum WindowInputSource
	{
		Keyboard,
		Controller
	}
	internal sealed class ItemSpawnTrigger : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler, IPointerExitHandler, ISubmitHandler
	{
		private const float RepeatDelaySeconds = 0.4f;

		private const float RepeatIntervalSeconds = 0.15f;

		private Button _button;

		private UnityAction? _spawn;

		private float _nextSpawnAt;

		private bool _holding;

		public bool SpawnEnabled { get; set; }

		public void Configure(Button button, UnityAction spawn)
		{
			_button = button;
			_spawn = spawn;
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0 && CanSpawn())
			{
				_holding = true;
				_nextSpawnAt = Time.unscaledTime + 0.4f;
				UnityAction? spawn = _spawn;
				if (spawn != null)
				{
					spawn.Invoke();
				}
			}
		}

		public void OnPointerUp(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				_holding = false;
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_holding = false;
		}

		public void OnSubmit(BaseEventData eventData)
		{
			if (CanSpawn())
			{
				UnityAction? spawn = _spawn;
				if (spawn != null)
				{
					spawn.Invoke();
				}
			}
		}

		public void BeginControllerHold()
		{
			if (CanSpawn())
			{
				_holding = true;
				_nextSpawnAt = Time.unscaledTime + 0.4f;
				UnityAction? spawn = _spawn;
				if (spawn != null)
				{
					spawn.Invoke();
				}
			}
		}

		public void EndControllerHold()
		{
			_holding = false;
		}

		private void Update()
		{
			if (!_holding)
			{
				return;
			}
			if (!CanSpawn())
			{
				_holding = false;
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (!(unscaledTime < _nextSpawnAt))
			{
				_nextSpawnAt = unscaledTime + 0.15f;
				UnityAction? spawn = _spawn;
				if (spawn != null)
				{
					spawn.Invoke();
				}
			}
		}

		private bool CanSpawn()
		{
			if (SpawnEnabled && (Object)(object)_button != (Object)null)
			{
				return ((UIBehaviour)_button).IsActive();
			}
			return false;
		}

		private void OnDisable()
		{
			_holding = false;
		}
	}
	internal sealed class ItemTile
	{
		private readonly Image _background;

		private readonly TMP_Text _label;

		private readonly RawImage _icon;

		private readonly Image _focusFrame;

		private readonly ControlInteractionState _interaction;

		private bool _canSpawn;

		public GameItemRecord Record { get; }

		public GameObject GameObject { get; }

		public Button Button { get; }

		public GameObject FavoriteMarker { get; }

		public ItemFavoriteTrigger FavoriteTrigger { get; }

		public ItemSpawnTrigger SpawnTrigger { get; }

		public RectTransform RectTransform => (RectTransform)GameObject.transform;

		public bool CanSpawn => _canSpawn;

		public ItemTile(GameItemRecord record, GameObject gameObject, Button button, Image background, TMP_Text label, RawImage icon, GameObject favoriteMarker, ItemFavoriteTrigger favoriteTrigger, ItemSpawnTrigger spawnTrigger)
		{
			Record = record;
			GameObject = gameObject;
			Button = button;
			_background = background;
			_label = label;
			_icon = icon;
			FavoriteMarker = favoriteMarker;
			FavoriteTrigger = favoriteTrigger;
			SpawnTrigger = spawnTrigger;
			_focusFrame = RuntimeUiFactory.CreateFocusFrame(((Component)button).transform);
			_interaction = ((Component)button).gameObject.AddComponent<ControlInteractionState>();
			_interaction.Changed += Render;
			((Selectable)button).transition = (Transition)0;
			Render();
		}

		public void SetFavorite(bool favorite)
		{
			FavoriteMarker.SetActive(favorite);
		}

		public void SetSpawnEnabled(bool enabled)
		{
			_canSpawn = enabled;
			SpawnTrigger.SpawnEnabled = enabled;
			Render();
		}

		public void SetFocused(bool focused)
		{
			_interaction.SetFocused(focused);
		}

		public void BeginControllerSubmit()
		{
			_interaction.SetControllerPressed(pressed: true);
			SpawnTrigger.BeginControllerHold();
		}

		public void EndControllerSubmit()
		{
			SpawnTrigger.EndControllerHold();
			_interaction.SetControllerPressed(pressed: false);
		}

		public bool TryToggleFavorite()
		{
			return FavoriteTrigger.TryInvoke();
		}

		public bool HasTruncatedName()
		{
			_label.ForceMeshUpdate(false, false);
			return _label.isTextOverflowing;
		}

		private void Render()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			ControlVisualState controlVisualState = ControllerVisualState.ForItem(_canSpawn, _interaction.Focused, _interaction.Hovered, _interaction.Pressed);
			((Graphic)_background).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Background);
			((Graphic)_label).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Foreground);
			((Graphic)_icon).color = new Color(1f, 1f, 1f, _canSpawn ? 1f : 0.55f);
			((Component)_focusFrame).gameObject.SetActive(controlVisualState.ShowFocus);
		}
	}
	internal sealed class PlayerTargetController
	{
		private readonly PlayerTargetService _service;

		private readonly ItemSpawnerView _view;

		private readonly Func<string, string> _localize;

		private readonly List<PlayerTarget> _dropdownTargets = new List<PlayerTarget>();

		private PlayerTarget[] _lastTargets = Array.Empty<PlayerTarget>();

		private int? _manualActorId;

		private float _lastRefresh;

		private bool _labelsDirty = true;

		private bool _updatingDropdown;

		public bool CanSpawn { get; private set; }

		public string ErrorKey { get; private set; } = "noTarget";

		public PlayerTargetController(PlayerTargetService service, ItemSpawnerView view, Func<string, string> localize)
		{
			_service = service;
			_view = view;
			_localize = localize;
		}

		public bool IsRefreshDue(float currentTime)
		{
			return currentTime - _lastRefresh >= 1f;
		}

		public bool Refresh(bool force)
		{
			_lastRefresh = Time.unscaledTime;
			PlayerTargetSnapshot playerTargetSnapshot = _service.Capture();
			IReadOnlyList<PlayerTarget> targets = playerTargetSnapshot.Targets;
			if (force || _labelsDirty || !TargetsEqual(targets, _lastTargets))
			{
				_lastTargets = targets.ToArray();
				_labelsDirty = false;
				UpdateDropdown(targets);
				force = true;
			}
			return UpdateSpawnState(playerTargetSnapshot, force);
		}

		public bool Select(int index)
		{
			if (_updatingDropdown)
			{
				return false;
			}
			_manualActorId = ((index > 0 && index <= _dropdownTargets.Count) ? new int?(_dropdownTargets[index - 1].ActorId) : ((int?)null));
			return UpdateSpawnState(_service.Capture(), force: false);
		}

		public bool TrySpawn(Item item, out string errorKey)
		{
			return _service.TrySpawn(item, _manualActorId, out errorKey);
		}

		public void InvalidateLabels()
		{
			_labelsDirty = true;
		}

		private void UpdateDropdown(IReadOnlyList<PlayerTarget> current)
		{
			_dropdownTargets.Clear();
			_dropdownTargets.AddRange(current.Where((PlayerTarget target) => target.IsSelectable));
			if (_manualActorId.HasValue && _dropdownTargets.All((PlayerTarget target) => target.ActorId != _manualActorId.Value))
			{
				_manualActorId = null;
			}
			Dictionary<string, int> duplicateNames = _dropdownTargets.GroupBy<PlayerTarget, string>((PlayerTarget target) => target.Name, StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, PlayerTarget>, string, int>((IGrouping<string, PlayerTarget> group) => group.Key, (IGrouping<string, PlayerTarget> group) => group.Count(), StringComparer.OrdinalIgnoreCase);
			List<string> list = new List<string> { _localize("smartTarget") };
			list.AddRange(_dropdownTargets.Select(delegate(PlayerTarget target)
			{
				string text = ((duplicateNames[target.Name] > 1) ? $"{target.Name} #{target.ActorId}" : target.Name);
				if (target.IsLocal)
				{
					text = text + " " + _localize("youSuffix");
				}
				return text;
			}));
			_updatingDropdown = true;
			try
			{
				int selectedIndex = (_manualActorId.HasValue ? (_dropdownTargets.FindIndex((PlayerTarget target) => target.ActorId == _manualActorId.Value) + 1) : 0);
				_view.SetTargets(list, selectedIndex);
			}
			finally
			{
				_updatingDropdown = false;
			}
		}

		private bool UpdateSpawnState(PlayerTargetSnapshot snapshot, bool force)
		{
			bool isConnected = PhotonNetwork.IsConnected;
			bool flag = isConnected && (Object)(object)snapshot.Resolve(_manualActorId) != (Object)null;
			bool num = flag != CanSpawn;
			CanSpawn = flag;
			ErrorKey = (isConnected ? "noTarget" : "notConnected");
			_view.SetSpawnEnabled(flag, force);
			return num || force;
		}

		private static bool TargetsEqual(IReadOnlyList<PlayerTarget> left, IReadOnlyList<PlayerTarget> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			for (int i = 0; i < left.Count; i++)
			{
				PlayerTarget playerTarget = left[i];
				PlayerTarget playerTarget2 = right[i];
				if (playerTarget.ActorId != playerTarget2.ActorId || !string.Equals(playerTarget.Name, playerTarget2.Name, StringComparison.Ordinal) || playerTarget.IsLocal != playerTarget2.IsLocal || playerTarget.IsSpectated != playerTarget2.IsSpectated || playerTarget.IsSelectable != playerTarget2.IsSelectable)
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class RuntimeUiAssets
	{
		private static Texture2D? _heartTexture;

		private static Texture2D? _filterClearTexture;

		private static Texture2D? _searchClearTexture;

		private static Sprite? _roundedRectSprite;

		private static Sprite? _roundedOutlineSprite;

		public static Texture2D HeartTexture => _heartTexture ?? (_heartTexture = CreateHeartTexture());

		public static Texture2D FilterClearTexture => _filterClearTexture ?? (_filterClearTexture = CreateFilterClearTexture());

		public static Texture2D SearchClearTexture => _searchClearTexture ?? (_searchClearTexture = CreateSearchClearTexture());

		public static Sprite RoundedRectSprite => _roundedRectSprite ?? (_roundedRectSprite = CreateRoundedRectSprite());

		public static Sprite RoundedOutlineSprite => _roundedOutlineSprite ?? (_roundedOutlineSprite = CreateRoundedOutlineSprite());

		public static void Release()
		{
			if ((Object)(object)_roundedRectSprite != (Object)null)
			{
				Texture2D texture = _roundedRectSprite.texture;
				Object.Destroy((Object)(object)_roundedRectSprite);
				Object.Destroy((Object)(object)texture);
				_roundedRectSprite = null;
			}
			if ((Object)(object)_roundedOutlineSprite != (Object)null)
			{
				Texture2D texture2 = _roundedOutlineSprite.texture;
				Object.Destroy((Object)(object)_roundedOutlineSprite);
				Object.Destroy((Object)(object)texture2);
				_roundedOutlineSprite = null;
			}
			DestroyTexture(ref _heartTexture);
			DestroyTexture(ref _filterClearTexture);
			DestroyTexture(ref _searchClearTexture);
		}

		private static Texture2D CreateHeartTexture()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0116: 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)
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = "ItemSpawnerEnhanced Heart",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[1024];
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					int num = 0;
					for (int k = 0; k < 4; k++)
					{
						for (int l = 0; l < 4; l++)
						{
							float num2 = (float)j + ((float)l + 0.5f) / 4f;
							float num3 = (float)i + ((float)k + 0.5f) / 4f;
							float num4 = (num2 - 16f) / 11f;
							float num5 = (num3 - 14.5f) / 11f;
							float num6 = num4 * num4 + num5 * num5 - 1f;
							if (num6 * num6 * num6 - num4 * num4 * num5 * num5 * num5 <= 0f)
							{
								num++;
							}
						}
					}
					byte b = (byte)(255 * num / 16);
					array[i * 32 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			return val;
		}

		private static Sprite CreateRoundedRectSprite()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = "ItemSpawnerEnhanced Rounded Rectangle",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[1024];
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(16f, 16f);
			float num = 8f;
			Vector2 val3 = default(Vector2);
			Vector2 val4 = default(Vector2);
			Vector2 val5 = default(Vector2);
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					int num2 = 0;
					for (int k = 0; k < 4; k++)
					{
						for (int l = 0; l < 4; l++)
						{
							((Vector2)(ref val3))..ctor((float)j + ((float)l + 0.5f) / 4f, (float)i + ((float)k + 0.5f) / 4f);
							((Vector2)(ref val4))..ctor(Mathf.Abs(val3.x - val2.x) - num, Mathf.Abs(val3.y - val2.y) - num);
							((Vector2)(ref val5))..ctor(Mathf.Max(val4.x, 0f), Mathf.Max(val4.y, 0f));
							if (((Vector2)(ref val5)).magnitude + Mathf.Min(Mathf.Max(val4.x, val4.y), 0f) - 8f <= 0f)
							{
								num2++;
							}
						}
					}
					byte b = (byte)(255 * num2 / 16);
					array[i * 32 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4(9f, 9f, 9f, 9f));
			((Object)obj).name = "ItemSpawnerEnhanced Rounded Rectangle";
			((Object)obj).hideFlags = (HideFlags)61;
			return obj;
		}

		private static Sprite CreateRoundedOutlineSprite()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(40, 40, (TextureFormat)4, false)
			{
				name = "ItemSpawnerEnhanced Focus Outline",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[1600];
			for (int i = 0; i < 40; i++)
			{
				for (int j = 0; j < 40; j++)
				{
					int num = 0;
					for (int k = 0; k < 4; k++)
					{
						for (int l = 0; l < 4; l++)
						{
							Vector2 point = new Vector2((float)j + ((float)l + 0.5f) / 4f, (float)i + ((float)k + 0.5f) / 4f);
							float num2 = RoundedRectDistance(point, 40f, 10f, 0f);
							float num3 = RoundedRectDistance(point, 40f, 10f, 3.5f);
							if (num2 <= 0f && num3 >= 0f)
							{
								num++;
							}
						}
					}
					byte b = (byte)(255 * num / 16);
					array[i * 40 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 40f, 40f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4(13f, 13f, 13f, 13f));
			((Object)obj).name = "ItemSpawnerEnhanced Focus Outline";
			((Object)obj).hideFlags = (HideFlags)61;
			return obj;
		}

		private static float RoundedRectDistance(Vector2 point, float size, float radius, float inset)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			//IL_0092: 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)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(size * 0.5f, size * 0.5f);
			float num = size - inset * 2f;
			float num2 = Mathf.Max(0f, radius - inset);
			float num3 = num * 0.5f - num2;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(Mathf.Abs(point.x - val.x) - num3, Mathf.Abs(point.y - val.y) - num3);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(Mathf.Max(val2.x, 0f), Mathf.Max(val2.y, 0f));
			return ((Vector2)(ref val3)).magnitude + Mathf.Min(Mathf.Max(val2.x, val2.y), 0f) - num2;
		}

		private static Texture2D CreateFilterClearTexture()
		{
			//IL_0018: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			return CreateLineTexture("ItemSpawnerEnhanced Clear Filters", (Vector2[])(object)new Vector2[16]
			{
				new Vector2(4f, 26f),
				new Vector2(27f, 26f),
				new Vector2(4f, 26f),
				new Vector2(13f, 16f),
				new Vector2(27f, 26f),
				new Vector2(20f, 18f),
				new Vector2(13f, 16f),
				new Vector2(13f, 5f),
				new Vector2(13f, 5f),
				new Vector2(18f, 8f),
				new Vector2(18f, 8f),
				new Vector2(18f, 14f),
				new Vector2(20f, 15f),
				new Vector2(28f, 7f),
				new Vector2(28f, 15f),
				new Vector2(20f, 7f)
			});
		}

		private static Texture2D CreateSearchClearTexture()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0032: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			return CreateLineTexture("ItemSpawnerEnhanced Clear Search", (Vector2[])(object)new Vector2[4]
			{
				new Vector2(7f, 7f),
				new Vector2(25f, 25f),
				new Vector2(25f, 7f),
				new Vector2(7f, 25f)
			});
		}

		private static Texture2D CreateLineTexture(string name, Vector2[] segments)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_00f0: 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)
			//IL_007f: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = name,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[1024];
			Vector2 point = default(Vector2);
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					int num = 0;
					for (int k = 0; k < 4; k++)
					{
						for (int l = 0; l < 4; l++)
						{
							((Vector2)(ref point))..ctor((float)j + ((float)l + 0.5f) / 4f, (float)i + ((float)k + 0.5f) / 4f);
							for (int m = 0; m < segments.Length; m += 2)
							{
								if (DistanceToSegment(point, segments[m], segments[m + 1]) <= 1.35f)
								{
									num++;
									break;
								}
							}
						}
					}
					byte b = (byte)(255 * num / 16);
					array[i * 32 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			return val;
		}

		private static float DistanceToSegment(Vector2 point, Vector2 start, Vector2 end)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0022: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			Vector2 val = end - start;
			float sqrMagnitude = ((Vector2)(ref val)).sqrMagnitude;
			if (sqrMagnitude <= Mathf.Epsilon)
			{
				return Vector2.Distance(point, start);
			}
			float num = Mathf.Clamp01(Vector2.Dot(point - start, val) / sqrMagnitude);
			return Vector2.Distance(point, start + val * num);
		}

		private static void DestroyTexture(ref Texture2D? texture)
		{
			if ((Object)(object)texture != (Object)null)
			{
				Object.Destroy((Object)(object)texture);
			}
			texture = null;
		}
	}
	internal static class RuntimeUiFactory
	{
		internal static readonly Color Backdrop = new Color(0.035f, 0.043f, 0.047f, 0.88f);

		internal static readonly Color Panel = new Color(0.1f, 0.115f, 0.12f, 0.98f);

		internal static readonly Color Surface = new Color(0.16f, 0.175f, 0.18f, 1f);

		internal static readonly Color SurfaceHover = new Color(0.22f, 0.235f, 0.235f, 1f);

		internal static readonly Color Accent = new Color(0.3f, 0.78f, 0.58f, 1f);

		internal static readonly Color TextPrimary = new Color(0.95f, 0.96f, 0.94f, 1f);

		internal static readonly Color TextMuted = new Color(0.68f, 0.71f, 0.69f, 1f);

		internal static readonly Color Error = new Color(0.94f, 0.52f, 0.42f, 1f);

		internal static readonly Color Favorite = new Color(0.95f, 0.38f, 0.52f, 1f);

		internal static readonly Color FocusRing = new Color(1f, 0.78f, 0.25f, 1f);

		internal static readonly Color SurfacePressed = Color.Lerp(SurfaceHover, Accent, 0.25f);

		internal static readonly Color DisabledSurface = new Color(Surface.r * 0.72f, Surface.g * 0.72f, Surface.b * 0.72f, 1f);

		public static RectTransform CreateRect(string name, Transform parent, params Type[] components)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			Type[] array = new Type[components.Length + 1];
			array[0] = typeof(RectTransform);
			Array.Copy(components, 0, array, 1, components.Length);
			GameObject val = new GameObject(name, array);
			val.transform.SetParent(parent, false);
			return (RectTransform)val.transform;
		}

		public static void Stretch(RectTransform rect, float left = 0f, float right = 0f, float bottom = 0f, float top = 0f)
		{
			//IL_0001: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}

		public static void ApplyRoundedCorners(Image image)
		{
			image.sprite = RuntimeUiAssets.RoundedRectSprite;
			image.type = (Type)1;
		}

		public static Image CreateFocusFrame(Transform parent, float outerInset = -5f, float separatorInset = 4f)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRect("ControllerFocus", parent, typeof(Image));
			Stretch(val, outerInset, outerInset, outerInset, outerInset);
			Image component = ((Component)val).GetComponent<Image>();
			component.sprite = RuntimeUiAssets.RoundedOutlineSprite;
			component.type = (Type)1;
			((Graphic)component).color = FocusRing;
			((Graphic)component).raycastTarget = false;
			RectTransform obj = CreateRect("InnerContrast", (Transform)(object)val, typeof(Image));
			Stretch(obj, separatorInset, separatorInset, separatorInset, separatorInset);
			Image component2 = ((Component)obj).GetComponent<Image>();
			component2.sprite = RuntimeUiAssets.RoundedOutlineSprite;
			component2.type = (Type)1;
			((Graphic)component2).color = Panel;
			((Graphic)component2).raycastTarget = false;
			((Component)component).gameObject.SetActive(false);
			((Component)component).transform.SetAsLastSibling();
			return component;
		}

		public static Color ResolvePalette(UiPaletteToken token)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			return (Color)(token switch
			{
				UiPaletteToken.Surface => Surface, 
				UiPaletteToken.SurfaceHover => SurfaceHover, 
				UiPaletteToken.SurfacePressed => SurfacePressed, 
				UiPaletteToken.Accent => Accent, 
				UiPaletteToken.AccentHover => Color.Lerp(Accent, Color.white, 0.12f), 
				UiPaletteToken.Panel => Panel, 
				UiPaletteToken.TextPrimary => TextPrimary, 
				UiPaletteToken.TextMuted => TextMuted, 
				UiPaletteToken.DisabledSurface => DisabledSurface, 
				_ => TextPrimary, 
			});
		}

		public static TextMeshProUGUI CreateText(string name, Transform parent, TMP_FontAsset font, float fontSize, Color color, TextAlignmentOptions alignment)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI component = ((Component)CreateRect(name, parent, typeof(TextMeshProUGUI))).GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).font = font;
			((TMP_Text)component).fontSize = fontSize;
			((Graphic)component).color = color;
			((TMP_Text)component).alignment = alignment;
			((TMP_Text)component).textWrappingMode = (TextWrappingModes)1;
			((TMP_Text)component).overflowMode = (TextOverflowModes)1;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		public static Button CreateTextButton(string name, Transform parent, TMP_FontAsset font, string label)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			RectTransform val = CreateRect(name, parent, typeof(Image), typeof(Button));
			Image component = ((Component)val).GetComponent<Image>();
			ApplyRoundedCorners(component);
			((Graphic)component).color = Surface;
			Button component2 = ((Component)val).GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((Selectable)component2).colors = CreateButtonColors();
			TextMeshProUGUI obj = CreateText("Label", (Transform)(object)val, font, 25f, TextPrimary, (TextAlignmentOptions)514);
			((TMP_Text)obj).text = label;
			Stretch(((TMP_Text)obj).rectTransform, 4f, 4f, 2f, 2f);
			return component2;
		}

		public static TMP_InputField CreateInputField(Transform parent, TMP_FontAsset font)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRect("Search", parent, typeof(Image), typeof(TMP_InputField), typeof(LayoutElement));
			Image component = ((Component)val).GetComponent<Image>();
			ApplyRoundedCorners(component);
			((Graphic)component).color = Surface;
			LayoutElement component2 = ((Component)val).GetComponent<LayoutElement>();
			component2.minWidth = 420f;
			component2.preferredWidth = 700f;
			component2.flexibleWidth = 1f;
			component2.minHeight = 52f;
			RectTransform val2 = CreateRect("Text Area", (Transform)(object)val, typeof(RectMask2D));
			Stretch(val2, 18f, 54f, 5f, 5f);
			TextMeshProUGUI val3 = CreateText("Placeholder", (Transform)(object)val2, font, 24f, TextMuted, (TextAlignmentOptions)4097);
			((TMP_Text)val3).fontStyle = (FontStyles)2;
			Stretch(((TMP_Text)val3).rectTransform);
			TextMeshProUGUI val4 = CreateText("Text", (Transform)(object)val2, font, 24f, TextPrimary, (TextAlignmentOptions)4097);
			((TMP_Text)val4).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)val4).overflowMode = (TextOverflowModes)0;
			Stretch(((TMP_Text)val4).rectTransform);
			TMP_InputField component3 = ((Component)val).GetComponent<TMP_InputField>();
			component3.textViewport = val2;
			component3.textComponent = (TMP_Text)(object)val4;
			component3.placeholder = (Graphic)(object)val3;
			component3.lineType = (LineType)0;
			component3.caretColor = Accent;
			component3.selectionColor = new Color(Accent.r, Accent.g, Accent.b, 0.35f);
			component3.customCaretColor = true;
			return component3;
		}

		public static Button CreateSearchClearButton(Transform parent)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_00c1: 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)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRect("ClearSearch", parent, typeof(Image), typeof(Button));
			Image component = ((Component)val).GetComponent<Image>();
			ApplyRoundedCorners(component);
			((Graphic)component).color = Color.white;
			Button component2 = ((Component)val).GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((Selectable)component2).colors = CreateButtonColors();
			RectTransform obj = CreateRect("Icon", (Transform)(object)val, typeof(RawImage));
			Stretch(obj, 9f, 9f, 9f, 9f);
			RawImage component3 = ((Component)obj).GetComponent<RawImage>();
			component3.texture = (Texture)(object)RuntimeUiAssets.SearchClearTexture;
			((Graphic)component3).color = TextPrimary;
			((Graphic)component3).raycastTarget = false;
			val.anchorMin = new Vector2(1f, 0.5f);
			val.anchorMax = new Vector2(1f, 0.5f);
			val.pivot = new Vector2(1f, 0.5f);
			val.anchoredPosition = new Vector2(-6f, 0f);
			val.sizeDelta = new Vector2(40f, 40f);
			((Component)component2).gameObject.SetActive(false);
			return component2;
		}

		public static (Button Button, RawImage Icon) CreateFilterClearButton(Transform parent)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRect("ClearTags", parent, typeof(Image), typeof(Button));
			Image component = ((Component)val).GetComponent<Image>();
			ApplyRoundedCorners(component);
			((Graphic)component).color = Surface;
			Button component2 = ((Component)val).GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((Selectable)component2).colors = CreateButtonColors();
			RectTransform obj = CreateRect("Icon", (Transform)(object)val, typeof(RawImage));
			Stretch(obj, 8f, 8f, 10f, 10f);
			RawImage component3 = ((Component)obj).GetComponent<RawImage>();
			component3.texture = (Texture)(object)RuntimeUiAssets.FilterClearTexture;
			((Graphic)component3).color = TextPrimary;
			((Graphic)component3).raycastTarget = false;
			return (Button: component2, Icon: component3);
		}

		public static TargetDropdownVisual CreateDropdown(Transform parent, TMP_FontAsset font)
		{
			//IL_0047: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: 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_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRect("Target", parent, typeof(Image), typeof(TMP_Dropdown), typeof(LayoutElement));
			Image component = ((Component)val).GetComponent<Image>();
			ApplyRoundedCorners(component);
			((Graphic)component).color = Surface;
			LayoutElement component2 = ((Component)val).GetComponent<LayoutElement>();
			component2.minWidth = 240f;
			component2.preferredWidth = 280f;
			component2.flexibleWidth = 0f;
			component2.minHeight = 52f;
			TextMeshProUGUI val2 = CreateText("Label", (Transform)(object)val, font, 22f, TextPrimary, (TextAlignmentOptions)4097);
			Stretch(((TMP_Text)val2).rectTransform, 16f, 42f, 3f, 3f);
			TextMeshProUGUI val3 = CreateText("Arrow", (Transform)(object)val, font, 20f, Accent, (TextAlignmentOptions)514);
			((TMP_Text)val3).text = "v";
			((TMP_Text)val3).rectTransform.anchorMin = new Vector2(1f, 0.5f);
			((TMP_Text)val3).rectTransform.anchorMax = new Vector2(1f, 0.5f);
			((TMP_Text)val3).rectTransform.pivot = new Vector2(1f, 0.5f);
			((TMP_Text)val3).rectTransform.anchoredPosition = new Vector2(-10f, 0f);
			((TMP_Text)val3).rectTransform.sizeDelta = new Vector2(30f, 40f);
			RectTransform val4 = CreateRect("Template", (Transform)(object)val, typeof(Image), typeof(ScrollRect));
			val4.anchorMin = new Vector2(0f, 0f);
			val4.anchorMax = new Vector2(1f, 0f);
			val4.pivot = new Vector2(0.5f, 1f);
			val4.anchoredPosition = new Vector2(0f, -4f);
			val4.sizeDelta = new Vector2(0f, 250f);
			Image component3 = ((Component)val4).GetComponent<Image>();
			ApplyRoundedCorners(component3);
			((Graphic)component3).color = new Color(0.08f, 0.09f, 0.095f, 1f);
			RectTransform val5 = CreateRect("Viewport", (Transform)(object)val4, typeof(Image), typeof(Mask));
			Stretch(val5, 4f, 4f, 4f, 4f);
			((Graphic)((Component)val5).GetComponent<Image>()).color = Color.white;
			((Component)val5).GetComponent<Mask>().showMaskGraphic = false;
			RectTransform val6 = CreateRect("Content", (Transform)(object)val5, typeof(VerticalLayoutGroup), typeof(ContentSizeFitter));
			val6.anchorMin = new Vector2(0f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(0.5f, 1f);
			val6.anchoredPosition = Vector2.zero;
			val6.sizeDelta = Vector2.zero;
			VerticalLayoutGroup component4 = ((Component)val6).GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 2f;
			((Component)val6).GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			RectTransform val7 = CreateRect("Item", (Transform)(object)val6, typeof(Toggle), typeof(LayoutElement));
			((Component)val7).GetComponent<LayoutElement>().preferredHeight = 40f;
			RectTransform val8 = CreateRect("Item Background", (Transform)(object)val7, typeof(Image));
			Stretch(val8);
			Image component5 = ((Component)val8).GetComponent<Image>();
			ApplyRoundedCorners(component5);
			((Graphic)component5).color = Surface;
			TextMeshProUGUI val9 = CreateText("Item Label", (Transform)(object)val7, font, 20f, TextPrimary, (TextAlignmentOptions)4097);
			Stretch(((TMP_Text)val9).rectTransform, 14f, 10f, 2f, 2f);
			Toggle component6 = ((Component)val7).GetComponent<Toggle>();
			((Selectable)component6).targetGraphic = (Graphic)(object)((Component)val8).GetComponent<Image>();
			component6.graphic = null;
			((Component)val7).gameObject.AddComponent<DropdownOptionVisual>().Configure(component5, (TMP_Text)(object)val9, component6);
			ScrollRect component7 = ((Component)val4).GetComponent<ScrollRect>();
			component7.content = val6;
			component7.viewport = val5;
			component7.horizontal = false;
			component7.vertical = true;
			component7.movementType = (MovementType)2;
			component7.scrollSensitivity = 25f;
			TMP_Dropdown component8 = ((Component)val).GetComponent<TMP_Dropdown>();
			((Selectable)component8).targetGraphic = (Graphic)(object)((Component)val).GetComponent<Image>();
			component8.template = val4;
			component8.captionText = (TMP_Text)(object)val2;
			component8.itemText = (TMP_Text)(object)val9;
			component8.options.Clear();
			((Component)val4).gameObject.SetActive(false);
			return new TargetDropdownVisual(component8, component, (TMP_Text)(object)val2, (TMP_Text)(object)val3);
		}

		public static (ScrollRect Scroll, RectTransform Content) CreateItemScroll(Transform parent)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			RectTransform val = CreateRect("Items", parent, typeof(ScrollRect));
			RectTransform val2 = CreateRect("Viewport", (Transform)(object)val, typeof(Image), typeof(Mask));
			Stretch(val2);
			((Graphic)((Component)val2).GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.01f);
			((Component)val2).GetComponent<Mask>().showMaskGraphic = false;
			RectTransform val3 = CreateRect("Content", (Transform)(object)val2, typeof(GridLayoutGroup), typeof(ContentSizeFitter));
			val3.anchorMin = new Vector2(0f, 1f);
			val3.anchorMax = new Vector2(1f, 1f);
			val3.pivot = new Vector2(0.5f, 1f);
			val3.anchoredPosition = Vector2.zero;
			val3.sizeDelta = Vector2.zero;
			GridLayoutGroup component = ((Component)val3).GetComponent<GridLayoutGroup>();
			component.cellSize = new Vector2(176f, 150f);
			component.spacing = new Vector2(12f, 12f);
			((LayoutGroup)component).padding = new RectOffset(4, 4, 4, 4);
			component.constraint = (Constraint)0;
			component.startAxis = (Axis)0;
			((LayoutGroup)component).childAlignment = (TextAnchor)1;
			((Component)val3).GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect component2 = ((Component)val).GetComponent<ScrollRect>();
			component2.viewport = val2;
			component2.content = val3;
			component2.horizontal = false;
			component2.vertical = true;
			component2.movementType = (MovementType)2;
			component2.scrollSensitivity = 40f;
			return (Scroll: component2, Content: val3);
		}

		internal static ColorBlock CreateButtonColors()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_005b: 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)
			ColorBlock defaultColorBlock = ColorBlock.defaultColorBlock;
			((ColorBlock)(ref defaultColorBlock)).normalColor = Surface;
			((ColorBlock)(ref defaultColorBlock)).highlightedColor = SurfaceHover;
			((ColorBlock)(ref defaultColorBlock)).pressedColor = Accent;
			((ColorBlock)(ref defaultColorBlock)).selectedColor = SurfaceHover;
			((ColorBlock)(ref defaultColorBlock)).disabledColor = new Color(Surface.r, Surface.g, Surface.b, 0.45f);
			((ColorBlock)(ref defaultColorBlock)).colorMultiplier = 1f;
			((ColorBlock)(ref defaultColorBlock)).fadeDuration = 0.08f;
			return defaultColorBlock;
		}
	}
	internal sealed class TagToggle
	{
		private readonly Image _background;

		private readonly RawImage? _heart;

		private readonly Image _focusFrame;

		private readonly ControlInteractionState _interaction;

		private bool _active;

		public ItemFilterTag Tag { get; }

		public Toggle Toggle { get; }

		public TMP_Text Label { get; }

		public TagToggle(ItemFilterTag tag, Toggle toggle, Image background, TMP_Text label, RawImage? heart)
		{
			Tag = tag;
			Toggle = toggle;
			_background = background;
			Label = label;
			_heart = heart;
			_focusFrame = RuntimeUiFactory.CreateFocusFrame(((Component)toggle).transform);
			_interaction = ((Component)toggle).gameObject.AddComponent<ControlInteractionState>();
			_interaction.Changed += Render;
			((Selectable)Toggle).transition = (Transition)0;
			Render();
		}

		public void SetActive(bool active)
		{
			_active = active;
			Render();
		}

		public void SetFocused(bool focused)
		{
			_interaction.SetFocused(focused);
		}

		public void SetControllerPressed(bool pressed)
		{
			_interaction.SetControllerPressed(pressed);
		}

		private void Render()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			ControlVisualState controlVisualState = ControllerVisualState.ForTag(_active, _interaction.Focused, _interaction.Hovered, _interaction.Pressed);
			((Graphic)_background).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Background);
			Color color = RuntimeUiFactory.ResolvePalette(controlVisualState.Foreground);
			((Graphic)Label).color = color;
			if ((Object)(object)_heart != (Object)null)
			{
				((Graphic)_heart).color = color;
			}
			((Component)_focusFrame).gameObject.SetActive(controlVisualState.ShowFocus);
		}
	}
	internal sealed class TargetDropdownVisual
	{
		private readonly Image _background;

		private readonly TMP_Text _caption;

		private readonly TMP_Text _arrow;

		private readonly Image _focusFrame;

		private readonly ControlInteractionState _interaction;

		private bool _enabled = true;

		private bool _expanded;

		public TMP_Dropdown Dropdown { get; }

		public bool Expanded => _expanded;

		public bool Enabled => _enabled;

		public TargetDropdownVisual(TMP_Dropdown dropdown, Image background, TMP_Text caption, TMP_Text arrow)
		{
			Dropdown = dropdown;
			_background = background;
			_caption = caption;
			_arrow = arrow;
			_focusFrame = RuntimeUiFactory.CreateFocusFrame(((Component)dropdown).transform);
			_interaction = ((Component)dropdown).gameObject.AddComponent<ControlInteractionState>();
			_interaction.Changed += Render;
			((Selectable)dropdown).transition = (Transition)0;
			Render();
		}

		public void SetFocused(bool focused)
		{
			_interaction.SetFocused(focused && _enabled && !_expanded);
		}

		public void SetExpanded(bool expanded)
		{
			if (_expanded != expanded)
			{
				_expanded = expanded;
				Render();
			}
		}

		public void SetEnabled(bool enabled)
		{
			_enabled = enabled;
			((Selectable)Dropdown).interactable = enabled;
			if (!enabled)
			{
				_interaction.SetFocused(focused: false);
			}
			Render();
		}

		public IReadOnlyList<DropdownOptionVisual> GetVisibleOptions()
		{
			return (from option in ((Component)Dropdown).GetComponentsInChildren<DropdownOptionVisual>(false)
				where ((Component)option).gameObject.activeInHierarchy
				orderby ((Component)option).transform.GetSiblingIndex()
				select option).ToArray();
		}

		private void Render()
		{
			//IL_0048: 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_007e: 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)
			ControlVisualState controlVisualState = ControllerVisualState.ForAction(_enabled, _interaction.Focused && !_expanded, _interaction.Hovered, _interaction.Pressed);
			((Graphic)_background).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Background);
			((Graphic)_caption).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Foreground);
			((Graphic)_arrow).color = (_enabled ? RuntimeUiFactory.Accent : RuntimeUiFactory.TextMuted);
			_arrow.text = (_expanded ? "^" : "v");
			((Component)_focusFrame).gameObject.SetActive(controlVisualState.ShowFocus && !_expanded);
		}
	}
	internal sealed class DropdownOptionVisual : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerDownHandler, IPointerUpHandler
	{
		[SerializeField]
		private Image _background;

		[SerializeField]
		private TMP_Text _label;

		[SerializeField]
		private Toggle _toggle;

		[SerializeField]
		private Image _focusFrame;

		private bool _focused;

		private bool _hovered;

		private bool _pressed;

		private bool _lastCurrent;

		public void Configure(Image background, TMP_Text label, Toggle toggle)
		{
			//IL_0042: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			_background = background;
			_label = label;
			_toggle = toggle;
			_focusFrame = RuntimeUiFactory.CreateFocusFrame(((Component)this).transform, 2f, 3f);
			((Selectable)_toggle).transition = (Transition)0;
			Navigation navigation = ((Selectable)_toggle).navigation;
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)_toggle).navigation = navigation;
			Render();
		}

		public void SetFocused(bool focused)
		{
			if (_focused != focused)
			{
				_focused = focused;
				Render();
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_hovered = true;
			Render();
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_hovered = false;
			_pressed = false;
			Render();
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				_pressed = true;
				Render();
			}
		}

		public void OnPointerUp(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				_pressed = false;
				Render();
			}
		}

		private void OnEnable()
		{
			_focused = false;
			_hovered = false;
			_pressed = false;
			_lastCurrent = (Object)(object)_toggle != (Object)null && _toggle.isOn;
			Render();
		}

		private void Update()
		{
			bool flag = (Object)(object)_toggle != (Object)null && _toggle.isOn;
			if (flag != _lastCurrent)
			{
				_lastCurrent = flag;
				Render();
			}
		}

		private void OnDisable()
		{
			_focused = false;
			_hovered = false;
			_pressed = false;
		}

		private void Render()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_background == (Object)null) && !((Object)(object)_label == (Object)null) && !((Object)(object)_toggle == (Object)null) && !((Object)(object)_focusFrame == (Object)null))
			{
				ControlVisualState controlVisualState = ControllerVisualState.ForTargetOption(_toggle.isOn, _focused, _hovered || _pressed);
				((Graphic)_background).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Background);
				((Graphic)_label).color = RuntimeUiFactory.ResolvePalette(controlVisualState.Foreground);
				((Component)_focusFrame).gameObject.SetActive(controlVisualState.ShowFocus);
			}
		}
	}
}
namespace ItemSpawnerEnhanced.Localization
{
	internal static class GameLanguage
	{
		public static string CurrentCode => ToCode(LocalizedText.CURRENT_LANGUAGE);

		public static string ToCode(Language language)
		{
			//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_0040: Expected I4, but got Unknown
			return (language - 1) switch
			{
				0 => "fr", 
				1 => "it", 
				2 => "de", 
				3 => "es-ES", 
				4 => "es-419", 
				5 => "pt-BR", 
				6 => "ru", 
				7 => "uk", 
				8 => "zh-Hans", 
				9 => "zh-Hant", 
				10 => "ja", 
				11 => "ko", 
				12 => "pl", 
				13 => "tr", 
				_ => "en", 
			};
		}
	}
	internal sealed class LocalizationCatalog
	{
		private readonly Dictionary<string, Dictionary<string, string>> _languages = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);

		public LocalizationCatalog(Assembly assembly)
		{
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				int num = text.IndexOf(".Localization.", StringComparison.Ordinal);
				if (num < 0 || !text.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string key = text.Substring(num + ".Localization.".Length, text.Length - num - ".Localization.".Length - ".json".Length);
				using Stream stream = assembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					continue;
				}
				using StreamReader streamReader = new StreamReader(stream);
				Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(streamReader.ReadToEnd());
				if (dictionary != null)
				{
					_languages[key] = dictionary;
				}
			}
		}

		public string Get(string languageCode, string key)
		{
			if (_languages.TryGetValue(languageCode, out Dictionary<string, string> value) && value.TryGetValue(key, out var value2) && !string.IsNullOrWhiteSpace(value2))
			{
				return value2;
			}
			if (_languages.TryGetValue("en", out Dictionary<string, string> value3) && value3.TryGetValue(key, out var value4))
			{
				return value4;
			}
			return key;
		}
	}
}
namespace ItemSpawnerEnhanced.Core
{
	internal static class ControllerBindingRules
	{
		public static string NormalizeBindingPath(string? path)
		{
			string text = path?.Trim() ?? string.Empty;
			if (!string.Equals(text, "None", StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			return string.Empty;
		}
	}
	internal enum ControllerNavigationDirection
	{
		Left,
		Right,
		Up,
		Down
	}
	internal static class ControllerNavigation
	{
		public static int MoveInGrid(int currentIndex, int itemCount, int columnCount, ControllerNavigationDirection direction)
		{
			if (itemCount <= 0)
			{
				return -1;
			}
			int num = Math.Clamp(currentIndex, 0, itemCount - 1);
			int num2 = Math.Max(1, columnCount);
			int num3 = num / num2;
			int num4 = num % num2;
			switch (direction)
			{
			case ControllerNavigationDirection.Left:
				if (num4 > 0)
				{
					return num - 1;
				}
				break;
			case ControllerNavigationDirection.Right:
				if (num4 + 1 < num2 && num + 1 < itemCount)
				{
					return num + 1;
				}
				break;
			case ControllerNavigationDirection.Up:
				if (num3 > 0)
				{
					return num - num2;
				}
				break;
			case ControllerNavigationDirection.Down:
				return MoveDown(num, num4, itemCount, num2);
			}
			return num;
		}

		public static int FindNearest(float horizontalPosition, IReadOnlyList<float> candidates)
		{
			if (candidates.Count == 0)
			{
				return -1;
			}
			int result = 0;
			float num = Math.Abs(candidates[0] - horizontalPosition);
			for (int i = 1; i < candidates.Count; i++)
			{
				float num2 = Math.Abs(candidates[i] - horizontalPosition);
				if (num2 < num)
				{
					result = i;
					num = num2;
				}
			}
			return result;
		}

		public static int ResolveFallbackIndex(int previousIndex, int itemCount)
		{
			if (itemCount > 0)
			{
				return Math.Clamp(previousIndex, 0, itemCount - 1);
			}
			return -1;
		}

		public static int MoveRegion(int currentRegion, int direction, IReadOnlyList<bool> availableRegions)
		{
			if (availableRegions.Count == 0)
			{
				return -1;
			}
			int num = Math.Clamp(currentRegion, 0, availableRegions.Count - 1);
			if (direction == 0)
			{
				return num;
			}
			int num2 = ((direction >= 0) ? 1 : (-1));
			for (int i = 1; i <= availableRegions.Count; i++)
			{
				int num3 = (num + num2 * i + availableRegions.Count) % availableRegions.Count;
				if (availableRegions[num3])
				{
					return num3;
				}
			}
			return num;
		}

		private static int MoveDown(int current, int column, int itemCount, int columns)
		{
			int num = current + columns;
			if (num < itemCount)
			{
				return num;
			}
			int num2 = itemCount - itemCount % columns;
			if (num2 == itemCount)
			{
				return current;
			}
			if (current >= num2)
			{
				return current;
			}
			if (current < num2 - columns)
			{
				return current;
			}
			int num3 = itemCount - num2;
			return num2 + Math.Min(column, num3 - 1);
		}
	}
	internal enum UiPaletteToken
	{
		Surface,
		SurfaceHover,
		SurfacePressed,
		Accent,
		AccentHover,
		Panel,
		TextPrimary,
		TextMuted,
		DisabledSurface
	}
	internal readonly struct ControlVisualState
	{
		public UiPaletteToken Background { get; }

		public UiPaletteToken Foreground { get; }

		public bool ShowFocus { get; }

		public ControlVisualState(UiPaletteToken background, UiPaletteToken foreground, bool showFocus)
		{
			Background = background;
			Foreground = foreground;
			ShowFocus = showFocus;
		}
	}
	internal static class ControllerVisualState
	{
		public static ControlVisualState ForTag(bool active, bool focused, bool hovered, bool pressed)
		{
			UiPaletteToken background = (pressed ? (active ? UiPaletteToken.AccentHover : UiPaletteToken.SurfacePressed) : ((!active) ? (hovered ? UiPaletteToken.SurfaceHover : UiPaletteToken.Surface) : (hovered ? UiPaletteToken.AccentHover : UiPaletteToken.Accent)));
			return new ControlVisualState(background, active ? UiPaletteToken.Panel : UiPaletteToken.TextPrimary, focused);
		}

		public static ControlVisualState ForTargetOption(bool current, bool focused, bool hovered)
		{
			return new ControlVisualState(current ? UiPaletteToken.Accent : (hovered ? UiPaletteToken.SurfaceHover : UiPaletteToken.Surface), current ? UiPaletteToken.Panel : UiPaletteToken.TextPrimary, focused);
		}

		public static ControlVisualState ForItem(bool canSpawn, bool focused, bool hovered, bool pressed)
		{
			return new ControlVisualState((!canSpawn) ? (hovered ? UiPaletteToken.SurfaceHover : UiPaletteToken.DisabledSurface) : (pressed ? UiPaletteToken.SurfacePressed : (hovered ? UiPaletteToken.SurfaceHover : UiPaletteToken.Surface)), canSpawn ? UiPaletteToken.TextPrimary : UiPaletteToken.TextMuted, focused);
		}

		public static ControlVisualState ForAction(bool enabled, bool focused, bool hovered, bool pressed)
		{
			return new ControlVisualState((!enabled) ? UiPaletteToken.DisabledSurface : (pressed ? UiPaletteToken.SurfacePressed : (hovered ? UiPaletteToken.SurfaceHover : UiPaletteToken.Surface)), enabled ? UiPaletteToken.TextPrimary : UiPaletteToken.TextMuted, enabled && focused);
		}
	}
	internal static class EditDistance
	{
		public static int DamerauLevenshtein(string source, string target, int maximum)
		{
			if (Math.Abs(source.Length - target.Length) > maximum)
			{
				return maximum + 1;
			}
			int[,] array = new int[source.Length + 1, target.Length + 1];
			for (int i = 0; i <= source.Length; i++)
			{
				array[i, 0] = i;
			}
			for (int j = 0; j <= target.Length; j++)
			{
				array[0, j] = j;
			}
			for (int k = 1; k <= source.Length; k++)
			{
				int num = int.MaxValue;
				for (int l = 1; l <= target.Length; l++)
				{
					int num2 = ((source[k - 1] != target[l - 1]) ? 1 : 0);
					int num3 = Math.Min(Math.Min(array[k - 1, l] + 1, array[k, l - 1] + 1), array[k - 1, l - 1] + num2);
					if (k > 1 && l > 1 && source[k - 1] == target[l - 2] && source[k - 2] == target[l - 1])
					{
						num3 = Math.Min(num3, array[k - 2, l - 2] + 1);
					}
					array[k, l] = num3;
					num = Math.Min(num, num3);
				}
				if (num > maximum)
				{
					return maximum + 1;
				}
			}
			return array[source.Length, target.Length];
		}
	}
	internal static class FavoriteItemCodec
	{
		public static string Serialize(IEnumerable<string> itemNames)
		{
			return JsonConvert.SerializeObject((object)itemNames.Where((string value) => !string.IsNullOrWhiteSpace(value)).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string value) => value, StringComparer.Ordinal));
		}

		public static HashSet<string> Deserialize(string serialized)
		{
			return new HashSet<string>((JsonConvert.DeserializeObject<string[]>(serialized) ?? Array.Empty<string>()).Where((string value) => !string.IsNullOrWhiteSpace(value)), StringComparer.Ordinal);
		}
	}
	internal static class ItemCategoryPolicy
	{
		public static ItemFilterTag ApplyConsumptionTags(ItemFilterTag tags, bool consumes, bool hasFoodEvidence)
		{
			if (hasFoodEvidence || tags.HasFlag(ItemFilterTag.Food))
			{
				return (tags | ItemFilterTag.Food) & ~ItemFilterTag.Consumable;
			}
			if (!consumes)
			{
				return tags;
			}
			return tags | ItemFilterTag.Consumable;
		}

		public static ItemFilterTag NormalizeEquipmentTag(ItemFilterTag tags)
		{
			if ((tags & (ItemFilterTag.Food | ItemFilterTag.Deployable)) == 0)
			{
				return tags;
			}
			return tags & ~ItemFilterTag.Equipment;
		}

		public static ItemFilterTag NormalizeConsumableTag(ItemFilterTag tags)
		{
			if (!tags.HasFlag(ItemFilterTag.Deployable))
			{
				return tags;
			}
			return tags & ~ItemFilterTag.Consumable;
		}
	}
	[Flags]
	internal enum ItemFilterTag
	{
		None = 0,
		Favorite = 1,
		Food = 2,
		Consumable = 4,
		Equipment = 8,
		Deployable = 0x10,
		Mystical = 0x20,
		Other = 0x40
	}
	internal enum TagMatchMode
	{
		And,
		Or
	}
	internal static class ItemTagSelection
	{
		public static ItemFilterTag Update(ItemFilterTag selectedTags, ItemFilterTag changedTag, bool selected, bool singleTagSelection)
		{
			if (!selected)
			{
				return selectedTags & ~changedTag;
			}
			if (!singleTagSelection)
			{
				return selectedTags | changedTag;
			}
			return changedTag;
		}

		public static ItemFilterTag NormalizeSingle(ItemFilterTag selectedTags)
		{
			if (selectedTags != ItemFilterTag.None)
			{
				return (ItemFilterTag)((int)selectedTags & (0 - selectedTags));
			}
			return ItemFilterTag.None;
		}
	}
	internal static class ItemFilterMatcher
	{
		public static bool Matches(ItemFilterTag itemTags, bool isFavorite, ItemFilterTag selectedTags, TagMatchMode matchMode)
		{
			if (selectedTags == ItemFilterTag.None)
			{
				return true;
			}
			if (isFavorite)
			{
				itemTags |= ItemFilterTag.Favorite;
			}
			if (matchMode != TagMatchMode.And)
			{
				return (itemTags & selectedTags) != 0;
			}
			return (itemTags & selectedTags) == selectedTags;
		}
	}
	[Flags]
	internal enum RefreshRequirement
	{
		None = 0,
		SearchIndex = 1,
		Catalog = 2
	}
	internal enum RebuildPhase
	{
		Idle,
		Catalog,
		SearchIndex
	}
	internal sealed class RefreshState
	{
		public RefreshRequirement Pending { get; private set; }

		public RebuildPhase Phase { get; private set; }

		public bool IsRebuilding => Phase != RebuildPhase.Idle;

		public RefreshState()
		{
			Request(RefreshRequirement.Catalog);
		}

		public void Request(RefreshRequirement requirement)
		{
			Pending |= requirement;
			if ((requirement & RefreshRequirement.Catalog) != RefreshRequirement.None)
			{
				Pending |= RefreshRequirement.SearchIndex;
			}
		}

		public void Begin(RebuildPhase phase)
		{
			if (phase == RebuildPhase.Idle)
			{
				throw new ArgumentOutOfRangeException("phase");
			}
			Phase = phase;
		}

		public void Complete(RebuildPhase phase)
		{
			if (Phase != phase)
			{
				throw new InvalidOperationException($"Cannot complete {phase} while rebuilding {Phase}.");
			}
			RefreshRequirement pending = Pending;
			Pending = (RefreshRequirement)((int)pending & (phase switch
			{
				RebuildPhase.Catalog => -3, 
				RebuildPhase.SearchIndex => -2, 
				_ => throw new ArgumentOutOfRangeException("phase"), 
			}));
		}

		public void Finish()
		{
			Phase = RebuildPhase.Idle;
		}

		public void Abort()
		{
			Phase = RebuildPhase.Idle;
		}
	}
	internal enum SearchAliasPriority
	{
		Internal = 100,
		Provider = 220,
		English = 260,
		Display = 400
	}
	internal readonly struct SearchAliasValue
	{
		public string Value { get; }

		public SearchAliasPriority Priority { get; }

		public SearchAliasValue(string value, SearchAliasPriority priority)
		{
			Value = value;
			Priority = priority;
		}
	}
	internal sealed class SearchIndex<T>
	{
		private sealed class Entry
		{
			private readonly Alias[] _aliases;

			public T Value { get; }

			public int Order { get; }

			public Entry(T value, int order, IEnumerable<SearchAliasValue> aliases)
			{
				Value = value;
				Order = order;
				_aliases = (from @group in (from alias in aliases
						where !string.IsNullOrWhiteSpace(alias.Value)
						select new Alias(alias.Value, (int)alias.Priority)).GroupBy<Alias, string>((Alias alias) => alias.Compact, StringComparer.Ordinal)
					select @group.OrderByDescending((Alias alias) => alias.Boost).First()).ToArray();
			}

			public int Score(string spacedQuery, string compactQuery)
			{
				int num = -1;
				Alias[] aliases = _aliases;
				foreach (Alias alias in aliases)
				{
					num = Math.Max(num, alias.Score(spacedQuery, compactQuery));
				}
				return num;
			}
		}

		private sealed class Alias
		{
			public string Spaced { get; }

			public string Compact { get; }

			public int Boost { get; }

			public Alias(string value, int boost)
			{
				Spaced = SearchNormalizer.Normalize(value, keepSpaces: true);
				Compact = SearchNormalizer.Normalize(value, keepSpaces: false);
				Boost = boost;
			}

			public int Score(string spacedQuery, string compactQuery)
			{
				if (Compact.Length == 0)
				{
					return -1;
				}
				if (Compact == compactQuery)
				{
					return 10000 + Boost;
				}
				if (Spaced.StartsWith(spacedQuery, StringComparison.Ordinal) || Compact.StartsWith(compactQuery, StringComparison.Ordinal))
				{
					return 8000 + Boost;
				}
				if (Spaced.Split(' ').Any((string token) => token.StartsWith(spacedQuery, StringComparison.Ordinal)))
				{
					return 7000 + Boost;
				}
				if (Spaced.Contains(spacedQuery, StringComparison.Ordinal) || Compact.Contains(compactQuery, StringComparison.Ordinal))
				{
					return 5000 + Boost;
				}
				int num = ((compactQuery.Length >= 4) ? ((compactQuery.Length <= 7) ? 1 : 2) : 0);
				if (num == 0)
				{
					return -1;
				}
				int num2 = EditDistance.DamerauLevenshtein(Compact, compactQuery, num);
				if (num2 > num)
				{
					return -1;
				}
				return 3000 + Boost - num2 * 300;
			}
		}

		internal sealed class Builder
		{
			private readonly List<Entry> _entries = new List<Entry>();

			public void Add(T value, IEnumerable<SearchAliasValue> aliases)
			{
				_entries.Add(new Entry(value, _entries.Count, aliases));
			}

			public SearchIndex<T> Build()
			{
				return new SearchIndex<T>(_entries.ToList());
			}
		}

		private readonly List<Entry> _entries;

		public SearchIndex(IEnumerable<(T Value, IEnumerable<SearchAliasValue> Aliases)> values)
		{
			_entries = values.Select<(T, IEnumerable<SearchAliasValue>), Entry>(((T Value, IEnumerable<SearchAliasValue> Aliases) value, int order) => new Entry(value.Value, order, value.Aliases)).ToList();
		}

		private SearchIndex(List<Entry> entries)
		{
			_entries = entries;
		}

		public IReadOnlyList<T> Search(string? query)
		{
			string spacedQuery = SearchNormalizer.Normalize(query, keepSpaces: true);
			string compactQuery = SearchNormalizer.Normalize(query, keepSpaces: false);
			if (compactQuery.Length == 0)
			{
				return _entries.Select((Entry entry) => entry.Value).ToArray();
			}
			return (from entry in _entries
				select (Entry: entry, Score: entry.Score(spacedQuery, compactQuery)) into result
				where result.Score >= 0
				orderby result.Score descending, result.Entry.Order
				select result.Entry.Value).ToArray();
		}
	}
	internal static class SearchNormalizer
	{
		public static string Normalize(string? value, bool keepSpaces)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			string text = value.Normalize(NormalizationForm.FormKD);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag = false;
			string text2 = text;
			foreach (char c in text2)
			{
				UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(c);
				if ((uint)(unicodeCategory - 5) <= 2u)
				{
					continue;
				}
				if (char.IsLetterOrDigit(c))
				{
					if (keepSpaces && flag && stringBuilder.Length > 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder.Append(char.ToLowerInvariant(c));
					flag = false;
				}
				else if (keepSpaces)
				{
					flag = true;
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal readonly struct TargetCandidate
	{
		public int ActorId { get; }

		public bool IsLocal { get; }

		public bool IsSpectated { get; }

		public bool IsSelectable { get; }

		public bool CanReceiveItem { get; }

		public TargetCandidate(int actorId, bool isLocal, bool isSpectated, bool isSelectable, bool canReceiveItem)
		{
			ActorId = actorId;
			IsLocal = isLocal;
			IsSpectated = isSpectated;
			IsSelectable = isSelectable;
			CanReceiveItem = canReceiveItem;
		}
	}
	internal static class TargetResolver
	{
		public static int? ResolveIndex(IReadOnlyList<TargetCandidate> candidates, int? manualActorId)
		{
			if (manualActorId.HasValue)
			{
				for (int i = 0; i < candidates.Count; i++)
				{
					TargetCandidate targetCandidate = candidates[i];
					if (targetCandidate.ActorId == manualActorId.Value && targetCandidate.IsSelectable)
					{
						return i;
					}
				}
			}
			for (int j = 0; j < candidates.Count; j++)
			{
				TargetCandidate targetCandidate2 = candidates[j];
				if (targetCandidate2.IsSpectated && targetCandidate2.CanReceiveItem)
				{
					return j;
				}
			}
			for (int k = 0; k < candidates.Count; k++)
			{
				TargetCandidate targetCandidate3 = candidates[k];
				if (targetCandidate3.IsLocal && targetCandidate3.CanReceiveItem)
				{
					return k;
				}
			}
			return null;
		}
	}
	internal static class VanillaItemCategories
	{
		private static readonly IReadOnlyDictionary<string, ItemFilterTag> Tags = BuildTags();

		public static IReadOnlyDictionary<string, ItemFilterTag> ReviewedTags => Tags;

		public static ItemFilterTag Resolve(string prefabName)
		{
			if (!Tags.TryGetValue(prefabName, out var value))
			{
				return ItemFilterTag.None;
			}
			return value;
		}

		private static IReadOnlyDictionary<string, ItemFilterTag> BuildTags()
		{
			Dictionary<string, ItemFilterTag> dictionary = new Dictionary<string, ItemFilterTag>(StringComparer.Ordinal);
			Add(dictionary, ItemFilterTag.Food, "Airplane Food", "Beehive", "NestEgg", "Lollipop", "Lollipop_Prop", "Clusterberry Black", "Berrynana Blue", "Shroomberry_Blue", "Berrynana Brown", "Mushroom Lace", "Mushroom Lace Poison", "Mushroom Normie Poison", "Mushroom Normie", "Mushroom Chubby", "Mushroom Cluster Poison", "Mushroom Cluster", "Item_Coconut", "EggTurkey", "EggRaven", "Egg", "Energy Drink", "FortifiedMilk", "FrogLegs", "Prickleberry_Gold", "Granola Bar", "Apple Berry Green", "C_Pawn_f Variant", "C_Bishop_m Variant", "C_Rook_m", "Kingberry Green", "C_Pawn_m", "C_Pawn_f", "C_Bishop_f", "C_Knight", "C_Bishop_m", "C_King", "C_Queen", "C_Rook_f", "C_Rook_f Variant", "Shroomberry_Green", "Item_Coconut_half", "Item_Honeycomb", "Glizzy_CattailVariant", "Glizzy", "Mandrake", "Marshmallow", "Mandrake_Hidden", "MedicinalRoot", "Napberry", "Winterberry Orange", "Berrynana Pink", "Kingberry Purple", "Shroomberry_Purple", "Clusterberry Red", "Apple Berry Red", "Prickleberry_Red", "Shroomberry_Red", "Pepper Berry", "Scorpion", "ScoutCookies", "ScoutCookies_Vanilla", "NestEgg_Raven", "Sports Drink", "EarlyWorm", "Bugfix", "TrailMix", "Berrynana Yellow", "Clusterberry Yellow", "Apple Berry Yellow", "Kingberry Yellow", "Shroomberry_Yellow", "Winterberry Yellow");
			Add(dictionary, ItemFilterTag.Consumable, "AloeVera", "Antidote", "AntiZooka", "Balloon", "BalloonBunch", "Bandages", "HealingDart Variant", "Bugle_Magic", "Candle", "Cure-All", "Cursed Skull", "Dynamite", "Lantern_Faerie", "FirstAidKit", "Flare", "Heat Pack", "Lantern", "PandorasBox", "Parachute", "HealingPuffShroom", "RescueHook", "RescueHook_Infinite", "RitualDagger", "ScoutEffigy", "Bugle_Scoutmaster Variant", "Sunscreen", "BookOfBones", "Torch", "Warp Compass", "Cheat Compass", "Cheat Compass 1", "WarpFungus");
			Add(dictionary, ItemFilterTag.Equipment, "AncientIdol", "Backpack", "Balloon", "BalloonBunch", "Binoculars_Prop", "Binoculars", "Bugle_Prop Variant", "Bugle", "Compass", "Fannypack", "Glider", "Jetpack", "Parasol", "Parasol_Roots Variant", "Parachute", "Pirate Compass", "Rocketpack");
			Add(dictionary, ItemFilterTag.Deployable, "RopeShooterAnti", "Anti-Rope Spool", "BounceShroom", "ChainShooter", "Flag_Plantable_Checkpoint", "CloudFungus", "MagicBean", "ClimbingSpike", "PortableStovetopItem", "RopeShooter", "RopeSpool", "ScoutCannonItem", "ShelfShroom");
			Add(dictionary, ItemFilterTag.Mystical, "AncientIdol", "RopeShooterAnti", "Anti-Rope Spool", "AntiZooka", "Cure-All", "Cursed Skull", "Lantern_Faerie", "PandorasBox", "RitualDagger", "ScoutEffigy", "Amulet_InfiniteStamina", "Amulet_Clone", "ScoutsHonor", "Amulet_SuperJump", "Amulet_Healing", "Bugle_Scoutmaster Variant", "Strange Gem", "BookOfBones", "Warp Compass", "Cheat Compass", "Cheat Compass 1");
			return dictionary;
		}

		private static void Add(IDictionary<string, ItemFilterTag> destination, ItemFilterTag tag, params string[] itemNames)
		{
			foreach (string key in itemNames)
			{
				destination.TryGetValue(key, out var value);
				destination[key] = value | tag;
			}
		}
	}
	internal static class VanillaItemVisibility
	{
		private static readonly HashSet<string> HiddenInternalNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
		{
			"ClimbingChalk", "Clusterberry_UNUSED", "FireWood", "GuidebookPage_13_FirstTeams", "Megaphone", "Mushroom Glow", "Stone", "Cheat Compass", "Cheat Compass 1", "BingBong_Prop Variant",
			"Binoculars_Prop", "Bugle_Prop Variant", "GuidebookPage", "Lollipop_Prop", "Mandrake_Hidden", "Parasol_Roots Variant", "ScoutmasterSoul", "Skull", "Warpsketball", "C_Bishop_f Variant",
			"C_Bishop_f", "C_Bishop_m Variant", "C_Bishop_m", "C_King Variant", "C_King", "C_Knight Variant", "C_Knight", "C_Pawn_f Variant", "C_Pawn_f", "C_Pawn_m Variant",
			"C_Pawn_m", "C_Queen Variant", "C_Queen", "C_Rook_f Variant", "C_Rook_f", "C_Rook_m Variant", "C_Rook_m"
		};

		public static IReadOnlyCollection<string> DefaultHiddenInternalNames => HiddenInternalNames;

		public static bool IsVisible(string internalName, bool showAllItems, bool isFavorite)
		{
			if (!(showAllItems || isFavorite))
			{
				return !IsDefaultHidden(internalName);
			}
			return true;
		}

		public static bool IsDefaultHidden(string internalName)
		{
			return HiddenInternalNames.Contains(internalName);
		}
	}
}
namespace ItemSpawnerEnhanced.Api
{
	public interface ISearchAliasProvider
	{
		string Id { get; }

		bool SupportsLanguage(string languageCode);

		IEnumerable<string> GetAliases(SearchAliasContext context);
	}
	public sealed class SearchAliasContext
	{
		public string ItemId { get; }

		public string UnlocalizedName { get; }

		public string DisplayName { get; }

		public string EnglishName { get; }

		public string LanguageCode { get; }

		public SearchAliasContext(string itemId, string unlocalizedName, string displayName, string englishName, string languageCode)
		{
			ItemId = itemId ?? throw new ArgumentNullException("itemId");
			UnlocalizedName = unlocalizedName ?? string.Empty;
			DisplayName = displayName ?? string.Empty;
			EnglishName = englishName ?? string.Empty;
			LanguageCode = languageCode ?? throw new ArgumentNullException("languageCode");
		}
	}
	public static class SearchAliasRegistry
	{
		private sealed class Registration : IDisposable
		{
			private string? _id;

			public Registration(string id)
			{
				_id = id;
			}

			public void Dispose()
			{
				string text = Interlocked.Exchange(ref _id, null);
				if (text != null)
				{
					Unregister(text);
				}
			}
		}

		private static readonly object Sync = new object();

		private static readonly Dictionary<string, ISearchAliasProvider> Providers = new Dictionary<string, ISearchAliasProvider>(StringComparer.OrdinalIgnoreCase);

		private static int _version;

		internal static int Version => Volatile.Read(in _version);

		public static IDisposable Register(ISearchAliasProvider provider)
		{
			if (provider == null)
			{
				throw new ArgumentNullException("provider");
			}
			string id = provider.Id;
			if (string.IsNullOrWhiteSpace(id))
			{
				throw new ArgumentException("Alias provider ID must not be empty.", "provider");
			}
			lock (Sync)
			{
				if (Providers.ContainsKey(id))
				{
					throw new InvalidOperationException("A search alias provider named '" + id + "' is already registered.");
				}
				Providers.Add(id, provider);
				Interlocked.Increment(ref _version);
			}
			return new Registration(id);
		}

		internal static IReadOnlyList<ISearchAliasProvider> Snapshot()
		{
			lock (Sync)
			{
				return Providers.Values.ToArray();
			}
		}

		internal static void ClearForTests()
		{
			lock (Sync)
			{
				Providers.Clear();
				Interlocked.Exchange(ref _version, 0);
			}
		}

		private static void Unregister(string id)
		{
			lock (Sync)
			{
				if (Providers.Remove(id))
				{
					Interlocked.Increment(ref _version);
				}
			}
		}
	}
}