using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PinRecipe")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PinRecipe")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b7fff297-caca-412c-8cb0-52556a76bd3f")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.3.0.0")]
namespace ValheimRecipePinner;

public class ContainerScanner
{
	public static List<Container> AllContainers = new List<Container>();

	private static readonly HashSet<Container> _containerSet = new HashSet<Container>();

	internal static readonly object ContainerLock = new object();

	public Dictionary<string, int> ContainerCache = new Dictionary<string, int>();

	private static readonly HashSet<int> _processedIDs = new HashSet<int>();

	private readonly List<Container> _snapshotBuffer = new List<Container>();

	private Vector3 _lastScanPos;

	private int _lastItemCount;

	private float _scanTimer;

	private float _moveScanCooldown;

	private const float MovementThresholdSqr = 4f;

	private const float MinMoveScanCooldown = 1f;

	private static volatile bool _isInitializing = false;

	public void InitializeContainers()
	{
		if (!RecipePinnerPlugin.EnableChestScanning.Value)
		{
			DebugLogger.Verbose("InitializeContainers skipped — chest scanning disabled");
			return;
		}
		if (_isInitializing)
		{
			DebugLogger.Verbose("InitializeContainers skipped — already initializing");
			return;
		}
		_isInitializing = true;
		try
		{
			DebugLogger.Verbose("Init containers");
			lock (ContainerLock)
			{
				if (AllContainers.Count > 0)
				{
					DebugLogger.Verbose($"InitializeContainers: list already populated ({AllContainers.Count}), skipping scan");
					return;
				}
				Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
				foreach (Container val in array)
				{
					if ((Object)(object)val != (Object)null && _containerSet.Add(val))
					{
						AllContainers.Add(val);
						if ((Object)(object)((Component)val).GetComponent<ContainerTracker>() == (Object)null)
						{
							((Component)val).gameObject.AddComponent<ContainerTracker>().MyContainer = val;
						}
					}
				}
				DebugLogger.Verbose($"Tracking {AllContainers.Count} containers");
			}
		}
		finally
		{
			_isInitializing = false;
		}
	}

	public static void ClearAll()
	{
		lock (ContainerLock)
		{
			AllContainers.Clear();
			_containerSet.Clear();
			DebugLogger.Verbose("ContainerScanner: all container references cleared");
		}
	}

	public void UpdateScanning()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//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)
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			return;
		}
		_scanTimer += Time.deltaTime;
		_moveScanCooldown += Time.deltaTime;
		bool flag = Vector3.SqrMagnitude(((Component)Player.m_localPlayer).transform.position - _lastScanPos) > 4f && _moveScanCooldown >= 1f;
		float num = (((Object)(object)InventoryGui.instance != (Object)null && (Object)(object)ReflectionHelper.GetCurrentContainer(InventoryGui.instance) != (Object)null) ? 0.5f : RecipePinnerPlugin.ChestScanInterval.Value);
		bool flag2 = _scanTimer >= num;
		if (!flag && !flag2)
		{
			return;
		}
		int num2 = 0;
		foreach (ItemData allItem in ((Humanoid)Player.m_localPlayer).GetInventory().GetAllItems())
		{
			num2 += allItem.m_stack;
		}
		bool flag3 = num2 != _lastItemCount;
		_lastItemCount = num2;
		DebugLogger.Verbose($"Scanning containers - Moved: {flag}, InvChanged: {flag3}, Interval: {flag2}");
		_scanTimer = 0f;
		if (flag)
		{
			_moveScanCooldown = 0f;
		}
		UpdateContainerCache();
	}

	private void UpdateContainerCache()
	{
		//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_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
		ContainerCache.Clear();
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			DebugLogger.Verbose("Cannot scan - player is null");
			return;
		}
		Vector3 position = ((Component)Player.m_localPlayer).transform.position;
		float value = RecipePinnerPlugin.ChestScanRange.Value;
		float num = value * value;
		_snapshotBuffer.Clear();
		lock (ContainerLock)
		{
			_snapshotBuffer.AddRange(AllContainers);
		}
		_processedIDs.Clear();
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		foreach (Container item in _snapshotBuffer)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)((Component)item).transform == (Object)null)
			{
				num3++;
				continue;
			}
			int instanceID = ((Object)item).GetInstanceID();
			if (!_processedIDs.Add(instanceID))
			{
				num3++;
				continue;
			}
			if (Vector3.SqrMagnitude(((Component)item).transform.position - position) > num)
			{
				num3++;
				continue;
			}
			bool flag = true;
			if (ReflectionHelper.CheckContainerAccess != null)
			{
				flag = ReflectionHelper.CheckContainerAccess(item, Player.m_localPlayer.GetPlayerID());
			}
			if (!flag)
			{
				num4++;
				continue;
			}
			Inventory inventory = item.GetInventory();
			if (inventory == null)
			{
				continue;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				string name = allItem.m_shared.m_name;
				if (ContainerCache.TryGetValue(name, out var value2))
				{
					ContainerCache[name] = value2 + allItem.m_stack;
				}
				else
				{
					ContainerCache[name] = allItem.m_stack;
				}
			}
			num2++;
		}
		_lastScanPos = position;
		DebugLogger.Verbose($"Container scan complete - Scanned: {num2}, Skipped: {num3}, AccessDenied: {num4}, UniqueItems: {ContainerCache.Count}");
	}

	[HarmonyPatch(typeof(Container), "Awake")]
	[HarmonyPostfix]
	public static void TrackContainerAwake(Container __instance)
	{
		if ((Object)(object)__instance == (Object)null || !RecipePinnerPlugin.EnableChestScanning.Value)
		{
			return;
		}
		lock (ContainerLock)
		{
			if (_containerSet.Add(__instance))
			{
				AllContainers.Add(__instance);
				(((Component)__instance).gameObject.GetComponent<ContainerTracker>() ?? ((Component)__instance).gameObject.AddComponent<ContainerTracker>()).MyContainer = __instance;
				DebugLogger.Verbose($"New container tracked: {((Object)__instance).name} (Total: {AllContainers.Count})");
			}
		}
	}

	public static void RemoveFromSet(Container c)
	{
		_containerSet.Remove(c);
	}
}
public class ContainerTracker : MonoBehaviour
{
	public Container MyContainer;

	private void OnDestroy()
	{
		if (ContainerScanner.AllContainers != null && (Object)(object)MyContainer != (Object)null)
		{
			lock (ContainerScanner.ContainerLock)
			{
				ContainerScanner.AllContainers.Remove(MyContainer);
				ContainerScanner.RemoveFromSet(MyContainer);
				DebugLogger.Verbose($"Container removed: {((Object)MyContainer).name} (Remaining: {ContainerScanner.AllContainers.Count})");
			}
		}
	}
}
public class DataPersistence
{
	public void SavePins()
	{
		try
		{
			string savePath = GetSavePath();
			if (string.IsNullOrEmpty(savePath))
			{
				DebugLogger.Warning("Cannot save - save path is invalid");
				return;
			}
			RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
			if (recipeManager == null)
			{
				DebugLogger.Warning("Cannot save - RecipeMgr is null");
				return;
			}
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in recipeManager.PinnedRecipeOrder)
			{
				int value3;
				if (!hashSet.Add(item))
				{
					DebugLogger.Warning("Skipping duplicate pin order entry while saving: " + item);
				}
				else if (item.StartsWith("GROUP:"))
				{
					string text = item.Substring(6);
					if (!recipeManager.PinGroups.TryGetValue(text, out var value))
					{
						continue;
					}
					List<string> list2 = new List<string>();
					foreach (string memberRecipeKey in value.MemberRecipeKeys)
					{
						int value2;
						int num = ((!value.MemberCounts.TryGetValue(memberRecipeKey, out value2)) ? 1 : value2);
						list2.Add($"{EscapeSaveValue(memberRecipeKey)}:{num}");
					}
					string text2 = string.Join(",", list2);
					list.Add("GROUP:" + EscapeSaveValue(text) + "|" + text2);
					DebugLogger.Verbose($"Saved group: {text} with {value.MemberRecipeKeys.Count} members");
				}
				else if (recipeManager.PinnedRecipes.TryGetValue(item, out value3))
				{
					list.Add($"{EscapeSaveValue(item)}:{value3}");
				}
			}
			WriteAllLinesAtomically(savePath, list);
			int count = recipeManager.PinGroups.Count;
			DebugLogger.Log($"Saved {list.Count} entries ({list.Count - count} pins, {count} groups) to: {savePath}");
		}
		catch (Exception ex)
		{
			DebugLogger.Error("Failed to save pins", ex);
		}
	}

	public void LoadPins()
	{
		string savePath = GetSavePath();
		if (string.IsNullOrEmpty(savePath))
		{
			DebugLogger.Warning("Cannot load - save path is invalid");
			return;
		}
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager == null)
		{
			DebugLogger.Warning("Cannot load - RecipeMgr is null");
			return;
		}
		if (!File.Exists(savePath))
		{
			DebugLogger.Log("No save file found at: " + savePath);
			return;
		}
		try
		{
			string[] array = File.ReadAllLines(savePath);
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			Dictionary<string, PinGroupData> dictionary2 = new Dictionary<string, PinGroupData>();
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				if (text.StartsWith("GROUP:"))
				{
					string text2 = text.Substring(6);
					int num4 = FindGroupSeparator(text2);
					if (num4 > 0 && num4 < text2.Length - 1)
					{
						string text3 = UnescapeSaveValue(text2.Substring(0, num4).Trim());
						string[] array3 = text2.Substring(num4 + 1).Trim().Split(new char[1] { ',' });
						if (!string.IsNullOrEmpty(text3) && array3.Length >= 2)
						{
							PinGroupData pinGroupData = new PinGroupData
							{
								GroupName = text3
							};
							string[] array4 = array3;
							for (int j = 0; j < array4.Length; j++)
							{
								string text4 = array4[j].Trim();
								if (string.IsNullOrEmpty(text4))
								{
									continue;
								}
								int num5 = text4.LastIndexOf(':');
								if (num5 > 0 && num5 < text4.Length - 1)
								{
									string text5 = UnescapeSaveValue(text4.Substring(0, num5));
									int result = 1;
									int.TryParse(text4.Substring(num5 + 1), out result);
									if (result < 1)
									{
										result = 1;
									}
									pinGroupData.MemberRecipeKeys.Add(text5);
									pinGroupData.MemberCounts[text5] = result;
								}
								else
								{
									string text6 = UnescapeSaveValue(text4);
									pinGroupData.MemberRecipeKeys.Add(text6);
									pinGroupData.MemberCounts[text6] = 1;
								}
							}
							if (pinGroupData.MemberRecipeKeys.Count >= 2)
							{
								string item = "GROUP:" + text3;
								if (!hashSet.Add(item))
								{
									DebugLogger.Warning("Duplicate group entry in save file, keeping first order position and latest data: " + text3);
									num3++;
								}
								else
								{
									list.Add(item);
								}
								dictionary2[text3] = pinGroupData;
								num2++;
								DebugLogger.Verbose($"Loaded group: {text3} with {pinGroupData.MemberRecipeKeys.Count} members");
							}
							else
							{
								DebugLogger.Warning("Group '" + text3 + "' has less than 2 members, skipping");
								num3++;
							}
						}
						else
						{
							DebugLogger.Warning("Invalid group format: " + text);
							num3++;
						}
					}
					else
					{
						DebugLogger.Warning("Invalid group line (missing pipe): " + text);
						num3++;
					}
					continue;
				}
				int num6 = text.LastIndexOf(':');
				if (num6 > 0 && num6 < text.Length - 1)
				{
					string text7 = UnescapeSaveValue(text.Substring(0, num6).Trim());
					if (int.TryParse(text.Substring(num6 + 1).Trim(), out var result2))
					{
						if (!hashSet.Add(text7))
						{
							DebugLogger.Warning("Duplicate pin entry in save file, keeping first order position and latest count: " + text7);
							num3++;
						}
						else
						{
							list.Add(text7);
						}
						dictionary[text7] = result2;
						num++;
					}
					else
					{
						DebugLogger.Warning("Invalid count value in save file: " + text);
						num3++;
					}
				}
				else
				{
					string text8 = UnescapeSaveValue(text.Trim());
					if (!hashSet.Add(text8))
					{
						DebugLogger.Warning("Duplicate legacy pin entry in save file, keeping first order position and latest count: " + text8);
						num3++;
					}
					else
					{
						list.Add(text8);
					}
					dictionary[text8] = 1;
					num++;
				}
			}
			recipeManager.PinnedRecipes.Clear();
			recipeManager.PinGroups.Clear();
			recipeManager.PinnedRecipeOrder.Clear();
			foreach (KeyValuePair<string, int> item2 in dictionary)
			{
				recipeManager.PinnedRecipes[item2.Key] = item2.Value;
			}
			foreach (KeyValuePair<string, PinGroupData> item3 in dictionary2)
			{
				recipeManager.PinGroups[item3.Key] = item3.Value;
			}
			recipeManager.PinnedRecipeOrder.AddRange(list);
			int effectivePinCount = recipeManager.GetEffectivePinCount();
			if (effectivePinCount > RecipePinnerPlugin.MaximumPins.Value)
			{
				int num7 = recipeManager.TrimToMaximumPins(RecipePinnerPlugin.MaximumPins.Value);
				DebugLogger.Warning($"Loaded save exceeded max effective pins ({effectivePinCount} > {RecipePinnerPlugin.MaximumPins.Value}) - trimmed {num7} effective pin(s)");
			}
			DebugLogger.Log($"Loaded {num} pins and {num2} groups from: {savePath} (Errors: {num3})");
		}
		catch (Exception ex)
		{
			DebugLogger.Error("Failed to load pins", ex);
		}
	}

	private void WriteAllLinesAtomically(string savePath, List<string> lines)
	{
		string? directoryName = Path.GetDirectoryName(savePath);
		if (string.IsNullOrEmpty(directoryName))
		{
			throw new IOException("Invalid save directory for path: " + savePath);
		}
		string fileName = Path.GetFileName(savePath);
		string text = Path.Combine(directoryName, $"{fileName}.{Guid.NewGuid():N}.tmp");
		string text2 = savePath + ".bak";
		try
		{
			File.WriteAllLines(text, lines);
			if (File.Exists(savePath))
			{
				if (File.Exists(text2))
				{
					File.Delete(text2);
				}
				File.Replace(text, savePath, text2, ignoreMetadataErrors: true);
			}
			else
			{
				File.Move(text, savePath);
			}
		}
		catch
		{
			try
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
			catch (Exception ex)
			{
				DebugLogger.Warning("Failed to delete temp save file '" + text + "': " + ex.Message);
			}
			throw;
		}
	}

	private static int FindGroupSeparator(string groupContent)
	{
		int num = groupContent.LastIndexOf('|');
		if (num >= 0)
		{
			return num;
		}
		return -1;
	}

	private static string EscapeSaveValue(string value)
	{
		if (string.IsNullOrEmpty(value))
		{
			return string.Empty;
		}
		return value.Replace("%", "%25").Replace("|", "%7C").Replace(",", "%2C")
			.Replace("\r", "%0D")
			.Replace("\n", "%0A");
	}

	private static string UnescapeSaveValue(string value)
	{
		if (string.IsNullOrEmpty(value) || value.IndexOf('%') < 0)
		{
			return value;
		}
		StringBuilder stringBuilder = new StringBuilder(value.Length);
		for (int i = 0; i < value.Length; i++)
		{
			if (value[i] == '%' && i + 2 < value.Length && IsHexDigit(value[i + 1]) && IsHexDigit(value[i + 2]))
			{
				string value2 = value.Substring(i + 1, 2);
				stringBuilder.Append((char)Convert.ToInt32(value2, 16));
				i += 2;
			}
			else
			{
				stringBuilder.Append(value[i]);
			}
		}
		return stringBuilder.ToString();
	}

	private static bool IsHexDigit(char c)
	{
		if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
		{
			if (c >= 'A')
			{
				return c <= 'F';
			}
			return false;
		}
		return true;
	}

	private string GetSavePath()
	{
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			DebugLogger.Verbose("Cannot get save path - local player is null");
			return null;
		}
		string playerName = Player.m_localPlayer.GetPlayerName();
		if (string.IsNullOrWhiteSpace(playerName))
		{
			DebugLogger.Warning("Cannot get save path - player name is empty");
			return null;
		}
		string text = Path.Combine(Paths.ConfigPath, "RecipePinner_Data");
		if (!Directory.Exists(text))
		{
			try
			{
				Directory.CreateDirectory(text);
				DebugLogger.Log("Created save directory: " + text);
			}
			catch (Exception ex)
			{
				DebugLogger.Error("Failed to create save directory: " + text, ex);
				return null;
			}
		}
		string text2 = playerName;
		char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
		foreach (char oldChar in invalidFileNameChars)
		{
			text2 = text2.Replace(oldChar, '_');
		}
		string text3 = Path.Combine(text, text2 + ".txt");
		DebugLogger.Verbose("Save path: " + text3);
		return text3;
	}
}
public static class DebugLogger
{
	private const string Prefix = "[RecipePinner]";

	public static void Log(string message)
	{
		if (IsDebugEnabled())
		{
			Debug.Log((object)("[RecipePinner] " + message));
		}
	}

	public static void Warning(string message)
	{
		Debug.LogWarning((object)("[RecipePinner] " + message));
	}

	public static void Error(string message)
	{
		Debug.LogError((object)("[RecipePinner] " + message));
	}

	public static void Error(string message, Exception ex)
	{
		Debug.LogError((object)("[RecipePinner] " + message + "\nException: " + ex.Message + "\nStackTrace: " + ex.StackTrace));
	}

	public static void Verbose(string message)
	{
		if (IsDebugEnabled())
		{
			Debug.Log((object)("[RecipePinner] [VERBOSE] " + message));
		}
	}

	private static bool IsDebugEnabled()
	{
		if ((Object)(object)RecipePinnerPlugin.Instance != (Object)null && RecipePinnerPlugin.EnableDebugLogging != null)
		{
			return RecipePinnerPlugin.EnableDebugLogging.Value;
		}
		return false;
	}
}
public class LocalizationManager
{
	private readonly RecipePinnerPlugin _plugin;

	private readonly Dictionary<string, string> _localizedText = new Dictionary<string, string>();

	private static readonly Dictionary<string, string> _defaultEnglish = new Dictionary<string, string>
	{
		{ "pinned", "Recipe Pinned!" },
		{ "unpinned", "Pin Removed" },
		{ "list_full", "List Full!" },
		{ "added_more", "Added More: {0}x" },
		{ "decreased", "Decreased: {0}x" },
		{ "cleared", "Pinned Recipes Cleared" },
		{ "clear_confirm_hotkey", "Press again to clear all pins" },
		{ "max_level", "Max Level Reached" },
		{ "no_upgrade_cost", "No upgrade cost found" },
		{ "gathering_title", "GATHERING LIST" },
		{ "gathering_opened", "Gathering List Opened" },
		{ "gathering_closed", "Gathering List Closed" },
		{ "gathering_empty", "No Recipes Pinned" },
		{ "gathering_hint", "Open/Close: {0}" },
		{ "mypins_title", "MY PINS" },
		{ "mypins_button", "Pins" },
		{ "mypins_empty", "No Recipes Pinned" },
		{ "group_button", "Group" },
		{ "group_confirm", "Confirm" },
		{ "group_cancel", "Cancel" },
		{ "group_name_prompt", "Enter group name:" },
		{ "group_created", "Group Created: {0}" },
		{ "group_disbanded", "Group Disbanded: {0}" },
		{ "group_select_hint", "Select pins to group" },
		{ "group_min_select", "Select at least 2 pins" },
		{ "group_need_more", "At least 2 pins needed to create a group" },
		{ "group_create_failed", "Group could not be created" },
		{ "group_name_exists", "Group '{0}' already exists" },
		{ "disband_button", "Disband" },
		{ "confirm_delete_group", "Delete group \"{0}\" and all member pins?" },
		{ "confirm_delete_pin", "Delete \"{0}\"?" },
		{ "confirm_remove_member", "Remove \"{0}\" from group \"{1}\"?" },
		{ "confirm_button", "Confirm" },
		{ "cancel_button", "Cancel" },
		{ "confirm_disband_group", "Disband group \"{0}\"? Members will become individual pins." },
		{ "clear_button", "Clear" },
		{ "clear_confirm_msg", "Remove all pins?" },
		{ "clear_no_pins", "No pins to clear" },
		{ "group_no_pins", "Not enough pins to group" },
		{ "close_button", "Close" },
		{ "controls_title", "CONTROLS" },
		{ "controls_config_note", "Controls can be changed in\nthe config file." },
		{ "controls_config_note_single", "Controls can be changed in the config file." },
		{ "howto_header", "HOW TO USE" },
		{ "howto_pin", "Hover over a recipe in the crafting menu and press [{0}] to pin it." },
		{ "howto_unpin", "Hold [{0}] and press [{1}] to unpin a recipe." },
		{ "howto_toggle_hud", "Press [{0}] to show or hide the pinned recipe overlay." },
		{ "howto_gathering", "Press [{0}] to open or close the gathering list." },
		{ "howto_next_page", "Press [{0}] to cycle through HUD pages." },
		{ "howto_clear_all", "Press [{0}] to remove all pinned recipes." },
		{ "keybindings_header", "KEY BINDINGS" },
		{ "ctrl_pin", "Pin Recipe" },
		{ "ctrl_unpin", "Unpin  (hold + Pin Recipe key)" },
		{ "ctrl_toggle_hud", "Toggle HUD Visibility" },
		{ "ctrl_gathering", "Toggle Gathering List" },
		{ "ctrl_next_page", "Next HUD Page" },
		{ "ctrl_clear_all", "Clear All Pins" }
	};

	public LocalizationManager(RecipePinnerPlugin plugin)
	{
		_plugin = plugin;
		DebugLogger.Log("LocalizationManager init");
	}

	public void LoadTranslations()
	{
		_localizedText.Clear();
		string text = RecipePinnerPlugin.LanguageOverride?.Value?.Trim();
		if (string.IsNullOrEmpty(text) || text.ToLower() == "auto")
		{
			text = ((Localization.instance == null) ? "English" : Localization.instance.GetSelectedLanguage());
			DebugLogger.Log("Auto-detected language: " + text);
		}
		else
		{
			DebugLogger.Log("Using forced language: " + text);
		}
		string text2 = text;
		char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
		foreach (char oldChar in invalidFileNameChars)
		{
			text2 = text2.Replace(oldChar, '_');
		}
		string text3 = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)_plugin).Info.Location), "RecipePinner_languages", text2 + ".json");
		if (!File.Exists(text3))
		{
			DebugLogger.Log("Language file not found: " + text3 + " - Using default English");
			return;
		}
		try
		{
			string text4 = File.ReadAllText(text3);
			int num = 0;
			string[] array = text4.Split(new string[3] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text5 = array[i].Trim();
				if (string.IsNullOrEmpty(text5) || text5 == "{" || text5 == "}" || !text5.Contains(":"))
				{
					continue;
				}
				string[] array2 = text5.Split(new char[1] { ':' }, 2);
				if (array2.Length == 2)
				{
					string text6 = array2[0].Trim(',', '"', ' ', '\t', '\r');
					string text7 = array2[1].Trim(',', '"', ' ', '\t', '\r');
					text7 = text7.Replace("\\\"", "\"").Replace("\\n", "\n").Replace("\\t", "\t")
						.Replace("\\\\", "\\");
					if (!string.IsNullOrEmpty(text6) && !string.IsNullOrEmpty(text7))
					{
						_localizedText[text6] = text7;
						num++;
					}
				}
			}
			DebugLogger.Log($"Loaded {num} translations from: {text}.json");
		}
		catch (Exception ex)
		{
			DebugLogger.Error("Failed to load language file: " + text3, ex);
		}
	}

	public string GetText(string key)
	{
		if (_localizedText.TryGetValue(key, out var value))
		{
			DebugLogger.Verbose("Translation found for '" + key + "': " + value);
			return value;
		}
		if (_defaultEnglish.TryGetValue(key, out var value2))
		{
			DebugLogger.Verbose("Using default English for '" + key + "': " + value2);
			return value2;
		}
		DebugLogger.Warning("No translation found for key: " + key);
		return key;
	}
}
public class PinnedRecipeData
{
	public Recipe RecipeRef;

	public string RawName;

	public string CachedHeader;

	public Sprite Icon;

	public int StackCount;

	public List<PinnedResData> Resources = new List<PinnedResData>();

	public bool IsDirty = true;

	public bool IsGroup;

	public PinGroupData GroupRef;
}
public class PinnedResData
{
	public string ItemName;

	public string CachedName;

	public Sprite Icon;

	public int RequiredAmount;

	public int LastKnownAmount;

	public int LastKnownInvAmount;

	public string CachedAmountString;
}
public class PinGroupData
{
	public string GroupName;

	public List<string> MemberRecipeKeys = new List<string>();

	public Dictionary<string, int> MemberCounts = new Dictionary<string, int>();

	public List<PinnedRecipeData> MemberPins = new List<PinnedRecipeData>();

	public List<PinnedResData> MergedResources = new List<PinnedResData>();

	public List<Sprite> MemberIcons = new List<Sprite>();

	public bool IsDirty = true;
}
public class RecipeManager
{
	public Dictionary<string, int> PinnedRecipes = new Dictionary<string, int>();

	public List<string> PinnedRecipeOrder = new List<string>();

	public List<PinnedRecipeData> CachedPins = new List<PinnedRecipeData>();

	public Dictionary<string, PinGroupData> PinGroups = new Dictionary<string, PinGroupData>();

	private readonly Dictionary<string, Recipe> _fakeRecipeCache = new Dictionary<string, Recipe>();

	private static readonly Regex CleanNameRegex = new Regex("<.*?>", RegexOptions.Compiled);

	private static readonly Regex AmountSuffixRegex = new Regex("\\s*[xX]?\\s*\\d+$", RegexOptions.Compiled);

	private static readonly Regex UpgradeStarRegex = new Regex("\\s*★(\\d+)$", RegexOptions.Compiled);

	private static readonly Dictionary<Type, FieldInfo> _cachedRecipeFields = new Dictionary<Type, FieldInfo>();

	private static readonly Dictionary<Type, PropertyInfo> _cachedRecipeProps = new Dictionary<Type, PropertyInfo>();

	private static readonly Dictionary<Type, FieldInfo> _cachedItemFields = new Dictionary<Type, FieldInfo>();

	private static readonly Dictionary<Type, PropertyInfo> _cachedItemProps = new Dictionary<Type, PropertyInfo>();

	private static readonly Dictionary<Type, PropertyInfo> _cachedElementProps = new Dictionary<Type, PropertyInfo>();

	private static readonly Dictionary<Type, FieldInfo> _cachedElementFields = new Dictionary<Type, FieldInfo>();

	private static readonly HashSet<Type> _elementLookupFailed = new HashSet<Type>();

	public void Cleanup()
	{
		DebugLogger.Log("RecipeManager cleanup");
		int count = _fakeRecipeCache.Count;
		foreach (Recipe value in _fakeRecipeCache.Values)
		{
			if ((Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)value);
			}
		}
		_fakeRecipeCache.Clear();
		DebugLogger.Log($"Cleaned {count} fake recipes");
		PinGroups.Clear();
		_cachedRecipeFields.Clear();
		_cachedRecipeProps.Clear();
		_cachedItemFields.Clear();
		_cachedItemProps.Clear();
		_cachedElementProps.Clear();
		_cachedElementFields.Clear();
		_elementLookupFailed.Clear();
	}

	public void RefreshRecipeCache()
	{
		DebugLogger.Verbose("Refreshing cache");
		CachedPins.Clear();
		if ((Object)(object)ObjectDB.instance == (Object)null)
		{
			DebugLogger.Warning("ObjectDB null, can't refresh");
			return;
		}
		int num = 0;
		int num2 = 0;
		Dictionary<string, int> dictionary = new Dictionary<string, int>();
		foreach (PinGroupData value9 in PinGroups.Values)
		{
			foreach (string memberRecipeKey in value9.MemberRecipeKeys)
			{
				int value;
				int num3 = ((!value9.MemberCounts.TryGetValue(memberRecipeKey, out value)) ? 1 : value);
				if (dictionary.ContainsKey(memberRecipeKey))
				{
					dictionary[memberRecipeKey] += num3;
				}
				else
				{
					dictionary[memberRecipeKey] = num3;
				}
			}
		}
		Dictionary<string, PinnedRecipeData> dictionary2 = new Dictionary<string, PinnedRecipeData>();
		int num4 = 0;
		foreach (KeyValuePair<string, PinGroupData> pinGroup in PinGroups)
		{
			PinGroupData value2 = pinGroup.Value;
			value2.MemberPins.Clear();
			value2.MergedResources.Clear();
			value2.MemberIcons.Clear();
			value2.IsDirty = true;
			Dictionary<string, PinnedResData> dictionary3 = new Dictionary<string, PinnedResData>();
			foreach (string memberRecipeKey2 in value2.MemberRecipeKeys)
			{
				int value3;
				int count = ((!value2.MemberCounts.TryGetValue(memberRecipeKey2, out value3)) ? 1 : value3);
				Recipe recipeByName = GetRecipeByName(memberRecipeKey2);
				if ((Object)(object)recipeByName == (Object)null)
				{
					DebugLogger.Warning("Group '" + value2.GroupName + "' member not found: " + memberRecipeKey2);
					continue;
				}
				PinnedRecipeData pinnedRecipeData = BuildPinnedRecipeData(recipeByName, memberRecipeKey2, count);
				if (pinnedRecipeData == null)
				{
					continue;
				}
				value2.MemberPins.Add(pinnedRecipeData);
				if ((Object)(object)pinnedRecipeData.Icon != (Object)null && value2.MemberIcons.Count < 4)
				{
					value2.MemberIcons.Add(pinnedRecipeData.Icon);
				}
				foreach (PinnedResData resource in pinnedRecipeData.Resources)
				{
					if (dictionary3.TryGetValue(resource.ItemName, out var value4))
					{
						value4.RequiredAmount += resource.RequiredAmount;
						continue;
					}
					dictionary3[resource.ItemName] = new PinnedResData
					{
						ItemName = resource.ItemName,
						CachedName = resource.CachedName,
						Icon = resource.Icon,
						RequiredAmount = resource.RequiredAmount,
						LastKnownAmount = -1,
						LastKnownInvAmount = -1
					};
				}
			}
			foreach (PinnedResData value10 in dictionary3.Values)
			{
				value2.MergedResources.Add(value10);
			}
			PinnedRecipeData value5 = new PinnedRecipeData
			{
				IsDirty = true,
				RecipeRef = null,
				RawName = value2.GroupName,
				CachedHeader = value2.GroupName,
				Icon = ((value2.MemberIcons.Count > 0) ? value2.MemberIcons[0] : null),
				StackCount = 1,
				Resources = value2.MergedResources,
				IsGroup = true,
				GroupRef = value2
			};
			dictionary2[pinGroup.Key] = value5;
			num4++;
			DebugLogger.Verbose($"Group pin built: {value2.GroupName} ({value2.MemberPins.Count} members, {value2.MergedResources.Count} resources)");
		}
		foreach (string item in GetDisplayPinOrder())
		{
			if (item.StartsWith("GROUP:"))
			{
				string key = item.Substring(6);
				if (dictionary2.TryGetValue(key, out var value6))
				{
					CachedPins.Add(value6);
				}
			}
			else
			{
				if (!PinnedRecipes.TryGetValue(item, out var value7))
				{
					continue;
				}
				if (dictionary.TryGetValue(item, out var value8))
				{
					int num5 = value7 - value8;
					if (num5 <= 0)
					{
						DebugLogger.Verbose($"Skipping grouped recipe (no excess): {item} (claims={value8})");
						continue;
					}
					value7 = num5;
					DebugLogger.Verbose($"Grouped recipe excess for overlay: {item} x{num5} (claims={value8})");
				}
				Recipe recipeByName2 = GetRecipeByName(item);
				if ((Object)(object)recipeByName2 != (Object)null)
				{
					PinnedRecipeData pinnedRecipeData2 = BuildPinnedRecipeData(recipeByName2, item, value7);
					if (pinnedRecipeData2 != null)
					{
						CachedPins.Add(pinnedRecipeData2);
						num++;
					}
					else
					{
						num2++;
					}
				}
				else
				{
					DebugLogger.Warning("Recipe not found: " + item);
					num2++;
				}
			}
		}
		DebugLogger.Log($"Cache refreshed: {num} pins, {num4} groups, {num2} failed");
		if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)RecipePinnerPlugin.Instance != (Object)null)
		{
			RecipePinnerPlugin.Instance.UIMgr.UpdateUI(RecipePinnerPlugin.IsUiVisible);
			RecipePinnerPlugin.Instance.UIMgr.RefreshMyPinsList();
		}
	}

	public List<string> GetDisplayPinOrder()
	{
		List<string> list = new List<string>();
		List<string> list2 = new List<string>();
		HashSet<string> hashSet = new HashSet<string>();
		Dictionary<string, string> dictionary = new Dictionary<string, string>();
		foreach (string item in PinnedRecipeOrder)
		{
			if (!item.StartsWith("GROUP:"))
			{
				continue;
			}
			string text = item.Substring(6);
			if (!PinGroups.TryGetValue(text, out var value))
			{
				continue;
			}
			foreach (string memberRecipeKey in value.MemberRecipeKeys)
			{
				dictionary[memberRecipeKey] = text;
			}
		}
		foreach (string item2 in PinnedRecipeOrder)
		{
			if (item2.StartsWith("GROUP:"))
			{
				string text2 = item2.Substring(6);
				if (PinGroups.ContainsKey(text2))
				{
					list.Add(item2);
					AppendDeferredExcessForGroup(list, list2, hashSet, dictionary, text2);
				}
			}
			else
			{
				if (!PinnedRecipes.TryGetValue(item2, out var value2))
				{
					continue;
				}
				int groupClaimCount = GetGroupClaimCount(item2);
				if (groupClaimCount <= 0)
				{
					list.Add(item2);
				}
				else
				{
					if (value2 <= groupClaimCount)
					{
						continue;
					}
					if (dictionary.ContainsKey(item2))
					{
						if (hashSet.Add(item2))
						{
							list2.Add(item2);
						}
					}
					else
					{
						list.Add(item2);
					}
				}
			}
		}
		foreach (string item3 in list2)
		{
			list.Add(item3);
		}
		return list;
	}

	private static void AppendDeferredExcessForGroup(List<string> displayOrder, List<string> deferredExcess, HashSet<string> deferredSet, Dictionary<string, string> lastClaimingGroup, string groupName)
	{
		int num = 0;
		while (num < deferredExcess.Count)
		{
			string text = deferredExcess[num];
			if (lastClaimingGroup.TryGetValue(text, out var value) && value == groupName)
			{
				displayOrder.Add(text);
				deferredSet.Remove(text);
				deferredExcess.RemoveAt(num);
			}
			else
			{
				num++;
			}
		}
	}

	public Recipe GetRecipeByName(string name)
	{
		if ((Object)(object)ObjectDB.instance == (Object)null)
		{
			return null;
		}
		if (_fakeRecipeCache.TryGetValue(name, out var value))
		{
			DebugLogger.Verbose("Found cached fake recipe: " + name);
			return value;
		}
		Match match = UpgradeStarRegex.Match(name);
		if (match.Success)
		{
			string name2 = name.Substring(0, match.Index).Trim();
			if (!int.TryParse(match.Groups[1].Value, out var result))
			{
				DebugLogger.Warning("Invalid upgrade level in recipe key: " + name);
				return null;
			}
			Recipe recipeByName = GetRecipeByName(name2);
			if ((Object)(object)recipeByName != (Object)null)
			{
				if (!IsValidUpgradeTarget(recipeByName, result, name))
				{
					return null;
				}
				Recipe val = CreateFakeUpgradeRecipe(recipeByName, result, name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
		}
		GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
		ItemDrop val2 = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
		if ((Object)(object)val2 != (Object)null)
		{
			Recipe recipe = ObjectDB.instance.GetRecipe(val2.m_itemData);
			if ((Object)(object)recipe != (Object)null)
			{
				DebugLogger.Verbose("Found standard recipe: " + name);
				return recipe;
			}
		}
		Recipe val3 = null;
		foreach (Recipe recipe2 in ObjectDB.instance.m_recipes)
		{
			if (((Object)recipe2).name == name)
			{
				val3 = recipe2;
				break;
			}
		}
		if ((Object)(object)val3 != (Object)null)
		{
			DebugLogger.Verbose("Found recipe in ObjectDB: " + name);
			return val3;
		}
		ZNetScene instance = ZNetScene.instance;
		GameObject val4 = ((instance != null) ? instance.GetPrefab(name) : null);
		if ((Object)(object)val4 != (Object)null)
		{
			Piece component = val4.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null && component.m_resources != null && component.m_resources.Length != 0)
			{
				Recipe val5 = ScriptableObject.CreateInstance<Recipe>();
				((Object)val5).hideFlags = (HideFlags)61;
				((Object)val5).name = name;
				val5.m_item = val4.GetComponent<ItemDrop>();
				val5.m_resources = (Requirement[])component.m_resources.Clone();
				_fakeRecipeCache[name] = val5;
				DebugLogger.Verbose("Created fake recipe for piece: " + name);
				return val5;
			}
		}
		DebugLogger.Warning("Recipe not found anywhere: " + name);
		return null;
	}

	private Recipe CreateFakeUpgradeRecipe(Recipe baseRecipe, int targetLevel, string customName)
	{
		//IL_006c: 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)
		//IL_007e: 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_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Expected O, but got Unknown
		if ((Object)(object)baseRecipe == (Object)null)
		{
			return null;
		}
		if (!IsValidUpgradeTarget(baseRecipe, targetLevel, customName))
		{
			return null;
		}
		Recipe val = ScriptableObject.CreateInstance<Recipe>();
		((Object)val).hideFlags = (HideFlags)61;
		((Object)val).name = customName;
		val.m_item = baseRecipe.m_item;
		val.m_amount = 1;
		int num = Mathf.Max(1, targetLevel - 1);
		List<Requirement> list = new List<Requirement>();
		Requirement[] resources = baseRecipe.m_resources;
		foreach (Requirement val2 in resources)
		{
			if (val2.m_amountPerLevel > 0)
			{
				Requirement item = new Requirement
				{
					m_resItem = val2.m_resItem,
					m_amount = val2.m_amountPerLevel * num,
					m_amountPerLevel = 0,
					m_recover = val2.m_recover
				};
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			Object.Destroy((Object)(object)val);
			return null;
		}
		val.m_resources = list.ToArray();
		_fakeRecipeCache[customName] = val;
		DebugLogger.Verbose("Created fake upgrade recipe: " + customName);
		return val;
	}

	private bool IsValidUpgradeTarget(Recipe baseRecipe, int targetLevel, string customName)
	{
		if (targetLevel < 2)
		{
			DebugLogger.Warning("Invalid upgrade level for '" + customName + "': target level must be at least 2");
			return false;
		}
		SharedData val = (baseRecipe.m_item?.m_itemData)?.m_shared;
		if (val == null)
		{
			DebugLogger.Warning("Cannot validate upgrade level for '" + customName + "' - item data is missing");
			return false;
		}
		int maxQuality = val.m_maxQuality;
		if (maxQuality < 2 || targetLevel > maxQuality)
		{
			DebugLogger.Warning($"Invalid upgrade level for '{customName}': target={targetLevel}, max={maxQuality}");
			return false;
		}
		return true;
	}

	public void ValidateAndCleanPins()
	{
		if ((Object)(object)ObjectDB.instance == (Object)null)
		{
			DebugLogger.Warning("Cannot validate pins - ObjectDB.instance is null");
			return;
		}
		DebugLogger.Log("Validating pins");
		List<string> list = new List<string>();
		foreach (string key in PinnedRecipes.Keys)
		{
			if ((Object)(object)GetRecipeByName(key) == (Object)null)
			{
				list.Add(key);
			}
		}
		if (list.Count > 0)
		{
			foreach (string item in list)
			{
				PinnedRecipes.Remove(item);
				PinnedRecipeOrder.Remove(item);
				DebugLogger.Warning("Removed invalid recipe: " + item);
			}
			DebugLogger.Log($"Removed {list.Count} invalid pins");
		}
		else
		{
			DebugLogger.Log("All individual pins valid");
		}
		int num = CleanInvalidGroupMembers();
		if (list.Count > 0 || num > 0)
		{
			RecipePinnerPlugin.Instance?.DataMgr.SavePins();
		}
	}

	private int CleanInvalidGroupMembers()
	{
		int num = 0;
		List<string> list = new List<string>();
		foreach (KeyValuePair<string, PinGroupData> pinGroup in PinGroups)
		{
			string key = pinGroup.Key;
			PinGroupData value = pinGroup.Value;
			List<string> list2 = new List<string>();
			foreach (string memberRecipeKey in value.MemberRecipeKeys)
			{
				if ((Object)(object)GetRecipeByName(memberRecipeKey) == (Object)null)
				{
					value.MemberCounts.Remove(memberRecipeKey);
					num++;
					DebugLogger.Warning("Removed invalid group member: " + memberRecipeKey + " from group '" + key + "'");
				}
				else
				{
					list2.Add(memberRecipeKey);
				}
			}
			if (list2.Count != value.MemberRecipeKeys.Count)
			{
				value.MemberRecipeKeys.Clear();
				value.MemberRecipeKeys.AddRange(list2);
			}
			List<string> list3 = new List<string>();
			foreach (string key2 in value.MemberCounts.Keys)
			{
				if (!value.MemberRecipeKeys.Contains(key2))
				{
					list3.Add(key2);
				}
			}
			foreach (string item in list3)
			{
				value.MemberCounts.Remove(item);
			}
			if (value.MemberRecipeKeys.Count < 2)
			{
				list.Add(key);
			}
		}
		foreach (string item2 in list)
		{
			PinGroups.Remove(item2);
			PinnedRecipeOrder.Remove("GROUP:" + item2);
			DebugLogger.Warning("Removed group '" + item2 + "' because it has less than 2 valid members");
		}
		if (num > 0 || list.Count > 0)
		{
			DebugLogger.Log($"Removed {num} invalid group member(s) and {list.Count} invalid group(s)");
		}
		return num + list.Count;
	}

	public void TryPinHoveredRecipe(InventoryGui gui)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Expected O, but got Unknown
		Transform recipeListRoot = ReflectionHelper.GetRecipeListRoot(gui);
		if (!(ReflectionHelper.GetAvailableRecipes(gui) is IList list) || (Object)(object)recipeListRoot == (Object)null)
		{
			DebugLogger.Verbose("Cannot pin - listRoot or availableRecipes is null");
			return;
		}
		ScrollRect componentInParent = ((Component)recipeListRoot).GetComponentInParent<ScrollRect>();
		bool flag = !((Selectable)gui.m_tabUpgrade).interactable;
		foreach (Transform item in recipeListRoot)
		{
			Transform val = item;
			if (!((Component)val).gameObject.activeInHierarchy)
			{
				continue;
			}
			RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
			if ((Object)(object)val2 == (Object)null || !IsVisibleInScroll(val2, componentInParent) || !InputHelper.IsMouseOverRect(val2, logHit: false))
			{
				continue;
			}
			string text = ExtractTextFromUI(val);
			if (string.IsNullOrEmpty(text))
			{
				continue;
			}
			string text2 = CleanNameRegex.Replace(text, string.Empty).Trim();
			text2 = text2.Replace("\r", "").Replace("\n", "");
			string text3 = AmountSuffixRegex.Replace(text2, "").Trim();
			int num = -1;
			for (int i = 0; i < list.Count; i++)
			{
				GameObject interfaceElementFromObject = GetInterfaceElementFromObject(list[i]);
				if (!((Object)(object)interfaceElementFromObject == (Object)null) && ((Object)(object)interfaceElementFromObject == (Object)(object)((Component)val).gameObject || interfaceElementFromObject.transform.IsChildOf(val)))
				{
					num = i;
					break;
				}
			}
			int num2 = -1;
			foreach (object item2 in list)
			{
				num2++;
				if (num >= 0 && num2 != num)
				{
					continue;
				}
				Recipe recipeFromObject = GetRecipeFromObject(item2);
				if (!((Object)(object)recipeFromObject != (Object)null))
				{
					continue;
				}
				bool flag2 = num >= 0;
				if (!flag2)
				{
					string rawRecipeName = GetRawRecipeName(recipeFromObject);
					if (string.IsNullOrEmpty(rawRecipeName))
					{
						continue;
					}
					string text4 = rawRecipeName;
					if (Localization.instance != null)
					{
						text4 = Localization.instance.Localize(rawRecipeName);
					}
					text4 = text4.Replace("\r", "").Replace("\n", "");
					flag2 = text4.Equals(text3, StringComparison.OrdinalIgnoreCase) || text4.Equals(text2, StringComparison.OrdinalIgnoreCase);
				}
				if (!flag2)
				{
					continue;
				}
				if (flag)
				{
					ItemData val3 = GetItemDataFromObject(item2) ?? ReflectionHelper.GetCraftUpgradeItem(gui);
					if (val3 != null)
					{
						int quality = val3.m_quality;
						int num3 = quality + 1;
						int maxQuality = val3.m_shared.m_maxQuality;
						if (quality >= maxQuality)
						{
							string text5 = RecipePinnerPlugin.Instance.LocalizationMgr.GetText("max_level");
							Player localPlayer = Player.m_localPlayer;
							if (localPlayer != null)
							{
								((Character)localPlayer).Message((MessageType)2, text5, 0, (Sprite)null);
							}
							return;
						}
						string name = ((Object)recipeFromObject.m_item).name;
						string text6 = $"{name} ★{num3}";
						if (IsUnpinHotkeyHeld() && !PinnedRecipes.ContainsKey(text6))
						{
							return;
						}
						DebugLogger.Verbose("Attempting to pin hovered recipe...");
						DebugLogger.Verbose($"Hovered: '{text3}' (UpgradeTab: {flag})");
						DebugLogger.Log("Attempting to pin upgrade: " + text6 + " (Base: " + name + ")");
						if ((Object)(object)GetRecipeByName(text6) != (Object)null)
						{
							TogglePin(text6);
							return;
						}
						string text7 = RecipePinnerPlugin.Instance.LocalizationMgr.GetText("no_upgrade_cost");
						Player localPlayer2 = Player.m_localPlayer;
						if (localPlayer2 != null)
						{
							((Character)localPlayer2).Message((MessageType)2, text7, 0, (Sprite)null);
						}
					}
					else
					{
						DebugLogger.Warning("Matched name but could not get ItemData for upgrade.");
					}
				}
				else if (!IsUnpinHotkeyHeld() || PinnedRecipes.ContainsKey(((Object)recipeFromObject).name))
				{
					DebugLogger.Verbose("Attempting to pin hovered recipe...");
					DebugLogger.Verbose($"Hovered: '{text3}' (UpgradeTab: {flag})");
					DebugLogger.Log("Matched recipe: " + ((Object)recipeFromObject).name);
					TogglePin(((Object)recipeFromObject).name);
				}
				return;
			}
		}
	}

	public void TryPinHoveredPiece()
	{
		if (!((Object)(object)Hud.instance == (Object)null))
		{
			Piece hoveredPiece = ReflectionHelper.GetHoveredPiece(Hud.instance);
			if ((Object)(object)hoveredPiece != (Object)null && hoveredPiece.m_resources != null && hoveredPiece.m_resources.Length != 0 && (!IsUnpinHotkeyHeld() || PinnedRecipes.ContainsKey(((Object)hoveredPiece).name)))
			{
				DebugLogger.Verbose("Attempting to pin hovered piece...");
				DebugLogger.Log("Pinning piece: " + ((Object)hoveredPiece).name);
				TogglePin(((Object)hoveredPiece).name);
			}
		}
	}

	private bool IsUnpinHotkeyHeld()
	{
		//IL_0010: 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)
		//IL_0016: 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)
		ConfigEntry<KeyCode> hotkeyUnpin = RecipePinnerPlugin.HotkeyUnpin;
		KeyCode val = (KeyCode)((hotkeyUnpin == null) ? 304 : ((int)hotkeyUnpin.Value));
		if ((int)val != 0)
		{
			return Input.GetKey(val);
		}
		return false;
	}

	private void TogglePin(string recipeName)
	{
		bool flag = IsUnpinHotkeyHeld();
		LocalizationManager localizationMgr = RecipePinnerPlugin.Instance.LocalizationMgr;
		if (PinnedRecipes.TryGetValue(recipeName, out var value))
		{
			if (flag)
			{
				int groupClaimCount = GetGroupClaimCount(recipeName);
				int num = groupClaimCount;
				value--;
				if (value < num)
				{
					if (groupClaimCount > 0)
					{
						value = groupClaimCount;
						PinnedRecipes[recipeName] = value;
						string groupContainingRecipe = GetGroupContainingRecipe(recipeName);
						Player localPlayer = Player.m_localPlayer;
						if (localPlayer != null)
						{
							((Character)localPlayer).Message((MessageType)2, "Cannot remove: in group \"" + groupContainingRecipe + "\"", 0, (Sprite)null);
						}
						DebugLogger.Log($"Hotkey unpin blocked: {recipeName} min={groupClaimCount}");
					}
					else
					{
						PinnedRecipes.Remove(recipeName);
						PinnedRecipeOrder.Remove(recipeName);
						Player localPlayer2 = Player.m_localPlayer;
						if (localPlayer2 != null)
						{
							((Character)localPlayer2).Message((MessageType)2, localizationMgr.GetText("unpinned"), 0, (Sprite)null);
						}
						DebugLogger.Log("Unpinned: " + recipeName);
					}
				}
				else if (value == 0)
				{
					PinnedRecipes.Remove(recipeName);
					PinnedRecipeOrder.Remove(recipeName);
					Player localPlayer3 = Player.m_localPlayer;
					if (localPlayer3 != null)
					{
						((Character)localPlayer3).Message((MessageType)2, localizationMgr.GetText("unpinned"), 0, (Sprite)null);
					}
					DebugLogger.Log("Unpinned: " + recipeName);
				}
				else
				{
					PinnedRecipes[recipeName] = value;
					int num2 = value - groupClaimCount;
					if (num2 > 0)
					{
						string text = string.Format(localizationMgr.GetText("decreased"), num2);
						Player localPlayer4 = Player.m_localPlayer;
						if (localPlayer4 != null)
						{
							((Character)localPlayer4).Message((MessageType)2, text, 0, (Sprite)null);
						}
					}
					else
					{
						Player localPlayer5 = Player.m_localPlayer;
						if (localPlayer5 != null)
						{
							((Character)localPlayer5).Message((MessageType)2, localizationMgr.GetText("unpinned"), 0, (Sprite)null);
						}
					}
					DebugLogger.Log($"Decreased pin count: {recipeName} = {value}");
				}
			}
			else
			{
				value++;
				PinnedRecipes[recipeName] = value;
				int groupClaimCount2 = GetGroupClaimCount(recipeName);
				if (groupClaimCount2 > 0)
				{
					int num3 = value - groupClaimCount2;
					if (num3 == 1)
					{
						if (!PinnedRecipeOrder.Contains(recipeName))
						{
							PinnedRecipeOrder.Add(recipeName);
						}
						Player localPlayer6 = Player.m_localPlayer;
						if (localPlayer6 != null)
						{
							((Character)localPlayer6).Message((MessageType)2, localizationMgr.GetText("pinned"), 0, (Sprite)null);
						}
					}
					else
					{
						string text2 = string.Format(localizationMgr.GetText("added_more"), num3);
						Player localPlayer7 = Player.m_localPlayer;
						if (localPlayer7 != null)
						{
							((Character)localPlayer7).Message((MessageType)2, text2, 0, (Sprite)null);
						}
					}
				}
				else
				{
					string text3 = string.Format(localizationMgr.GetText("added_more"), value);
					Player localPlayer8 = Player.m_localPlayer;
					if (localPlayer8 != null)
					{
						((Character)localPlayer8).Message((MessageType)2, text3, 0, (Sprite)null);
					}
				}
				DebugLogger.Log($"Increased pin count: {recipeName} = {value}");
			}
		}
		else
		{
			if (flag)
			{
				return;
			}
			if (GetEffectivePinCount() < RecipePinnerPlugin.MaximumPins.Value)
			{
				PinnedRecipes.Add(recipeName, 1);
				if (!PinnedRecipeOrder.Contains(recipeName))
				{
					PinnedRecipeOrder.Add(recipeName);
				}
				Player localPlayer9 = Player.m_localPlayer;
				if (localPlayer9 != null)
				{
					((Character)localPlayer9).Message((MessageType)2, localizationMgr.GetText("pinned"), 0, (Sprite)null);
				}
				DebugLogger.Log("Pinned new recipe: " + recipeName);
			}
			else
			{
				Player localPlayer10 = Player.m_localPlayer;
				if (localPlayer10 != null)
				{
					((Character)localPlayer10).Message((MessageType)2, localizationMgr.GetText("list_full"), 0, (Sprite)null);
				}
				DebugLogger.Warning($"Cannot pin {recipeName} - max pins reached ({RecipePinnerPlugin.MaximumPins.Value})");
			}
		}
		RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
	}

	private Recipe GetRecipeFromObject(object data)
	{
		if (data == null)
		{
			return null;
		}
		Recipe val = (Recipe)((data is Recipe) ? data : null);
		if (val != null)
		{
			return val;
		}
		Type type = data.GetType();
		if (_cachedRecipeFields.TryGetValue(type, out var value))
		{
			object? value2 = value.GetValue(data);
			return (Recipe)((value2 is Recipe) ? value2 : null);
		}
		if (_cachedRecipeProps.TryGetValue(type, out var value3))
		{
			object? value4 = value3.GetValue(data, null);
			return (Recipe)((value4 is Recipe) ? value4 : null);
		}
		PropertyInfo property = type.GetProperty("Key");
		if (property != null)
		{
			object? value5 = property.GetValue(data, null);
			Recipe val2 = (Recipe)((value5 is Recipe) ? value5 : null);
			if (val2 != null)
			{
				_cachedRecipeProps[type] = property;
				return val2;
			}
		}
		FieldInfo field = type.GetField("m_recipe", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null)
		{
			object? value6 = field.GetValue(data);
			Recipe val3 = (Recipe)((value6 is Recipe) ? value6 : null);
			if (val3 != null)
			{
				_cachedRecipeFields[type] = field;
				return val3;
			}
		}
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (FieldInfo fieldInfo in fields)
		{
			if (fieldInfo.FieldType == typeof(Recipe))
			{
				_cachedRecipeFields[type] = fieldInfo;
				object? value7 = fieldInfo.GetValue(data);
				return (Recipe)((value7 is Recipe) ? value7 : null);
			}
		}
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.PropertyType == typeof(Recipe) && propertyInfo.CanRead)
			{
				_cachedRecipeProps[type] = propertyInfo;
				object? value8 = propertyInfo.GetValue(data, null);
				return (Recipe)((value8 is Recipe) ? value8 : null);
			}
		}
		return null;
	}

	private ItemData GetItemDataFromObject(object data)
	{
		if (data == null)
		{
			return null;
		}
		Type type = data.GetType();
		if (_cachedItemFields.TryGetValue(type, out var value))
		{
			object? value2 = value.GetValue(data);
			return (ItemData)((value2 is ItemData) ? value2 : null);
		}
		if (_cachedItemProps.TryGetValue(type, out var value3))
		{
			object? value4 = value3.GetValue(data, null);
			return (ItemData)((value4 is ItemData) ? value4 : null);
		}
		PropertyInfo property = type.GetProperty("Value");
		if (property != null)
		{
			object? value5 = property.GetValue(data, null);
			ItemData val = (ItemData)((value5 is ItemData) ? value5 : null);
			if (val != null)
			{
				_cachedItemProps[type] = property;
				return val;
			}
		}
		PropertyInfo property2 = type.GetProperty("Item2");
		if (property2 != null)
		{
			object? value6 = property2.GetValue(data, null);
			ItemData val2 = (ItemData)((value6 is ItemData) ? value6 : null);
			if (val2 != null)
			{
				_cachedItemProps[type] = property2;
				return val2;
			}
		}
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (FieldInfo fieldInfo in fields)
		{
			if (fieldInfo.FieldType == typeof(ItemData))
			{
				_cachedItemFields[type] = fieldInfo;
				object? value7 = fieldInfo.GetValue(data);
				return (ItemData)((value7 is ItemData) ? value7 : null);
			}
		}
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.PropertyType == typeof(ItemData) && propertyInfo.CanRead)
			{
				_cachedItemProps[type] = propertyInfo;
				object? value8 = propertyInfo.GetValue(data, null);
				return (ItemData)((value8 is ItemData) ? value8 : null);
			}
		}
		return null;
	}

	private GameObject GetInterfaceElementFromObject(object data)
	{
		if (data == null)
		{
			return null;
		}
		Type type = data.GetType();
		if (_elementLookupFailed.Contains(type))
		{
			return null;
		}
		if (_cachedElementProps.TryGetValue(type, out var value))
		{
			object? value2 = value.GetValue(data, null);
			return (GameObject)((value2 is GameObject) ? value2 : null);
		}
		if (_cachedElementFields.TryGetValue(type, out var value3))
		{
			object? value4 = value3.GetValue(data);
			return (GameObject)((value4 is GameObject) ? value4 : null);
		}
		PropertyInfo property = type.GetProperty("InterfaceElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (property != null && property.PropertyType == typeof(GameObject) && property.CanRead)
		{
			_cachedElementProps[type] = property;
			object? value5 = property.GetValue(data, null);
			return (GameObject)((value5 is GameObject) ? value5 : null);
		}
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.PropertyType == typeof(GameObject) && propertyInfo.CanRead)
			{
				_cachedElementProps[type] = propertyInfo;
				object? value6 = propertyInfo.GetValue(data, null);
				return (GameObject)((value6 is GameObject) ? value6 : null);
			}
		}
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (FieldInfo fieldInfo in fields)
		{
			if (fieldInfo.FieldType == typeof(GameObject))
			{
				_cachedElementFields[type] = fieldInfo;
				object? value7 = fieldInfo.GetValue(data);
				return (GameObject)((value7 is GameObject) ? value7 : null);
			}
		}
		_elementLookupFailed.Add(type);
		DebugLogger.Warning("GetInterfaceElementFromObject: no GameObject member on '" + type.Name + "' - falling back to name matching");
		return null;
	}

	private string ExtractTextFromUI(Transform child)
	{
		Text componentInChildren = ((Component)child).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			return componentInChildren.text;
		}
		Component[] componentsInChildren = ((Component)child).GetComponentsInChildren<Component>(true);
		foreach (Component val in componentsInChildren)
		{
			if (!((object)val).GetType().Name.Contains("TextMeshPro") && !((object)val).GetType().Name.Contains("TMP_Text"))
			{
				continue;
			}
			PropertyInfo property = ((object)val).GetType().GetProperty("text");
			if (property != null)
			{
				string text = property.GetValue(val, null) as string;
				if (!string.IsNullOrEmpty(text))
				{
					return text;
				}
			}
		}
		return null;
	}

	private string GetRawRecipeName(Recipe r)
	{
		if ((Object)(object)r.m_item != (Object)null && r.m_item.m_itemData != null)
		{
			return r.m_item.m_itemData.m_shared.m_name;
		}
		ZNetScene instance = ZNetScene.instance;
		GameObject val = ((instance != null) ? instance.GetPrefab(((Object)r).name) : null);
		if ((Object)(object)val != (Object)null)
		{
			ItemDrop component = val.GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null)
			{
				return component.m_itemData.m_shared.m_name;
			}
			Piece component2 = val.GetComponent<Piece>();
			if ((Object)(object)component2 != (Object)null)
			{
				return component2.m_name;
			}
		}
		return null;
	}

	private bool IsVisibleInScroll(RectTransform item, ScrollRect scrollRect)
	{
		//IL_00a5: 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_00b1: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)item == (Object)null || !((Component)item).gameObject.activeInHierarchy)
		{
			return false;
		}
		if ((Object)(object)scrollRect == (Object)null || (Object)(object)scrollRect.viewport == (Object)null)
		{
			return true;
		}
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		scrollRect.viewport.GetWorldCorners(array);
		Rect val = default(Rect);
		((Rect)(ref val))..ctor(array[0].x, array[0].y, array[2].x - array[0].x, array[2].y - array[0].y);
		Vector3[] array2 = (Vector3[])(object)new Vector3[4];
		item.GetWorldCorners(array2);
		Vector3 val2 = (array2[0] + array2[2]) / 2f;
		return ((Rect)(ref val)).Contains(val2);
	}

	private PinnedRecipeData BuildPinnedRecipeData(Recipe r, string recipeName, int count)
	{
		if ((Object)(object)r == (Object)null)
		{
			return null;
		}
		PinnedRecipeData pinnedRecipeData = new PinnedRecipeData
		{
			IsDirty = true,
			RecipeRef = r,
			StackCount = count
		};
		if ((Object)(object)r.m_item != (Object)null && r.m_item.m_itemData != null)
		{
			pinnedRecipeData.Icon = r.m_item.m_itemData.GetIcon();
			pinnedRecipeData.RawName = r.m_item.m_itemData.m_shared?.m_name;
		}
		else if ((Object)(object)r.m_item != (Object)null)
		{
			DebugLogger.Warning("BuildPinnedRecipeData: recipe '" + recipeName + "' has item without itemData, using fallback name");
		}
		else
		{
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(((Object)r).name) : null);
			if ((Object)(object)val != (Object)null)
			{
				Piece component = val.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null)
				{
					pinnedRecipeData.Icon = component.m_icon;
					pinnedRecipeData.RawName = component.m_name;
				}
			}
		}
		if (string.IsNullOrEmpty(pinnedRecipeData.RawName))
		{
			pinnedRecipeData.RawName = ((Object)r).name;
		}
		string text = pinnedRecipeData.RawName;
		if (Localization.instance != null)
		{
			Match match = UpgradeStarRegex.Match(recipeName);
			text = ((!match.Success) ? Localization.instance.Localize(pinnedRecipeData.RawName) : (Localization.instance.Localize(pinnedRecipeData.RawName) + match.Value));
		}
		text = text.Replace("\r", "").Replace("\n", "");
		if (r.m_amount > 1)
		{
			text += $" (x{r.m_amount})";
		}
		if (count > 1)
		{
			text = $"{count}x {text}";
		}
		pinnedRecipeData.CachedHeader = text;
		if (r.m_resources == null)
		{
			DebugLogger.Warning("BuildPinnedRecipeData: recipe '" + recipeName + "' has null resources, skipping");
			return null;
		}
		Requirement[] resources = r.m_resources;
		foreach (Requirement val2 in resources)
		{
			if (val2 == null || val2.m_amount <= 0)
			{
				continue;
			}
			if ((Object)(object)val2.m_resItem == (Object)null || val2.m_resItem.m_itemData == null)
			{
				DebugLogger.Warning("BuildPinnedRecipeData: skipping invalid resource in '" + recipeName + "'");
				continue;
			}
			PinnedResData pinnedResData = new PinnedResData
			{
				ItemName = val2.m_resItem.m_itemData.m_shared?.m_name,
				Icon = val2.m_resItem.m_itemData.GetIcon(),
				RequiredAmount = val2.m_amount * count,
				LastKnownAmount = -1,
				LastKnownInvAmount = -1
			};
			if (string.IsNullOrEmpty(pinnedResData.ItemName))
			{
				DebugLogger.Warning("BuildPinnedRecipeData: skipping resource with empty item name in '" + recipeName + "'");
				continue;
			}
			string text2 = pinnedResData.ItemName;
			if (Localization.instance != null)
			{
				text2 = Localization.instance.Localize(pinnedResData.ItemName);
			}
			text2 = text2.Replace("\r", "").Replace("\n", "");
			pinnedResData.CachedName = text2;
			pinnedRecipeData.Resources.Add(pinnedResData);
		}
		return pinnedRecipeData;
	}

	public bool CreateGroup(string groupName, List<string> selectedKeys)
	{
		if (string.IsNullOrWhiteSpace(groupName))
		{
			DebugLogger.Warning("CreateGroup: group name is empty");
			return false;
		}
		if (selectedKeys == null || selectedKeys.Count < 2)
		{
			DebugLogger.Warning($"CreateGroup: need at least 2 pins, got {selectedKeys?.Count ?? 0}");
			return false;
		}
		if (PinGroups.ContainsKey(groupName))
		{
			DebugLogger.Warning("CreateGroup: group '" + groupName + "' already exists");
			return false;
		}
		PinGroupData pinGroupData = new PinGroupData
		{
			GroupName = groupName
		};
		foreach (string selectedKey in selectedKeys)
		{
			if (PinnedRecipes.TryGetValue(selectedKey, out var value))
			{
				int groupClaimCount = GetGroupClaimCount(selectedKey);
				int num = value - groupClaimCount;
				if (num <= 0)
				{
					DebugLogger.Warning($"CreateGroup: recipe key '{selectedKey}' has no ungrouped excess to claim (total={value}, claims={groupClaimCount}), skipping");
					continue;
				}
				pinGroupData.MemberRecipeKeys.Add(selectedKey);
				pinGroupData.MemberCounts[selectedKey] = num;
				DebugLogger.Verbose($"CreateGroup: added member '{selectedKey}' to group '{groupName}' (claim={num}, total={value}, previousClaims={groupClaimCount})");
			}
			else
			{
				DebugLogger.Warning("CreateGroup: recipe key '" + selectedKey + "' not found in PinnedRecipes, skipping");
			}
		}
		if (pinGroupData.MemberRecipeKeys.Count < 2)
		{
			DebugLogger.Warning($"CreateGroup: only {pinGroupData.MemberRecipeKeys.Count} valid members, need at least 2");
			return false;
		}
		PinGroups[groupName] = pinGroupData;
		string item = "GROUP:" + groupName;
		PinnedRecipeOrder.Add(item);
		DebugLogger.Log($"Group created: '{groupName}' with {pinGroupData.MemberRecipeKeys.Count} members (added to end)");
		RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
		return true;
	}

	public bool DisbandGroup(string groupName)
	{
		if (!PinGroups.TryGetValue(groupName, out var value))
		{
			DebugLogger.Warning("DisbandGroup: group '" + groupName + "' not found");
			return false;
		}
		PinGroups.Remove(groupName);
		PinnedRecipeOrder.Remove("GROUP:" + groupName);
		DebugLogger.Log($"Group disbanded: '{groupName}' ({value.MemberRecipeKeys.Count} members restored)");
		RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
		return true;
	}

	public void DecrementGroupMemberCounts(string recipeKey)
	{
		string text = null;
		foreach (string item in PinnedRecipeOrder)
		{
			if (item.StartsWith("GROUP:"))
			{
				string text2 = item.Substring(6);
				if (PinGroups.TryGetValue(text2, out var value) && value.MemberCounts.ContainsKey(recipeKey))
				{
					text = text2;
				}
			}
		}
		if (text == null)
		{
			return;
		}
		string text3 = text;
		if (!PinGroups.TryGetValue(text3, out var value2))
		{
			return;
		}
		int num = value2.MemberCounts[recipeKey];
		int num2 = num - 1;
		if (num2 <= 0)
		{
			value2.MemberCounts.Remove(recipeKey);
			value2.MemberRecipeKeys.Remove(recipeKey);
			DebugLogger.Log($"AutoUnpin: '{recipeKey}' claim reached 0, removed from group '{text3}' ({value2.MemberRecipeKeys.Count} remaining)");
			if (value2.MemberRecipeKeys.Count < 2)
			{
				DebugLogger.Log($"AutoUnpin: Group '{text3}' auto-disbanded ({value2.MemberRecipeKeys.Count} members)");
				PinGroups.Remove(text3);
				PinnedRecipeOrder.Remove("GROUP:" + text3);
			}
		}
		else
		{
			value2.MemberCounts[recipeKey] = num2;
			DebugLogger.Log($"AutoUnpin: '{recipeKey}' claim decremented in group '{text3}': {num}->{num2}");
		}
	}

	public void RemoveMemberFromGroup(string groupName, string recipeKey)
	{
		if (!PinGroups.TryGetValue(groupName, out var value))
		{
			DebugLogger.Warning("RemoveMemberFromGroup: group '" + groupName + "' not found");
			return;
		}
		if (!value.MemberRecipeKeys.Remove(recipeKey))
		{
			DebugLogger.Warning("RemoveMemberFromGroup: '" + recipeKey + "' not in group '" + groupName + "'");
			return;
		}
		int value2;
		int num = ((!value.MemberCounts.TryGetValue(recipeKey, out value2)) ? 1 : value2);
		value.MemberCounts.Remove(recipeKey);
		DebugLogger.Log($"Removed '{recipeKey}' from group '{groupName}' (claim={num}, {value.MemberRecipeKeys.Count} remaining)");
		if (PinnedRecipes.TryGetValue(recipeKey, out var value3))
		{
			int num2 = value3 - num;
			if (num2 <= 0)
			{
				PinnedRecipes.Remove(recipeKey);
				PinnedRecipeOrder.Remove(recipeKey);
			}
			else
			{
				PinnedRecipes[recipeKey] = num2;
			}
		}
		if (value.MemberRecipeKeys.Count < 2)
		{
			DebugLogger.Log($"Group '{groupName}' has {value.MemberRecipeKeys.Count} member(s), auto-disbanding");
			PinGroups.Remove(groupName);
			PinnedRecipeOrder.Remove("GROUP:" + groupName);
		}
		RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
		if (GetEffectivePinCount() < 2)
		{
			RecipePinnerPlugin.Instance?.UIMgr.CloseGatheringList();
		}
	}

	public void RemovePinFromMyPinsPanel(string key)
	{
		if (PinGroups.TryGetValue(key, out var value))
		{
			foreach (string memberRecipeKey in value.MemberRecipeKeys)
			{
				if (PinnedRecipes.TryGetValue(memberRecipeKey, out var value2))
				{
					int value3;
					int num = ((!value.MemberCounts.TryGetValue(memberRecipeKey, out value3)) ? 1 : value3);
					int num2 = value2 - num;
					if (num2 <= 0)
					{
						PinnedRecipes.Remove(memberRecipeKey);
						PinnedRecipeOrder.Remove(memberRecipeKey);
						DebugLogger.Verbose("Removed group member pin entirely: " + memberRecipeKey);
					}
					else
					{
						PinnedRecipes[memberRecipeKey] = num2;
						DebugLogger.Verbose($"Group member pin kept as individual: {memberRecipeKey} x{num2}");
					}
				}
			}
			PinGroups.Remove(key);
			PinnedRecipeOrder.Remove("GROUP:" + key);
			DebugLogger.Log("Removed group: " + key + " (member excess pins preserved)");
		}
		else
		{
			int groupClaimCount = GetGroupClaimCount(key);
			if (groupClaimCount > 0)
			{
				if (PinnedRecipes.TryGetValue(key, out var value4) && value4 > groupClaimCount)
				{
					PinnedRecipes[key] = groupClaimCount;
					DebugLogger.Log($"Removed individual excess for grouped pin: {key} (kept {groupClaimCount} for groups)");
				}
				else
				{
					DebugLogger.Log($"No individual excess to remove for: {key} (claims={groupClaimCount})");
				}
			}
			else
			{
				PinnedRecipes.Remove(key);
				PinnedRecipeOrder.Remove(key);
				DebugLogger.Log("Removed pin: " + key);
			}
		}
		RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
		if (GetEffectivePinCount() < 2)
		{
			RecipePinnerPlugin.Instance?.UIMgr.CloseGatheringList();
		}
	}

	public void AdjustPinCount(string key, int delta, bool showMessage = true)
	{
		if (!PinnedRecipes.TryGetValue(key, out var value))
		{
			DebugLogger.Warning("AdjustPinCount: recipe '" + key + "' not found");
			return;
		}
		int groupClaimCount = GetGroupClaimCount(key);
		int num = ((groupClaimCount <= 0) ? 1 : (groupClaimCount + 1));
		value += delta;
		DebugLogger.Log($"AdjustPinCount: {key} -> {value} (min={num}, claims={groupClaimCount})");
		if (value < num)
		{
			value = num;
			DebugLogger.Log($"AdjustPinCount: clamped to minimum {num} for '{key}'");
			return;
		}
		PinnedRecipes[key] = value;
		if (showMessage)
		{
			LocalizationManager localizationManager = RecipePinnerPlugin.Instance?.LocalizationMgr;
			if (localizationManager != null)
			{
				int num2 = value - groupClaimCount;
				if (delta > 0)
				{
					string text = string.Format(localizationManager.GetText("added_more"), num2);
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
					}
				}
				else
				{
					string text2 = string.Format(localizationManager.GetText("decreased"), num2);
					Player localPlayer2 = Player.m_localPlayer;
					if (localPlayer2 != null)
					{
						((Character)localPlayer2).Message((MessageType)2, text2, 0, (Sprite)null);
					}
				}
			}
		}
		RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
	}

	public string GetGroupContainingRecipe(string recipeKey)
	{
		foreach (KeyValuePair<string, PinGroupData> pinGroup in PinGroups)
		{
			if (pinGroup.Value.MemberRecipeKeys.Contains(recipeKey))
			{
				return pinGroup.Key;
			}
		}
		return null;
	}

	public int GetGroupClaimCount(string recipeKey)
	{
		int num = 0;
		foreach (PinGroupData value2 in PinGroups.Values)
		{
			if (value2.MemberCounts.TryGetValue(recipeKey, out var value))
			{
				num += value;
			}
			else if (value2.MemberRecipeKeys.Contains(recipeKey))
			{
				num++;
			}
		}
		return num;
	}

	public int TrimToMaximumPins(int maxEffectivePins)
	{
		int num = 0;
		while (GetEffectivePinCount() > maxEffectivePins)
		{
			bool flag = false;
			for (int num2 = PinnedRecipeOrder.Count - 1; num2 >= 0; num2--)
			{
				string text = PinnedRecipeOrder[num2];
				if (text.StartsWith("GROUP:"))
				{
					string key = text.Substring(6);
					PinnedRecipeOrder.RemoveAt(num2);
					if (PinGroups.TryGetValue(key, out var value))
					{
						foreach (string memberRecipeKey in value.MemberRecipeKeys)
						{
							if (PinnedRecipes.TryGetValue(memberRecipeKey, out var value2))
							{
								int value3;
								int num3 = ((!value.MemberCounts.TryGetValue(memberRecipeKey, out value3)) ? 1 : value3);
								int num4 = value2 - num3;
								if (num4 > 0)
								{
									PinnedRecipes[memberRecipeKey] = num4;
									continue;
								}
								PinnedRecipes.Remove(memberRecipeKey);
								PinnedRecipeOrder.Remove(memberRecipeKey);
							}
						}
						PinGroups.Remove(key);
					}
					num++;
					flag = true;
					break;
				}
				if (PinnedRecipes.TryGetValue(text, out var value4))
				{
					int groupClaimCount = GetGroupClaimCount(text);
					if (value4 > groupClaimCount)
					{
						if (groupClaimCount > 0)
						{
							PinnedRecipes[text] = groupClaimCount;
						}
						else
						{
							PinnedRecipes.Remove(text);
							PinnedRecipeOrder.RemoveAt(num2);
						}
						num++;
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				break;
			}
		}
		return num;
	}

	public int GetEffectivePinCount()
	{
		int num = PinGroups.Count;
		foreach (KeyValuePair<string, int> pinnedRecipe in PinnedRecipes)
		{
			int groupClaimCount = GetGroupClaimCount(pinnedRecipe.Key);
			if (pinnedRecipe.Value > groupClaimCount)
			{
				num++;
			}
		}
		return num;
	}
}
[BepInPlugin("com.Kadrio.RecipePinner", "Recipe Pinner", "1.3.0")]
public class RecipePinnerPlugin : BaseUnityPlugin
{
	public enum PinLayoutMode
	{
		AutoDetect,
		ForceVertical,
		ForceHorizontal,
		ForceBottomRightHorizontal
	}

	public class ConfigurationManagerAttributes
	{
		public bool? ShowRangeAsPercent;

		public Action<ConfigEntryBase> CustomDrawer;

		public bool? Browsable;

		public string Category;

		public object DefaultValue;

		public bool? HideDefaultButton;

		public bool? HideSettingName;

		public string Description;

		public string DispName;

		public int? Order;

		public bool? ReadOnly;

		public bool? IsAdvanced;

		public Func<object, string> ObjToStr;

		public Func<string, object> StrToObj;
	}

	public static RecipePinnerPlugin Instance;

	public LocalizationManager LocalizationMgr;

	public RecipeManager RecipeMgr;

	public ContainerScanner ContainerMgr;

	public UIManager UIMgr;

	public DataPersistence DataMgr;

	internal bool _mluiMapListEnabled;

	internal bool _mluiNoMapListEnabled;

	internal bool _mluiInstalled;

	private bool _startupInitialized;

	private string _lastLanguage = "";

	private string _currentSessionPlayer;

	private const float ClearAllConfirmWindow = 2f;

	private float _clearAllArmedUntil;

	private static bool _isUiVisible = true;

	public static ConfigEntry<bool> EnableMod;

	public static ConfigEntry<string> LanguageOverride;

	public static ConfigEntry<PinLayoutMode> LayoutModeConfig;

	public static ConfigEntry<int> MaximumPins;

	public static ConfigEntry<int> PinsPerPage;

	public static ConfigEntry<bool> AutoUnpinAfterCrafting;

	public static ConfigEntry<bool> AutoUnpinAfterBuilding;

	public static ConfigEntry<KeyCode> HotkeyPin;

	public static ConfigEntry<KeyCode> HotkeyUnpin;

	public static ConfigEntry<KeyCode> HotkeyClearAll;

	public static ConfigEntry<KeyCode> HotkeyToggleVisibility;

	public static ConfigEntry<KeyCode> HotkeyPageSwitch;

	public static ConfigEntry<KeyCode> HotkeyGatheringList;

	public static ConfigEntry<bool> EnableChestScanning;

	public static ConfigEntry<float> ChestScanRange;

	public static ConfigEntry<float> ChestScanInterval;

	public static ConfigEntry<float> UIScale;

	public static ConfigEntry<float> BackgroundOpacity;

	public static ConfigEntry<int> FontSizeRecipeName;

	public static ConfigEntry<int> FontSizeMaterials;

	public static ConfigEntry<int> HudRecipeIconSize;

	public static ConfigEntry<int> HudMaterialIconSize;

	public static ConfigEntry<int> HudGroupIconSize;

	public static ConfigEntry<bool> EnableCraftReadiness;

	public static ConfigEntry<Color> ColorHeader;

	public static ConfigEntry<Color> ColorEnoughInInventory;

	public static ConfigEntry<Color> ColorEnoughWithChests;

	public static ConfigEntry<Color> ColorMissing;

	public static ConfigEntry<Color> ColorCraftReady;

	public static ConfigEntry<Color> ColorCraftNotReady;

	public static ConfigEntry<Color> ColorPaginationActive;

	public static ConfigEntry<float> PaginationInactiveOpacity;

	public static ConfigEntry<int> PaginationDotSize;

	public static ConfigEntry<int> PaginationDotSpacing;

	public static ConfigEntry<bool> EnableGatheringList;

	public static ConfigEntry<bool> AutoOpenGatheringList;

	public static ConfigEntry<int> GatheringListColumns;

	public static ConfigEntry<int> GatheringListFontSizeTitle;

	public static ConfigEntry<int> GatheringListFontSizeMaterials;

	public static ConfigEntry<Vector2> ContainerGatheringListPosition;

	public static ConfigEntry<int> GroupCompactThreshold;

	public static ConfigEntry<int> GroupCompactMaxRows;

	public static ConfigEntry<int> GroupIconFontSize;

	public static ConfigEntry<float> MyPinsPanelWidth;

	public static ConfigEntry<float> MyPinsPanelHeight;

	public static ConfigEntry<Vector2> MyPinsPanelPosition;

	public static ConfigEntry<Color> ButtonTextColor;

	public static ConfigEntry<Vector2> MyPinsButtonPosition;

	public static ConfigEntry<int> MyPinsButtonSize;

	public static ConfigEntry<float> VerticalListWidth;

	public static ConfigEntry<float> VerticalPinSpacing;

	public static ConfigEntry<Vector2> VerticalPosition;

	public static ConfigEntry<float> HorizontalColumnWidth;

	public static ConfigEntry<float> HorizontalPinSpacing;

	public static ConfigEntry<Vector2> HorizontalPosition;

	public static ConfigEntry<float> BottomRightColumnWidth;

	public static ConfigEntry<float> BottomRightPinSpacing;

	public static ConfigEntry<Vector2> BottomRightPosition;

	public static ConfigEntry<bool> EnableDebugLogging;

	public static bool IsUiVisible => _isUiVisible;

	internal bool IsPinDataLoaded => _startupInitialized;

	public bool IsHorizontalMode
	{
		get
		{
			if (LayoutModeConfig.Value == PinLayoutMode.ForceBottomRightHorizontal)
			{
				return true;
			}
			if (LayoutModeConfig.Value == PinLayoutMode.ForceHorizontal)
			{
				return true;
			}
			if (LayoutModeConfig.Value == PinLayoutMode.ForceVertical)
			{
				return false;
			}
			if (!_mluiInstalled)
			{
				return false;
			}
			if (Game.m_noMap)
			{
				return _mluiNoMapListEnabled;
			}
			return _mluiMapListEnabled;
		}
	}

	private void Awake()
	{
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		BindConfigs();
		DebugLogger.Log("Plugin init");
		LocalizationMgr = new LocalizationManager(this);
		RecipeMgr = new RecipeManager();
		ContainerMgr = new ContainerScanner();
		UIMgr = new UIManager();
		DataMgr = new DataPersistence();
		DebugLogger.Log("Managers ready");
		Harmony val = new Harmony("com.Kadrio.RecipePinner");
		val.PatchAll(typeof(RecipePinnerPlugin));
		val.PatchAll(typeof(ContainerScanner));
		DebugLogger.Log("Patches applied");
	}

	private void Start()
	{
		DebugLogger.Log("Start()");
		LocalizationMgr.LoadTranslations();
		ReadMyLittleUIConfig();
		ContainerMgr.InitializeContainers();
		DebugLogger.Log("Start done");
	}

	private void OnDestroy()
	{
		DebugLogger.Log("OnDestroy");
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer != (Object)null && !string.IsNullOrEmpty(localPlayer.GetPlayerName()))
		{
			if (EnableMod == null || !EnableMod.Value)
			{
				DebugLogger.Verbose("OnDestroy save skipped - mod is disabled");
			}
			else if (!_startupInitialized)
			{
				DebugLogger.Verbose("OnDestroy save skipped - pin data not loaded yet");
			}
			else
			{
				DataMgr.SavePins();
			}
		}
		RecipeMgr.Cleanup();
	}

	private void OnApplicationFocus(bool hasFocus)
	{
		if (hasFocus)
		{
			UIMgr?.ResetMyPinsInputState("application focus restored");
		}
	}

	private void Update()
	{
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_041d: Unknown result type (might be due to invalid IL or missing references)
		if (!EnableMod.Value)
		{
			return;
		}
		ReflectionHelper.UpdateGuiScale();
		if (!_startupInitialized && (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_recipes.Count > 0)
		{
			DebugLogger.Log("First init");
			_lastLanguage = Localization.instance.GetSelectedLanguage();
			DataMgr.LoadPins();
			RecipeMgr.ValidateAndCleanPins();
			RecipeMgr.RefreshRecipeCache();
			_startupInitialized = true;
			DebugLogger.Log($"Init done - {RecipeMgr.PinnedRecipes.Count} pins loaded");
		}
		if (EnableChestScanning.Value && (Object)(object)Player.m_localPlayer != (Object)null && RecipeMgr.CachedPins.Count > 0)
		{
			ContainerMgr.UpdateScanning();
		}
		bool flag = (Input.GetKeyDown(HotkeyToggleVisibility.Value) || Input.GetKeyDown(HotkeyPin.Value) || Input.GetKeyDown(HotkeyClearAll.Value) || Input.GetKeyDown(HotkeyPageSwitch.Value) || Input.GetKeyDown(HotkeyGatheringList.Value)) && AreRecipePinnerHotkeysBlocked();
		if (Input.GetKeyDown(HotkeyToggleVisibility.Value) && !flag)
		{
			_isUiVisible = !_isUiVisible;
			DebugLogger.Log($"UI visibility toggled: {_isUiVisible}");
		}
		if ((Object)(object)Player.m_localPlayer != (Object)null)
		{
			UpdatePlayerSession();
		}
		bool flag2 = (Object)(object)Player.m_localPlayer != (Object)null && ((Character)Player.m_localPlayer).InPlaceMode();
		if (Input.GetKeyDown(HotkeyPin.Value) && !flag)
		{
			if ((Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible())
			{
				RecipeMgr.TryPinHoveredRecipe(InventoryGui.instance);
			}
			else if (flag2)
			{
				RecipeMgr.TryPinHoveredPiece();
			}
		}
		if (Input.GetKeyDown(HotkeyClearAll.Value) && !flag && (RecipeMgr.PinnedRecipes.Count > 0 || RecipeMgr.PinGroups.Count > 0))
		{
			if (Time.unscaledTime <= _clearAllArmedUntil)
			{
				_clearAllArmedUntil = 0f;
				int count = RecipeMgr.PinnedRecipes.Count;
				int count2 = RecipeMgr.PinGroups.Count;
				RecipeMgr.PinnedRecipes.Clear();
				RecipeMgr.PinnedRecipeOrder.Clear();
				RecipeMgr.PinGroups.Clear();
				_isUiVisible = true;
				RecipeMgr.RefreshRecipeCache();
				UIMgr.CloseGatheringList();
				UIMgr.RefreshMyPinsList();
				DataMgr.SavePins();
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, LocalizationMgr.GetText("cleared"), 0, (Sprite)null);
				}
				DebugLogger.Log($"Cleared {count} pinned recipes and {count2} groups");
			}
			else
			{
				_clearAllArmedUntil = Time.unscaledTime + 2f;
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)2, LocalizationMgr.GetText("clear_confirm_hotkey"), 0, (Sprite)null);
				}
				DebugLogger.Log("Clear-all armed - press again to confirm");
			}
		}
		if (Localization.instance != null)
		{
			string selectedLanguage = Localization.instance.GetSelectedLanguage();
			if (_lastLanguage != selectedLanguage)
			{
				DebugLogger.Log("Language changed from " + _lastLanguage + " to " + selectedLanguage);
				_lastLanguage = selectedLanguage;
				LocalizationMgr.LoadTranslations();
				if ((Object)(object)ObjectDB.instance != (Object)null)
				{
					RecipeMgr.RefreshRecipeCache();
				}
				UIMgr?.DestroyUI();
				UIMgr?.DestroyMyPinsUI();
			}
		}
		if (Input.GetKeyDown(HotkeyPageSwitch.Value) && _isUiVisible && !flag)
		{
			UIMgr?.CyclePage();
		}
		if (Input.GetKeyDown(HotkeyGatheringList.Value) && !flag && EnableGatheringList.Value)
		{
			UIMgr?.ToggleGatheringList();
		}
		if ((Object)(object)Player.m_localPlayer != (Object)null)
		{
			UIMgr?.UpdateMyPinsInventoryState();
		}
	}

	private bool AreRecipePinnerHotkeysBlocked()
	{
		if (InputHelper.IsInputBlocked())
		{
			return true;
		}
		if (UIMgr != null && UIMgr.IsMyPinsPanelOpen)
		{
			return true;
		}
		if (ControlsInfoPanel.IsOpen)
		{
			return true;
		}
		InventoryGui instance = InventoryGui.instance;
		if ((Object)(object)instance != (Object)null && InventoryGui.IsVisible() && ReflectionHelper.IsBlockingInventoryPanelOpen(instance))
		{
			return true;
		}
		return false;
	}

	private void UpdatePlayerSession()
	{
		if ((Object)(object)Player.m_localPlayer == (Object)null || ((Character)Player.m_localPlayer).IsDead())
		{
			UIMgr?.UpdateUI(isVisible: false);
			return;
		}
		string playerName = Player.m_localPlayer.GetPlayerName();
		if (string.IsNullOrEmpty(playerName))
		{
			return;
		}
		if (_currentSessionPlayer != playerName)
		{
			DebugLogger.Log("Player session changed from '" + _currentSessionPlayer + "' to '" + playerName + "'");
			RecipeMgr.PinnedRecipes.Clear();
			RecipeMgr.PinnedRecipeOrder.Clear();
			RecipeMgr.CachedPins.Clear();
			RecipeMgr.PinGroups.Clear();
			UIMgr.DestroyUI();
			UIMgr.DestroyMyPinsUI();
			_currentSessionPlayer = playerName;
			DataMgr.LoadPins();
			if ((Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_recipes.Count > 0)
			{
				RecipeMgr.ValidateAndCleanPins();
			}
			RecipeMgr.RefreshRecipeCache();
		}
		UIMgr.UpdateUI(_isUiVisible);
	}

	private void ReadMyLittleUIConfig()
	{
		if (!Chainloader.PluginInfos.ContainsKey("shudnal.MyLittleUI"))
		{
			_mluiInstalled = false;
			DebugLogger.Log("MyLittleUI not detected");
			return;
		}
		_mluiInstalled = true;
		_mluiMapListEnabled = true;
		_mluiNoMapListEnabled = true;
		string path = Path.Combine(Paths.ConfigPath, "shudnal.MyLittleUI.cfg");
		if (!File.Exists(path))
		{
			DebugLogger.Log("MyLittleUI installed but config not found");
			return;
		}
		try
		{
			string[] array = File.ReadAllLines(path);
			string text = "";
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string text2 = array2[i].Trim();
				bool value;
				if (text2.StartsWith("[") && text2.EndsWith("]"))
				{
					text = text2;
				}
				else if (TryReadBoolConfigValue(text2, "Enable", out value))
				{
					if (text == "[Status effects - Map - List]")
					{
						_mluiMapListEnabled = value;
					}
					else if (text == "[Status effects - Nomap - List]")
					{
						_mluiNoMapListEnabled = value;
					}
				}
			}
			DebugLogger.Log($"MyLittleUI Config: MapList={_mluiMapListEnabled}, NoMapList={_mluiNoMapListEnabled}");
		}
		catch (Exception ex)
		{
			DebugLogger.Error("Error reading MyLittleUI config", ex);
		}
	}

	private static bool TryReadBoolConfigValue(string line, string key, out bool value)
	{
		value = false;
		int num = line.IndexOf('=');
		if (num <= 0)
		{
			return false;
		}
		if (!string.Equals(line.Substring(0, num).Trim(), key, StringComparison.OrdinalIgnoreCase))
		{
			return false;
		}
		string text = line.Substring(num + 1);
		int num2 = text.IndexOf('#');
		if (num2 >= 0)
		{
			text = text.Substring(0, num2);
		}
		return bool.TryParse(text.Trim(), out value);
	}

	[HarmonyPatch(typeof(Game), "SavePlayerProfile")]
	[HarmonyPostfix]
	public static void AutoSavePinsHook()
	{
		if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Instance == (Object)null))
		{
			if (EnableMod == null || !EnableMod.Value)
			{
				DebugLogger.Verbose("Auto-save skipped - mod is disabled");
				return;
			}
			if (!Instance.IsPinDataLoaded)
			{
				DebugLogger.Verbose("Auto-save skipped - pin data not loaded yet");
				return;
			}
			DebugLogger.Log("Auto-saving pins");
			Instance.DataMgr.SavePins();
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	[HarmonyPostfix]
	public static void AutoUnpinHook(InventoryGui __instance)
	{
		if (!EnableMod.Value || !AutoUnpinAfterCrafting.Value || (Object)(object)Instance == (Object)null)
		{
			return;
		}
		Recipe craftRecipe = ReflectionHelper.GetCraftRecipe(__instance);
		if (!((Object)(object)craftRecipe != (Object)null))
		{
			return;
		}
		string text = null;
		if (!((Selectable)__instance.m_tabUpgrade).interactable)
		{
			ItemData craftUpgradeItem = ReflectionHelper.GetCraftUpgradeItem(__instance);
			if (craftUpgradeItem != null)
			{
				string name = ((Object)craftRecipe.m_item).name;
				int quality = craftUpgradeItem.m_quality;
				int num = quality + 1;
				text = $"{name} ★{num}";
				DebugLogger.Log($"Upgrade crafted: Unpinning target {text} (Base Level: {quality})");
			}
		}
		else
		{
			text = ((Object)craftRecipe).name;
		}
		if (text != null && Instance.RecipeMgr.PinnedRecipes.TryGetValue(text, out var value))
		{
			bool num2 = value > Instance.RecipeMgr.GetGroupClaimCount(text);
			value--;
			DebugLogger.Log($"Auto-unpin: {text}, remaining count: {value}");
			if (num2)
			{
				DebugLogger.Verbose("Auto-unpin: consumed ungrouped copy of '" + text + "', group claims untouched");
			}
			else
			{
				Instance.RecipeMgr.DecrementGroupMemberCounts(text);
			}
			if (value <= 0)
			{
				Instance.RecipeMgr.PinnedRecipes.Remove(text);
				Instance.RecipeMgr.PinnedRecipeOrder.Remove(text);
				DebugLogger.Log("Recipe " + text + " fully unpinned");
			}
			else
			{
				Instance.RecipeMgr.PinnedRecipes[text] = value;
			}
			Instance.RecipeMgr.RefreshRecipeCache();
			Instance.DataMgr.SavePins();
			if (Instance.RecipeMgr.GetEffectivePinCount() < 2)
			{
				Instance.UIMgr.CloseGatheringList();
			}
		}
		else if (text != null)
		{
			string text2 = string.Join(", ", Instance.RecipeMgr.PinnedRecipes.Keys);
			DebugLogger.Verbose("Auto-unpin: '" + text + "' not found in PinnedRecipes. Current keys: [" + text2 + "]");
		}
	}

	[HarmonyPatch(typeof(Player), "PlacePiece")]
	[HarmonyPostfix]
	public static void AutoUnpinBuildHook(Piece piece)
	{
		DebugLogger.Verbose("AutoUnpinBuildHook fired (PlacePiece postfix)");
		if ((Object)(object)Instance == (Object)null || !EnableMod.Value || !AutoUnpinAfterBuilding.Value)
		{
			DebugLogger.Verbose($"AutoUnpinBuildHook early exit: Instance={(Object)(object)Instance != (Object)null}, EnableMod={EnableMod?.Value}, AutoUnpin={AutoUnpinAfterBuilding?.Value}");
			return;
		}
		if ((Object)(object)piece == (Object)null)
		{
			DebugLogger.Verbose("AutoUnpinBuildHook: piece is null");
			return;
		}
		string text = ((Object)piece).name.Replace("(Clone)", "").Trim();
		if (!Instance.RecipeMgr.PinnedRecipes.TryGetValue(text, out var value))
		{
			DebugLogger.Verbose("AutoUnpinBuildHook: '" + text + "' not pinned");
			return;
		}
		bool num = value > Instance.RecipeMgr.GetGroupClaimCount(text);
		value--;
		DebugLogger.Log($"Auto-unpin (Build): {text}, remaining count: {value}");
		if (num)
		{
			DebugLogger.Verbose("Auto-unpin (Build): consumed ungrouped copy of '" + text + "', group claims untouched");
		}
		else
		{
			Instance.RecipeMgr.DecrementGroupMemberCounts(text);
		}
		if (value <= 0)
		{
			Instance.RecipeMgr.PinnedRecipes.Remove(text);
			Instance.RecipeMgr.PinnedRecipeOrder.Remove(text);
			DebugLogger.Log("Build recipe " + text + " fully unpinned");
		}
		else
		{
			Instance.RecipeMgr.PinnedRecipes[text] = value;
		}
		Instance.RecipeMgr.RefreshRecipeCache();
		Instance.DataMgr.SavePins();
		if (Instance.RecipeMgr.GetEffectivePinCount() < 2)
		{
			Instance.UIMgr.CloseGatheringList();
		}
	}

	[HarmonyPatch(typeof(Player), "TakeInput")]
	[HarmonyPrefix]
	public static bool Player_TakeInput_BlockDuringDialog()
	{
		if (GroupNameDialog.IsDialogOpen || ConfirmDialog.IsDialogOpen)
		{
			return false;
		}
		if (Instance?.UIMgr != null && Instance.UIMgr.IsMyPinsPanelOpen)
		{
			return false;
		}
		return true;
	}

	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	[HarmonyPrefix]
	public static bool InventoryGui_Hide_BlockDuringDialog()
	{
		if (GroupNameDialog.IsDialogOpen)
		{
			DebugLogger.Verbose("InventoryGui.Hide blocked - GroupNameDialog is open");
			return false;
		}
		if (ConfirmDialog.IsDialogOpen)
		{
			DebugLogger.Verbose("InventoryGui.Hide blocked - ConfirmDialog is open");
			return false;
		}
		if (ControlsInfoPanel.IsOpen)
		{
			ControlsInfoPanel.Instance?.Hide();
			DebugLogger.Log("InventoryGui.Hide intercepted (ESC) - closing ControlsInfoPanel only");
			return false;
		}
		if (Instance?.UIMgr != null && Instance.UIMgr.IsMyPinsPanelOpen)
		{
			bool keyDown = Input.GetKeyDown((KeyCode)27);
			Instance.UIMgr.ToggleMyPinsPanel();
			if (keyDown)
			{
				DebugLogger.Log("InventoryGui.Hide intercepted (ESC) - closing My Pins panel only");
				return false;
			}
			DebugLogger.Log("InventoryGui.Hide intercepted (Tab) - closing My Pins panel + inventory");
			return true;
		}
		return true;
	}

	private void BindConfigs()
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Expected O, but got Unknown
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Expected O, but got Unknown
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Expected O, but got Unknown
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Expected O, but got Unknown
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Expected O, but got Unknown
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Expected O, but got Unknown
		//IL_027e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0288: Expected O, but got Unknown
		//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cd: Expected O, but got Unknown
		//IL_0308: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Expected O, but got Unknown
		//IL_034d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0357: Expected O, but got Unknown
		//IL_0392: Unknown result type (might be due to invalid IL or missing references)
		//IL_039c: Expected O, but got Unknown
		//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03de: Expected O, but got Unknown
		//IL_0415: Unknown result type (might be due to invalid IL or missing references)
		//IL_041f: Expected O, but got Unknown
		//IL_047e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0488: Expected O, but got Unknown
		//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_04db: Expected O, but got Unknown
		//IL_0524: Unknown result type (might be due to invalid IL or missing references)
		//IL_052e: Expected O, but got Unknown
		//IL_058d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0597: Expected O, but got Unknown
		//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e0: Expected O, but got Unknown
		//IL_0635: Unknown result type (might be due to invalid IL or missing references)
		//IL_063f: Expected O, but got Unknown
		//IL_0695: Unknown result type (might be due to invalid IL or missing references)
		//IL_069f: Expected O, but got Unknown
		//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_06ff: Expected O, but got Unknown
		//IL_0755: Unknown result type (might be due to invalid IL or missing references)
		//IL_075f: Expected O, but got Unknown
		//IL_07ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_07b6: Expected O, but got Unknown
		//IL_07f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_081b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0825: Expected O, but got Unknown
		//IL_0864: Unknown result type (might be due to invalid IL or missing references)
		//IL_088a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0894: Expected O, but got Unknown
		//IL_08d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_08f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0903: Expected O, but got Unknown
		//IL_0942: Unknown result type (might be due to invalid IL or missing references)
		//IL_0968: Unknown result type (might be due to invalid IL or missing references)
		//IL_0972: Expected O, but got Unknown
		//IL_09b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_09d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_09e1: Expected O, but got Unknown
		//IL_0a20: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a46: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a50: Expected O, but got Unknown
		//IL_0a8f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ab5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0abf: Expected O, but got Unknown
		//IL_0b1e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b28: Expected O, but got Unknown
		//IL_0b7d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b87: Expected O, but got Unknown
		//IL_0bdb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0be5: Expected O, but got Unknown
		//IL_0c32: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c3c: Expected O, but got Unknown
		//IL_0c89: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c93: Expected O, but got Unknown
		//IL_0cd1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cdb: Expected O, but got Unknown
		//IL_0d30: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d3a: Expected O, but got Unknown
		//IL_0d8f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d99: Expected O, but got Unknown
		//IL_0dce: Unknown result type (might be due to invalid IL or missing references)
		//IL_0df4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dfe: Expected O, but got Unknown
		//IL_0e3c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e46: Expected O, but got Unknown
		//IL_0e9a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ea4: Expected O, but got Unknown
		//IL_0ef9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f03: Expected O, but got Unknown
		//IL_0f62: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f6c: Expected O, but got Unknown
		//IL_0fcb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0fd5: Expected O, but got Unknown
		//IL_1000: Unknown result type (might be due to invalid IL or missing references)
		//IL_1026: Unknown result type (might be due to invalid IL or missing references)
		//IL_1030: Expected O, but got Unknown
		//IL_106f: Unknown result type (might be due to invalid IL or missing references)
		//IL_1095: Unknown result type (might be due to invalid IL or missing references)
		//IL_109f: Expected O, but got Unknown
		//IL_10d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_10fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_1104: Expected O, but got Unknown
		//IL_115d: Unknown result type (might be due to invalid IL or missing references)
		//IL_1167: Expected O, but got Unknown
		//IL_11b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_11c2: Expected O, but got Unknown
		//IL_11fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_1207: Expected O, but got Unknown
		//IL_1226: Unknown result type (might be due to invalid IL or missing references)
		//IL_124c: Unknown result type (might be due to invalid IL or missing references)
		//IL_1256: Expected O, but got Unknown
		//IL_1291: Unknown result type (might be due to invalid IL or missing references)
		//IL_129b: Expected O, but got Unknown
		//IL_12d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_12e0: Expected O, but got Unknown
		//IL_12ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_1325: Unknown result type (might be due to invalid IL or missing references)
		//IL_132f: Expected O, but got Unknown
		//IL_136a: Unknown result type (might be due to invalid IL or missing references)
		//IL_1374: Expected O, but got Unknown
		//IL_13af: Unknown result type (might be due to invalid IL or missing references)
		//IL_13b9: Expected O, but got Unknown
		//IL_13d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_13fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_1408: Expected O, but got Unknown
		//IL_143f: Unknown result type (might be due to invalid IL or missing references)
		//IL_1449: Expected O, but got Unknown
		EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("01 - General", "EnableMod", true, new ConfigDescription("Enable or disable the mod completely.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		EnableMod.SettingChanged += delegate
		{
			if (!EnableMod.Value)
			{
				UIMgr?.DestroyUI();
				UIMgr?.DestroyMyPinsUI();
			}
		};
		LanguageOverride = ((BaseUnityPlugin)this).Config.Bind<string>("01 - General", "LanguageOverride", "Auto", new ConfigDescription("Force a specific language (e.g., 'German', 'Turkish'). 'Auto' uses the game language.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		LanguageOverride.SettingChanged += delegate
		{
			LocalizationMgr?.LoadTranslations();
			RecipeMgr?.RefreshRecipeCache();
			UIMgr?.DestroyUI();
			UIMgr?.DestroyMyPinsUI();
		};
		LayoutModeConfig = ((BaseUnityPlugin)this).Config.Bind<PinLayoutMode>("01 - General", "LayoutMode", PinLayoutMode.AutoDetect, new ConfigDescription("HUD pin layout position.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		LayoutModeConfig.SettingChanged += delegate
		{
			ReadMyLittleUIConfig();
			UIMgr?.DestroyUI();
		};
		MaximumPins = ((BaseUnityPlugin)this).Config.Bind<int>("01 - General", "MaximumPins", 10, new ConfigDescription("Maximum number of pins allowed at once.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		MaximumPins.SettingChanged += delegate
		{
			int num = RecipeMgr?.TrimToMaximumPins(MaximumPins.Value) ?? 0;
			if (num > 0)
			{
				DebugLogger.Log($"MaximumPins reduced, trimmed {num} effective pin(s)");
				RecipeMgr?.RefreshRecipeCache();
			}
			UIMgr?.ResetPage();
			UIMgr?.DestroyUI();
			if (num > 0)
			{
				DataMgr?.SavePins();
			}
		};
		PinsPerPage = ((BaseUnityPlugin)this).Config.Bind<int>("01 - General", "PinsPerPage", 5, new ConfigDescription("How many pins to show per HUD page.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 95
			}
		}));
		PinsPerPage.SettingChanged += delegate
		{
			UIMgr?.ResetPage();
			UIMgr?.DestroyUI();
		};
		AutoUnpinAfterCrafting = ((BaseUnityPlugin)this).Config.Bind<bool>("01 - General", "AutoUnpinAfterCrafting", true, new ConfigDescription("Automatically unpin a recipe after it is crafted.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 94
			}
		}));
		AutoUnpinAfterBuilding = ((BaseUnityPlugin)this).Config.Bind<bool>("01 - General", "AutoUnpinAfterBuilding", true, new ConfigDescription("Automatically unpin a recipe after placing a building piece.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 93
			}
		}));
		HotkeyPin = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("02 - Controls", "HotkeyPin", (KeyCode)325, new ConfigDescription("Hotkey to pin the currently viewed recipe.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		HotkeyUnpin = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("02 - Controls", "HotkeyUnpin", (KeyCode)304, new ConfigDescription("Hold this key + press the Pin hotkey over a recipe or build piece to decrease/remove that pin.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		HotkeyToggleVisibility = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("02 - Controls", "HotkeyToggleVisibility", (KeyCode)288, new ConfigDescription("Hotkey to show/hide the HUD pin overlay.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		HotkeyGatheringList = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("02 - Controls", "HotkeyGatheringList", (KeyCode)289, new ConfigDescription("Hotkey to toggle the Gathering List panel.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		HotkeyPageSwitch = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("02 - Controls", "HotkeyPageSwitch", (KeyCode)308, new ConfigDescription("Press this key to cycle through HUD pages.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 95
			}
		}));
		HotkeyClearAll = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("02 - Controls", "HotkeyClearAll", (KeyCode)112, new ConfigDescription("Hotkey to clear all pinned recipes.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 94
			}
		}));
		EnableChestScanning = ((BaseUnityPlugin)this).Config.Bind<bool>("03 - Chest Scanner", "EnableChestScanning", false, new ConfigDescription("Count materials found in nearby chests towards requirements.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		EnableChestScanning.SettingChanged += delegate
		{
			if (EnableChestScanning.Value)
			{
				ContainerScanner.ClearAll();
				ContainerMgr?.InitializeContainers();
			}
			else
			{
				ContainerScanner.ClearAll();
			}
			RecipeMgr?.RefreshRecipeCache();
		};
		ChestScanRange = ((BaseUnityPlugin)this).Config.Bind<float>("03 - Chest Scanner", "ChestScanRange", 20f, new ConfigDescription("Radius (meters) in which chests are scanned.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 100f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		ChestScanInterval = ((BaseUnityPlugin)this).Config.Bind<float>("03 - Chest Scanner", "ChestScanInterval", 3f, new ConfigDescription("How often (seconds) chests are re-scanned.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 10f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		UIScale = ((BaseUnityPlugin)this).Config.Bind<float>("04 - HUD Appearance", "UIScale", 0.75f, new ConfigDescription("Global UI scale multiplier.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 3f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		UIScale.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		BackgroundOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("04 - HUD Appearance", "BackgroundOpacity", 0.5f, new ConfigDescription("Background panel opacity (0 = transparent, 1 = opaque).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		FontSizeRecipeName = ((BaseUnityPlugin)this).Config.Bind<int>("04 - HUD Appearance", "FontSizeRecipeName", 16, new ConfigDescription("Font size for recipe/group name in HUD pins.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 40), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		FontSizeRecipeName.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		FontSizeMaterials = ((BaseUnityPlugin)this).Config.Bind<int>("04 - HUD Appearance", "FontSizeMaterials", 15, new ConfigDescription("Font size for material names and amounts in HUD pins.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 40), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		FontSizeMaterials.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		HudRecipeIconSize = ((BaseUnityPlugin)this).Config.Bind<int>("04 - HUD Appearance", "HudRecipeIconSize", 28, new ConfigDescription("Size (px) of the recipe icon in the HUD pin header.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(12, 64), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 95
			}
		}));
		HudRecipeIconSize.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		HudMaterialIconSize = ((BaseUnityPlugin)this).Config.Bind<int>("04 - HUD Appearance", "HudMaterialIconSize", 20, new ConfigDescription("Size (px) of the material icons in the HUD pin resource list.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 48), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 94
			}
		}));
		HudMaterialIconSize.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		HudGroupIconSize = ((BaseUnityPlugin)this).Config.Bind<int>("04 - HUD Appearance", "HudGroupIconSize", 28, new ConfigDescription("Size (px) of the group icon (stacked cards) in the HUD pin header.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(12, 64), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 93
			}
		}));
		HudGroupIconSize.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		EnableCraftReadiness = ((BaseUnityPlugin)this).Config.Bind<bool>("04 - HUD Appearance", "EnableCraftReadiness", true, new ConfigDescription("Show a colored accent bar indicating whether a recipe can be crafted.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 92
			}
		}));
		EnableCraftReadiness.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		ColorHeader = ((BaseUnityPlugin)this).Config.Bind<Color>("05 - Colors", "ColorHeader", new Color(1f, 0.808f, 0f, 1f), new ConfigDescription("Recipe/group name text color.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		ColorHeader.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
			UIMgr?.DestroyUI();
		};
		ColorEnoughInInventory = ((BaseUnityPlugin)this).Config.Bind<Color>("05 - Colors", "ColorEnoughInInventory", new Color(0f, 1f, 0f, 1f), new ConfigDescription("Material amount color when you have enough in your inventory.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		ColorEnoughInInventory.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		ColorEnoughWithChests = ((BaseUnityPlugin)this).Config.Bind<Color>("05 - Colors", "ColorEnoughWithChests", new Color(1f, 1f, 0f, 1f), new ConfigDescription("Material amount color when enough only if chests are counted.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		ColorEnoughWithChests.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		ColorMissing = ((BaseUnityPlugin)this).Config.Bind<Color>("05 - Colors", "ColorMissing", new Color(1f, 0.33f, 0.33f, 1f), new ConfigDescription("Material amount color when materials are missing.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		ColorMissing.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		ColorCraftReady = ((BaseUnityPlugin)this).Config.Bind<Color>("05 - Colors", "ColorCraftReady", new Color(0.2f, 0.9f, 0.3f, 0.85f), new ConfigDescription("Accent bar color when all materials are available.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 95
			}
		}));
		ColorCraftReady.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		ColorCraftNotReady = ((BaseUnityPlugin)this).Config.Bind<Color>("05 - Colors", "ColorCraftNotReady", new Color(0.9f, 0.25f, 0.25f, 0.5f), new ConfigDescription("Accent bar color when materials are missing.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 94
			}
		}));
		ColorCraftNotReady.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		ColorPaginationActive = ((BaseUnityPlugin)this).Config.Bind<Color>("06 - Pagination", "ColorPaginationActive", new Color(1f, 0.717f, 0.368f, 1f), new ConfigDescription("Active page indicator dot color.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		ColorPaginationActive.SettingChanged += delegate
		{
			UIMgr?.UpdateUI(isVisible: true);
		};
		PaginationInactiveOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("06 - Pagination", "PaginationInactiveOpacity", 0.3f, new ConfigDescription("Opacity of inactive page indicator dots.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		PaginationInactiveOpacity.SettingChanged += delegate
		{
			UIMgr?.UpdateUI(isVisible: true);
		};
		PaginationDotSize = ((BaseUnityPlugin)this).Config.Bind<int>("06 - Pagination", "PaginationDotSize", 10, new ConfigDescription("Size of the pagination dot squares.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 20), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		PaginationDotSize.SettingChanged += delegate
		{
			UIMgr?.UpdateUI(isVisible: true);
		};
		PaginationDotSpacing = ((BaseUnityPlugin)this).Config.Bind<int>("06 - Pagination", "PaginationDotSpacing", 8, new ConfigDescription("Space between pagination squares.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		PaginationDotSpacing.SettingChanged += delegate
		{
			UIMgr?.UpdateUI(isVisible: true);
		};
		EnableGatheringList = ((BaseUnityPlugin)this).Config.Bind<bool>("07 - Gathering List", "EnableGatheringList", true, new ConfigDescription("Enable the Gathering List (aggregated material overview).", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		EnableGatheringList.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		AutoOpenGatheringList = ((BaseUnityPlugin)this).Config.Bind<bool>("07 - Gathering List", "AutoOpenGatheringList", true, new ConfigDescription("Automatically open the Gathering List when 2+ recipes are pinned.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		GatheringListColumns = ((BaseUnityPlugin)this).Config.Bind<int>("07 - Gathering List", "GatheringListColumns", 4, new ConfigDescription("Number of columns in the Gathering List grid (horizontal modes only). Panel width adjusts proportionally.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		GatheringListColumns.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		GatheringListFontSizeTitle = ((BaseUnityPlugin)this).Config.Bind<int>("07 - Gathering List", "GatheringListFontSizeTitle", 20, new ConfigDescription("Font size for the Gathering List title.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 40), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		GatheringListFontSizeTitle.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		GatheringListFontSizeMaterials = ((BaseUnityPlugin)this).Config.Bind<int>("07 - Gathering List", "GatheringListFontSizeMaterials", 15, new ConfigDescription("Font size for material amounts in the Gathering List.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 40), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 95
			}
		}));
		GatheringListFontSizeMaterials.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		ContainerGatheringListPosition = ((BaseUnityPlugin)this).Config.Bind<Vector2>("07 - Gathering List", "ContainerGatheringListPosition", new Vector2(-400f, 320f), new ConfigDescription("Gathering List position offset (X, Y) when a container (chest/inventory) is open.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 94
			}
		}));
		GroupCompactThreshold = ((BaseUnityPlugin)this).Config.Bind<int>("08 - Groups", "GroupCompactThreshold", 4, new ConfigDescription("Number of unique materials above which a group pin switches to compact (grid) layout. Default: 4 (triggers at 5+).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		GroupCompactThreshold.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		GroupCompactMaxRows = ((BaseUnityPlugin)this).Config.Bind<int>("08 - Groups", "GroupCompactMaxRows", 3, new ConfigDescription("Number of grid rows a compact group pin shows before collapsing the rest into a \"+N\" cell. Default: 3.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		GroupCompactMaxRows.SettingChanged += delegate
		{
			RecipeMgr?.RefreshRecipeCache();
		};
		GroupIconFontSize = ((BaseUnityPlugin)this).Config.Bind<int>("08 - Groups", "GroupIconFontSize", 16, new ConfigDescription("Font size of the member count number displayed on the group icon.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 32), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		GroupIconFontSize.SettingChanged += delegate
		{
			UIMgr?.DestroyUI();
		};
		MyPinsPanelWidth = ((BaseUnityPlugin)this).Config.Bind<float>("09 - My Pins Panel", "PanelWidth", 375f, new ConfigDescription("Width of the My Pins panel.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(200f, 600f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		MyPinsPanelWidth.SettingChanged += delegate
		{
			UIMgr?.DestroyMyPinsUI();
		};
		MyPinsPanelHeight = ((BaseUnityPlugin)this).Config.Bind<float>("09 - My Pins Panel", "PanelHeight", 480f, new ConfigDescription("Height of the My Pins panel.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(200f, 800f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		MyPinsPanelHeight.SettingChanged += delegate
		{
			UIMgr?.DestroyMyPinsUI();
		};
		MyPinsPanelPosition = ((BaseUnityPlugin)this).Config.Bind<Vector2>("09 - My Pins Panel", "PanelPosition", Vector2.zero, new ConfigDescription("Position offset (X, Y) of the My Pins panel from the screen center. (0, 0) = perfectly centered.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		MyPinsPanelPosition.SettingChanged += delegate
		{
			UIMgr?.DestroyMyPinsUI();
		};
		ButtonTextColor = ((BaseUnityPlugin)this).Config.Bind<Color>("09 - My Pins Panel", "ButtonIconColor", new Color(1f, 0.631f, 0.239f, 1f), new ConfigDescription("Tint color of the pin icon on the My Pins button (default: #ffa13d).", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 96
			}
		}));
		ButtonTextColor.SettingChanged += delegate
		{
			UIMgr?.DestroyMyPinsUI();
		};
		MyPinsButtonPosition = ((BaseUnityPlugin)this).Config.Bind<Vector2>("09 - My Pins Panel", "MyPinsButtonPosition", new Vector2(-500f, 570f), new ConfigDescription("Position offset (X, Y) of the My Pins button from the inventory.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 95
			}
		}));
		MyPinsButtonPosition.SettingChanged += delegate
		{
			UIMgr?.DestroyMyPinsUI();
		};
		MyPinsButtonSize = ((BaseUnityPlugin)this).Config.Bind<int>("09 - My Pins Panel", "MyPinsButtonSize", 40, new ConfigDescription("Size of the My Pins icon button in pixels.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(20, 200), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 94
			}
		}));
		MyPinsButtonSize.SettingChanged += delegate
		{
			UIMgr?.DestroyMyPinsUI();
		};
		VerticalListWidth = ((BaseUnityPlugin)this).Config.Bind<float>("10 - Layout (Vertical Mode)", "ListWidth", 265f, new ConfigDescription("Width of the pin list panel.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		VerticalPinSpacing = ((BaseUnityPlugin)this).Config.Bind<float>("10 - Layout (Vertical Mode)", "PinSpacing", 10f, new ConfigDescription("Vertical spacing between pin cards.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		VerticalPosition = ((BaseUnityPlugin)this).Config.Bind<Vector2>("10 - Layout (Vertical Mode)", "Position", new Vector2(-40f, -250f), new ConfigDescription("Anchor position offset (X, Y).", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		HorizontalColumnWidth = ((BaseUnityPlugin)this).Config.Bind<float>("11 - Layout (Horizontal - Map Side)", "ColumnWidth", 265f, new ConfigDescription("Width of each pin column.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		HorizontalPinSpacing = ((BaseUnityPlugin)this).Config.Bind<float>("11 - Layout (Horizontal - Map Side)", "PinSpacing", 10f, new ConfigDescription("Spacing between pin cards in the column.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		HorizontalPosition = ((BaseUnityPlugin)this).Config.Bind<Vector2>("11 - Layout (Horizontal - Map Side)", "Position", new Vector2(-250f, -40f), new ConfigDescription("Anchor position offset (X, Y).", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		BottomRightColumnWidth = ((BaseUnityPlugin)this).Config.Bind<float>("12 - Layout (Horizontal - Bottom Right)", "ColumnWidth", 265f, new ConfigDescription("Width of each pin column.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		BottomRightPinSpacing = ((BaseUnityPlugin)this).Config.Bind<float>("12 - Layout (Horizontal - Bottom Right)", "PinSpacing", 10f, new ConfigDescription("Spacing between pin cards in the column.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 98
			}
		}));
		BottomRightPosition = ((BaseUnityPlugin)this).Config.Bind<Vector2>("12 - Layout (Horizontal - Bottom Right)", "Position", new Vector2(-40f, 40f), new ConfigDescription("Anchor position offset (X, Y).", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 97
			}
		}));
		EnableDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("13 - Debug", "EnableDebugLogging", false, new ConfigDescription("Enable verbose debug logging to the BepInEx console.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 99
			}
		}));
		DebugLogger.Log("Config loaded");
	}
}
public static class ReflectionHelper
{
	private static Func<float> _getGuiScale;

	private static Func<InventoryGui, Transform> _getRecipeListRoot;

	private static Func<InventoryGui, object> _getAvailableRecipes;

	private static Func<InventoryGui, Container> _getCurrentContainer;

	private static Func<InventoryGui, Recipe> _getCraftRecipe;

	private static Func<InventoryGui, ItemData> _getCraftUpgradeItem;

	private static Func<Hud, Piece> _getHoveredPiece;

	private static FieldInfo[] _blockingInventoryPanelFields;

	public static Func<Container, long, bool> CheckContainerAccess;

	public static float currentGuiScaleValue;

	static ReflectionHelper()
	{
		currentGuiScaleValue = 1f;
		InitializeReflection();
	}

	public static void InitializeReflection()
	{
		DebugLogger.Log("Reflection init");
		int num = 0;
		int num2 = 0;
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(GuiScaler), "m_largeGuiScale");
			if (fieldInfo != null && fieldInfo.IsStatic)
			{
				_getGuiScale = Expression.Lambda<Func<float>>(Expression.Field(null, fieldInfo), Array.Empty<ParameterExpression>()).Compile();
				num++;
				DebugLogger.Verbose("✓ GuiScaler.m_largeGuiScale");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ GuiScaler.m_largeGuiScale not found");
			}
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(InventoryGui), "m_recipeListRoot");
			if (fieldInfo2 != null)
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(InventoryGui), "arg");
				_getRecipeListRoot = Expression.Lambda<Func<InventoryGui, Transform>>(Expression.Field(parameterExpression, fieldInfo2), new ParameterExpression[1] { parameterExpression }).Compile();
				num++;
				DebugLogger.Verbose("✓ InventoryGui.m_recipeListRoot");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ InventoryGui.m_recipeListRoot not found");
			}
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(InventoryGui), "m_availableRecipes");
			if (fieldInfo3 != null)
			{
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(InventoryGui), "arg");
				_getAvailableRecipes = Expression.Lambda<Func<InventoryGui, object>>(Expression.Field(parameterExpression2, fieldInfo3), new ParameterExpression[1] { parameterExpression2 }).Compile();
				num++;
				DebugLogger.Verbose("✓ InventoryGui.m_availableRecipes");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ InventoryGui.m_availableRecipes not found");
			}
			FieldInfo fieldInfo4 = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");
			if (fieldInfo4 != null)
			{
				ParameterExpression parameterExpression3 = Expression.Parameter(typeof(InventoryGui), "arg");
				_getCurrentContainer = Expression.Lambda<Func<InventoryGui, Container>>(Expression.Field(parameterExpression3, fieldInfo4), new ParameterExpression[1] { parameterExpression3 }).Compile();
				num++;
				DebugLogger.Verbose("✓ InventoryGui.m_currentContainer");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ InventoryGui.m_currentContainer not found");
			}
			FieldInfo fieldInfo5 = AccessTools.Field(typeof(InventoryGui), "m_craftRecipe");
			if (fieldInfo5 != null)
			{
				ParameterExpression parameterExpression4 = Expression.Parameter(typeof(InventoryGui), "arg");
				_getCraftRecipe = Expression.Lambda<Func<InventoryGui, Recipe>>(Expression.Field(parameterExpression4, fieldInfo5), new ParameterExpression[1] { parameterExpression4 }).Compile();
				num++;
				DebugLogger.Verbose("✓ InventoryGui.m_craftRecipe");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ InventoryGui.m_craftRecipe not found");
			}
			FieldInfo fieldInfo6 = AccessTools.Field(typeof(InventoryGui), "m_craftUpgradeItem");
			if (fieldInfo6 != null)
			{
				ParameterExpression parameterExpression5 = Expression.Parameter(typeof(InventoryGui), "arg");
				_getCraftUpgradeItem = Expression.Lambda<Func<InventoryGui, ItemData>>(Expression.Field(parameterExpression5, fieldInfo6), new ParameterExpression[1] { parameterExpression5 }).Compile();
				num++;
				DebugLogger.Verbose("✓ InventoryGui.m_craftUpgradeItem");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ InventoryGui.m_craftUpgradeItem not found");
			}
			FieldInfo fieldInfo7 = AccessTools.Field(typeof(Hud), "m_hoveredPiece");
			if (fieldInfo7 != null)
			{
				ParameterExpression parameterExpression6 = Expression.Parameter(typeof(Hud), "arg");
				_getHoveredPiece = Expression.Lambda<Func<Hud, Piece>>(Expression.Field(parameterExpression6, fieldInfo7), new ParameterExpression[1] { parameterExpression6 }).Compile();
				num++;
				DebugLogger.Verbose("✓ Hud.m_hoveredPiece");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ Hud.m_hoveredPiece not found");
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(Container), "CheckAccess", new Type[1] { typeof(long) }, (Type[])null);
			if (methodInfo != null)
			{
				CheckContainerAccess = AccessTools.MethodDelegate<Func<Container, long, bool>>(methodInfo, (object)null, true);
				num++;
				DebugLogger.Verbose("✓ Container.CheckAccess");
			}
			else
			{
				num2++;
				DebugLogger.Warning("✗ Container.CheckAccess not found");
			}
			DebugLogger.Log($"Reflection done: {num} ok, {num2} failed");
			if (num2 > 0)
			{
				DebugLogger.Warning("Some reflection targets failed");
			}
		}
		catch (Exception ex)
		{
			DebugLogger.Error("Reflection init failed", ex);
		}
	}

	public static void UpdateGuiScale()
	{
		if (_getGuiScale != null)
		{
			currentGuiScaleValue = _getGuiScale();
		}
		else
		{
			currentGuiScaleValue = 1f;
		}
	}

	public static Transform GetRecipeListRoot(InventoryGui gui)
	{
		if (_getRecipeListRoot == null)
		{
			DebugLogger.Warning("GetRecipeListRoot delegate is null");
			return null;
		}
		return _getRecipeListRoot(gui);
	}

	public static object GetAvailableRecipes(InventoryGui gui)
	{
		if (_getAvailableRecipes == null)
		{
			DebugLogger.Warning("GetAvailableRecipes delegate is null");
			return null;
		}
		return _getAvailableRecipes(gui);
	}

	public static Container GetCurrentContainer(InventoryGui gui)
	{
		if (_getCurrentContainer == null)
		{
			DebugLogger.Verbose("GetCurrentContainer delegate is null");
			return null;
		}
		return _getCurrentContainer(gui);
	}

	public static Recipe GetCraftRecipe(InventoryGui gui)
	{
		if (_getCraftRecipe == null)
		{
			DebugLogger.Warning("GetCraftRecipe delegate is null");
			return null;
		}
		return _getCraftRecipe(gui);
	}

	public static ItemData GetCraftUpgradeItem(InventoryGui gui)
	{
		return _getCraftUpgradeItem?.Invoke(gui);
	}

	public static Piece GetHoveredPiece(Hud hud)
	{
		if (_getHoveredPiece == null)
		{
			DebugLogger.Verbose("GetHoveredPiece delegate is null");
			return null;
		}
		return _getHoveredPiece(hud);
	}

	public static bool IsBlockingInventoryPanelOpen(InventoryGui gui)
	{
		if ((Object)(object)gui == (Object)null)
		{
			return false;
		}
		FieldInfo[] blockingInventoryPanelFields = GetBlockingInventoryPanelFields();
		for (int i = 0; i < blockingInventoryPanelFields.Length; i++)
		{
			if (IsActiveUnityObject(blockingInventoryPanelFields[i].GetValue(gui)))
			{
				return true;
			}
		}
		return false;
	}

	private static FieldInfo[] GetBlockingInventoryPanelFields()
	{
		if (_blockingInventoryPanelFields != null)
		{
			return _blockingInventoryPanelFields;
		}
		List<FieldInfo> list = new List<FieldInfo>();
		FieldInfo[] fields = typeof(InventoryGui).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (FieldInfo fieldInfo in fields)
		{
			string text = fieldInfo.Name.ToLowerInvariant();
			if ((text.Contains("troph") || text.Contains("skill") || text.Contains("compendium") || text.Contains("texts")) && (typeof(GameObject).IsAssignableFrom(fieldInfo.FieldType) || typeof(Component).IsAssignableFrom(fieldInfo.FieldType)))
			{
				list.Add(fieldInfo);
			}
		}
		_blockingInventoryPanelFields = list.ToArray();
		return _blockingInventoryPanelFields;
	}

	private static bool IsActiveUnityObject(object value)
	{
		GameObject val = (GameObject)((value is GameObject) ? value : null);
		if (val != null)
		{
			return val.activeInHierarchy;
		}
		Component val2 = (Component)((value is Component) ? value : null);
		if (val2 != null)
		{
			if ((Object)(object)val2.gameObject != (Object)null)
			{
				return val2.gameObject.activeInHierarchy;
			}
			return false;
		}
		return false;
	}
}
public static class InputHelper
{
	public static bool IsInputBlocked()
	{
		if (GroupNameDialog.IsDialogOpen)
		{
			return true;
		}
		if (ConfirmDialog.IsDialogOpen)
		{
			return true;
		}
		if (Console.IsVisible())
		{
			return true;
		}
		if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
		{
			return true;
		}
		if (TextInput.IsVisible())
		{
			return true;
		}
		return false;
	}

	public static bool IsMouseOverRect(RectTransform rect, bool logHit = true)
	{
		//IL_0016: 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)
		if ((Object)(object)rect == (Object)null)
		{
			DebugLogger.Verbose("IsMouseOverRect: rect is null");
			return false;
		}
		bool num = RectTransformUtility.RectangleContainsScreenPoint(rect, Vector2.op_Implicit(Input.mousePosition));
		if (num && logHit)
		{
			DebugLogger.Verbose("Mouse over rect: " + ((Object)((Component)rect).gameObject).name);
		}
		return num;
	}
}
public class GatheringItemUI : MonoBehaviour
{
	public Image Icon;

	public Text AmountText;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
	}
}
public class GatheringListUI : MonoBehaviour
{
	public RectTransform PanelRect;

	public Image BgImage;

	public Text TitleText;

	public Transform ItemListRoot;

	public Text HintText;

	public List<GatheringItemUI> ItemSlots = new List<GatheringItemUI>();

	private Coroutine _layoutCoroutine;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
	}

	public void RefreshLayout()
	{
		if (((Component)this).gameObject.activeInHierarchy)
		{
			if (_layoutCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_layoutCoroutine);
			}
			_layoutCoroutine = ((MonoBehaviour)this).StartCoroutine(FixLayout());
		}
	}

	private void OnDisable()
	{
		_layoutCoroutine = null;
	}

	private IEnumerator FixLayout()
	{
		yield return null;
		if ((Object)(object)ItemListRoot != (Object)null)
		{
			Transform itemListRoot = ItemListRoot;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemListRoot is RectTransform) ? itemListRoot : null));
		}
		if ((Object)(object)PanelRect != (Object)null)
		{
			LayoutRebuilder.ForceRebuildLayoutImmediate(PanelRect);
		}
	}

	public void ApplyColumns(int configCols)
	{
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: 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)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)ItemListRoot == (Object)null)
		{
			return;
		}
		GridLayoutGroup component = ((Component)ItemListRoot).GetComponent<GridLayoutGroup>();
		if (!((Object)(object)component == (Object)null))
		{
			VerticalLayoutGroup component2 = ((Component)this).GetComponent<VerticalLayoutGroup>();
			float num = (((Object)(object)component2 != (Object)null) ? ((float)(((LayoutGroup)component2).padding.left + ((LayoutGroup)component2).padding.right)) : 22f);
			float x = component.cellSize.x;
			float x2 = component.spacing.x;
			if (configCols > 0)
			{
				component.constraintCount = configCols;
				float num2 = (float)configCols * (x + x2) - x2 + num;
				PanelRect.sizeDelta = new Vector2(num2, PanelRect.sizeDelta.y);
			}
			else
			{
				float num3 = PanelRect.sizeDelta.x - num;
				int constraintCount = Mathf.Max(1, Mathf.FloorToInt((num3 + x2) / (x + x2)));
				component.constraintCount = constraintCount;
			}
		}
	}

	public static float CalculateWidthForColumns(int cols)
	{
		float num = 58f;
		float num2 = 4f;
		float num3 = 22f;
		return (float)cols * (num + num2) - num2 + num3;
	}
}
public class GatheringItemData
{
	public string ItemName;

	public string DisplayName;

	public Sprite Icon;

	public int TotalRequired;

	public int TotalHave;

	public bool IsComplete;
}
public static class UIBuilder
{
	private static Color DividerColor = new Color(1f, 1f, 1f, 0.1f);

	private static Sprite _cachedUiSprite;

	private static bool _spriteSearchDone = false;

	private static Font _cachedNorseFont;

	private static Sprite _cachedPinIcon;

	private static bool _pinIconLoadAttempted = false;

	private static bool _vanillaBtnCached = false;

	private static Sprite _vanillaBtnSprite;

	private static Material _vanillaBtnMaterial;

	private static ColorBlock _vanillaBtnColors;

	private static Font _vanillaBtnFont;

	private static int _vanillaBtnFontSize;

	private static FontStyle _vanillaBtnFontStyle;

	private static Color _vanillaBtnTextColor;

	private static bool _vanillaBtnHasOutline;

	private static Color _vanillaBtnOutlineColor;

	private static Vector2 _vanillaBtnOutlineDistance;

	private static Transition _vanillaBtnTransition;

	private static SpriteState _vanillaBtnSpriteState;

	private static AnimationTriggers _vanillaBtnAnimTriggers;

	private static GameObject _cachedButtonSfxPrefab;

	private static Color ValheimOrange => (Color)(((??)RecipePinnerPlugin.ButtonTextColor?.Value) ?? new Color(1f, 0.631f, 0.239f, 1f));

	private static Sprite LoadPinIconSprite()
	{
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Expected O, but got Unknown
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		if (_pinIconLoadAttempted)
		{
			return _cachedPinIcon;
		}
		_pinIconLoadAttempted = true;
		try
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("RecipePinner.pinIcon.png");
			if (stream == null)
			{
				DebugLogger.Warning("pin.png embedded resource not found");
				return null;
			}
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				stream.CopyTo(memoryStream);
				array = memoryStream.ToArray();
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			bool flag = false;
			MethodInfo method = typeof(Texture2D).GetMethod("LoadImage", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(byte[]) }, null);
			if (method != null)
			{
				flag = (bool)(method.Invoke(val, new object[1] { array }) ?? ((object)false));
			}
			else
			{
				Type type = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule");
				if (type != null)
				{
					MethodInfo method2 = type.GetMethod("LoadImage", new Type[2]
					{
						typeof(Texture2D),
						typeof(byte[])
					});
					if (method2 != null)
					{
						flag = (bool)(method2.Invoke(null, new object[2] { val, array }) ?? ((object)false));
					}
				}
			}
			if (!flag)
			{
				DebugLogger.Warning("pin.png: LoadImage failed (reflection)");
				return null;
			}
			_cachedPinIcon = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			DebugLogger.Log($"pin.png loaded: {((Texture)val).width}x{((Texture)val).height}");
			return _cachedPinIcon;
		}
		catch (Exception ex)
		{
			DebugLogger.Warning("pin.png load error: " + ex.Message);
			return null;
		}
	}

	private static bool TryGetTrophiesPanelBackground(out Sprite sprite, out Material material)
	{
		sprite = null;
		material = null;
		if ((Object)(object)InventoryGui.instance == (Object)null || (Object)(object)InventoryGui.instance.m_trophiesPanel == (Object)null)
		{
			DebugLogger.Warning("TryGetTrophiesPanelBackground: InventoryGui or m_trophiesPanel is null");
			return false;
		}
		GameObject trophiesPanel = InventoryGui.instance.m_trophiesPanel;
		Image component = trophiesPanel.GetComponent<Image>();
		if ((Object)(object)component != (Object)null && (Object)(object)component.sprite != (Object)null)
		{
			sprite = component.sprite;
			material = ((Graphic)component).material;
			DebugLogger.Verbose("TryGetTrophiesPanelBackground: Found on root - sprite=" + ((Object)sprite).name + ", material=" + (((Object)(object)material != (Object)null) ? ((Object)material).name : "null"));
			return true;
		}
		Transform val = trophiesPanel.transform.Find("background") ?? trophiesPanel.transform.Find("Background") ?? trophiesPanel.transform.Find("bg");
		if ((Object)(object)val != (Object)null)
		{
			Image component2 = ((Component)val).GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component2.sprite != (Object)null)
			{
				sprite = component2.sprite;
				material = ((Graphic)component2).material;
				DebugLogger.Verbose("TryGetTrophiesPanelBackground: Found on child '" + ((Object)val).name + "' - sprite=" + ((Object)sprite).name);
				return true;
			}
		}
		Image[] componentsInChildren = trophiesPanel.GetComponentsInChildren<Image>(true);
		foreach (Image val2 in componentsInChildren)
		{
			if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sprite != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)(object)trophiesPanel)
			{
				sprite = val2.sprite;
				material = ((Graphic)val2).material;
				DebugLogger.Verbose("TryGetTrophiesPanelBackground: Found on child '" + ((Object)((Component)val2).gameObject).name + "' via iteration");
				return true;
			}
		}
		DebugLogger.Warning("TryGetTrophiesPanelBackground: No suitable background found");
		return false;
	}

	private static bool TryGetVanillaInputFieldStyle(out Sprite sprite, out Material material, out Color color, out Selectable source)
	{
		//IL_0007: 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_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		sprite = null;
		material = null;
		color = Color.white;
		source = null;
		TextInput instance = TextInput.instance;
		if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_inputField == (Object)null)
		{
			DebugLogger.Verbose("TryGetVanillaInputFieldStyle: TextInput or m_inputField is null");
			return false;
		}
		Graphic targetGraphic = ((Selectable)instance.m_inputField).targetGraphic;
		Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)instance.m_inputField).GetComponent<Image>();
		}
		if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null)
		{
			DebugLogger.Verbose("TryGetVanillaInputFieldStyle: no background Image with a sprite");
			return false;
		}
		sprite = val.sprite;
		material = ((Graphic)val).material;
		color = ((Graphic)val).color;
		source = (Selectable)(object)instance.m_inputField;
		DebugLogger.Verbose("TryGetVanillaInputFieldStyle: sprite=" + ((Object)sprite).name + ", material=" + (((Object)(object)material != (Object)null) ? ((Object)material).name : "null"));
		return true;
	}

	private static Sprite GetBackgroundSprite()
	{
		if ((Object)(object)_cachedUiSprite != (Object)null)
		{
			return _cachedUiSprite;
		}
		if (_spriteSearchDone)
		{
			return null;
		}
		Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
		Sprite val = null;
		Sprite[] array2 = array;
		foreach (Sprite val2 in array2)
		{
			if (!((Object)(object)val2 == (Object)null))
			{
				if (((Object)val2).name == "UISprite")
				{
					_cachedUiSprite = val2;
					break;
				}
				if ((Object)(object)val == (Object)null && ((Object)val2).name == "Knob")
				{
					val = val2;
				}
			}
		}
		if ((Object)(object)_cachedUiSprite == (Object)null)
		{
			_cachedUiSprite = val;
		}
		_spriteSearchDone = true;
		if ((Object)(object)_cachedUiSprite != (Object)null)
		{
			DebugLogger.Verbose("Found background sprite: " + ((Object)_cachedUiSprite).name);
		}
		else
		{
			DebugLogger.Warning("No suitable background sprite found");
		}
		return _cachedUiSprite;
	}

	public static Sprite GetUISpritePublic()
	{
		return GetBackgroundSprite();
	}

	public static void PlayButtonSFX()
	{
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_cachedButtonSfxPrefab == (Object)null)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance != (Object)null)
			{
				EffectList setActiveGroupEffects = instance.m_setActiveGroupEffects;
				if (setActiveGroupEffects != null && setActiveGroupEffects.m_effectPrefabs?.Length > 0)
				{
					_cachedButtonSfxPrefab = instance.m_setActiveGroupEffects.m_effectPrefabs[0].m_prefab;
					if ((Object)(object)_cachedButtonSfxPrefab != (Object)null)
					{
						DebugLogger.Log("Cached button SFX prefab: " + ((Object)_cachedButtonSfxPrefab).name);
					}
				}
			}
		}
		if ((Object)(object)_cachedButtonSfxPrefab != (Object)null)
		{
			Player localPlayer = Player.m_localPlayer;
			Vector3 val = (((Object)(object)localPlayer != (Object)null) ? ((Component)localPlayer).transform.position : Vector3.zero);
			Object.Instantiate<GameObject>(_cachedButtonSfxPrefab, val, Quaternion.identity);
		}
	}

	private static void CacheVanillaButtonStyle()
	{
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: 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_00d2: 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_010d: 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_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		if (_vanillaBtnCached)
		{
			return;
		}
		_vanillaBtnCached = true;
		if ((Object)(object)InventoryGui.instance == (Object)null)
		{
			return;
		}
		FieldInfo fieldInfo = AccessTools.Field(typeof(InventoryGui), "m_craftButton");
		if (fieldInfo == null)
		{
			DebugLogger.Warning("Vanilla button style: m_craftButton field not found");
			return;
		}
		object? value = fieldInfo.GetValue(InventoryGui.instance);
		Button val = (Button)((value is Button) ? value : null);
		if ((Object)(object)val == (Object)null)
		{
			DebugLogger.Warning("Vanilla button style: m_craftButton value is null");
			return;
		}
		Image component = ((Component)val).GetComponent<Image>();
		if ((Object)(object)component != (Object)null)
		{
			_vanillaBtnSprite = component.sprite;
			_vanillaBtnMaterial = ((Graphic)component).material;
		}
		_vanillaBtnColors = ((Selectable)val).colors;
		Text componentInChildren = ((Component)val).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			_vanillaBtnFont = componentInChildren.font;
			_vanillaBtnFontSize = componentInChildren.fontSize;
			_vanillaBtnFontStyle = componentInChildren.fontStyle;
			_vanillaBtnTextColor = ((Graphic)componentInChildren).color;
		}
		Outline componentInChildren2 = ((Component)val).GetComponentInChildren<Outline>();
		if ((Object)(object)componentInChildren2 != (Object)null)
		{
			_vanillaBtnHasOutline = true;
			_vanillaBtnOutlineColor = ((Shadow)componentInChildren2).effectColor;
			_vanillaBtnOutlineDistance = ((Shadow)componentInChildren2).effectDistance;
		}
		_vanillaBtnTransition = ((Selectable)val).transition;
		_vanillaBtnSpriteState = ((Selectable)val).spriteState;
		_vanillaBtnAnimTriggers = ((Selectable)val).animationTriggers;
		Sprite vanillaBtnSprite = _vanillaBtnSprite;
		string arg = ((vanillaBtnSprite != null) ? ((Object)vanillaBtnSprite).name : null);
		Font vanillaBtnFont = _vanillaBtnFont;
		DebugLogger.Log($"Vanilla button style cached (sprite={arg}, font={((vanillaBtnFont != null) ? ((Object)vanillaBtnFont).name : null)}, transition={_vanillaBtnTransition})");
	}

	public static Button CreateVanillaButton(Transform parent, string label, float minWidth = -1f, float minHeight = 35f)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected O, but got Unknown
		//IL_006d: 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_00dc: 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_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: 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_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: 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_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Invalid comparison between Unknown and I4
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Invalid comparison between Unknown and I4
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0200: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Expected O, but got Unknown
		//IL_0269: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_031c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0332: Unknown result type (might be due to invalid IL or missing references)
		//IL_0302: Unknown result type (might be due to invalid IL or missing references)
		//IL_030e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0344: Unknown result type (might be due to invalid IL or missing references)
		//IL_034f: Unknown result type (might be due to invalid IL or missing references)
		//IL_035a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0364: Unknown result type (might be due to invalid IL or missing references)
		//IL_037b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Expected O, but got Unknown
		CacheVanillaButtonStyle();
		GameObject val = new GameObject("Btn_" + label, new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		Image val2 = val.AddComponent<Image>();
		if ((Object)(object)_vanillaBtnSprite != (Object)null)
		{
			val2.sprite = _vanillaBtnSprite;
			((Graphic)val2).material = _vanillaBtnMaterial;
			val2.type = (Type)((_vanillaBtnSprite.border != Vector4.zero) ? 1 : 0);
			((Graphic)val2).color = Color.white;
		}
		else
		{
			Sprite val3 = (val2.sprite = GetBackgroundSprite());
			if ((Object)(object)val3 != (Object)null && val3.border != Vector4.zero)
			{
				val2.type = (Type)1;
			}
			((Graphic)val2).color = new Color(0.2f, 0.2f, 0.2f, 0.9f);
		}
		((Graphic)val2).raycastTarget = true;
		Button val4 = val.AddComponent<Button>();
		if ((Object)(object)_vanillaBtnSprite != (Object)null)
		{
			((Selectable)val4).colors = _vanillaBtnColors;
			((Selectable)val4).transition = _vanillaBtnTransition;
			if ((int)_vanillaBtnTransition == 2)
			{
				((Selectable)val4).spriteState = _vanillaBtnSpriteState;
			}
			if ((int)_vanillaBtnTransition == 3 && _vanillaBtnAnimTriggers != null)
			{
				((Selectable)val4).animationTriggers = _vanillaBtnAnimTriggers;
			}
		}
		else
		{
			ColorBlock colors = ((Selectable)val4).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(1f, 0.77f, 0.31f, 0.9f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 0.85f, 0.5f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.8f, 0.6f, 0.2f, 1f);
			((Selectable)val4).colors = colors;
		}
		((Selectable)val4).targetGraphic = (Graphic)(object)val2;
		LayoutElement val5 = val.AddComponent<LayoutElement>();
		val5.minHeight = minHeight;
		if (minWidth > 0f)
		{
			val5.minWidth = minWidth;
		}
		val5.flexibleWidth = 1f;
		GameObject val6 = new GameObject("Text", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val6.transform.SetParent(val.transform, false);
		Text val7 = val6.AddComponent<Text>();
		((Graphic)val7).raycastTarget = false;
		val7.text = label;
		val7.alignment = (TextAnchor)4;
		if ((Object)(object)_vanillaBtnFont != (Object)null)
		{
			val7.font = _vanillaBtnFont;
			val7.fontSize = _vanillaBtnFontSize;
			val7.fontStyle = _vanillaBtnFontStyle;
		}
		else
		{
			Font val8 = null;
			Font[] array = Resources.FindObjectsOfTypeAll<Font>();
			foreach (Font val9 in array)
			{
				if ((Object)(object)val9 != (Object)null && ((Object)val9).name == "AveriaSerifLibre-Bold")
				{
					val8 = val9;
					break;
				}
			}
			val7.font = val8 ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			val7.fontSize = 16;
			val7.fontStyle = (FontStyle)1;
		}
		((Graphic)val7).color = ValheimOrange;
		Outline val10 = val6.AddComponent<Outline>();
		if (_vanillaBtnHasOutline)
		{
			((Shadow)val10).effectColor = _vanillaBtnOutlineColor;
			((Shadow)val10).effectDistance = _vanillaBtnOutlineDistance;
		}
		else
		{
			((Shadow)val10).effectColor = Color.black;
			((Shadow)val10).effectDistance = new Vector2(1f, -1f);
		}
		RectTransform component = val6.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		((UnityEvent)val4.onClick).AddListener(new UnityAction(PlayButtonSFX));
		return val4;
	}

	public static Button CreateSmallVanillaButton(Transform parent, string label, float size = 32f)
	{
		Button obj = CreateVanillaButton(parent, label, -1f, size);
		LayoutElement component = ((Component)obj).GetComponent<LayoutElement>();
		component.minWidth = size;
		component.minHeight = size;
		component.preferredWidth = size;
		component.preferredHeight = size;
		component.flexibleWidth = 0f;
		return obj;
	}

	public static GameObject CreateModalOverlay(Transform parent, Action onClick)
	{
		//IL_002f: 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_003b: 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_004f: 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_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: 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)
		//IL_00a6: 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_00ba: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Expected O, but got Unknown
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Expected O, but got Unknown
		DebugLogger.Log("Creating modal overlay");
		GameObject val = new GameObject("ModalOverlay", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = new Color(0f, 0f, 0f, 0.35f);
		((Graphic)val2).raycastTarget = true;
		Button val3 = val.AddComponent<Button>();
		((Selectable)val3).targetGraphic = (Graphic)(object)val2;
		ColorBlock colors = ((Selectable)val3).colors;
		((ColorBlock)(ref colors)).normalColor = Color.white;
		((ColorBlock)(ref colors)).highlightedColor = Color.white;
		((ColorBlock)(ref colors)).pressedColor = Color.white;
		((ColorBlock)(ref colors)).selectedColor = Color.white;
		((ColorBlock)(ref colors)).disabledColor = Color.white;
		((Selectable)val3).colors = colors;
		if (onClick != null)
		{
			((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
			{
				onClick();
			});
		}
		val.SetActive(false);
		DebugLogger.Log("Modal overlay created");
		return val;
	}

	public static PinSlotUI CreatePinSlot(Transform parent, Font font)
	{
		//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_0025: Expected O, but got Unknown
		//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_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Expected O, but got Unknown
		//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Expected O, but got Unknown
		//IL_028b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0290: Unknown result type (might be due to invalid IL or missing references)
		//IL_0297: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0378: Unknown result type (might be due to invalid IL or missing references)
		//IL_037d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0384: Unknown result type (might be due to invalid IL or missing references)
		//IL_0397: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0416: Unknown result type (might be due to invalid IL or missing references)
		//IL_041b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0422: Unknown result type (might be due to invalid IL or missing references)
		//IL_0434: Unknown result type (might be due to invalid IL or missing references)
		//IL_0452: Unknown result type (might be due to invalid IL or missing references)
		//IL_0457: Unknown result type (might be due to invalid IL or missing references)
		//IL_0477: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d4: Expected O, but got Unknown
		//IL_053f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0544: Unknown result type (might be due to invalid IL or missing references)
		//IL_054d: Expected O, but got Unknown
		//IL_057a: Unknown result type (might be due to invalid IL or missing references)
		//IL_058f: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("PinSlot", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		PinSlotUI pinSlotUI = val.AddComponent<PinSlotUI>();
		pinSlotUI.Rect = val.GetComponent<RectTransform>();
		Image val2 = val.AddComponent<Image>();
		Sprite val3 = (val2.sprite = GetBackgroundSprite());
		if ((Object)(object)val3 != (Object)null && val3.border != Vector4.zero)
		{
			val2.type = (Type)1;
		}
		else
		{
			val2.type = (Type)0;
		}
		float num = ((RecipePinnerPlugin.BackgroundOpacity != null) ? RecipePinnerPlugin.BackgroundOpacity.Value : 0.45f);
		((Graphic)val2).color = new Color(0f, 0f, 0f, num);
		((Graphic)val2).raycastTarget = false;
		GameObject val4 = new GameObject("AccentBar", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val4.transform.SetParent(val.transform, false);
		Image val5 = val4.AddComponent<Image>();
		((Graphic)val5).raycastTarget = false;
		((Graphic)val5).color = new Color(0.9f, 0.25f, 0.25f, 0.5f);
		RectTransform component = val4.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 0f);
		component.anchorMax = new Vector2(0f, 1f);
		component.pivot = new Vector2(0f, 0.5f);
		component.sizeDelta = new Vector2(4f, 0f);
		component.anchoredPosition = Vector2.zero;
		val4.AddComponent<LayoutElement>().ignoreLayout = true;
		pinSlotUI.AccentBar = val5;
		VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 5f;
		((LayoutGroup)obj).padding = new RectOffset(14, 8, 8, 8);
		ContentSizeFitter obj2 = val.AddComponent<ContentSizeFitter>();
		obj2.horizontalFit = (FitMode)0;
		obj2.verticalFit = (FitMode)2;
		GameObject val6 = new GameObject("HeaderRow", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val6.transform.SetParent(val.transform, false);
		HorizontalLayoutGroup obj3 = val6.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj3).spacing = 8f;
		LayoutElement obj4 = val6.AddComponent<LayoutElement>();
		obj4.minHeight = 30f;
		obj4.flexibleHeight = 0f;
		obj4.flexibleWidth = 1f;
		GameObject val7 = new GameObject("Icon", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val7.transform.SetParent(val6.transform, false);
		Image val8 = val7.AddComponent<Image>();
		((Graphic)val8).raycastTarget = false;
		val8.preserveAspect = true;
		pinSlotUI.IconImage = val8;
		LayoutElement obj5 = val7.AddComponent<LayoutElement>();
		int num2 = RecipePinnerPlugin.HudRecipeIconSize?.Value ?? 28;
		obj5.minWidth = num2;
		obj5.minHeight = num2;
		obj5.preferredWidth = num2;
		obj5.preferredHeight = num2;
		obj5.flexibleWidth = 0f;
		int size = RecipePinnerPlugin.HudGroupIconSize?.Value ?? 28;
		var (val9, groupCountText) = CreateGroupIconWidget(val6.transform, font, size);
		val9.SetActive(false);
		pinSlotUI.GroupIconContainer = val9.transform;
		pinSlotUI.GroupCountText = groupCountText;
		GameObject val10 = new GameObject("Title", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val10.transform.SetParent(val6.transform, false);
		Text val11 = val10.AddComponent<Text>();
		((Graphic)val11).raycastTarget = false;
		val11.font = font;
		val11.fontSize = 18;
		val11.alignment = (TextAnchor)3;
		val11.horizontalOverflow = (HorizontalWrapMode)0;
		val11.verticalOverflow = (VerticalWrapMode)1;
		((Graphic)val11).color = ValheimOrange;
		pinSlotUI.HeaderText = val11;
		LayoutElement obj6 = val10.AddComponent<LayoutElement>();
		obj6.minHeight = 24f;
		obj6.flexibleWidth = 1f;
		GameObject val12 = new GameObject("Divider", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val12.transform.SetParent(val.transform, false);
		Image val13 = val12.AddComponent<Image>();
		val13.sprite = GetBackgroundSprite();
		if ((Object)(object)val3 != (Object)null && val3.border != Vector4.zero)
		{
			val13.type = (Type)1;
		}
		else
		{
			val13.type = (Type)0;
		}
		((Graphic)val13).color = DividerColor;
		((Graphic)val13).raycastTarget = false;
		LayoutElement obj7 = val12.AddComponent<LayoutElement>();
		obj7.minHeight = 2f;
		obj7.preferredHeight = 2f;
		obj7.flexibleWidth = 1f;
		GameObject val14 = new GameObject("ResourceList", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val14.transform.SetParent(val.transform, false);
		VerticalLayoutGroup obj8 = val14.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj8).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj8).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj8).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj8).spacing = 3f;
		val14.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
		pinSlotUI.ResourceListRoot = val14.transform;
		GameObject val15 = new GameObject("CompactResourceList", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val15.transform.SetParent(val.transform, false);
		val15.SetActive(false);
		GridLayoutGroup obj9 = val15.AddComponent<GridLayoutGroup>();
		obj9.cellSize = new Vector2(58f, 65f);
		obj9.spacing = new Vector2(4f, 3f);
		obj9.constraint = (Constraint)1;
		obj9.constraintCount = 4;
		((LayoutGroup)obj9).childAlignment = (TextAnchor)1;
		val15.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
		pinSlotUI.CompactResourceRoot = val15.transform;
		DebugLogger.Verbose("Created pin slot UI");
		return pinSlotUI;
	}

	public static (GameObject root, Text countText) CreateGroupIconWidget(Transform parent, Font font, int size = 28)
	{
		//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_0025: Expected O, but got Unknown
		//IL_003c: 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_00b1: 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_00cf: 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_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: 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_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		//IL_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_021b: Unknown result type (might be due to invalid IL or missing references)
		//IL_023d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0249: Unknown result type (might be due to invalid IL or missing references)
		//IL_025b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("GroupIconWidget", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		val.GetComponent<RectTransform>().sizeDelta = new Vector2((float)size, (float)size);
		LayoutElement obj = val.AddComponent<LayoutElement>();
		obj.minWidth = size;
		obj.minHeight = size;
		obj.preferredWidth = size;
		obj.preferredHeight = size;
		obj.flexibleWidth = 0f;
		Sprite backgroundSprite = GetBackgroundSprite();
		bool flag = (Object)(object)backgroundSprite != (Object)null && backgroundSprite.border != Vector4.zero;
		GameObject val2 = new GameObject("BackCard", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val2.transform.SetParent(val.transform, false);
		Image obj2 = val2.AddComponent<Image>();
		obj2.sprite = backgroundSprite;
		obj2.type = (Type)(flag ? 1 : 0);
		((Graphic)obj2).color = new Color(0.65f, 0.52f, 0.34f, 0.92f);
		((Graphic)obj2).raycastTarget = false;
		RectTransform component = val2.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = new Vector2(1f, -2f);
		component.offsetMax = new Vector2(3f, -1f);
		((Transform)component).localRotation = Quaternion.Euler(0f, 0f, -10f);
		GameObject val3 = new GameObject("FrontCard", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		Image obj3 = val3.AddComponent<Image>();
		obj3.sprite = backgroundSprite;
		obj3.type = (Type)(flag ? 1 : 0);
		((Graphic)obj3).color = new Color(0.92f, 0.82f, 0.62f, 0.97f);
		((Graphic)obj3).raycastTarget = false;
		RectTransform component2 = val3.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0.05f, 0.07f);
		component2.anchorMax = new Vector2(0.93f, 0.95f);
		component2.offsetMin = Vector2.zero;
		component2.offsetMax = Vector2.zero;
		GameObject val4 = new GameObject("GroupCount", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val4.transform.SetParent(val.transform, false);
		Text val5 = val4.AddComponent<Text>();
		((Graphic)val5).raycastTarget = false;
		val5.font = font;
		val5.fontSize = RecipePinnerPlugin.GroupIconFontSize?.Value ?? 16;
		val5.fontStyle = (FontStyle)1;
		val5.alignment = (TextAnchor)4;
		((Graphic)val5).color = new Color(0.22f, 0.13f, 0.04f, 1f);
		val5.text = "?";
		RectTransform component3 = val4.GetComponent<RectTransform>();
		component3.anchorMin = Vector2.zero;
		component3.anchorMax = Vector2.one;
		component3.offsetMin = Vector2.zero;
		component3.offsetMax = Vector2.zero;
		return (root: val, countText: val5);
	}

	public static ResourceSlotUI CreateResourceSlot(Transform parent, Font font)
	{
		//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_0025: Expected O, but got Unknown
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Expected O, but got Unknown
		//IL_013d: 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_014b: Expected O, but got Unknown
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Expected O, but got Unknown
		GameObject val = new GameObject("ResSlot", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		ResourceSlotUI resourceSlotUI = val.AddComponent<ResourceSlotUI>();
		HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
		((LayoutGroup)obj).childAlignment = (TextAnchor)3;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
		LayoutElement obj2 = val.AddComponent<LayoutElement>();
		obj2.minHeight = 22f;
		obj2.flexibleHeight = 0f;
		GameObject val2 = new GameObject("Icon", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val2.transform.SetParent(val.transform, false);
		resourceSlotUI.ResIcon = val2.AddComponent<Image>();
		((Graphic)resourceSlotUI.ResIcon).raycastTarget = false;
		resourceSlotUI.ResIcon.preserveAspect = true;
		LayoutElement obj3 = val2.AddComponent<LayoutElement>();
		int num = RecipePinnerPlugin.HudMaterialIconSize?.Value ?? 20;
		obj3.minWidth = num;
		obj3.minHeight = num;
		obj3.preferredWidth = num;
		obj3.preferredHeight = num;
		obj3.flexibleWidth = 0f;
		GameObject val3 = new GameObject("Name", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		resourceSlotUI.ResName = val3.AddComponent<Text>();
		((Graphic)resourceSlotUI.ResName).raycastTarget = false;
		resourceSlotUI.ResName.font = font;
		resourceSlotUI.ResName.fontSize = 15;
		resourceSlotUI.ResName.alignment = (TextAnchor)3;
		resourceSlotUI.ResName.horizontalOverflow = (HorizontalWrapMode)0;
		((Graphic)resourceSlotUI.ResName).color = new Color(0.9f, 0.9f, 0.9f, 1f);
		val3.AddComponent<LayoutElement>().flexibleWidth = 1f;
		GameObject val4 = new GameObject("Amount", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val4.transform.SetParent(val.transform, false);
		resourceSlotUI.ResAmount = val4.AddComponent<Text>();
		((Graphic)resourceSlotUI.ResAmount).raycastTarget = false;
		resourceSlotUI.ResAmount.font = font;
		resourceSlotUI.ResAmount.fontSize = 15;
		resourceSlotUI.ResAmount.alignment = (TextAnchor)5;
		val4.AddComponent<LayoutElement>().minWidth = 40f;
		DebugLogger.Verbose("Created resource slot UI");
		return resourceSlotUI;
	}

	public static GameObject CreatePaginationContainer(Transform parent)
	{
		//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_0024: 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_003d: 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_008a: Expected O, but got Unknown
		GameObject val = new GameObject("PaginationDots", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		val.AddComponent<LayoutElement>().ignoreLayout = true;
		HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = RecipePinnerPlugin.PaginationDotSpacing.Value;
		((LayoutGroup)obj).childAlignment = (TextAnchor)4;
		ContentSizeFitter obj2 = val.AddComponent<ContentSizeFitter>();
		obj2.horizontalFit = (FitMode)2;
		obj2.verticalFit = (FitMode)2;
		return val;
	}

	public static Image CreatePageDot(Transform parent)
	{
		//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_0024: 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_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("PageDot", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		Image val2 = val.AddComponent<Image>();
		val2.type = (Type)0;
		((Graphic)val2).raycastTarget = false;
		int value = RecipePinnerPlugin.PaginationDotSize.Value;
		RectTransform component = val.GetComponent<RectTransform>();
		component.sizeDelta = new Vector2((float)value, (float)value);
		((Transform)component).localRotation = Quaternion.Euler(0f, 0f, 45f);
		return val2;
	}

	public static GatheringListUI CreateGatheringListPanel(Transform parent, Font font, string title)
	{
		//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_0025: Expected O, but got Unknown
		//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_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Expected O, but got Unknown
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: 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_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: 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_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_0220: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Unknown result type (might be due to invalid IL or missing references)
		//IL_0294: Unknown result type (might be due to invalid IL or missing references)
		//IL_0299: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Expected O, but got Unknown
		//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0331: Unknown result type (might be due to invalid IL or missing references)
		//IL_033a: Expected O, but got Unknown
		//IL_038d: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("GatheringListPanel", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		GatheringListUI gatheringListUI = val.AddComponent<GatheringListUI>();
		gatheringListUI.PanelRect = val.GetComponent<RectTransform>();
		Image val2 = val.AddComponent<Image>();
		Sprite val3 = (val2.sprite = GetBackgroundSprite());
		if ((Object)(object)val3 != (Object)null && val3.border != Vector4.zero)
		{
			val2.type = (Type)1;
		}
		else
		{
			val2.type = (Type)0;
		}
		float num = ((RecipePinnerPlugin.BackgroundOpacity != null) ? RecipePinnerPlugin.BackgroundOpacity.Value : 0.45f);
		((Graphic)val2).color = new Color(0f, 0f, 0f, num);
		((Graphic)val2).raycastTarget = false;
		gatheringListUI.BgImage = val2;
		VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 4f;
		((LayoutGroup)obj).padding = new RectOffset(14, 8, 8, 8);
		ContentSizeFitter obj2 = val.AddComponent<ContentSizeFitter>();
		obj2.horizontalFit = (FitMode)0;
		obj2.verticalFit = (FitMode)2;
		GameObject val4 = new GameObject("Header", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val4.transform.SetParent(val.transform, false);
		Text val5 = val4.AddComponent<Text>();
		((Graphic)val5).raycastTarget = false;
		val5.font = font;
		int fontSize = ((RecipePinnerPlugin.GatheringListFontSizeTitle != null) ? RecipePinnerPlugin.GatheringListFontSizeTitle.Value : 15);
		val5.fontSize = fontSize;
		val5.alignment = (TextAnchor)4;
		((Graphic)val5).color = RecipePinnerPlugin.ColorHeader?.Value ?? ValheimOrange;
		val5.text = title;
		gatheringListUI.TitleText = val5;
		LayoutElement obj3 = val4.AddComponent<LayoutElement>();
		obj3.minHeight = 24f;
		obj3.flexibleWidth = 1f;
		GameObject val6 = new GameObject("Divider", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val6.transform.SetParent(val.transform, false);
		Image val7 = val6.AddComponent<Image>();
		val7.sprite = GetBackgroundSprite();
		if ((Object)(object)val3 != (Object)null && val3.border != Vector4.zero)
		{
			val7.type = (Type)1;
		}
		else
		{
			val7.type = (Type)0;
		}
		((Graphic)val7).color = DividerColor;
		((Graphic)val7).raycastTarget = false;
		LayoutElement obj4 = val6.AddComponent<LayoutElement>();
		obj4.minHeight = 2f;
		obj4.preferredHeight = 2f;
		obj4.flexibleWidth = 1f;
		GameObject val8 = new GameObject("ItemList", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val8.transform.SetParent(val.transform, false);
		GridLayoutGroup obj5 = val8.AddComponent<GridLayoutGroup>();
		obj5.cellSize = new Vector2(58f, 65f);
		obj5.spacing = new Vector2(4f, 3f);
		obj5.constraint = (Constraint)1;
		obj5.constraintCount = 4;
		((LayoutGroup)obj5).childAlignment = (TextAnchor)1;
		val8.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
		gatheringListUI.ItemListRoot = val8.transform;
		GameObject val9 = new GameObject("HintText", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val9.transform.SetParent(val.transform, false);
		Text val10 = val9.AddComponent<Text>();
		((Graphic)val10).raycastTarget = false;
		val10.font = font;
		val10.fontSize = 20;
		val10.alignment = (TextAnchor)4;
		((Graphic)val10).color = new Color(0.7f, 0.7f, 0.7f, 0.7f);
		val10.text = "";
		gatheringListUI.HintText = val10;
		LayoutElement obj6 = val9.AddComponent<LayoutElement>();
		obj6.minHeight = 22f;
		obj6.flexibleWidth = 1f;
		DebugLogger.Verbose("Created gathering list panel");
		return gatheringListUI;
	}

	public static GatheringItemUI CreateGatheringItemSlot(Transform parent, Font font)
	{
		//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_0025: Expected O, but got Unknown
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Expected O, but got Unknown
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Expected O, but got Unknown
		//IL_011f: 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_012c: Expected O, but got Unknown
		GameObject val = new GameObject("GatherItem", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		GatheringItemUI gatheringItemUI = val.AddComponent<GatheringItemUI>();
		VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
		((LayoutGroup)obj).childAlignment = (TextAnchor)1;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 1f;
		((LayoutGroup)obj).padding = new RectOffset(0, 0, 1, 0);
		GameObject val2 = new GameObject("Icon", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val2.transform.SetParent(val.transform, false);
		gatheringItemUI.Icon = val2.AddComponent<Image>();
		((Graphic)gatheringItemUI.Icon).raycastTarget = false;
		gatheringItemUI.Icon.preserveAspect = true;
		LayoutElement obj2 = val2.AddComponent<LayoutElement>();
		obj2.minWidth = 45f;
		obj2.minHeight = 45f;
		obj2.preferredWidth = 45f;
		obj2.preferredHeight = 45f;
		GameObject val3 = new GameObject("Amount", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		gatheringItemUI.AmountText = val3.AddComponent<Text>();
		((Graphic)gatheringItemUI.AmountText).raycastTarget = false;
		gatheringItemUI.AmountText.font = font;
		int fontSize = ((RecipePinnerPlugin.GatheringListFontSizeMaterials != null) ? RecipePinnerPlugin.GatheringListFontSizeMaterials.Value : 15);
		gatheringItemUI.AmountText.fontSize = fontSize;
		gatheringItemUI.AmountText.alignment = (TextAnchor)4;
		gatheringItemUI.AmountText.horizontalOverflow = (HorizontalWrapMode)1;
		val3.AddComponent<LayoutElement>().minHeight = 16f;
		return gatheringItemUI;
	}

	public static Button CreateMyPinsButton(Transform parent, Font font)
	{
		//IL_003e: 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_0043: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: 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_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: 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_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: 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)
		//IL_019c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		DebugLogger.Log("Creating My Pins button");
		int num = RecipePinnerPlugin.MyPinsButtonSize?.Value ?? 50;
		Sprite val = LoadPinIconSprite();
		Vector2 val2 = (((Object)(object)val != (Object)null) ? new Vector2((float)num, (float)num) : new Vector2(120f, (float)num));
		string label = (((Object)(object)val != (Object)null) ? string.Empty : (RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("mypins_button") ?? "\ud83d\udccc"));
		Button val3 = CreateVanillaButton(parent, label, (int)val2.x, (int)val2.y);
		((Object)((Component)val3).gameObject).name = "MyPinsButton";
		LayoutElement component = ((Component)val3).GetComponent<LayoutElement>();
		component.flexibleWidth = 0f;
		component.preferredWidth = val2.x;
		((Component)val3).GetComponent<RectTransform>().sizeDelta = val2;
		Text componentInChildren = ((Component)val3).GetComponentInChildren<Text>();
		if ((Object)(object)val != (Object)null)
		{
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Component)componentInChildren).gameObject.SetActive(false);
			}
			GameObject val4 = new GameObject("PinIcon", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val4.transform.SetParent(((Component)val3).transform, false);
			RectTransform component2 = val4.GetComponent<RectTransform>();
			float num2 = 6f;
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(num2, num2);
			component2.offsetMax = new Vector2(0f - num2, 0f - num2);
			Image obj = val4.AddComponent<Image>();
			obj.sprite = val;
			obj.preserveAspect = true;
			Color color = RecipePinnerPlugin.ButtonTextColor?.Value ?? ((_vanillaBtnTextColor != default(Color)) ? _vanillaBtnTextColor : Color.white);
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			DebugLogger.Log("My Pins button: icon mode");
		}
		else
		{
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = 16;
			}
			DebugLogger.Log("My Pins button: text fallback mode");
		}
		DebugLogger.Log("My Pins button created");
		return val3;
	}

	public static MyPinsPanelUI CreateMyPinsPanel(Transform parent, Font font)
	{
		//IL_0028: 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_0035: Expected O, but got Unknown
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Expected O, but got Unknown
		//IL_01cb: 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_01d9: Expected O, but got Unknown
		//IL_0306: Unknown result type (might be due to invalid IL or missing references)
		//IL_035b: Unknown result type (might be due to invalid IL or missing references)
		//IL_036f: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0455: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cd: Expected O, but got Unknown
		//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0674: Unknown result type (might be due to invalid IL or missing references)
		//IL_0679: Unknown result type (might be due to invalid IL or missing references)
		//IL_0682: Expected O, but got Unknown
		//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0713: Unknown result type (might be due to invalid IL or missing references)
		//IL_0735: Unknown result type (might be due to invalid IL or missing references)
		//IL_073a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0743: Expected O, but got Unknown
		//IL_075f: Unknown result type (might be due to invalid IL or missing references)
		//IL_076a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0775: Unknown result type (might be due to invalid IL or missing references)
		//IL_077f: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_07f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_080b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0842: Unknown result type (might be due to invalid IL or missing references)
		//IL_0847: Unknown result type (might be due to invalid IL or missing references)
		//IL_085f: Unknown result type (might be due to invalid IL or missing references)
		//IL_087f: Unknown result type (might be due to invalid IL or missing references)
		//IL_089f: Unknown result type (might be due to invalid IL or missing references)
		//IL_08bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_08df: Unknown result type (might be due to invalid IL or missing references)
		//IL_0903: Unknown result type (might be due to invalid IL or missing references)
		//IL_0933: Unknown result type (might be due to invalid IL or missing references)
		//IL_0938: Unknown result type (might be due to invalid IL or missing references)
		//IL_0941: Expected O, but got Unknown
		//IL_0960: Unknown result type (might be due to invalid IL or missing references)
		//IL_096c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0978: Unknown result type (might be due to invalid IL or missing references)
		//IL_0984: Unknown result type (might be due to invalid IL or missing references)
		//IL_09d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_09da: Unknown result type (might be due to invalid IL or missing references)
		//IL_09e3: Expected O, but got Unknown
		//IL_0a0c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a22: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a38: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a4e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a64: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ae1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ae6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b00: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b3f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bbe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bc3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bca: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bdc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c08: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c66: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d1d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dc5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dca: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dd1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0de3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e04: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f02: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f27: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f31: Expected O, but got Unknown
		DebugLogger.Log("Creating My Pins panel");
		GameObject val = new GameObject("MyPinsPanel", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		MyPinsPanelUI panel = val.AddComponent<MyPinsPanelUI>();
		panel.PanelRect = val.GetComponent<RectTransform>();
		float num = RecipePinnerPlugin.MyPinsPanelWidth?.Value ?? 340f;
		float num2 = RecipePinnerPlugin.MyPinsPanelHeight?.Value ?? 450f;
		panel.PanelRect.sizeDelta = new Vector2(num, num2);
		Image val2 = val.AddComponent<Image>();
		if (TryGetTrophiesPanelBackground(out var sprite, out var material))
		{
			val2.sprite = sprite;
			((Graphic)val2).material = material;
			val2.type = (Type)((sprite.border != Vector4.zero) ? 1 : 0);
			((Graphic)val2).color = Color.white;
			DebugLogger.Log("My Pins panel: Using trophies panel background");
		}
		else
		{
			Sprite val3 = (val2.sprite = GetBackgroundSprite());
			if ((Object)(object)val3 != (Object)null && val3.border != Vector4.zero)
			{
				val2.type = (Type)1;
			}
			else
			{
				val2.type = (Type)0;
			}
			((Graphic)val2).color = new Color(0f, 0f, 0f, 0.85f);
			DebugLogger.Warning("My Pins panel: Using fallback background");
		}
		((Graphic)val2).raycastTarget = true;
		panel.BgImage = val2;
		VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
		((LayoutGroup)obj).padding = new RectOffset(14, 14, 12, 12);
		GameObject val4 = new GameObject("Title", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val4.transform.SetParent(val.transform, false);
		Text val5 = val4.AddComponent<Text>();
		((Graphic)val5).raycastTarget = false;
		Font val6 = null;
		Font[] array = Resources.FindObjectsOfTypeAll<Font>();
		foreach (Font val7 in array)
		{
			if ((Object)(object)val7 != (Object)null && ((Object)val7).name.ToLowerInvariant().Contains("norse"))
			{
				DebugLogger.Log("Found Norse font variant: '" + ((Object)val7).name + "'");
				if ((Object)(object)val6 == (Object)null || ((Object)val7).name.ToLowerInvariant().Contains("bold"))
				{
					val6 = val7;
				}
			}
		}
		if ((Object)(object)val6 != (Object)null)
		{
			DebugLogger.Log("Using Norse font: '" + ((Object)val6).name + "'");
		}
		else
		{
			DebugLogger.Warning("Norse font not found, using fallback game font");
		}
		_cachedNorseFont = val6;
		val5.font = val6 ?? font;
		val5.fontSize = 28;
		val5.fontStyle = (FontStyle)(!((Object)(object)val6 != (Object)null));
		val5.alignment = (TextAnchor)4;
		((Graphic)val5).color = new Color(1f, 0.718f, 0.357f, 1f);
		string text = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("mypins_title") ?? "MY PINS";
		val5.text = text;
		panel.TitleText = val5;
		Outline obj2 = val4.AddComponent<Outline>();
		((Shadow)obj2).effectColor = Color.black;
		((Shadow)obj2).effectDistance = new Vector2(2f, -2f);
		LayoutElement obj3 = val4.AddComponent<LayoutElement>();
		obj3.minHeight = 36f;
		obj3.flexibleWidth = 1f;
		GameObject val8 = new GameObject("TopButtonRow", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val8.transform.SetParent(val.transform, false);
		HorizontalLayoutGroup obj4 = val8.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj4).spacing = 6f;
		((HorizontalOrVerticalLayoutGroup)obj4).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj4).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandHeight = false;
		LayoutElement obj5 = val8.AddComponent<LayoutElement>();
		obj5.minHeight = 47f;
		obj5.preferredHeight = 47f;
		obj5.flexibleHeight = 0f;
		obj5.flexibleWidth = 1f;
		Button val9 = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_button") ?? "Group", parent: val8.transform, minWidth: -1f, minHeight: 47f);
		((Object)((Component)val9).gameObject).name = "GroupButton";
		panel.GroupButton = val9;
		panel.GroupButtonText = ((Component)val9).GetComponentInChildren<Text>();
		Text componentInChildren = ((Component)val9).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.fontSize = 20;
		}
		LayoutElement component = ((Component)val9).GetComponent<LayoutElement>();
		if ((Object)(object)component != (Object)null)
		{
			component.minHeight = 47f;
			component.preferredHeight = 47f;
			component.flexibleHeight = 0f;
		}
		Button val10 = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("clear_button") ?? "Clear", parent: val8.transform, minWidth: -1f, minHeight: 47f);
		((Object)((Component)val10).gameObject).name = "ClearButton";
		panel.ClearButton = val10;
		Text componentInChildren2 = ((Component)val10).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren2 != (Object)null)
		{
			componentInChildren2.fontSize = 20;
		}
		LayoutElement component2 = ((Component)val10).GetComponent<LayoutElement>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.minHeight = 47f;
			component2.preferredHeight = 47f;
			component2.flexibleHeight = 0f;
		}
		GameObject val11 = new GameObject("ScrollView", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val11.transform.SetParent(val.transform, false);
		Image obj6 = val11.AddComponent<Image>();
		((Graphic)obj6).color = new Color(0f, 0f, 0f, 0.35f);
		((Graphic)obj6).raycastTarget = true;
		ScrollRect val12 = val11.AddComponent<ScrollRect>();
		val12.horizontal = false;
		val12.vertical = true;
		val12.movementType = (MovementType)2;
		val12.scrollSensitivity = 200f;
		LayoutElement obj7 = val11.AddComponent<LayoutElement>();
		obj7.flexibleHeight = 1f;
		obj7.flexibleWidth = 1f;
		float num3 = 10f;
		GameObject val13 = new GameObject("Scrollbar", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val13.transform.SetParent(val11.transform, false);
		RectTransform component3 = val13.GetComponent<RectTransform>();
		component3.anchorMin = new Vector2(1f, 0f);
		component3.anchorMax = new Vector2(1f, 1f);
		component3.pivot = new Vector2(1f, 0.5f);
		component3.sizeDelta = new Vector2(num3, 0f);
		component3.anchoredPosition = Vector2.zero;
		((Graphic)val13.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.3f);
		GameObject val14 = new GameObject("HandleArea", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val14.transform.SetParent(val13.transform, false);
		RectTransform component4 = val14.GetComponent<RectTransform>();
		component4.anchorMin = Vector2.zero;
		component4.anchorMax = Vector2.one;
		component4.offsetMin = Vector2.zero;
		component4.offsetMax = Vector2.zero;
		GameObject val15 = new GameObject("Handle", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val15.transform.SetParent(val14.transform, false);
		RectTransform component5 = val15.GetComponent<RectTransform>();
		component5.anchorMin = Vector2.zero;
		component5.anchorMax = new Vector2(1f, 0.3f);
		component5.offsetMin = Vector2.zero;
		component5.offsetMax = Vector2.zero;
		Image val16 = val15.AddComponent<Image>();
		((Graphic)val16).color = Color.white;
		Scrollbar val17 = val13.AddComponent<Scrollbar>();
		val17.handleRect = component5;
		((Selectable)val17).targetGraphic = (Graphic)(object)val16;
		val17.direction = (Direction)2;
		((Selectable)val17).transition = (Transition)1;
		ColorBlock colors = ((Selectable)val17).colors;
		((ColorBlock)(ref colors)).normalColor = new Color(0.89f, 0.62f, 0.33f, 1f);
		((ColorBlock)(ref colors)).highlightedColor = new Color(0.96f, 0.76f, 0.08f, 1f);
		((ColorBlock)(ref colors)).pressedColor = new Color(0.75f, 0.58f, 0.05f, 1f);
		((ColorBlock)(ref colors)).selectedColor = new Color(0.89f, 0.62f, 0.33f, 1f);
		((ColorBlock)(ref colors)).disabledColor = new Color(0.89f, 0.62f, 0.33f, 0.5f);
		((ColorBlock)(ref colors)).colorMultiplier = 1f;
		((ColorBlock)(ref colors)).fadeDuration = 0.1f;
		((Selectable)val17).colors = colors;
		val12.verticalScrollbar = val17;
		val12.verticalScrollbarVisibility = (ScrollbarVisibility)1;
		GameObject val18 = new GameObject("Viewport", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val18.transform.SetParent(val11.transform, false);
		RectTransform component6 = val18.GetComponent<RectTransform>();
		component6.anchorMin = Vector2.zero;
		component6.anchorMax = Vector2.one;
		component6.offsetMin = Vector2.zero;
		component6.offsetMax = Vector2.zero;
		val18.AddComponent<RectMask2D>();
		val12.viewport = component6;
		ScrollbarViewportFitter scrollbarViewportFitter = val11.AddComponent<ScrollbarViewportFitter>();
		scrollbarViewportFitter.VerticalScrollbar = val17;
		scrollbarViewportFitter.Viewport = component6;
		scrollbarViewportFitter.ScrollbarWidth = num3;
		GameObject val19 = new GameObject("Content", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val19.transform.SetParent(val18.transform, false);
		RectTransform component7 = val19.GetComponent<RectTransform>();
		component7.anchorMin = new Vector2(0f, 1f);
		component7.anchorMax = new Vector2(1f, 1f);
		component7.pivot = new Vector2(0.5f, 1f);
		component7.offsetMin = new Vector2(0f, 0f);
		component7.offsetMax = new Vector2(0f, 0f);
		VerticalLayoutGroup obj8 = val19.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj8).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj8).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj8).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj8).spacing = 4f;
		val19.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
		val12.content = component7;
		panel.PinListRoot = val19.transform;
		panel.ScrollView = val12;
		GameObject val20 = new GameObject("EmptyText", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val20.transform.SetParent(val19.transform, false);
		Text val21 = val20.AddComponent<Text>();
		((Graphic)val21).raycastTarget = false;
		val21.font = font;
		val21.fontSize = 16;
		val21.alignment = (TextAnchor)4;
		((Graphic)val21).color = new Color(0.7f, 0.7f, 0.7f, 0.6f);
		string text2 = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("mypins_empty") ?? "No Recipes Pinned";
		val21.text = text2;
		panel.EmptyText = val21;
		LayoutElement obj9 = val20.AddComponent<LayoutElement>();
		obj9.minHeight = 40f;
		obj9.flexibleWidth = 1f;
		GameObject val22 = new GameObject("ConfirmRowContainer", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val22.transform.SetParent(val.transform, false);
		HorizontalLayoutGroup obj10 = val22.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj10).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj10).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj10).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj10).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj10).spacing = 6f;
		LayoutElement obj11 = val22.AddComponent<LayoutElement>();
		obj11.minHeight = 47f;
		obj11.preferredHeight = 47f;
		obj11.flexibleHeight = 0f;
		obj11.flexibleWidth = 1f;
		Button val23 = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_cancel") ?? "Cancel", parent: val22.transform, minWidth: -1f, minHeight: 47f);
		((Object)((Component)val23).gameObject).name = "CancelButton";
		panel.CancelButton = val23;
		Text componentInChildren3 = ((Component)val23).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren3 != (Object)null)
		{
			componentInChildren3.fontSize = 20;
		}
		LayoutElement component8 = ((Component)val23).GetComponent<LayoutElement>();
		if ((Object)(object)component8 != (Object)null)
		{
			component8.minHeight = 47f;
			component8.preferredHeight = 47f;
			component8.flexibleHeight = 0f;
		}
		Button val24 = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_confirm") ?? "Confirm", parent: val22.transform, minWidth: -1f, minHeight: 47f);
		((Object)((Component)val24).gameObject).name = "ConfirmButton";
		panel.ConfirmButton = val24;
		Text componentInChildren4 = ((Component)val24).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren4 != (Object)null)
		{
			componentInChildren4.fontSize = 20;
		}
		LayoutElement component9 = ((Component)val24).GetComponent<LayoutElement>();
		if ((Object)(object)component9 != (Object)null)
		{
			component9.minHeight = 47f;
			component9.preferredHeight = 47f;
			component9.flexibleHeight = 0f;
		}
		val22.SetActive(false);
		GameObject val25 = new GameObject("CloseButtonContainer", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val25.transform.SetParent(val.transform, false);
		HorizontalLayoutGroup obj12 = val25.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj12).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj12).childControlWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj12).childForceExpandWidth = false;
		((LayoutGroup)obj12).childAlignment = (TextAnchor)4;
		LayoutElement obj13 = val25.AddComponent<LayoutElement>();
		obj13.minHeight = 47f;
		obj13.preferredHeight = 47f;
		obj13.flexibleHeight = 0f;
		obj13.flexibleWidth = 1f;
		Button val26 = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("close_button") ?? "Close", parent: val25.transform, minWidth: 175f, minHeight: 47f);
		((Object)((Component)val26).gameObject).name = "CloseButton";
		panel.CloseButton = val26;
		Text componentInChildren5 = ((Component)val26).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren5 != (Object)null)
		{
			componentInChildren5.fontSize = 20;
		}
		LayoutElement component10 = ((Component)val26).GetComponent<LayoutElement>();
		component10.flexibleWidth = 0f;
		component10.minWidth = 175f;
		component10.minHeight = 47f;
		component10.preferredWidth = 175f;
		component10.preferredHeight = 47f;
		((Component)val26).GetComponent<RectTransform>().sizeDelta = new Vector2(175f, 47f);
		Button val27 = CreateInfoButton(val.transform);
		((UnityEvent)val27.onClick).AddListener((UnityAction)delegate
		{
			panel.ControlsPanel?.Show();
			PlayButtonSFX();
		});
		panel.InfoButton = val27;
		ControlsInfoPanel controlsInfoPanel = CreateControlsInfoPanel(val.transform, font, val6 ?? font);
		panel.ControlsPanel = controlsInfoPanel;
		controlsInfoPanel.InfoButton = val27;
		((Component)controlsInfoPanel).transform.SetAsLastSibling();
		((Component)val27).transform.SetAsLastSibling();
		DebugLogger.Log("My Pins panel created");
		return panel;
	}

	private static Button CreateInfoButton(Transform panelParent)
	{
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: 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)
		Button obj = CreateVanillaButton(panelParent, "i", 32f, 32f);
		((Object)((Component)obj).gameObject).name = "InfoButton";
		Text componentInChildren = ((Component)obj).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.fontStyle = (FontStyle)2;
			componentInChildren.fontSize = 18;
		}
		LayoutElement component = ((Component)obj).GetComponent<LayoutElement>();
		component.ignoreLayout = true;
		component.preferredWidth = 32f;
		component.preferredHeight = 32f;
		component.minWidth = 32f;
		component.minHeight = 32f;
		component.flexibleWidth = 0f;
		RectTransform component2 = ((Component)obj).GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(1f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(1f, 1f);
		component2.sizeDelta = new Vector2(32f, 32f);
		component2.anchoredPosition = new Vector2(-8f, -8f);
		return obj;
	}

	public static MyPinItemUI CreateMyPinItem(Transform parent, Font font)
	{
		//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_0025: Expected O, but got Unknown
		//IL_0054: 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_00a6: Expected O, but got Unknown
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Expected O, but got Unknown
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_0212: Unknown result type (might be due to invalid IL or missing references)
		//IL_027f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_028d: Expected O, but got Unknown
		//IL_032b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0330: Unknown result type (might be due to invalid IL or missing references)
		//IL_0337: Unknown result type (might be due to invalid IL or missing references)
		//IL_034a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0371: Unknown result type (might be due to invalid IL or missing references)
		//IL_039b: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0400: Unknown result type (might be due to invalid IL or missing references)
		//IL_0444: Unknown result type (might be due to invalid IL or missing references)
		//IL_0449: Unknown result type (might be due to invalid IL or missing references)
		//IL_0452: Expected O, but got Unknown
		//IL_0491: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("MyPinItem", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		MyPinItemUI myPinItemUI = val.AddComponent<MyPinItemUI>();
		Image obj = val.AddComponent<Image>();
		((Graphic)obj).color = new Color(0f, 0f, 0f, 0f);
		((Graphic)obj).raycastTarget = true;
		HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
		((LayoutGroup)obj2).childAlignment = (TextAnchor)3;
		((HorizontalOrVerticalLayoutGroup)obj2).spacing = 10f;
		((LayoutGroup)obj2).padding = new RectOffset(6, 6, 4, 4);
		LayoutElement obj3 = val.AddComponent<LayoutElement>();
		obj3.minHeight = 38f;
		obj3.flexibleWidth = 1f;
		Button val2 = CreateSmallVanillaButton(val.transform, "►", 26f);
		((Object)((Component)val2).gameObject).name = "ExpandBtn";
		Text componentInChildren = ((Component)val2).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.fontSize = 11;
		}
		((Component)val2).gameObject.SetActive(false);
		myPinItemUI.ExpandButton = val2;
		myPinItemUI.ExpandButtonText = componentInChildren;
		GameObject val3 = new GameObject("SelectToggle", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		Toggle val4 = val3.AddComponent<Toggle>();
		Image val5 = val3.AddComponent<Image>();
		((Graphic)val5).color = new Color(0.3f, 0.3f, 0.3f, 0.8f);
		((Selectable)val4).targetGraphic = (Graphic)(object)val5;
		GameObject val6 = new GameObject("Checkmark", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val6.transform.SetParent(val3.transform, false);
		Image val7 = val6.AddComponent<Image>();
		((Graphic)val7).color = ValheimOrange;
		RectTransform component = val6.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0.15f, 0.15f);
		component.anchorMax = new Vector2(0.85f, 0.85f);
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		val4.graphic = (Graphic)(object)val7;
		LayoutElement obj4 = val3.AddComponent<LayoutElement>();
		obj4.minWidth = 22f;
		obj4.minHeight = 22f;
		obj4.preferredWidth = 22f;
		obj4.preferredHeight = 22f;
		val3.SetActive(false);
		myPinItemUI.SelectToggle = val4;
		GameObject val8 = new GameObject("IconRoot", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val8.transform.SetParent(val.transform, false);
		myPinItemUI.IconRoot = val8.transform;
		HorizontalLayoutGroup obj5 = val8.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj5).childControlHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj5).childControlWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandWidth = false;
		((LayoutGroup)obj5).childAlignment = (TextAnchor)4;
		((HorizontalOrVerticalLayoutGroup)obj5).spacing = 2f;
		LayoutElement obj6 = val8.AddComponent<LayoutElement>();
		obj6.minWidth = 30f;
		obj6.minHeight = 30f;
		obj6.preferredWidth = 30f;
		obj6.preferredHeight = 30f;
		GameObject val9 = new GameObject("Icon", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val9.transform.SetParent(val8.transform, false);
		Image val10 = val9.AddComponent<Image>();
		((Graphic)val10).raycastTarget = false;
		val10.preserveAspect = true;
		val9.GetComponent<RectTransform>().sizeDelta = new Vector2(28f, 28f);
		myPinItemUI.Icon = val10;
		GameObject val11 = new GameObject("Name", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val11.transform.SetParent(val.transform, false);
		Text val12 = val11.AddComponent<Text>();
		((Graphic)val12).raycastTarget = false;
		val12.font = font;
		val12.fontSize = 15;
		val12.alignment = (TextAnchor)3;
		val12.horizontalOverflow = (HorizontalWrapMode)0;
		((Graphic)val12).color = new Color(0.95f, 0.95f, 0.95f, 1f);
		myPinItemUI.NameText = val12;
		LayoutElement obj7 = val11.AddComponent<LayoutElement>();
		obj7.flexibleWidth = 1f;
		obj7.minWidth = 60f;
		GameObject val13 = new GameObject("Count", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val13.transform.SetParent(val.transform, false);
		Text val14 = val13.AddComponent<Text>();
		((Graphic)val14).raycastTarget = false;
		val14.font = font;
		val14.fontSize = 15;
		val14.alignment = (TextAnchor)4;
		((Graphic)val14).color = ValheimOrange;
		myPinItemUI.CountText = val14;
		val13.AddComponent<LayoutElement>().minWidth = 30f;
		Button minusButton = CreateSmallVanillaButton(val.transform, "-");
		myPinItemUI.MinusButton = minusButton;
		Button plusButton = CreateSmallVanillaButton(val.transform, "+");
		myPinItemUI.PlusButton = plusButton;
		Button val15 = CreateSmallVanillaButton(val.transform, "⊘");
		((Component)val15).gameObject.SetActive(false);
		myPinItemUI.DisbandButton = val15;
		Button deleteButton = CreateSmallVanillaButton(val.transform, "X");
		myPinItemUI.DeleteButton = deleteButton;
		return myPinItemUI;
	}

	private static ControlsInfoPanel CreateControlsInfoPanel(Transform panelParent, Font font, Font titleFont)
	{
		//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_0025: Expected O, but got Unknown
		//IL_0045: 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_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: 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_00b1: 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_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Expected O, but got Unknown
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_021b: Unknown result type (might be due to invalid IL or missing references)
		//IL_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_026b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Expected O, but got Unknown
		//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0300: Unknown result type (might be due to invalid IL or missing references)
		//IL_0307: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		//IL_0389: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_040a: Unknown result type (might be due to invalid IL or missing references)
		//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("ControlsInfoPanel", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(panelParent, false);
		val.AddComponent<LayoutElement>().ignoreLayout = true;
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = new Vector2(-80f, -125f);
		component.offsetMax = new Vector2(80f, 20f);
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).raycastTarget = true;
		if (TryGetTrophiesPanelBackground(out var sprite, out var material))
		{
			val2.sprite = sprite;
			((Graphic)val2).material = material;
			val2.type = (Type)((sprite.border != Vector4.zero) ? 1 : 0);
			((Graphic)val2).color = Color.white;
		}
		else
		{
			Sprite backgroundSprite = GetBackgroundSprite();
			if ((Object)(object)backgroundSprite != (Object)null)
			{
				val2.sprite = backgroundSprite;
				val2.type = (Type)1;
			}
			((Graphic)val2).color = new Color(0f, 0f, 0f, 0.92f);
		}
		ControlsInfoPanel controlsInfoPanel = val.AddComponent<ControlsInfoPanel>();
		VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
		((LayoutGroup)obj).padding = new RectOffset(20, 20, 14, 14);
		GameObject val3 = new GameObject("Title", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		Text obj2 = val3.AddComponent<Text>();
		obj2.text = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("controls_title") ?? "CONTROLS";
		obj2.font = titleFont;
		obj2.fontSize = 28;
		obj2.fontStyle = (FontStyle)(!((Object)(object)titleFont != (Object)(object)font));
		obj2.alignment = (TextAnchor)4;
		((Graphic)obj2).color = new Color(1f, 0.718f, 0.357f, 1f);
		((Graphic)obj2).raycastTarget = false;
		Outline obj3 = val3.AddComponent<Outline>();
		((Shadow)obj3).effectColor = Color.black;
		((Shadow)obj3).effectDistance = new Vector2(2f, -2f);
		LayoutElement obj4 = val3.AddComponent<LayoutElement>();
		obj4.minHeight = 36f;
		obj4.flexibleWidth = 1f;
		GameObject val4 = new GameObject("Rows", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val4.transform.SetParent(val.transform, false);
		VerticalLayoutGroup obj5 = val4.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj5).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj5).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj5).spacing = 4f;
		LayoutElement obj6 = val4.AddComponent<LayoutElement>();
		obj6.flexibleWidth = 1f;
		obj6.flexibleHeight = 1f;
		controlsInfoPanel.RowsParent = val4.transform;
		GameObject val5 = new GameObject("Note", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val5.transform.SetParent(val.transform, false);
		Text obj7 = val5.AddComponent<Text>();
		obj7.text = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("controls_config_note_single") ?? "Controls can be changed in the config file.";
		obj7.font = font;
		obj7.fontSize = 14;
		obj7.fontStyle = (FontStyle)2;
		obj7.alignment = (TextAnchor)4;
		obj7.horizontalOverflow = (HorizontalWrapMode)1;
		((Graphic)obj7).color = new Color(0.7f, 0.67f, 0.58f, 1f);
		((Graphic)obj7).raycastTarget = false;
		LayoutElement obj8 = val5.AddComponent<LayoutElement>();
		obj8.flexibleWidth = 1f;
		obj8.minHeight = 22f;
		GameObject val6 = new GameObject("CloseButtonContainer", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val6.transform.SetParent(val.transform, false);
		HorizontalLayoutGroup obj9 = val6.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj9).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj9).childControlWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj9).childForceExpandWidth = false;
		((LayoutGroup)obj9).childAlignment = (TextAnchor)4;
		LayoutElement obj10 = val6.AddComponent<LayoutElement>();
		obj10.minHeight = 47f;
		obj10.preferredHeight = 47f;
		obj10.flexibleHeight = 0f;
		obj10.flexibleWidth = 1f;
		Button val7 = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("close_button") ?? "Close", parent: val6.transform, minWidth: 175f, minHeight: 47f);
		((Object)((Component)val7).gameObject).name = "ControlsCloseButton";
		Text componentInChildren = ((Component)val7).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.fontSize = 20;
		}
		LayoutElement component2 = ((Component)val7).GetComponent<LayoutElement>();
		component2.flexibleWidth = 0f;
		component2.minWidth = 175f;
		component2.preferredWidth = 175f;
		component2.minHeight = 47f;
		component2.preferredHeight = 47f;
		((Component)val7).GetComponent<RectTransform>().sizeDelta = new Vector2(175f, 47f);
		controlsInfoPanel.CloseButton = val7;
		controlsInfoPanel.Initialize(font, GetBackgroundSprite());
		val.SetActive(false);
		DebugLogger.Log("ControlsInfoPanel created");
		return controlsInfoPanel;
	}

	public static GroupNameDialog CreateGroupNameDialog(Transform parent, Font font)
	{
		//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_002f: Expected O, but got Unknown
		//IL_004a: 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_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: 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_00c0: 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_00cd: Expected O, but got Unknown
		//IL_00fb: 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)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Expected O, but got Unknown
		//IL_023c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0241: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: 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_0285: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0304: Unknown result type (might be due to invalid IL or missing references)
		//IL_030d: Expected O, but got Unknown
		//IL_0389: Unknown result type (might be due to invalid IL or missing references)
		//IL_034e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0353: Unknown result type (might be due to invalid IL or missing references)
		//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0406: Unknown result type (might be due to invalid IL or missing references)
		//IL_0419: Unknown result type (might be due to invalid IL or missing references)
		//IL_0450: Unknown result type (might be due to invalid IL or missing references)
		//IL_0468: Unknown result type (might be due to invalid IL or missing references)
		//IL_0473: Unknown result type (might be due to invalid IL or missing references)
		//IL_0488: Unknown result type (might be due to invalid IL or missing references)
		//IL_049c: Unknown result type (might be due to invalid IL or missing references)
		//IL_04be: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_051c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0538: Unknown result type (might be due to invalid IL or missing references)
		//IL_0543: Unknown result type (might be due to invalid IL or missing references)
		//IL_0558: Unknown result type (might be due to invalid IL or missing references)
		//IL_056c: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0607: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_036a: Unknown result type (might be due to invalid IL or missing references)
		//IL_064f: Unknown result type (might be due to invalid IL or missing references)
		DebugLogger.Log("Creating Group Name Dialog");
		GameObject val = new GameObject("GroupNameDialogOverlay", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		GroupNameDialog groupNameDialog = val.AddComponent<GroupNameDialog>();
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = new Color(0f, 0f, 0f, 0.5f);
		((Graphic)val2).raycastTarget = true;
		groupNameDialog.OverlayBg = val2;
		GameObject val3 = new GameObject("DialogBox", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		groupNameDialog.DialogRect = val3.GetComponent<RectTransform>();
		groupNameDialog.DialogRect.anchorMin = new Vector2(0.5f, 0.5f);
		groupNameDialog.DialogRect.anchorMax = new Vector2(0.5f, 0.5f);
		groupNameDialog.DialogRect.pivot = new Vector2(0.5f, 0.5f);
		groupNameDialog.DialogRect.sizeDelta = new Vector2(320f, 160f);
		Image val4 = val3.AddComponent<Image>();
		if (TryGetTrophiesPanelBackground(out var sprite, out var material))
		{
			val4.sprite = sprite;
			((Graphic)val4).material = material;
			val4.type = (Type)((sprite.border != Vector4.zero) ? 1 : 0);
			((Graphic)val4).color = Color.white;
		}
		else
		{
			Sprite backgroundSprite = GetBackgroundSprite();
			val4.sprite = backgroundSprite;
			val4.type = (Type)0;
			((Graphic)val4).color = new Color(0.1f, 0.1f, 0.1f, 0.95f);
		}
		((Graphic)val4).raycastTarget = true;
		groupNameDialog.BgImage = val4;
		VerticalLayoutGroup obj = val3.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 10f;
		((LayoutGroup)obj).padding = new RectOffset(20, 20, 16, 16);
		GameObject val5 = new GameObject("Prompt", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val5.transform.SetParent(val3.transform, false);
		Text val6 = val5.AddComponent<Text>();
		((Graphic)val6).raycastTarget = false;
		val6.font = font;
		val6.fontSize = 16;
		val6.alignment = (TextAnchor)4;
		((Graphic)val6).color = ValheimOrange;
		string text = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_name_prompt") ?? "Enter group name:";
		val6.text = text;
		groupNameDialog.PromptText = val6;
		LayoutElement obj2 = val5.AddComponent<LayoutElement>();
		obj2.minHeight = 24f;
		obj2.flexibleWidth = 1f;
		GameObject val7 = new GameObject("InputField", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val7.transform.SetParent(val3.transform, false);
		Image val8 = val7.AddComponent<Image>();
		if (TryGetVanillaInputFieldStyle(out var sprite2, out var material2, out var color, out var source))
		{
			val8.sprite = sprite2;
			((Graphic)val8).material = material2;
			val8.type = (Type)((sprite2.border != Vector4.zero) ? 1 : 0);
			((Graphic)val8).color = color;
		}
		else
		{
			((Graphic)val8).color = new Color(0.15f, 0.12f, 0.08f, 0.9f);
		}
		InputField val9 = val7.AddComponent<InputField>();
		val9.characterLimit = 30;
		((Selectable)val9).targetGraphic = (Graphic)(object)val8;
		if ((Object)(object)source != (Object)null)
		{
			((Selectable)val9).transition = source.transition;
			((Selectable)val9).colors = source.colors;
			((Selectable)val9).spriteState = source.spriteState;
		}
		GameObject val10 = new GameObject("Text", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val10.transform.SetParent(val7.transform, false);
		Text val11 = val10.AddComponent<Text>();
		val11.font = font;
		val11.fontSize = 16;
		val11.alignment = (TextAnchor)3;
		((Graphic)val11).color = new Color(0.95f, 0.95f, 0.95f, 1f);
		val11.supportRichText = false;
		RectTransform component2 = val10.GetComponent<RectTransform>();
		component2.anchorMin = Vector2.zero;
		component2.anchorMax = Vector2.one;
		component2.offsetMin = new Vector2(8f, 2f);
		component2.offsetMax = new Vector2(-8f, -2f);
		GameObject val12 = new GameObject("Placeholder", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val12.transform.SetParent(val7.transform, false);
		Text val13 = val12.AddComponent<Text>();
		val13.font = font;
		val13.fontSize = 16;
		val13.fontStyle = (FontStyle)2;
		val13.alignment = (TextAnchor)3;
		((Graphic)val13).color = new Color(0.6f, 0.6f, 0.6f, 0.5f);
		val13.text = "...";
		RectTransform component3 = val12.GetComponent<RectTransform>();
		component3.anchorMin = Vector2.zero;
		component3.anchorMax = Vector2.one;
		component3.offsetMin = new Vector2(8f, 2f);
		component3.offsetMax = new Vector2(-8f, -2f);
		val9.textComponent = val11;
		val9.placeholder = (Graphic)(object)val13;
		groupNameDialog.NameInput = val9;
		LayoutElement obj3 = val7.AddComponent<LayoutElement>();
		obj3.minHeight = 32f;
		obj3.flexibleWidth = 1f;
		GameObject val14 = new GameObject("ButtonRow", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val14.transform.SetParent(val3.transform, false);
		HorizontalLayoutGroup obj4 = val14.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj4).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj4).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj4).spacing = 12f;
		LayoutElement obj5 = val14.AddComponent<LayoutElement>();
		obj5.minHeight = 35f;
		obj5.flexibleWidth = 1f;
		Button cancelButton = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_cancel") ?? "Cancel", parent: val14.transform);
		groupNameDialog.CancelButton = cancelButton;
		Button confirmButton = CreateVanillaButton(label: RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_confirm") ?? "Confirm", parent: val14.transform);
		groupNameDialog.ConfirmButton = confirmButton;
		DebugLogger.Log("Group Name Dialog created");
		return groupNameDialog;
	}

	public static void CreateGroupIconRow(Transform iconRoot, List<Sprite> icons, int maxIcons = 4)
	{
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)iconRoot == (Object)null)
		{
			return;
		}
		for (int num = iconRoot.childCount - 1; num >= 0; num--)
		{
			GameObject gameObject = ((Component)iconRoot.GetChild(num)).gameObject;
			if (((Object)gameObject).name == "Icon")
			{
				gameObject.SetActive(false);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)gameObject);
			}
		}
		int num2 = Mathf.Min(icons?.Count ?? 0, maxIcons);
		if (num2 != 0)
		{
			float num3 = ((num2 <= 2) ? 24f : ((num2 <= 3) ? 20f : 16f));
			LayoutElement component = ((Component)iconRoot).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.preferredWidth = (num3 + 2f) * (float)num2;
				component.minWidth = component.preferredWidth;
			}
			for (int i = 0; i < num2; i++)
			{
				GameObject val = new GameObject($"GroupIcon_{i}", new Type[1] { typeof(RectTransform) })
				{
					layer = 5
				};
				val.transform.SetParent(iconRoot, false);
				Image obj = val.AddComponent<Image>();
				((Graphic)obj).raycastTarget = false;
				obj.preserveAspect = true;
				obj.sprite = icons[i];
				val.GetComponent<RectTransform>().sizeDelta = new Vector2(num3, num3);
			}
			DebugLogger.Verbose($"Created group icon row with {num2} icons (max {maxIcons})");
		}
	}

	public static ConfirmDialog CreateConfirmDialog(Transform parent, Font font)
	{
		//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_002f: Expected O, but got Unknown
		//IL_004a: 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_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: 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_00c0: 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_00cd: Expected O, but got Unknown
		//IL_00fb: 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)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: 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_022c: Expected O, but got Unknown
		//IL_024a: Unknown result type (might be due to invalid IL or missing references)
		//IL_024f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0256: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0300: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: Expected O, but got Unknown
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		DebugLogger.Log("Creating Confirm Dialog");
		GameObject val = new GameObject("ConfirmDialogOverlay", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(parent, false);
		ConfirmDialog confirmDialog = val.AddComponent<ConfirmDialog>();
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = new Color(0f, 0f, 0f, 0.5f);
		((Graphic)val2).raycastTarget = true;
		confirmDialog.OverlayBg = val2;
		GameObject val3 = new GameObject("DialogBox", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val3.transform.SetParent(val.transform, false);
		confirmDialog.DialogRect = val3.GetComponent<RectTransform>();
		confirmDialog.DialogRect.anchorMin = new Vector2(0.5f, 0.5f);
		confirmDialog.DialogRect.anchorMax = new Vector2(0.5f, 0.5f);
		confirmDialog.DialogRect.pivot = new Vector2(0.5f, 0.5f);
		confirmDialog.DialogRect.sizeDelta = new Vector2(320f, 140f);
		Image val4 = val3.AddComponent<Image>();
		if (TryGetTrophiesPanelBackground(out var sprite, out var material))
		{
			val4.sprite = sprite;
			((Graphic)val4).material = material;
			val4.type = (Type)((sprite.border != Vector4.zero) ? 1 : 0);
			((Graphic)val4).color = Color.white;
		}
		else
		{
			Sprite backgroundSprite = GetBackgroundSprite();
			val4.sprite = backgroundSprite;
			val4.type = (Type)0;
			((Graphic)val4).color = new Color(0.1f, 0.1f, 0.1f, 0.95f);
		}
		((Graphic)val4).raycastTarget = true;
		confirmDialog.BgImage = val4;
		VerticalLayoutGroup obj = val3.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 12f;
		((LayoutGroup)obj).padding = new RectOffset(20, 20, 20, 16);
		((LayoutGroup)obj).childAlignment = (TextAnchor)4;
		GameObject val5 = new GameObject("Message", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val5.transform.SetParent(val3.transform, false);
		Text val6 = val5.AddComponent<Text>();
		((Graphic)val6).raycastTarget = false;
		val6.font = font;
		val6.fontSize = 16;
		val6.alignment = (TextAnchor)4;
		((Graphic)val6).color = new Color(0.95f, 0.95f, 0.95f, 1f);
		val6.horizontalOverflow = (HorizontalWrapMode)0;
		val6.verticalOverflow = (VerticalWrapMode)1;
		confirmDialog.MessageText = val6;
		LayoutElement obj2 = val5.AddComponent<LayoutElement>();
		obj2.minHeight = 40f;
		obj2.flexibleWidth = 1f;
		GameObject val7 = new GameObject("ButtonRow", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val7.transform.SetParent(val3.transform, false);
		HorizontalLayoutGroup obj3 = val7.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj3).spacing = 16f;
		((LayoutGroup)obj3).childAlignment = (TextAnchor)4;
		val7.AddComponent<LayoutElement>().minHeight = 32f;
		LocalizationManager obj4 = RecipePinnerPlugin.Instance?.LocalizationMgr;
		string label = obj4?.GetText("cancel_button") ?? "Cancel";
		string label2 = obj4?.GetText("confirm_button") ?? "Confirm";
		confirmDialog.CancelButton = CreateVanillaButton(val7.transform, label, -1f, 40f);
		confirmDialog.ConfirmButton = CreateVanillaButton(val7.transform, label2, -1f, 40f);
		val.SetActive(false);
		DebugLogger.Log("Confirm Dialog created");
		return confirmDialog;
	}
}
public class PinSlotUI : MonoBehaviour
{
	public RectTransform Rect;

	public Image IconImage;

	public Text HeaderText;

	public Transform ResourceListRoot;

	public Transform CompactResourceRoot;

	public Image AccentBar;

	public Transform GroupIconContainer;

	public Text GroupCountText;

	public PinnedRecipeData CurrentData;

	public float LastSlotWidth = -1f;

	public bool LastUncap;

	private Coroutine _layoutCoroutine;

	private Image _cachedBg;

	private ContentSizeFitter _cachedCsf;

	public List<ResourceSlotUI> ResourceSlots = new List<ResourceSlotUI>();

	public List<GatheringItemUI> CompactSlots = new List<GatheringItemUI>();

	private const int CompactOverflowFontSize = 22;

	public Image BgImage
	{
		get
		{
			if (!Object.op_Implicit((Object)(object)_cachedBg))
			{
				return _cachedBg = ((Component)this).GetComponent<Image>();
			}
			return _cachedBg;
		}
	}

	public ContentSizeFitter Csf
	{
		get
		{
			if (!Object.op_Implicit((Object)(object)_cachedCsf))
			{
				return _cachedCsf = ((Component)this).GetComponent<ContentSizeFitter>();
			}
			return _cachedCsf;
		}
	}

	private static int CompactThreshold => RecipePinnerPlugin.GroupCompactThreshold?.Value ?? 4;

	private static int CompactMaxRows => RecipePinnerPlugin.GroupCompactMaxRows?.Value ?? 3;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
	}

	public void UpdateData(PinnedRecipeData data, Font font, float slotWidth, bool uncap)
	{
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0228: Unknown result type (might be due to invalid IL or missing references)
		//IL_0236: Unknown result type (might be due to invalid IL or missing references)
		if (data.IsGroup && data.GroupRef != null && (Object)(object)GroupIconContainer != (Object)null)
		{
			if ((Object)(object)IconImage != (Object)null)
			{
				((Component)IconImage).gameObject.SetActive(false);
			}
			((Component)GroupIconContainer).gameObject.SetActive(true);
			if ((Object)(object)GroupCountText != (Object)null)
			{
				GroupCountText.text = data.GroupRef.MemberRecipeKeys.Count.ToString();
			}
		}
		else
		{
			if ((Object)(object)IconImage != (Object)null)
			{
				((Component)IconImage).gameObject.SetActive(true);
			}
			if ((Object)(object)GroupIconContainer != (Object)null)
			{
				((Component)GroupIconContainer).gameObject.SetActive(false);
			}
			if ((Object)(object)IconImage != (Object)null)
			{
				IconImage.sprite = data.Icon;
			}
		}
		HeaderText.text = data.CachedHeader;
		HeaderText.font = font;
		HeaderText.fontSize = RecipePinnerPlugin.FontSizeRecipeName.Value;
		((Graphic)HeaderText).color = RecipePinnerPlugin.ColorHeader.Value;
		int count = data.Resources.Count;
		bool flag = data.IsGroup && count > CompactThreshold && (Object)(object)CompactResourceRoot != (Object)null;
		if ((Object)(object)ResourceListRoot != (Object)null)
		{
			((Component)ResourceListRoot).gameObject.SetActive(!flag);
		}
		if ((Object)(object)CompactResourceRoot != (Object)null)
		{
			((Component)CompactResourceRoot).gameObject.SetActive(flag);
		}
		if (flag)
		{
			int num = count;
			int num2 = 0;
			float minHeight = 65f;
			int num3 = ((RecipePinnerPlugin.GatheringListFontSizeMaterials != null) ? RecipePinnerPlugin.GatheringListFontSizeMaterials.Value : 15);
			GridLayoutGroup component = ((Component)CompactResourceRoot).GetComponent<GridLayoutGroup>();
			if ((Object)(object)component != (Object)null && slotWidth > 0f)
			{
				VerticalLayoutGroup component2 = ((Component)this).GetComponent<VerticalLayoutGroup>();
				float num4 = (((Object)(object)component2 != (Object)null) ? ((float)(((LayoutGroup)component2).padding.left + ((LayoutGroup)component2).padding.right)) : 22f);
				float x = component.cellSize.x;
				float x2 = component.spacing.x;
				minHeight = component.cellSize.y;
				int num5 = Mathf.Max(1, Mathf.FloorToInt((slotWidth - num4 + x2 + 4f) / (x + x2)));
				if (component.constraintCount != num5)
				{
					component.constraintCount = num5;
				}
				int num6 = num5 * CompactMaxRows;
				if (!uncap && count > num6)
				{
					num = num6 - 1;
					num2 = count - num;
				}
			}
			int num7 = num + ((num2 > 0) ? 1 : 0);
			while (CompactSlots.Count < num7)
			{
				CompactSlots.Add(UIBuilder.CreateGatheringItemSlot(CompactResourceRoot, font));
			}
			for (int i = 0; i < CompactSlots.Count; i++)
			{
				if ((Object)(object)CompactSlots[i] == (Object)null)
				{
					continue;
				}
				if (i < num)
				{
					PinnedResData pinnedResData = data.Resources[i];
					CompactSlots[i].SetActive(active: true);
					if ((Object)(object)CompactSlots[i].Icon != (Object)null)
					{
						if (!((Component)CompactSlots[i].Icon).gameObject.activeSelf)
						{
							((Component)CompactSlots[i].Icon).gameObject.SetActive(true);
						}
						CompactSlots[i].Icon.sprite = pinnedResData.Icon;
					}
					if (!((Object)(object)CompactSlots[i].AmountText != (Object)null))
					{
						continue;
					}
					if (CompactSlots[i].AmountText.fontSize != num3)
					{
						CompactSlots[i].AmountText.fontSize = num3;
						LayoutElement component3 = ((Component)CompactSlots[i].AmountText).GetComponent<LayoutElement>();
						if ((Object)(object)component3 != (Object)null)
						{
							component3.minHeight = 16f;
						}
					}
					CompactSlots[i].AmountText.text = pinnedResData.CachedAmountString ?? "";
				}
				else if (num2 > 0 && i == num)
				{
					CompactSlots[i].SetActive(active: true);
					if ((Object)(object)CompactSlots[i].Icon != (Object)null)
					{
						((Component)CompactSlots[i].Icon).gameObject.SetActive(false);
					}
					if (!((Object)(object)CompactSlots[i].AmountText != (Object)null))
					{
						continue;
					}
					CompactSlots[i].AmountText.text = "+" + num2;
					if (CompactSlots[i].AmountText.fontSize != 22)
					{
						CompactSlots[i].AmountText.fontSize = 22;
						LayoutElement component4 = ((Component)CompactSlots[i].AmountText).GetComponent<LayoutElement>();
						if ((Object)(object)component4 != (Object)null)
						{
							component4.minHeight = minHeight;
						}
					}
				}
				else
				{
					CompactSlots[i].SetActive(active: false);
				}
			}
		}
		else
		{
			while (ResourceSlots.Count < count)
			{
				ResourceSlots.Add(UIBuilder.CreateResourceSlot(ResourceListRoot, font));
			}
			for (int j = 0; j < ResourceSlots.Count; j++)
			{
				if (j < count)
				{
					ResourceSlots[j].SetActive(active: true);
					ResourceSlots[j].UpdateResource(data.Resources[j]);
				}
				else
				{
					ResourceSlots[j].SetActive(active: false);
				}
			}
		}
		if (((Component)this).gameObject.activeInHierarchy)
		{
			if (_layoutCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_layoutCoroutine);
			}
			_layoutCoroutine = ((MonoBehaviour)this).StartCoroutine(FixLayout());
		}
	}

	private void OnDisable()
	{
		_layoutCoroutine = null;
	}

	private IEnumerator FixLayout()
	{
		yield return null;
		if ((Object)(object)ResourceListRoot != (Object)null && ((Component)ResourceListRoot).gameObject.activeSelf)
		{
			Transform resourceListRoot = ResourceListRoot;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((resourceListRoot is RectTransform) ? resourceListRoot : null));
		}
		if ((Object)(object)CompactResourceRoot != (Object)null && ((Component)CompactResourceRoot).gameObject.activeSelf)
		{
			Transform compactResourceRoot = CompactResourceRoot;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((compactResourceRoot is RectTransform) ? compactResourceRoot : null));
		}
		if ((Object)(object)Rect != (Object)null)
		{
			LayoutRebuilder.ForceRebuildLayoutImmediate(Rect);
		}
		if ((Object)(object)((Component)this).transform.parent != (Object)null)
		{
			Transform parent = ((Component)this).transform.parent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((parent is RectTransform) ? parent : null));
		}
	}
}
public class ResourceSlotUI : MonoBehaviour
{
	public Image ResIcon;

	public Text ResName;

	public Text ResAmount;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
	}

	public void UpdateResource(PinnedResData res)
	{
		if ((Object)(object)ResIcon != (Object)null)
		{
			ResIcon.sprite = res.Icon;
		}
		if ((Object)(object)ResName != (Object)null)
		{
			ResName.text = res.CachedName;
		}
		if ((Object)(object)ResAmount != (Object)null)
		{
			ResAmount.text = res.CachedAmountString ?? "";
		}
		if (RecipePinnerPlugin.FontSizeMaterials != null)
		{
			int value = RecipePinnerPlugin.FontSizeMaterials.Value;
			if ((Object)(object)ResName != (Object)null)
			{
				ResName.fontSize = value;
			}
			if ((Object)(object)ResAmount != (Object)null)
			{
				ResAmount.fontSize = value;
			}
		}
	}
}
public class UIManager
{
	private Transform _pinListRoot;

	private readonly List<PinSlotUI> _pinPool = new List<PinSlotUI>();

	private Font _cachedFont;

	private readonly Dictionary<string, int> _reusableInvCounts = new Dictionary<string, int>();

	private const float DefaultVerticalPositionX = -40f;

	private const float DefaultVerticalPositionY = -250f;

	private const float MluMapListDisabledVerticalY = -275f;

	private const float MluNoMapListDisabledVerticalY = -75f;

	private int _currentPage;

	private GameObject _paginationRoot;

	private readonly List<Image> _pageDots = new List<Image>();

	private GatheringListUI _gatheringListPanel;

	private bool _gatheringListVisible;

	private bool _gatheringListRepositioned;

	private readonly List<GatheringItemData> _gatheringData = new List<GatheringItemData>();

	private readonly Dictionary<string, GatheringItemData> _gatheringAggregator = new Dictionary<string, GatheringItemData>();

	private int _previousPinCount;

	private string _lastHintKey;

	private MyPinsPanelUI _myPinsPanel;

	private GroupNameDialog _groupNameDialog;

	private ConfirmDialog _confirmDialog;

	private GameObject _modalOverlay;

	private Button _myPinsButton;

	private bool _isSelectionMode;

	private readonly List<string> _selectedForGroup = new List<string>();

	private readonly HashSet<string> _expandedGroups = new HashSet<string>();

	private bool _inventoryWasOpen;

	private int _lastKnownPinCount = -1;

	private int _lastKnownGroupCount = -1;

	public int CurrentPage => _currentPage;

	public bool IsMyPinsPanelOpen
	{
		get
		{
			if ((Object)(object)_myPinsPanel != (Object)null)
			{
				return ((Component)_myPinsPanel).gameObject.activeSelf;
			}
			return false;
		}
	}

	public void DestroyUI()
	{
		DebugLogger.Verbose("DestroyUI");
		if ((Object)(object)_pinListRoot != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_pinListRoot).gameObject);
			_pinListRoot = null;
		}
		_pinPool?.Clear();
		_pageDots.Clear();
		_paginationRoot = null;
		if ((Object)(object)_gatheringListPanel != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_gatheringListPanel).gameObject);
			_gatheringListPanel = null;
		}
		_gatheringData.Clear();
		_gatheringAggregator.Clear();
		_lastHintKey = null;
		_previousPinCount = 0;
		DebugLogger.Log("UI destroyed");
	}

	public void ResetPage()
	{
		_currentPage = 0;
	}

	public void CyclePage()
	{
		int count = RecipePinnerPlugin.Instance.RecipeMgr.CachedPins.Count;
		int num = Mathf.Min(RecipePinnerPlugin.PinsPerPage.Value, RecipePinnerPlugin.MaximumPins.Value);
		if (num < 1)
		{
			num = 1;
		}
		if (count > num)
		{
			int num2 = Mathf.CeilToInt((float)count / (float)num);
			_currentPage++;
			if (_currentPage >= num2)
			{
				_currentPage = 0;
			}
			DebugLogger.Log($"Switched to Page: {_currentPage + 1}/{num2}");
			UpdateUI(RecipePinnerPlugin.IsUiVisible);
		}
	}

	public void UpdateUI(bool isVisible)
	{
		//IL_0379: Unknown result type (might be due to invalid IL or missing references)
		//IL_0383: Unknown result type (might be due to invalid IL or missing references)
		//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_039d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03df: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)Player.m_localPlayer == (Object)null || ((Character)Player.m_localPlayer).IsDead())
		{
			HideHudOverlay();
			return;
		}
		Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
		if (inventory == null)
		{
			HideHudOverlay();
			return;
		}
		RecipePinnerPlugin instance = RecipePinnerPlugin.Instance;
		RecipeManager recipeMgr = instance.RecipeMgr;
		ContainerScanner containerMgr = instance.ContainerMgr;
		if (_pinPool.Count != RecipePinnerPlugin.MaximumPins.Value)
		{
			DebugLogger.Log($"Pin limit changed ({_pinPool.Count} -> {RecipePinnerPlugin.MaximumPins.Value}), rebuilding");
			ResetPage();
			DestroyUI();
		}
		if ((Object)(object)_pinListRoot == (Object)null)
		{
			_pinPool.Clear();
			CreateCanvasUI();
			if ((Object)(object)_pinListRoot == (Object)null)
			{
				return;
			}
			foreach (PinnedRecipeData cachedPin in recipeMgr.CachedPins)
			{
				cachedPin.IsDirty = true;
			}
		}
		UpdateLayout();
		if ((Object)(object)_pinListRoot == (Object)null)
		{
			return;
		}
		bool flag = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		bool flag2 = isVisible && recipeMgr.CachedPins.Count > 0;
		int count = recipeMgr.CachedPins.Count;
		if (RecipePinnerPlugin.AutoOpenGatheringList.Value && RecipePinnerPlugin.EnableGatheringList.Value && !_gatheringListVisible && count >= 2 && _previousPinCount < 2)
		{
			_gatheringListVisible = true;
			DebugLogger.Log("Gathering list auto-opened (2+ pins detected)");
		}
		if (_gatheringListVisible && count < 2 && _previousPinCount >= 2)
		{
			_gatheringListVisible = false;
			_gatheringListPanel?.SetActive(active: false);
			DebugLogger.Log("Gathering list auto-closed (less than 2 pins)");
		}
		_previousPinCount = count;
		if (!flag2 && _gatheringListVisible && (Object)(object)_gatheringListPanel != (Object)null && recipeMgr.CachedPins.Count > 0)
		{
			if (!((Component)_pinListRoot).gameObject.activeSelf)
			{
				((Component)_pinListRoot).gameObject.SetActive(true);
			}
			for (int i = 0; i < _pinPool.Count; i++)
			{
				if ((Object)(object)_pinPool[i] != (Object)null && ((Component)_pinPool[i]).gameObject.activeSelf)
				{
					_pinPool[i].SetActive(active: false);
				}
			}
			if ((Object)(object)_paginationRoot != (Object)null && _paginationRoot.activeSelf)
			{
				_paginationRoot.SetActive(false);
			}
			_gatheringListPanel.SetActive(active: true);
			(((Component)_gatheringListPanel).GetComponent<LayoutElement>() ?? ((Component)_gatheringListPanel).gameObject.AddComponent<LayoutElement>()).ignoreLayout = true;
			RectTransform panelRect = _gatheringListPanel.PanelRect;
			bool num = RecipePinnerPlugin.LayoutModeConfig.Value == RecipePinnerPlugin.PinLayoutMode.ForceBottomRightHorizontal;
			bool flag3 = (Object)(object)Player.m_localPlayer.GetControlledShip() != (Object)null;
			bool num2 = num || flag3 || flag;
			bool flag4 = RecipePinnerPlugin.Instance.IsHorizontalMode || flag3 || flag;
			float num3 = (num2 ? RecipePinnerPlugin.BottomRightColumnWidth.Value : (flag4 ? RecipePinnerPlugin.HorizontalColumnWidth.Value : RecipePinnerPlugin.VerticalListWidth.Value));
			if (flag && (Object)(object)ReflectionHelper.GetCurrentContainer(InventoryGui.instance) != (Object)null)
			{
				RepositionGatheringListForInventory();
			}
			else
			{
				if (_gatheringListRepositioned)
				{
					RestoreGatheringListParent();
					_gatheringListRepositioned = false;
				}
				panelRect.sizeDelta = new Vector2(num3, panelRect.sizeDelta.y);
				if (!flag4)
				{
					((Component)_pinListRoot).GetComponent<RectTransform>().anchoredPosition = GetVerticalLayoutPosition();
					panelRect.anchorMin = new Vector2(0.5f, 1f);
					panelRect.anchorMax = new Vector2(0.5f, 1f);
					panelRect.pivot = new Vector2(0.5f, 1f);
				}
				panelRect.anchoredPosition = Vector2.zero;
			}
			Inventory inventory2 = ((Humanoid)Player.m_localPlayer).GetInventory();
			if (inventory2 != null)
			{
				_reusableInvCounts.Clear();
				foreach (ItemData allItem in inventory2.GetAllItems())
				{
					string name = allItem.m_shared.m_name;
					if (_reusableInvCounts.TryGetValue(name, out var value))
					{
						_reusableInvCounts[name] = value + allItem.m_stack;
					}
					else
					{
						_reusableInvCounts[name] = allItem.m_stack;
					}
				}
			}
			UpdateGatheringList();
			return;
		}
		if (((Component)_pinListRoot).gameObject.activeSelf != flag2)
		{
			((Component)_pinListRoot).gameObject.SetActive(flag2);
		}
		if (!flag2)
		{
			if (_gatheringListRepositioned && (Object)(object)_gatheringListPanel != (Object)null)
			{
				RestoreGatheringListParent();
				_gatheringListRepositioned = false;
				_gatheringListPanel.SetActive(_gatheringListVisible);
			}
			return;
		}
		if (flag && (Object)(object)_gatheringListPanel != (Object)null && recipeMgr.CachedPins.Count > 0 && _gatheringListVisible)
		{
			bool num4 = (Object)(object)ReflectionHelper.GetCurrentContainer(InventoryGui.instance) != (Object)null;
			_gatheringListPanel.SetActive(active: true);
			if (num4)
			{
				RepositionGatheringListForInventory();
			}
		}
		else if (_gatheringListRepositioned && (Object)(object)_gatheringListPanel != (Object)null)
		{
			RestoreGatheringListParent();
			_gatheringListRepositioned = false;
			_gatheringListPanel.SetActive(_gatheringListVisible);
		}
		_reusableInvCounts.Clear();
		foreach (ItemData allItem2 in inventory.GetAllItems())
		{
			string name2 = allItem2.m_shared.m_name;
			if (_reusableInvCounts.TryGetValue(name2, out var value2))
			{
				_reusableInvCounts[name2] = value2 + allItem2.m_stack;
			}
			else
			{
				_reusableInvCounts[name2] = allItem2.m_stack;
			}
		}
		int count2 = recipeMgr.CachedPins.Count;
		int num5 = Mathf.Min(RecipePinnerPlugin.PinsPerPage.Value, _pinPool.Count);
		if (num5 < 1)
		{
			num5 = 1;
		}
		int num6 = ((count2 <= 0) ? 1 : Mathf.CeilToInt((float)count2 / (float)num5));
		if (_currentPage >= num6)
		{
			_currentPage = num6 - 1;
		}
		if (_currentPage < 0)
		{
			_currentPage = 0;
		}
		int num7 = _currentPage * num5;
		if (num7 >= count2 && _currentPage > 0)
		{
			_currentPage--;
			num7 = _currentPage * num5;
		}
		int num8 = Mathf.Min(num7 + num5, count2);
		bool uncapCompact = count2 == 1 && recipeMgr.CachedPins[0] != null && recipeMgr.CachedPins[0].IsGroup;
		for (int j = 0; j < _pinPool.Count; j++)
		{
			if (!((Object)(object)_pinPool[j] == (Object)null))
			{
				int num9 = num7 + j;
				if (num9 < num8)
				{
					UpdatePinSlot(j, recipeMgr.CachedPins[num9], containerMgr, uncapCompact);
				}
				else if (((Component)_pinPool[j]).gameObject.activeSelf)
				{
					_pinPool[j].SetActive(active: false);
				}
			}
		}
		bool flag5 = (Object)(object)Player.m_localPlayer.GetControlledShip() != (Object)null;
		bool flag6 = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		bool isHorizontal = RecipePinnerPlugin.Instance.IsHorizontalMode || flag5 || flag6;
		EqualizePinHeights(num7, num8, isHorizontal);
		int totalPages = 1;
		if (count2 > 0)
		{
			totalPages = Mathf.CeilToInt((float)count2 / (float)num5);
		}
		UpdatePageDots(totalPages);
		UpdateGatheringList();
	}

	private void HideHudOverlay()
	{
		if ((Object)(object)_pinListRoot != (Object)null && ((Component)_pinListRoot).gameObject.activeSelf)
		{
			((Component)_pinListRoot).gameObject.SetActive(false);
		}
		if ((Object)(object)_paginationRoot != (Object)null && _paginationRoot.activeSelf)
		{
			_paginationRoot.SetActive(false);
		}
		if ((Object)(object)_gatheringListPanel != (Object)null && ((Component)_gatheringListPanel).gameObject.activeSelf)
		{
			_gatheringListPanel.SetActive(active: false);
		}
	}

	private void UpdatePageDots(int totalPages)
	{
		//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_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: 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)
		if ((Object)(object)_paginationRoot == (Object)null)
		{
			return;
		}
		HorizontalLayoutGroup component = _paginationRoot.GetComponent<HorizontalLayoutGroup>();
		if ((Object)(object)component != (Object)null)
		{
			((HorizontalOrVerticalLayoutGroup)component).spacing = RecipePinnerPlugin.PaginationDotSpacing.Value;
		}
		if (totalPages <= 1)
		{
			if (_paginationRoot.activeSelf)
			{
				_paginationRoot.SetActive(false);
			}
			return;
		}
		if (!_paginationRoot.activeSelf)
		{
			_paginationRoot.SetActive(true);
		}
		while (_pageDots.Count < totalPages)
		{
			_pageDots.Add(UIBuilder.CreatePageDot(_paginationRoot.transform));
		}
		int value = RecipePinnerPlugin.PaginationDotSize.Value;
		Color value2 = RecipePinnerPlugin.ColorPaginationActive.Value;
		for (int i = 0; i < _pageDots.Count; i++)
		{
			if (i < totalPages)
			{
				((Component)_pageDots[i]).gameObject.SetActive(true);
				if (i == _currentPage)
				{
					((Graphic)_pageDots[i]).color = value2;
					((Graphic)_pageDots[i]).rectTransform.sizeDelta = new Vector2((float)value * 1.2f, (float)value * 1.2f);
					continue;
				}
				Color color = value2;
				color.a = RecipePinnerPlugin.PaginationInactiveOpacity.Value;
				((Graphic)_pageDots[i]).color = color;
				((Graphic)_pageDots[i]).rectTransform.sizeDelta = new Vector2((float)value, (float)value);
			}
			else
			{
				((Component)_pageDots[i]).gameObject.SetActive(false);
			}
		}
	}

	private void UpdateDotsPosition()
	{
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: 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_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: 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_00cf: 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)
		if ((Object)(object)_paginationRoot == (Object)null || (Object)(object)_pinListRoot == (Object)null)
		{
			return;
		}
		RectTransform component = _paginationRoot.GetComponent<RectTransform>();
		bool flag = RecipePinnerPlugin.LayoutModeConfig.Value == RecipePinnerPlugin.PinLayoutMode.ForceBottomRightHorizontal;
		bool flag2 = (Object)(object)Player.m_localPlayer.GetControlledShip() != (Object)null;
		bool flag3 = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		if (RecipePinnerPlugin.Instance.IsHorizontalMode || flag2 || flag3)
		{
			bool num = flag || flag2 || flag3;
			float num2 = 0f - (num ? RecipePinnerPlugin.BottomRightColumnWidth.Value : RecipePinnerPlugin.HorizontalColumnWidth.Value) / 2f;
			if (num)
			{
				component.anchorMin = new Vector2(1f, 0f);
				component.anchorMax = new Vector2(1f, 0f);
				component.pivot = new Vector2(0.5f, 1f);
				component.anchoredPosition = new Vector2(num2, -15f);
			}
			else
			{
				component.anchorMin = new Vector2(1f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 0f);
				component.anchoredPosition = new Vector2(num2, 15f);
			}
		}
		else
		{
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(0f, 20f);
		}
	}

	private void EqualizePinHeights(int startIndex, int endIndex, bool isHorizontal)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Invalid comparison between Unknown and I4
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < _pinPool.Count; i++)
		{
			PinSlotUI pinSlotUI = _pinPool[i];
			if ((Object)(object)pinSlotUI?.Csf == (Object)null)
			{
				continue;
			}
			bool flag = startIndex + i < endIndex;
			if (isHorizontal && flag)
			{
				if ((int)pinSlotUI.Csf.verticalFit != 0)
				{
					pinSlotUI.Csf.verticalFit = (FitMode)0;
				}
			}
			else if ((int)pinSlotUI.Csf.verticalFit != 2)
			{
				pinSlotUI.Csf.verticalFit = (FitMode)2;
			}
		}
	}

	private void UpdatePinSlot(int index, PinnedRecipeData pinData, ContainerScanner containerMgr, bool uncapCompact)
	{
		//IL_004d: 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_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: 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)
		//IL_0228: Unknown result type (might be due to invalid IL or missing references)
		//IL_022d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0210: Unknown result type (might be due to invalid IL or missing references)
		//IL_033f: 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_0344: Unknown result type (might be due to invalid IL or missing references)
		//IL_034c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0351: Unknown result type (might be due to invalid IL or missing references)
		//IL_0360: Unknown result type (might be due to invalid IL or missing references)
		PinSlotUI pinSlotUI = _pinPool[index];
		if ((Object)(object)pinSlotUI == (Object)null || (Object)(object)((Component)pinSlotUI).gameObject == (Object)null)
		{
			return;
		}
		if (!((Component)pinSlotUI).gameObject.activeSelf)
		{
			pinSlotUI.SetActive(active: true);
		}
		if ((Object)(object)pinSlotUI.BgImage != (Object)null && Mathf.Abs(((Graphic)pinSlotUI.BgImage).color.a - RecipePinnerPlugin.BackgroundOpacity.Value) > 0.01f)
		{
			((Graphic)pinSlotUI.BgImage).color = new Color(0f, 0f, 0f, RecipePinnerPlugin.BackgroundOpacity.Value);
		}
		bool flag = RecipePinnerPlugin.LayoutModeConfig.Value == RecipePinnerPlugin.PinLayoutMode.ForceBottomRightHorizontal;
		bool flag2 = (Object)(object)Player.m_localPlayer.GetControlledShip() != (Object)null;
		bool flag3 = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		bool num = RecipePinnerPlugin.Instance.IsHorizontalMode || flag2 || flag3;
		float num2 = ((!num) ? RecipePinnerPlugin.VerticalListWidth.Value : ((flag || flag2 || flag3) ? RecipePinnerPlugin.BottomRightColumnWidth.Value : RecipePinnerPlugin.HorizontalColumnWidth.Value));
		if (num)
		{
			RectTransform val = pinSlotUI.Rect ?? ((Component)pinSlotUI).GetComponent<RectTransform>();
			if (Mathf.Abs(val.sizeDelta.x - num2) > 1f)
			{
				val.sizeDelta = new Vector2(num2, val.sizeDelta.y);
			}
		}
		bool flag4 = pinSlotUI.CurrentData != pinData;
		pinSlotUI.CurrentData = pinData;
		foreach (PinnedResData resource in pinData.Resources)
		{
			_reusableInvCounts.TryGetValue(resource.ItemName, out var value);
			int value2 = 0;
			if (RecipePinnerPlugin.EnableChestScanning.Value)
			{
				containerMgr.ContainerCache.TryGetValue(resource.ItemName, out value2);
			}
			int num3 = value + value2;
			if (num3 != resource.LastKnownAmount || value != resource.LastKnownInvAmount || resource.CachedAmountString == null)
			{
				resource.LastKnownAmount = num3;
				resource.LastKnownInvAmount = value;
				Color val2 = ((value >= resource.RequiredAmount) ? RecipePinnerPlugin.ColorEnoughInInventory.Value : ((num3 >= resource.RequiredAmount) ? RecipePinnerPlugin.ColorEnoughWithChests.Value : RecipePinnerPlugin.ColorMissing.Value));
				string arg = "#" + ColorUtility.ToHtmlStringRGBA(val2);
				string text = $"<color={arg}>{num3}/{resource.RequiredAmount}</color>";
				if (resource.CachedAmountString != text)
				{
					resource.CachedAmountString = text;
					pinData.IsDirty = true;
				}
			}
		}
		if ((Object)(object)pinSlotUI.AccentBar != (Object)null)
		{
			if (RecipePinnerPlugin.EnableCraftReadiness.Value)
			{
				if (!((Component)pinSlotUI.AccentBar).gameObject.activeSelf)
				{
					((Component)pinSlotUI.AccentBar).gameObject.SetActive(true);
				}
				bool flag5 = true;
				for (int i = 0; i < pinData.Resources.Count; i++)
				{
					if (pinData.Resources[i].LastKnownAmount < pinData.Resources[i].RequiredAmount)
					{
						flag5 = false;
						break;
					}
				}
				Color val3 = (flag5 ? RecipePinnerPlugin.ColorCraftReady.Value : RecipePinnerPlugin.ColorCraftNotReady.Value);
				if (((Graphic)pinSlotUI.AccentBar).color != val3)
				{
					((Graphic)pinSlotUI.AccentBar).color = val3;
				}
			}
			else if (((Component)pinSlotUI.AccentBar).gameObject.activeSelf)
			{
				((Component)pinSlotUI.AccentBar).gameObject.SetActive(false);
			}
		}
		bool flag6 = Mathf.Abs(num2 - pinSlotUI.LastSlotWidth) > 0.5f;
		bool flag7 = uncapCompact != pinSlotUI.LastUncap;
		if (flag4 || pinData.IsDirty || flag6 || flag7)
		{
			pinSlotUI.UpdateData(pinData, _cachedFont, num2, uncapCompact);
			pinSlotUI.LastSlotWidth = num2;
			pinSlotUI.LastUncap = uncapCompact;
			pinData.IsDirty = false;
		}
	}

	private void CreateCanvasUI()
	{
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Expected O, but got Unknown
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: 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_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_pinListRoot != (Object)null)
		{
			return;
		}
		if ((Object)(object)Hud.instance == (Object)null || (Object)(object)Hud.instance.m_rootObject == (Object)null)
		{
			DebugLogger.Warning("Cannot create canvas - Hud.instance is null");
			return;
		}
		if ((Object)(object)_cachedFont == (Object)null)
		{
			_cachedFont = GetGameFont();
		}
		if ((Object)(object)_cachedFont == (Object)null)
		{
			DebugLogger.Error("Cannot create UI - no valid font found");
			return;
		}
		DebugLogger.Log("CreateCanvasUI");
		Transform transform = Hud.instance.m_rootObject.transform;
		GameObject val = new GameObject("PinListRoot", new Type[1] { typeof(RectTransform) })
		{
			layer = 5
		};
		val.transform.SetParent(transform, false);
		_pinListRoot = val.transform;
		_pinListRoot.localScale = Vector3.one * RecipePinnerPlugin.UIScale.Value;
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(1f, 1f);
		component.anchorMax = new Vector2(1f, 1f);
		component.pivot = new Vector2(1f, 1f);
		bool flag = (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)Player.m_localPlayer.GetControlledShip() != (Object)null;
		bool flag2 = RecipePinnerPlugin.LayoutModeConfig.Value == RecipePinnerPlugin.PinLayoutMode.ForceBottomRightHorizontal;
		bool flag3 = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		bool flag4 = flag || flag2 || flag3;
		bool flag5 = RecipePinnerPlugin.Instance.IsHorizontalMode || flag || flag3;
		DebugLogger.Verbose($"UI Layout - Horizontal: {flag5}, BottomRight: {flag4}, Sailing: {flag}");
		if (flag5)
		{
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((LayoutGroup)obj).childAlignment = (TextAnchor)(flag4 ? 8 : 2);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = RecipePinnerPlugin.HorizontalPinSpacing.Value;
			ContentSizeFitter obj2 = val.AddComponent<ContentSizeFitter>();
			obj2.horizontalFit = (FitMode)2;
			obj2.verticalFit = (FitMode)2;
		}
		else
		{
			VerticalLayoutGroup obj3 = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 8f;
			val.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
		}
		for (int i = 0; i < RecipePinnerPlugin.MaximumPins.Value; i++)
		{
			PinSlotUI pinSlotUI = UIBuilder.CreatePinSlot(_pinListRoot, _cachedFont);
			if ((Object)(object)pinSlotUI != (Object)null)
			{
				pinSlotUI.SetActive(active: false);
				_pinPool.Add(pinSlotUI);
			}
		}
		_paginationRoot = UIBuilder.CreatePaginationContainer(_pinListRoot);
		_paginationRoot.transform.SetAsLastSibling();
		if (RecipePinnerPlugin.EnableGatheringList.Value)
		{
			string title = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("gathering_title") ?? "TOTAL NEEDS";
			_gatheringListPanel = UIBuilder.CreateGatheringListPanel(_pinListRoot, _cachedFont, title);
			_gatheringListPanel.SetActive(_gatheringListVisible);
			DebugLogger.Log("Gathering list panel ready");
		}
		DebugLogger.Log($"UI ready ({_pinPool.Count} slots)");
	}

	private void UpdateLayout()
	{
		//IL_008c: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_pinListRoot == (Object)null)
		{
			return;
		}
		RecipePinnerPlugin instance = RecipePinnerPlugin.Instance;
		bool num = RecipePinnerPlugin.LayoutModeConfig.Value == RecipePinnerPlugin.PinLayoutMode.ForceBottomRightHorizontal;
		bool flag = !num && (Object)(object)Player.m_localPlayer.GetControlledShip() != (Object)null;
		bool flag2 = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		bool flag3 = num || flag || flag2;
		bool flag4 = instance.IsHorizontalMode || flag || flag2;
		bool flag5 = (Object)(object)((Component)_pinListRoot).GetComponent<HorizontalLayoutGroup>() != (Object)null;
		if (flag4 != flag5)
		{
			DebugLogger.Log("Layout mode changed - rebuilding UI");
			DestroyUI();
			return;
		}
		if (_pinListRoot.localScale.x != RecipePinnerPlugin.UIScale.Value)
		{
			_pinListRoot.localScale = Vector3.one * RecipePinnerPlugin.UIScale.Value;
		}
		RectTransform component = ((Component)_pinListRoot).GetComponent<RectTransform>();
		if (flag4)
		{
			UpdateHorizontalLayout(component, flag3);
		}
		else
		{
			UpdateVerticalLayout(component);
		}
		UpdateDotsPosition();
		UpdateGatheringListPosition(flag4, flag3);
	}

	private void UpdateHorizontalLayout(RectTransform rootRect, bool isBottomRightMode)
	{
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: 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_0107: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: 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_004e: 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_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Invalid comparison between Unknown and I4
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Invalid comparison between Unknown and I4
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: 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_00c6: 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_01fd: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		HorizontalLayoutGroup component = ((Component)_pinListRoot).GetComponent<HorizontalLayoutGroup>();
		if (isBottomRightMode)
		{
			if (rootRect.anchorMin != new Vector2(1f, 0f))
			{
				rootRect.anchorMin = new Vector2(1f, 0f);
				rootRect.anchorMax = new Vector2(1f, 0f);
				rootRect.pivot = new Vector2(1f, 0f);
			}
			if ((Object)(object)component != (Object)null && (int)((LayoutGroup)component).childAlignment != 8)
			{
				((LayoutGroup)component).childAlignment = (TextAnchor)8;
			}
			if ((Object)(object)component != (Object)null && Mathf.Abs(((HorizontalOrVerticalLayoutGroup)component).spacing - RecipePinnerPlugin.BottomRightPinSpacing.Value) > 0.01f)
			{
				((HorizontalOrVerticalLayoutGroup)component).spacing = RecipePinnerPlugin.BottomRightPinSpacing.Value;
			}
			Vector2 value = RecipePinnerPlugin.BottomRightPosition.Value;
			if (rootRect.anchoredPosition != value)
			{
				rootRect.anchoredPosition = value;
			}
			return;
		}
		if (rootRect.anchorMin != new Vector2(1f, 1f))
		{
			rootRect.anchorMin = new Vector2(1f, 1f);
			rootRect.anchorMax = new Vector2(1f, 1f);
			rootRect.pivot = new Vector2(1f, 1f);
		}
		if ((Object)(object)component != (Object)null && (int)((LayoutGroup)component).childAlignment != 2)
		{
			((LayoutGroup)component).childAlignment = (TextAnchor)2;
		}
		if ((Object)(object)component != (Object)null && Mathf.Abs(((HorizontalOrVerticalLayoutGroup)component).spacing - RecipePinnerPlugin.HorizontalPinSpacing.Value) > 0.01f)
		{
			((HorizontalOrVerticalLayoutGroup)component).spacing = RecipePinnerPlugin.HorizontalPinSpacing.Value;
		}
		Vector2 value2 = RecipePinnerPlugin.HorizontalPosition.Value;
		if (Game.m_noMap && RecipePinnerPlugin.Instance._mluiInstalled && RecipePinnerPlugin.Instance._mluiNoMapListEnabled)
		{
			if (Mathf.Abs(value2.x - -250f) < 1f)
			{
				value2.x = -270f;
			}
			if (Mathf.Abs(value2.y - -40f) < 1f)
			{
				value2.y = -15f;
			}
		}
		if (rootRect.anchoredPosition != value2)
		{
			rootRect.anchoredPosition = value2;
		}
	}

	private void UpdateVerticalLayout(RectTransform rootRect)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: 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_0051: 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)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: 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_011b: Unknown result type (might be due to invalid IL or missing references)
		if (rootRect.anchorMin != new Vector2(1f, 1f))
		{
			rootRect.anchorMin = new Vector2(1f, 1f);
			rootRect.anchorMax = new Vector2(1f, 1f);
			rootRect.pivot = new Vector2(1f, 1f);
		}
		VerticalLayoutGroup component = ((Component)_pinListRoot).GetComponent<VerticalLayoutGroup>();
		if ((Object)(object)component != (Object)null && Mathf.Abs(((HorizontalOrVerticalLayoutGroup)component).spacing - RecipePinnerPlugin.VerticalPinSpacing.Value) > 0.01f)
		{
			((HorizontalOrVerticalLayoutGroup)component).spacing = RecipePinnerPlugin.VerticalPinSpacing.Value;
		}
		Vector2 verticalLayoutPosition = GetVerticalLayoutPosition();
		if (RecipePinnerPlugin.Instance.RecipeMgr.CachedPins.Count > RecipePinnerPlugin.PinsPerPage.Value)
		{
			verticalLayoutPosition.y -= 30f;
		}
		if (rootRect.anchoredPosition != verticalLayoutPosition)
		{
			rootRect.anchoredPosition = verticalLayoutPosition;
		}
		if (Mathf.Abs(rootRect.sizeDelta.x - RecipePinnerPlugin.VerticalListWidth.Value) > 1f)
		{
			rootRect.sizeDelta = new Vector2(RecipePinnerPlugin.VerticalListWidth.Value, 0f);
		}
	}

	private Vector2 GetVerticalLayoutPosition()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: 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_0030: 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)
		Vector2 value = RecipePinnerPlugin.VerticalPosition.Value;
		if (RecipePinnerPlugin.LayoutModeConfig.Value != RecipePinnerPlugin.PinLayoutMode.AutoDetect)
		{
			return value;
		}
		RecipePinnerPlugin instance = RecipePinnerPlugin.Instance;
		if ((Object)(object)instance == (Object)null || !instance._mluiInstalled || !IsDefaultVerticalPosition(value))
		{
			return value;
		}
		if (Game.m_noMap)
		{
			if (!instance._mluiNoMapListEnabled)
			{
				value.y = -75f;
			}
		}
		else if (!instance._mluiMapListEnabled)
		{
			value.y = -275f;
		}
		return value;
	}

	private static bool IsDefaultVerticalPosition(Vector2 position)
	{
		//IL_0000: 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)
		if (Mathf.Abs(position.x - -40f) < 1f)
		{
			return Mathf.Abs(position.y - -250f) < 1f;
		}
		return false;
	}

	private Font GetGameFont()
	{
		Font[] array = Resources.FindObjectsOfTypeAll<Font>();
		Font[] array2 = array;
		foreach (Font val in array2)
		{
			if ((Object)(object)val != (Object)null && ((Object)val).name == "AveriaSerifLibre-Bold")
			{
				DebugLogger.Log("Found game font: AveriaSerifLibre-Bold");
				return val;
			}
		}
		array2 = array;
		foreach (Font val2 in array2)
		{
			if ((Object)(object)val2 != (Object)null && ((Object)val2).name == "Arial")
			{
				DebugLogger.Log("Using fallback font: Arial");
				return val2;
			}
		}
		try
		{
			DebugLogger.Log("Creating dynamic font from OS: Arial");
			return Font.CreateDynamicFontFromOSFont("Arial", 14);
		}
		catch
		{
			DebugLogger.Warning("Failed to create dynamic font, using first available font");
			return (array.Length != 0) ? array[0] : null;
		}
	}

	public void ToggleGatheringList()
	{
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (!_gatheringListVisible && (recipeManager == null || recipeManager.CachedPins.Count == 0))
		{
			DebugLogger.Log("Gathering list toggle blocked: no pins");
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				string text = (RecipePinnerPlugin.Instance?.LocalizationMgr)?.GetText("gathering_empty") ?? "No Recipes Pinned";
				((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
			return;
		}
		_gatheringListVisible = !_gatheringListVisible;
		DebugLogger.Log($"Gathering list toggled: {_gatheringListVisible}");
		_gatheringListPanel?.SetActive(_gatheringListVisible);
		if ((Object)(object)Player.m_localPlayer != (Object)null)
		{
			LocalizationManager localizationManager = RecipePinnerPlugin.Instance?.LocalizationMgr;
			string text2 = ((!_gatheringListVisible) ? (localizationManager?.GetText("gathering_closed") ?? "Gathering List Closed") : (localizationManager?.GetText("gathering_opened") ?? "Gathering List Opened"));
			((Character)Player.m_localPlayer).Message((MessageType)2, text2, 0, (Sprite)null);
		}
	}

	public void CloseGatheringList()
	{
		_gatheringListVisible = false;
		_gatheringListPanel?.SetActive(active: false);
		if (_gatheringListRepositioned)
		{
			RestoreGatheringListParent();
			_gatheringListRepositioned = false;
		}
		_gatheringData.Clear();
		_gatheringAggregator.Clear();
		if (!((Object)(object)_gatheringListPanel != (Object)null))
		{
			return;
		}
		foreach (GatheringItemUI itemSlot in _gatheringListPanel.ItemSlots)
		{
			if ((Object)(object)itemSlot != (Object)null && ((Component)itemSlot).gameObject.activeSelf)
			{
				itemSlot.SetActive(active: false);
			}
		}
	}

	private void UpdateGatheringListPosition(bool isHorizontal, bool isBottomRight)
	{
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: 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_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_gatheringListPanel == (Object)null)
		{
			return;
		}
		LayoutElement val = ((Component)_gatheringListPanel).GetComponent<LayoutElement>() ?? ((Component)_gatheringListPanel).gameObject.AddComponent<LayoutElement>();
		RectTransform panelRect = _gatheringListPanel.PanelRect;
		int configCols = RecipePinnerPlugin.GatheringListColumns?.Value ?? 4;
		if (isHorizontal)
		{
			val.ignoreLayout = true;
			_gatheringListPanel.ApplyColumns(configCols);
			if (isBottomRight)
			{
				panelRect.anchorMin = new Vector2(1f, 1f);
				panelRect.anchorMax = new Vector2(1f, 1f);
				panelRect.pivot = new Vector2(1f, 0f);
				panelRect.anchoredPosition = new Vector2(0f, 10f);
			}
			else
			{
				panelRect.anchorMin = new Vector2(1f, 0f);
				panelRect.anchorMax = new Vector2(1f, 0f);
				panelRect.pivot = new Vector2(1f, 1f);
				panelRect.anchoredPosition = new Vector2(0f, -10f);
			}
		}
		else
		{
			val.ignoreLayout = false;
			_gatheringListPanel.ApplyColumns(4);
		}
	}

	private void RepositionGatheringListForInventory()
	{
		//IL_00b6: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_gatheringListPanel == (Object)null))
		{
			Hud instance = Hud.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject rootObject = instance.m_rootObject;
				obj = ((rootObject != null) ? rootObject.transform : null);
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val != (Object)null && (Object)(object)((Component)_gatheringListPanel).transform.parent != (Object)(object)val)
			{
				((Component)_gatheringListPanel).transform.SetParent(val, false);
			}
			(((Component)_gatheringListPanel).GetComponent<LayoutElement>() ?? ((Component)_gatheringListPanel).gameObject.AddComponent<LayoutElement>()).ignoreLayout = true;
			RectTransform panelRect = _gatheringListPanel.PanelRect;
			_gatheringListPanel.ApplyColumns(4);
			Vector2 anchoredPosition = (Vector2)(((??)RecipePinnerPlugin.ContainerGatheringListPosition?.Value) ?? new Vector2(-460f, 0f));
			panelRect.anchorMin = new Vector2(0.5f, 0.5f);
			panelRect.anchorMax = new Vector2(0.5f, 0.5f);
			panelRect.pivot = new Vector2(0.5f, 1f);
			panelRect.anchoredPosition = anchoredPosition;
			((Transform)panelRect).localScale = Vector3.one * RecipePinnerPlugin.UIScale.Value;
			_gatheringListRepositioned = true;
		}
	}

	private void RestoreGatheringListParent()
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_gatheringListPanel == (Object)null) && !((Object)(object)_pinListRoot == (Object)null))
		{
			if ((Object)(object)((Component)_gatheringListPanel).transform.parent != (Object)(object)_pinListRoot)
			{
				((Component)_gatheringListPanel).transform.SetParent(_pinListRoot, false);
				((Component)_gatheringListPanel).transform.localScale = Vector3.one;
			}
			LayoutElement component = ((Component)_gatheringListPanel).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.ignoreLayout = false;
			}
		}
	}

	private void UpdateGatheringList()
	{
		//IL_0052: 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_03f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_033b: Unknown result type (might be due to invalid IL or missing references)
		//IL_032f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0340: Unknown result type (might be due to invalid IL or missing references)
		//IL_0347: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_gatheringListPanel == (Object)null)
		{
			return;
		}
		bool activeSelf = ((Component)_gatheringListPanel).gameObject.activeSelf;
		if (!_gatheringListVisible && !_gatheringListRepositioned && !activeSelf)
		{
			return;
		}
		if ((Object)(object)_gatheringListPanel.BgImage != (Object)null && Mathf.Abs(((Graphic)_gatheringListPanel.BgImage).color.a - RecipePinnerPlugin.BackgroundOpacity.Value) > 0.01f)
		{
			((Graphic)_gatheringListPanel.BgImage).color = new Color(0f, 0f, 0f, RecipePinnerPlugin.BackgroundOpacity.Value);
		}
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager == null)
		{
			return;
		}
		ContainerScanner containerMgr = RecipePinnerPlugin.Instance.ContainerMgr;
		_gatheringAggregator.Clear();
		_gatheringData.Clear();
		foreach (PinnedRecipeData cachedPin in recipeManager.CachedPins)
		{
			foreach (PinnedResData resource in cachedPin.Resources)
			{
				if (_gatheringAggregator.TryGetValue(resource.ItemName, out var value))
				{
					value.TotalRequired += resource.RequiredAmount;
					continue;
				}
				GatheringItemData gatheringItemData = new GatheringItemData
				{
					ItemName = resource.ItemName,
					DisplayName = (resource.CachedName ?? resource.ItemName),
					Icon = resource.Icon,
					TotalRequired = resource.RequiredAmount
				};
				_gatheringAggregator[resource.ItemName] = gatheringItemData;
				_gatheringData.Add(gatheringItemData);
			}
		}
		foreach (GatheringItemData gatheringDatum in _gatheringData)
		{
			_reusableInvCounts.TryGetValue(gatheringDatum.ItemName, out var value2);
			int value3 = 0;
			if (RecipePinnerPlugin.EnableChestScanning.Value)
			{
				containerMgr.ContainerCache.TryGetValue(gatheringDatum.ItemName, out value3);
			}
			gatheringDatum.TotalHave = value2 + value3;
			gatheringDatum.IsComplete = gatheringDatum.TotalHave >= gatheringDatum.TotalRequired;
		}
		GatheringListUI gatheringListPanel = _gatheringListPanel;
		while (gatheringListPanel.ItemSlots.Count < _gatheringData.Count)
		{
			gatheringListPanel.ItemSlots.Add(UIBuilder.CreateGatheringItemSlot(gatheringListPanel.ItemListRoot, _cachedFont));
		}
		for (int i = 0; i < gatheringListPanel.ItemSlots.Count; i++)
		{
			if (i < _gatheringData.Count)
			{
				GatheringItemUI gatheringItemUI = gatheringListPanel.ItemSlots[i];
				if (!((Object)(object)gatheringItemUI == (Object)null))
				{
					GatheringItemData gatheringItemData2 = _gatheringData[i];
					if (!((Component)gatheringItemUI).gameObject.activeSelf)
					{
						gatheringItemUI.SetActive(active: true);
					}
					if ((Object)(object)gatheringItemUI.Icon != (Object)null)
					{
						gatheringItemUI.Icon.sprite = gatheringItemData2.Icon;
					}
					Color val = (gatheringItemData2.IsComplete ? RecipePinnerPlugin.ColorEnoughInInventory.Value : RecipePinnerPlugin.ColorMissing.Value);
					string arg = "#" + ColorUtility.ToHtmlStringRGBA(val);
					if ((Object)(object)gatheringItemUI.AmountText != (Object)null)
					{
						gatheringItemUI.AmountText.text = $"<color={arg}>{gatheringItemData2.TotalHave}/{gatheringItemData2.TotalRequired}</color>";
					}
				}
			}
			else
			{
				GatheringItemUI gatheringItemUI2 = gatheringListPanel.ItemSlots[i];
				if ((Object)(object)gatheringItemUI2 != (Object)null && ((Component)gatheringItemUI2).gameObject.activeSelf)
				{
					gatheringItemUI2.SetActive(active: false);
				}
			}
		}
		if ((Object)(object)gatheringListPanel.HintText != (Object)null)
		{
			string text = ((object)RecipePinnerPlugin.HotkeyGatheringList.Value/*cast due to .constrained prefix*/).ToString();
			if (_lastHintKey != text)
			{
				_lastHintKey = text;
				string format = (RecipePinnerPlugin.Instance?.LocalizationMgr)?.GetText("gathering_hint") ?? "Open/Close: {0}";
				gatheringListPanel.HintText.text = string.Format(format, text);
			}
			((Component)gatheringListPanel.HintText).transform.SetAsLastSibling();
		}
		gatheringListPanel.RefreshLayout();
	}

	public void ResetMyPinsInputState(string reason)
	{
		if (!IsMyPinsPanelOpen && !ControlsInfoPanel.IsOpen && !GroupNameDialog.IsDialogOpen && !ConfirmDialog.IsDialogOpen)
		{
			return;
		}
		try
		{
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
		}
		catch (Exception ex)
		{
			DebugLogger.Warning("ResetMyPinsInputState: EventSystem reset failed (" + ex.Message + ")");
		}
		try
		{
			Input.ResetInputAxes();
		}
		catch (Exception ex2)
		{
			DebugLogger.Warning("ResetMyPinsInputState: Unity input reset failed (" + ex2.Message + ")");
		}
		try
		{
			if (ZInput.instance != null)
			{
				ZInput.ResetButtonStatus("Forward");
				ZInput.ResetButtonStatus("Backward");
				ZInput.ResetButtonStatus("Left");
				ZInput.ResetButtonStatus("Right");
				ZInput.ResetButtonStatus("Jump");
				ZInput.ResetButtonStatus("Crouch");
				ZInput.ResetButtonStatus("Run");
				ZInput.ResetButtonStatus("Use");
				ZInput.ResetButtonStatus("Attack");
				ZInput.ResetButtonStatus("SecondAttack");
				ZInput.ResetButtonStatus("Block");
				ZInput.ResetButtonStatus("Inventory");
				ZInput.ResetButtonStatus("Hide");
				ZInput.ResetButtonStatus("Sit");
				ZInput.ResetButtonStatus("GPower");
				ZInput.ResetButtonStatus("Emote1");
				ZInput.ResetButtonStatus("Emote2");
			}
		}
		catch (Exception ex3)
		{
			DebugLogger.Warning("ResetMyPinsInputState: ZInput reset failed (" + ex3.Message + ")");
		}
		DebugLogger.Verbose("My Pins input state reset (" + reason + ")");
	}

	public void UpdateMyPinsInventoryState()
	{
		if (RecipePinnerPlugin.EnableMod != null && !RecipePinnerPlugin.EnableMod.Value)
		{
			HideMyPinsPanel();
			if ((Object)(object)_myPinsButton != (Object)null)
			{
				((Component)_myPinsButton).gameObject.SetActive(false);
			}
			_inventoryWasOpen = false;
			return;
		}
		bool flag = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
		if (flag && !_inventoryWasOpen)
		{
			EnsureMyPinsButton();
			if ((Object)(object)_myPinsButton != (Object)null)
			{
				((Component)_myPinsButton).gameObject.SetActive(true);
			}
		}
		else if (!flag && _inventoryWasOpen)
		{
			HideMyPinsPanel();
		}
		if (flag && (Object)(object)_myPinsPanel != (Object)null && ((Component)_myPinsPanel).gameObject.activeSelf)
		{
			RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
			if (recipeManager != null)
			{
				int count = recipeManager.PinnedRecipes.Count;
				int count2 = recipeManager.PinGroups.Count;
				if (count != _lastKnownPinCount || count2 != _lastKnownGroupCount)
				{
					_lastKnownPinCount = count;
					_lastKnownGroupCount = count2;
					RefreshMyPinsList();
				}
			}
		}
		_inventoryWasOpen = flag;
	}

	private void EnsureMyPinsButton()
	{
		//IL_00f8: 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_0122: 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_013f: 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_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Expected O, but got Unknown
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_myPinsButton != (Object)null || (Object)(object)InventoryGui.instance == (Object)null)
		{
			return;
		}
		Transform transform = ((Component)InventoryGui.instance).transform;
		if ((Object)(object)transform == (Object)null)
		{
			DebugLogger.Warning("EnsureMyPinsButton: InventoryGui root is null");
			return;
		}
		Transform val = transform;
		try
		{
			Button craftButton = InventoryGui.instance.m_craftButton;
			if ((Object)(object)craftButton != (Object)null && (Object)(object)((Component)craftButton).transform.parent != (Object)null)
			{
				val = ((Component)craftButton).transform.parent;
				DebugLogger.Log("EnsureMyPinsButton: Using m_craftButton.parent = '" + ((Object)val).name + "'");
			}
			else
			{
				DebugLogger.Warning("EnsureMyPinsButton: m_craftButton or its parent is null, falling back to invRoot");
			}
		}
		catch (Exception ex)
		{
			DebugLogger.Warning("EnsureMyPinsButton: m_craftButton lookup failed: " + ex.Message);
		}
		_myPinsButton = UIBuilder.CreateMyPinsButton(val, _cachedFont);
		if ((Object)(object)_myPinsButton == (Object)null)
		{
			DebugLogger.Error("EnsureMyPinsButton: Failed to create button");
			return;
		}
		RectTransform component = ((Component)_myPinsButton).GetComponent<RectTransform>();
		component.anchorMin = new Vector2(1f, 1f);
		component.anchorMax = new Vector2(1f, 1f);
		component.pivot = new Vector2(1f, 1f);
		Vector2 anchoredPosition = (Vector2)(((??)RecipePinnerPlugin.MyPinsButtonPosition?.Value) ?? new Vector2(-10f, -10f));
		component.anchoredPosition = anchoredPosition;
		((UnityEvent)_myPinsButton.onClick).AddListener(new UnityAction(ToggleMyPinsPanel));
		Outline componentInChildren = ((Component)_myPinsButton).GetComponentInChildren<Outline>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			((Shadow)componentInChildren).effectDistance = new Vector2(3f, -3f);
		}
		DebugLogger.Log("My Pins button ensured on inventory");
	}

	private void EnsureMyPinsPanel()
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: 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_00d5: 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_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Expected O, but got Unknown
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Expected O, but got Unknown
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Expected O, but got Unknown
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Expected O, but got Unknown
		//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Expected O, but got Unknown
		if ((Object)(object)_myPinsPanel != (Object)null || (Object)(object)InventoryGui.instance == (Object)null)
		{
			return;
		}
		Transform transform = ((Component)InventoryGui.instance).transform;
		DebugLogger.Log("Creating My Pins panel (persistent)");
		_myPinsPanel = UIBuilder.CreateMyPinsPanel(transform, _cachedFont);
		if ((Object)(object)_myPinsPanel == (Object)null)
		{
			DebugLogger.Error("EnsureMyPinsPanel: UIBuilder returned null");
			return;
		}
		_myPinsPanel.PanelRect.anchorMin = new Vector2(0.5f, 0.5f);
		_myPinsPanel.PanelRect.anchorMax = new Vector2(0.5f, 0.5f);
		_myPinsPanel.PanelRect.pivot = new Vector2(0.5f, 0.5f);
		_myPinsPanel.PanelRect.anchoredPosition = RecipePinnerPlugin.MyPinsPanelPosition?.Value ?? Vector2.zero;
		if ((Object)(object)_myPinsPanel.GroupButton != (Object)null)
		{
			((UnityEvent)_myPinsPanel.GroupButton.onClick).AddListener(new UnityAction(OnGroupButtonClicked));
		}
		if ((Object)(object)_myPinsPanel.ConfirmButton != (Object)null)
		{
			((UnityEvent)_myPinsPanel.ConfirmButton.onClick).AddListener((UnityAction)delegate
			{
				DebugLogger.Log("Confirm button clicked - confirming group selection");
				OnGroupButtonClicked();
			});
		}
		if ((Object)(object)_myPinsPanel.CancelButton != (Object)null)
		{
			((UnityEvent)_myPinsPanel.CancelButton.onClick).AddListener((UnityAction)delegate
			{
				DebugLogger.Log("Cancel button clicked - exiting selection mode");
				ExitSelectionMode();
				RefreshMyPinsList();
			});
		}
		if ((Object)(object)_myPinsPanel.CloseButton != (Object)null)
		{
			((UnityEvent)_myPinsPanel.CloseButton.onClick).AddListener((UnityAction)delegate
			{
				DebugLogger.Log("Close button clicked");
				ToggleMyPinsPanel();
			});
		}
		if ((Object)(object)_myPinsPanel.ClearButton != (Object)null)
		{
			((UnityEvent)_myPinsPanel.ClearButton.onClick).AddListener(new UnityAction(OnClearButtonClicked));
		}
		_myPinsPanel.SetActive(active: false);
		_modalOverlay = UIBuilder.CreateModalOverlay(transform, delegate
		{
			DebugLogger.Log("Modal overlay clicked - closing My Pins panel");
			ToggleMyPinsPanel();
		});
		_modalOverlay.transform.SetAsLastSibling();
		((Component)_myPinsPanel).transform.SetAsLastSibling();
		_groupNameDialog = UIBuilder.CreateGroupNameDialog(transform, _cachedFont);
		if ((Object)(object)_groupNameDialog != (Object)null)
		{
			_groupNameDialog.OnConfirm = OnGroupNameConfirmed;
			_groupNameDialog.OnCancel = OnGroupNameCancelled;
			_groupNameDialog.SetActive(active: false);
		}
		_confirmDialog = UIBuilder.CreateConfirmDialog(transform, _cachedFont);
		if ((Object)(object)_confirmDialog != (Object)null)
		{
			_confirmDialog.SetActive(active: false);
		}
		DebugLogger.Log("My Pins panel, overlay, and dialogs created (persistent)");
	}

	public void ToggleMyPinsPanel()
	{
		DebugLogger.Log("ToggleMyPinsPanel called");
		if (RecipePinnerPlugin.EnableMod != null && !RecipePinnerPlugin.EnableMod.Value)
		{
			HideMyPinsPanel();
			if ((Object)(object)_myPinsButton != (Object)null)
			{
				((Component)_myPinsButton).gameObject.SetActive(false);
			}
			DebugLogger.Verbose("ToggleMyPinsPanel ignored - mod disabled");
			return;
		}
		EnsureMyPinsPanel();
		if ((Object)(object)_myPinsPanel == (Object)null)
		{
			DebugLogger.Error("ToggleMyPinsPanel: Panel is null after ensure");
			return;
		}
		bool flag = !((Component)_myPinsPanel).gameObject.activeSelf;
		if (!flag)
		{
			_myPinsPanel.ControlsPanel?.Hide();
		}
		_myPinsPanel.SetActive(flag);
		if ((Object)(object)_modalOverlay != (Object)null)
		{
			_modalOverlay.SetActive(flag);
		}
		if (flag)
		{
			if ((Object)(object)_modalOverlay != (Object)null)
			{
				_modalOverlay.transform.SetAsLastSibling();
			}
			((Component)_myPinsPanel).transform.SetAsLastSibling();
			if ((Object)(object)_groupNameDialog != (Object)null)
			{
				((Component)_groupNameDialog).transform.SetAsLastSibling();
			}
			RefreshMyPinsList();
			DebugLogger.Log("My Pins panel opened (with overlay)");
		}
		else
		{
			if (_isSelectionMode)
			{
				ExitSelectionMode();
			}
			DebugLogger.Log("My Pins panel closed");
		}
	}

	private void HideMyPinsPanel()
	{
		if (_isSelectionMode)
		{
			ExitSelectionMode();
		}
		if ((Object)(object)_modalOverlay != (Object)null)
		{
			_modalOverlay.SetActive(false);
		}
		if ((Object)(object)_myPinsPanel != (Object)null)
		{
			if ((Object)(object)_myPinsPanel.ControlsPanel != (Object)null && ControlsInfoPanel.IsOpen)
			{
				_myPinsPanel.ControlsPanel.Hide();
			}
			_myPinsPanel.SetActive(active: false);
		}
		if ((Object)(object)_groupNameDialog != (Object)null)
		{
			_groupNameDialog.SetActive(active: false);
		}
		if ((Object)(object)_confirmDialog != (Object)null)
		{
			_confirmDialog.SetActive(active: false);
		}
		_lastKnownPinCount = -1;
		_lastKnownGroupCount = -1;
		DebugLogger.Verbose("My Pins button+panel hidden (inventory closed)");
	}

	public void CloseMyPinsPanel()
	{
		HideMyPinsPanel();
	}

	public void RefreshMyPinsList()
	{
		//IL_0ae9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0af3: Expected O, but got Unknown
		//IL_0b06: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b10: Expected O, but got Unknown
		//IL_0a6d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a77: Expected O, but got Unknown
		//IL_0a8a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a94: Expected O, but got Unknown
		//IL_0b7d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b87: Expected O, but got Unknown
		//IL_0b4b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b55: Expected O, but got Unknown
		//IL_0c37: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c41: Expected O, but got Unknown
		//IL_0bac: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bb6: Expected O, but got Unknown
		//IL_0c1a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c24: Expected O, but got Unknown
		//IL_0bfa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c04: Expected O, but got Unknown
		//IL_0ceb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cf5: Expected O, but got Unknown
		//IL_0cce: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cd8: Expected O, but got Unknown
		//IL_0cae: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cb8: Expected O, but got Unknown
		if ((Object)(object)_myPinsPanel == (Object)null || !((Component)_myPinsPanel).gameObject.activeSelf)
		{
			return;
		}
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager == null)
		{
			return;
		}
		List<MyPinDisplayItem> list = new List<MyPinDisplayItem>();
		Dictionary<string, int> dictionary = new Dictionary<string, int>();
		foreach (PinGroupData value7 in recipeManager.PinGroups.Values)
		{
			foreach (string memberRecipeKey in value7.MemberRecipeKeys)
			{
				int value;
				int num = ((!value7.MemberCounts.TryGetValue(memberRecipeKey, out value)) ? 1 : value);
				if (dictionary.ContainsKey(memberRecipeKey))
				{
					dictionary[memberRecipeKey] += num;
				}
				else
				{
					dictionary[memberRecipeKey] = num;
				}
			}
		}
		Dictionary<string, MyPinDisplayItem> dictionary2 = new Dictionary<string, MyPinDisplayItem>();
		foreach (KeyValuePair<string, PinGroupData> pinGroup in recipeManager.PinGroups)
		{
			PinGroupData value2 = pinGroup.Value;
			dictionary2[pinGroup.Key] = new MyPinDisplayItem
			{
				Key = value2.GroupName,
				DisplayName = value2.GroupName,
				Icon = null,
				Count = value2.MemberRecipeKeys.Count,
				IsGroup = true,
				GroupData = value2
			};
		}
		foreach (string item2 in recipeManager.GetDisplayPinOrder())
		{
			if (item2.StartsWith("GROUP:"))
			{
				if (_isSelectionMode)
				{
					continue;
				}
				string text = item2.Substring(6);
				if (!dictionary2.TryGetValue(text, out var value3))
				{
					continue;
				}
				list.Add(value3);
				if (!_expandedGroups.Contains(text) || value3.GroupData == null)
				{
					continue;
				}
				foreach (string memberRecipeKey2 in value3.GroupData.MemberRecipeKeys)
				{
					int value4;
					int count = ((!value3.GroupData.MemberCounts.TryGetValue(memberRecipeKey2, out value4)) ? 1 : value4);
					string text2 = memberRecipeKey2;
					Sprite icon = null;
					PinnedRecipeData pinnedRecipeData = null;
					foreach (PinnedRecipeData memberPin in value3.GroupData.MemberPins)
					{
						if (memberPin != null && (((Object)(object)memberPin.RecipeRef != (Object)null && ((Object)memberPin.RecipeRef).name == memberRecipeKey2) || memberPin.RawName == memberRecipeKey2))
						{
							pinnedRecipeData = memberPin;
							break;
						}
					}
					if (pinnedRecipeData != null)
					{
						text2 = (string.IsNullOrEmpty(pinnedRecipeData.CachedHeader) ? memberRecipeKey2 : pinnedRecipeData.CachedHeader);
						string text3 = count + "x ";
						if (text2.StartsWith(text3))
						{
							text2 = text2.Substring(text3.Length);
						}
						icon = pinnedRecipeData.Icon;
					}
					else
					{
						Recipe recipeByName = recipeManager.GetRecipeByName(memberRecipeKey2);
						if ((Object)(object)recipeByName != (Object)null && (Object)(object)recipeByName.m_item != (Object)null && recipeByName.m_item.m_itemData != null)
						{
							icon = recipeByName.m_item.m_itemData.GetIcon();
							string text4 = ((recipeByName.m_item.m_itemData.m_shared != null) ? recipeByName.m_item.m_itemData.m_shared.m_name : null);
							if (Localization.instance != null && !string.IsNullOrEmpty(text4))
							{
								text2 = Localization.instance.Localize(text4);
							}
							if (recipeByName.m_amount > 1)
							{
								text2 += $" (x{recipeByName.m_amount})";
							}
						}
						else
						{
							foreach (PinnedRecipeData cachedPin in recipeManager.CachedPins)
							{
								if (!cachedPin.IsGroup && (Object)(object)cachedPin.RecipeRef != (Object)null && ((Object)cachedPin.RecipeRef).name == memberRecipeKey2)
								{
									text2 = cachedPin.CachedHeader;
									icon = cachedPin.Icon;
									break;
								}
							}
						}
					}
					list.Add(new MyPinDisplayItem
					{
						Key = memberRecipeKey2,
						DisplayName = text2,
						Icon = icon,
						Count = count,
						IsGroup = false,
						IsSubItem = true,
						ParentGroupName = text,
						GroupData = null
					});
				}
			}
			else
			{
				if (!recipeManager.PinnedRecipes.TryGetValue(item2, out var value5))
				{
					continue;
				}
				if (dictionary.TryGetValue(item2, out var value6))
				{
					value5 -= value6;
					if (value5 <= 0)
					{
						continue;
					}
				}
				string text5 = item2;
				Sprite icon2 = null;
				Recipe recipeByName2 = recipeManager.GetRecipeByName(item2);
				if ((Object)(object)recipeByName2 != (Object)null && (Object)(object)recipeByName2.m_item != (Object)null && recipeByName2.m_item.m_itemData != null)
				{
					icon2 = recipeByName2.m_item.m_itemData.GetIcon();
					string text6 = ((recipeByName2.m_item.m_itemData.m_shared != null) ? recipeByName2.m_item.m_itemData.m_shared.m_name : null);
					if (Localization.instance != null && !string.IsNullOrEmpty(text6))
					{
						text5 = Localization.instance.Localize(text6);
					}
					if (recipeByName2.m_amount > 1)
					{
						text5 += $" (x{recipeByName2.m_amount})";
					}
				}
				else
				{
					foreach (PinnedRecipeData cachedPin2 in recipeManager.CachedPins)
					{
						if (!cachedPin2.IsGroup && (Object)(object)cachedPin2.RecipeRef != (Object)null && ((Object)cachedPin2.RecipeRef).name == item2)
						{
							text5 = cachedPin2.CachedHeader;
							icon2 = cachedPin2.Icon;
							break;
						}
					}
				}
				list.Add(new MyPinDisplayItem
				{
					Key = item2,
					DisplayName = text5,
					Icon = icon2,
					Count = value5,
					IsGroup = false,
					IsSubItem = false,
					ParentGroupName = null,
					GroupData = null
				});
			}
		}
		while (_myPinsPanel.PinItems.Count < list.Count)
		{
			MyPinItemUI item = UIBuilder.CreateMyPinItem(_myPinsPanel.PinListRoot, _cachedFont);
			_myPinsPanel.PinItems.Add(item);
			DebugLogger.Log($"Created pool item #{_myPinsPanel.PinItems.Count} under {((Object)_myPinsPanel.PinListRoot).name}");
		}
		for (int i = 0; i < _myPinsPanel.PinItems.Count; i++)
		{
			MyPinItemUI myPinItemUI = _myPinsPanel.PinItems[i];
			if (i < list.Count)
			{
				MyPinDisplayItem myPinDisplayItem = list[i];
				if (!((Component)myPinItemUI).gameObject.activeSelf)
				{
					myPinItemUI.SetActive(active: true);
				}
				myPinItemUI.RecipeKey = myPinDisplayItem.Key;
				myPinItemUI.IsGroupItem = myPinDisplayItem.IsGroup;
				myPinItemUI.IsSubItem = myPinDisplayItem.IsSubItem;
				myPinItemUI.ParentGroupName = myPinDisplayItem.ParentGroupName;
				myPinItemUI.SetSubItemStyle(myPinDisplayItem.IsSubItem);
				if ((Object)(object)myPinItemUI.NameText != (Object)null)
				{
					myPinItemUI.NameText.text = myPinDisplayItem.DisplayName;
				}
				if ((Object)(object)myPinItemUI.CountText != (Object)null)
				{
					if (myPinDisplayItem.IsGroup)
					{
						myPinItemUI.CountText.text = $"({myPinDisplayItem.Count})";
					}
					else
					{
						myPinItemUI.CountText.text = ((myPinDisplayItem.Count > 1) ? $"x{myPinDisplayItem.Count}" : "");
					}
				}
				if ((Object)(object)myPinItemUI.IconRoot != (Object)null)
				{
					for (int num2 = myPinItemUI.IconRoot.childCount - 1; num2 >= 0; num2--)
					{
						GameObject gameObject = ((Component)myPinItemUI.IconRoot.GetChild(num2)).gameObject;
						if (!(((Object)gameObject).name == "Icon"))
						{
							Object.Destroy((Object)(object)gameObject);
						}
					}
					LayoutElement component = ((Component)myPinItemUI.IconRoot).GetComponent<LayoutElement>();
					if ((Object)(object)component != (Object)null)
					{
						component.minWidth = 30f;
						component.preferredWidth = 30f;
						component.minHeight = 30f;
						component.preferredHeight = 30f;
					}
				}
				if (myPinDisplayItem.IsGroup && myPinDisplayItem.GroupData != null)
				{
					if ((Object)(object)myPinItemUI.Icon != (Object)null)
					{
						((Component)myPinItemUI.Icon).gameObject.SetActive(false);
					}
					UIBuilder.CreateGroupIconWidget(myPinItemUI.IconRoot, _cachedFont, 30).countText.text = myPinDisplayItem.GroupData.MemberRecipeKeys.Count.ToString();
				}
				else if ((Object)(object)myPinItemUI.Icon != (Object)null)
				{
					((Component)myPinItemUI.Icon).gameObject.SetActive((Object)(object)myPinDisplayItem.Icon != (Object)null);
					myPinItemUI.Icon.sprite = myPinDisplayItem.Icon;
				}
				string capturedKey = myPinDisplayItem.Key;
				string capturedName = myPinDisplayItem.DisplayName;
				bool capturedIsGroup = myPinDisplayItem.IsGroup;
				bool isSubItem = myPinDisplayItem.IsSubItem;
				string capturedParent = myPinDisplayItem.ParentGroupName;
				int count2 = myPinDisplayItem.Count;
				if ((Object)(object)myPinItemUI.ExpandButton != (Object)null)
				{
					((Component)myPinItemUI.ExpandButton).gameObject.SetActive(capturedIsGroup);
					if (capturedIsGroup)
					{
						bool flag = _expandedGroups.Contains(capturedKey);
						if ((Object)(object)myPinItemUI.ExpandButtonText != (Object)null)
						{
							myPinItemUI.ExpandButtonText.text = (flag ? "▼" : "►");
						}
						((UnityEventBase)myPinItemUI.ExpandButton.onClick).RemoveAllListeners();
						((UnityEvent)myPinItemUI.ExpandButton.onClick).AddListener((UnityAction)delegate
						{
							OnExpandToggle(capturedKey);
						});
						((UnityEvent)myPinItemUI.ExpandButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
					}
				}
				if ((Object)(object)myPinItemUI.DisbandButton != (Object)null)
				{
					((Component)myPinItemUI.DisbandButton).gameObject.SetActive(capturedIsGroup);
					if (capturedIsGroup)
					{
						((UnityEventBase)myPinItemUI.DisbandButton.onClick).RemoveAllListeners();
						((UnityEvent)myPinItemUI.DisbandButton.onClick).AddListener((UnityAction)delegate
						{
							OnDisbandGroup(capturedKey, capturedName);
						});
						((UnityEvent)myPinItemUI.DisbandButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
					}
				}
				if ((Object)(object)myPinItemUI.DeleteButton != (Object)null)
				{
					((UnityEventBase)myPinItemUI.DeleteButton.onClick).RemoveAllListeners();
					if (isSubItem)
					{
						((UnityEvent)myPinItemUI.DeleteButton.onClick).AddListener((UnityAction)delegate
						{
							OnSubItemDelete(capturedParent, capturedKey, capturedName);
						});
						((Component)myPinItemUI.DeleteButton).gameObject.SetActive(true);
					}
					else
					{
						((UnityEvent)myPinItemUI.DeleteButton.onClick).AddListener((UnityAction)delegate
						{
							OnPinDelete(capturedKey, capturedName, capturedIsGroup);
						});
						((Component)myPinItemUI.DeleteButton).gameObject.SetActive(true);
					}
					((UnityEvent)myPinItemUI.DeleteButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
				}
				if ((Object)(object)myPinItemUI.PlusButton != (Object)null)
				{
					((UnityEventBase)myPinItemUI.PlusButton.onClick).RemoveAllListeners();
					if (!capturedIsGroup)
					{
						if (isSubItem)
						{
							((UnityEvent)myPinItemUI.PlusButton.onClick).AddListener((UnityAction)delegate
							{
								OnSubItemCountChange(capturedParent, capturedKey, 1);
							});
						}
						else
						{
							((UnityEvent)myPinItemUI.PlusButton.onClick).AddListener((UnityAction)delegate
							{
								OnPinCountChange(capturedKey, 1);
							});
						}
					}
					((UnityEvent)myPinItemUI.PlusButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
					((Component)myPinItemUI.PlusButton).gameObject.SetActive(!capturedIsGroup);
				}
				if ((Object)(object)myPinItemUI.MinusButton != (Object)null)
				{
					((UnityEventBase)myPinItemUI.MinusButton.onClick).RemoveAllListeners();
					bool flag2 = !capturedIsGroup && count2 > 1;
					if (flag2)
					{
						if (isSubItem)
						{
							((UnityEvent)myPinItemUI.MinusButton.onClick).AddListener((UnityAction)delegate
							{
								OnSubItemCountChange(capturedParent, capturedKey, -1);
							});
						}
						else
						{
							((UnityEvent)myPinItemUI.MinusButton.onClick).AddListener((UnityAction)delegate
							{
								OnPinCountChange(capturedKey, -1);
							});
						}
					}
					((UnityEvent)myPinItemUI.MinusButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
					((Component)myPinItemUI.MinusButton).gameObject.SetActive(flag2);
				}
				myPinItemUI.SetSelectionMode(_isSelectionMode);
			}
			else if (((Component)myPinItemUI).gameObject.activeSelf)
			{
				myPinItemUI.SetActive(active: false);
				if ((Object)(object)myPinItemUI.NameText != (Object)null)
				{
					myPinItemUI.NameText.text = "";
				}
				if ((Object)(object)myPinItemUI.CountText != (Object)null)
				{
					myPinItemUI.CountText.text = "";
				}
				if ((Object)(object)myPinItemUI.Icon != (Object)null)
				{
					myPinItemUI.Icon.sprite = null;
				}
				myPinItemUI.RecipeKey = null;
			}
		}
		if ((Object)(object)_myPinsPanel.EmptyText != (Object)null)
		{
			((Component)_myPinsPanel.EmptyText).gameObject.SetActive(list.Count == 0);
		}
		int num3 = 0;
		foreach (MyPinDisplayItem item3 in list)
		{
			if (!item3.IsGroup && !item3.IsSubItem)
			{
				num3++;
			}
		}
		Canvas.ForceUpdateCanvases();
		_myPinsPanel.RefreshLayout();
		DebugLogger.Verbose($"My Pins list refreshed: {list.Count} items ({num3} individual)");
	}

	private void OnClearButtonClicked()
	{
		DebugLogger.Log("Clear button clicked");
		RecipeManager recipeMgr = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeMgr == null || (recipeMgr.PinnedRecipes.Count == 0 && recipeMgr.PinGroups.Count == 0))
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				string text = (RecipePinnerPlugin.Instance?.LocalizationMgr)?.GetText("mypins_empty") ?? "No Recipes Pinned";
				((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
			return;
		}
		if ((Object)(object)_confirmDialog == (Object)null)
		{
			DebugLogger.Error("Clear: ConfirmDialog is null");
			return;
		}
		string message = (RecipePinnerPlugin.Instance?.LocalizationMgr)?.GetText("clear_confirm_msg") ?? "Remove all pins?";
		_confirmDialog.Show(message, delegate
		{
			DebugLogger.Log("Clear confirmed - removing all pins");
			if (recipeMgr != null)
			{
				recipeMgr.PinnedRecipes.Clear();
				recipeMgr.PinnedRecipeOrder.Clear();
				recipeMgr.PinGroups.Clear();
				recipeMgr.RefreshRecipeCache();
				RecipePinnerPlugin.Instance?.DataMgr.SavePins();
			}
			RefreshMyPinsList();
		});
	}

	private void OnGroupButtonClicked()
	{
		if (_isSelectionMode)
		{
			ConfirmGroupSelection();
			return;
		}
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager != null)
		{
			int num = 0;
			foreach (KeyValuePair<string, int> pinnedRecipe in recipeManager.PinnedRecipes)
			{
				int groupClaimCount = recipeManager.GetGroupClaimCount(pinnedRecipe.Key);
				if (pinnedRecipe.Value > groupClaimCount)
				{
					num++;
				}
			}
			if (num < 2)
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					string text = (RecipePinnerPlugin.Instance?.LocalizationMgr)?.GetText("group_need_more") ?? "At least 2 ungrouped pins are needed to create a group";
					((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
				}
				return;
			}
		}
		EnterSelectionMode();
	}

	public void EnterSelectionMode()
	{
		_isSelectionMode = true;
		_selectedForGroup.Clear();
		if ((Object)(object)_myPinsPanel?.GroupButton != (Object)null)
		{
			((Component)((Component)_myPinsPanel.GroupButton).transform.parent).gameObject.SetActive(false);
		}
		if ((Object)(object)_myPinsPanel?.ConfirmButton != (Object)null)
		{
			((Component)((Component)_myPinsPanel.ConfirmButton).transform.parent).gameObject.SetActive(true);
		}
		if ((Object)(object)_myPinsPanel?.CloseButton != (Object)null)
		{
			((Component)((Component)_myPinsPanel.CloseButton).transform.parent).gameObject.SetActive(false);
		}
		RefreshMyPinsList();
		if ((Object)(object)Player.m_localPlayer != (Object)null)
		{
			string text = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_select_hint") ?? "Select pins to group";
			((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
		}
		DebugLogger.Log("Entered selection mode");
	}

	public void ExitSelectionMode()
	{
		_isSelectionMode = false;
		_selectedForGroup.Clear();
		if ((Object)(object)_myPinsPanel?.GroupButton != (Object)null)
		{
			((Component)((Component)_myPinsPanel.GroupButton).transform.parent).gameObject.SetActive(true);
		}
		if ((Object)(object)_myPinsPanel?.ConfirmButton != (Object)null)
		{
			((Component)((Component)_myPinsPanel.ConfirmButton).transform.parent).gameObject.SetActive(false);
		}
		if ((Object)(object)_myPinsPanel?.CloseButton != (Object)null)
		{
			((Component)((Component)_myPinsPanel.CloseButton).transform.parent).gameObject.SetActive(true);
		}
		if ((Object)(object)_myPinsPanel?.ClearButton != (Object)null)
		{
			((Component)_myPinsPanel.ClearButton).gameObject.SetActive(true);
		}
		if ((Object)(object)_myPinsPanel != (Object)null)
		{
			foreach (MyPinItemUI pinItem in _myPinsPanel.PinItems)
			{
				if (((Component)pinItem).gameObject.activeSelf)
				{
					pinItem.SetSelectionMode(selectionMode: false);
				}
			}
		}
		DebugLogger.Log("Exited selection mode");
	}

	private void ConfirmGroupSelection()
	{
		_selectedForGroup.Clear();
		foreach (MyPinItemUI pinItem in _myPinsPanel.PinItems)
		{
			if (((Component)pinItem).gameObject.activeSelf && !pinItem.IsGroupItem && (Object)(object)pinItem.SelectToggle != (Object)null && pinItem.SelectToggle.isOn)
			{
				_selectedForGroup.Add(pinItem.RecipeKey);
			}
		}
		if (_selectedForGroup.Count < 2)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				string text = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_min_select") ?? "Select at least 2 pins";
				((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
			DebugLogger.Log($"Group selection rejected: only {_selectedForGroup.Count} selected");
		}
		else
		{
			DebugLogger.Log($"Group selection confirmed: {_selectedForGroup.Count} pins selected");
			ShowGroupNameDialog();
		}
	}

	private void ShowGroupNameDialog()
	{
		if ((Object)(object)_groupNameDialog == (Object)null)
		{
			DebugLogger.Error("ShowGroupNameDialog: Dialog is null");
			return;
		}
		_groupNameDialog.SetActive(active: true);
		DebugLogger.Log("Group name dialog shown");
	}

	private bool OnGroupNameConfirmed(string groupName)
	{
		DebugLogger.Log("Group name confirmed: '" + groupName + "'");
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager == null)
		{
			return false;
		}
		bool num = recipeManager.CreateGroup(groupName, _selectedForGroup);
		if (num && (Object)(object)Player.m_localPlayer != (Object)null)
		{
			string format = RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_created") ?? "Group Created: {0}";
			((Character)Player.m_localPlayer).Message((MessageType)2, string.Format(format, groupName), 0, (Sprite)null);
		}
		if (!num)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				string text = ((!recipeManager.PinGroups.ContainsKey(groupName)) ? (RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_create_failed") ?? "Group could not be created") : string.Format(RecipePinnerPlugin.Instance?.LocalizationMgr?.GetText("group_name_exists") ?? "Group '{0}' already exists", groupName));
				((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
			return false;
		}
		ExitSelectionMode();
		RefreshMyPinsList();
		return true;
	}

	private void OnGroupNameCancelled()
	{
		DebugLogger.Log("Group name cancelled");
		_groupNameDialog?.SetActive(active: false);
	}

	private void OnPinDelete(string key, string displayName, bool isGroup)
	{
		DebugLogger.Log("OnPinDelete requested: " + key);
		RecipeManager recipeMgr = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeMgr == null)
		{
			return;
		}
		LocalizationManager localizationManager = RecipePinnerPlugin.Instance?.LocalizationMgr;
		string message = (isGroup ? string.Format(localizationManager?.GetText("confirm_delete_group") ?? "Delete group \"{0}\" and all member pins?", displayName) : string.Format(localizationManager?.GetText("confirm_delete_pin") ?? "Delete \"{0}\"?", displayName));
		if ((Object)(object)_confirmDialog != (Object)null)
		{
			_confirmDialog.Show(message, delegate
			{
				DebugLogger.Log("OnPinDelete confirmed: " + key);
				recipeMgr.RemovePinFromMyPinsPanel(key);
				if (isGroup)
				{
					_expandedGroups.Remove(key);
				}
				RefreshMyPinsList();
			});
		}
		else
		{
			recipeMgr.RemovePinFromMyPinsPanel(key);
			if (isGroup)
			{
				_expandedGroups.Remove(key);
			}
			RefreshMyPinsList();
		}
	}

	private void OnPinCountChange(string key, int delta)
	{
		DebugLogger.Log($"OnPinCountChange: {key} delta={delta}");
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager != null)
		{
			recipeManager.AdjustPinCount(key, delta, showMessage: false);
			RefreshMyPinsList();
		}
	}

	private void OnSubItemCountChange(string groupName, string key, int delta)
	{
		DebugLogger.Log($"OnSubItemCountChange: group={groupName} key={key} delta={delta}");
		RecipeManager recipeManager = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeManager == null)
		{
			return;
		}
		if (string.IsNullOrEmpty(groupName) || !recipeManager.PinGroups.TryGetValue(groupName, out var value))
		{
			DebugLogger.Warning("OnSubItemCountChange: group '" + groupName + "' not found for key '" + key + "'");
			return;
		}
		if (!value.MemberRecipeKeys.Contains(key))
		{
			DebugLogger.Warning("OnSubItemCountChange: key '" + key + "' not found in group '" + groupName + "'");
			return;
		}
		int value2;
		int num = ((!value.MemberCounts.TryGetValue(key, out value2)) ? 1 : value2);
		if (!recipeManager.PinnedRecipes.TryGetValue(key, out var value3))
		{
			DebugLogger.Warning("SubItem: " + key + " missing from PinnedRecipes while adjusting group claim; ignoring change");
			return;
		}
		int num2 = num + delta;
		if (num2 < 1)
		{
			num2 = 1;
		}
		int num3 = num2 - num;
		value.MemberCounts[key] = num2;
		int num4 = Math.Max(1, value3 + num3);
		recipeManager.PinnedRecipes[key] = num4;
		DebugLogger.Log($"SubItem: {groupName}/{key} claim {num}->{num2}, total={num4}");
		recipeManager.RefreshRecipeCache();
		RecipePinnerPlugin.Instance?.DataMgr.SavePins();
		RefreshMyPinsList();
	}

	private void OnExpandToggle(string groupName)
	{
		if (_expandedGroups.Contains(groupName))
		{
			_expandedGroups.Remove(groupName);
			DebugLogger.Log("Group collapsed: " + groupName);
		}
		else
		{
			_expandedGroups.Add(groupName);
			DebugLogger.Log("Group expanded: " + groupName);
		}
		RefreshMyPinsList();
	}

	private void OnDisbandGroup(string groupName, string displayName)
	{
		DebugLogger.Log("OnDisbandGroup requested: " + groupName);
		RecipeManager recipeMgr = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeMgr == null)
		{
			return;
		}
		LocalizationManager locMgr = RecipePinnerPlugin.Instance?.LocalizationMgr;
		string message = string.Format(locMgr?.GetText("confirm_disband_group") ?? "Disband group \"{0}\"? Members will become individual pins.", displayName);
		if ((Object)(object)_confirmDialog != (Object)null)
		{
			_confirmDialog.Show(message, delegate
			{
				DebugLogger.Log("OnDisbandGroup confirmed: " + groupName);
				recipeMgr.DisbandGroup(groupName);
				_expandedGroups.Remove(groupName);
				RefreshMyPinsList();
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					string format = locMgr?.GetText("group_disbanded") ?? "Group Disbanded: {0}";
					((Character)Player.m_localPlayer).Message((MessageType)2, string.Format(format, displayName), 0, (Sprite)null);
				}
			});
		}
		else
		{
			recipeMgr.DisbandGroup(groupName);
			_expandedGroups.Remove(groupName);
			RefreshMyPinsList();
		}
	}

	private void OnSubItemDelete(string groupName, string recipeKey, string displayName)
	{
		DebugLogger.Log("OnSubItemDelete requested: " + recipeKey + " from group " + groupName);
		RecipeManager recipeMgr = RecipePinnerPlugin.Instance?.RecipeMgr;
		if (recipeMgr == null)
		{
			return;
		}
		string message = string.Format((RecipePinnerPlugin.Instance?.LocalizationMgr)?.GetText("confirm_remove_member") ?? "Remove \"{0}\" from group \"{1}\"?", displayName, groupName);
		if ((Object)(object)_confirmDialog != (Object)null)
		{
			_confirmDialog.Show(message, delegate
			{
				DebugLogger.Log("OnSubItemDelete confirmed: " + recipeKey + " from group " + groupName);
				recipeMgr.RemoveMemberFromGroup(groupName, recipeKey);
				if (!recipeMgr.PinGroups.ContainsKey(groupName))
				{
					_expandedGroups.Remove(groupName);
				}
				RefreshMyPinsList();
			});
		}
		else
		{
			recipeMgr.RemoveMemberFromGroup(groupName, recipeKey);
			if (!recipeMgr.PinGroups.ContainsKey(groupName))
			{
				_expandedGroups.Remove(groupName);
			}
			RefreshMyPinsList();
		}
	}

	public void DestroyMyPinsUI()
	{
		DebugLogger.Verbose("DestroyMyPinsUI");
		if ((Object)(object)_myPinsButton != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_myPinsButton).gameObject);
			_myPinsButton = null;
		}
		if ((Object)(object)_modalOverlay != (Object)null)
		{
			Object.Destroy((Object)(object)_modalOverlay);
			_modalOverlay = null;
		}
		if ((Object)(object)_myPinsPanel != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_myPinsPanel).gameObject);
			_myPinsPanel = null;
		}
		if ((Object)(object)_groupNameDialog != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_groupNameDialog).gameObject);
			_groupNameDialog = null;
		}
		if ((Object)(object)_confirmDialog != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_confirmDialog).gameObject);
			_confirmDialog = null;
		}
		_isSelectionMode = false;
		_selectedForGroup.Clear();
		_inventoryWasOpen = false;
		_expandedGroups.Clear();
		_lastKnownPinCount = -1;
		_lastKnownGroupCount = -1;
		DebugLogger.Log("My Pins UI destroyed");
	}
}
internal class MyPinDisplayItem
{
	public string Key;

	public string DisplayName;

	public Sprite Icon;

	public int Count;

	public bool IsGroup;

	public bool IsSubItem;

	public string ParentGroupName;

	public PinGroupData GroupData;
}
public class MyPinsPanelUI : MonoBehaviour
{
	public RectTransform PanelRect;

	public Image BgImage;

	public Text TitleText;

	public Transform PinListRoot;

	public ScrollRect ScrollView;

	public Button GroupButton;

	public Button ConfirmButton;

	public Button CancelButton;

	public Button ClearButton;

	public Button CloseButton;

	public Button InfoButton;

	public ControlsInfoPanel ControlsPanel;

	public Text GroupButtonText;

	public Text EmptyText;

	public List<MyPinItemUI> PinItems = new List<MyPinItemUI>();

	private Coroutine _layoutCoroutine;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
	}

	public void RefreshLayout()
	{
		if (((Component)this).gameObject.activeInHierarchy)
		{
			if (_layoutCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_layoutCoroutine);
			}
			_layoutCoroutine = ((MonoBehaviour)this).StartCoroutine(FixLayout());
		}
	}

	private void OnDisable()
	{
		_layoutCoroutine = null;
	}

	private IEnumerator FixLayout()
	{
		yield return null;
		if ((Object)(object)PinListRoot != (Object)null)
		{
			Transform pinListRoot = PinListRoot;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((pinListRoot is RectTransform) ? pinListRoot : null));
		}
		if ((Object)(object)PanelRect != (Object)null)
		{
			LayoutRebuilder.ForceRebuildLayoutImmediate(PanelRect);
		}
	}
}
public class MyPinItemUI : MonoBehaviour
{
	public Image Icon;

	public Transform IconRoot;

	public Text NameText;

	public Text CountText;

	public Button DeleteButton;

	public Button PlusButton;

	public Button MinusButton;

	public Button ExpandButton;

	public Text ExpandButtonText;

	public Button DisbandButton;

	public Toggle SelectToggle;

	public string RecipeKey;

	public bool IsGroupItem;

	public bool IsSubItem;

	public string ParentGroupName;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
	}

	public void SetSubItemStyle(bool isSubItem)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Expected O, but got Unknown
		//IL_00dc: 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)
		IsSubItem = isSubItem;
		HorizontalLayoutGroup component = ((Component)this).GetComponent<HorizontalLayoutGroup>();
		if ((Object)(object)component != (Object)null)
		{
			((LayoutGroup)component).padding = (isSubItem ? new RectOffset(24, 6, 2, 2) : new RectOffset(6, 6, 4, 4));
		}
		LayoutElement component2 = ((Component)this).GetComponent<LayoutElement>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.minHeight = (isSubItem ? 32 : 38);
		}
		if ((Object)(object)NameText != (Object)null)
		{
			NameText.fontSize = (isSubItem ? 13 : 15);
		}
		if ((Object)(object)CountText != (Object)null)
		{
			CountText.fontSize = (isSubItem ? 13 : 15);
		}
		Image component3 = ((Component)this).GetComponent<Image>();
		if ((Object)(object)component3 != (Object)null)
		{
			((Graphic)component3).color = (isSubItem ? new Color(0.15f, 0.15f, 0.15f, 0.3f) : new Color(0f, 0f, 0f, 0.25f));
		}
	}

	public void SetSelectionMode(bool selectionMode)
	{
		if ((Object)(object)SelectToggle != (Object)null)
		{
			((Component)SelectToggle).gameObject.SetActive(selectionMode && !IsGroupItem && !IsSubItem);
			if (!selectionMode)
			{
				SelectToggle.isOn = false;
			}
		}
		if ((Object)(object)DeleteButton != (Object)null && selectionMode)
		{
			((Component)DeleteButton).gameObject.SetActive(false);
		}
		if ((Object)(object)PlusButton != (Object)null && selectionMode)
		{
			((Component)PlusButton).gameObject.SetActive(false);
		}
		if ((Object)(object)MinusButton != (Object)null && selectionMode)
		{
			((Component)MinusButton).gameObject.SetActive(false);
		}
		if ((Object)(object)ExpandButton != (Object)null && IsGroupItem)
		{
			((Component)ExpandButton).gameObject.SetActive(!selectionMode);
		}
		if ((Object)(object)DisbandButton != (Object)null && IsGroupItem)
		{
			((Component)DisbandButton).gameObject.SetActive(!selectionMode);
		}
	}
}
public class GroupNameDialog : MonoBehaviour
{
	public RectTransform DialogRect;

	public Image BgImage;

	public Image OverlayBg;

	public Text PromptText;

	public InputField NameInput;

	public Button ConfirmButton;

	public Button CancelButton;

	public Func<string, bool> OnConfirm;

	public Action OnCancel;

	public static bool IsDialogOpen;

	private bool _inputLocked;

	private bool _listenersWired;

	public void SetActive(bool active)
	{
		if (active && (Object)(object)NameInput == (Object)null)
		{
			((Component)this).gameObject.SetActive(false);
			UnlockGameInput();
			IsDialogOpen = false;
			DebugLogger.Error("GroupNameDialog: NameInput is null, dialog closed to avoid input lock");
			return;
		}
		((Component)this).gameObject.SetActive(active);
		if (active)
		{
			WireButtonListeners();
			LockGameInput();
			ClearInput();
		}
		else
		{
			UnlockGameInput();
		}
	}

	private void WireButtonListeners()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Expected O, but got Unknown
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Expected O, but got Unknown
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Expected O, but got Unknown
		if (!_listenersWired)
		{
			if ((Object)(object)ConfirmButton != (Object)null)
			{
				((UnityEventBase)ConfirmButton.onClick).RemoveAllListeners();
				((UnityEvent)ConfirmButton.onClick).AddListener(new UnityAction(OnConfirmClicked));
				((UnityEvent)ConfirmButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
			}
			if ((Object)(object)CancelButton != (Object)null)
			{
				((UnityEventBase)CancelButton.onClick).RemoveAllListeners();
				((UnityEvent)CancelButton.onClick).AddListener(new UnityAction(OnCancelClicked));
				((UnityEvent)CancelButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
			}
			if ((Object)(object)NameInput != (Object)null)
			{
				((UnityEventBase)NameInput.onEndEdit).RemoveAllListeners();
				((UnityEvent<string>)(object)NameInput.onEndEdit).AddListener((UnityAction<string>)OnInputEndEdit);
			}
			_listenersWired = true;
		}
	}

	private void OnInputEndEdit(string text)
	{
		if (IsDialogOpen && ((Component)this).gameObject.activeSelf && (Input.GetKeyDown((KeyCode)13) || Input.GetKeyDown((KeyCode)271)))
		{
			DebugLogger.Log("GroupNameDialog: Enter via onEndEdit");
			OnConfirmClicked();
		}
	}

	private void OnConfirmClicked()
	{
		if (!IsDialogOpen || !((Component)this).gameObject.activeSelf)
		{
			return;
		}
		InputField nameInput = NameInput;
		string text = ((nameInput == null) ? null : nameInput.text?.Trim());
		if (!string.IsNullOrEmpty(text))
		{
			DebugLogger.Log("GroupNameDialog: Confirm clicked with name '" + text + "'");
			Func<string, bool> onConfirm = OnConfirm;
			if (onConfirm == null || onConfirm(text))
			{
				SetActive(active: false);
			}
			else
			{
				ClearInput();
			}
		}
	}

	private void OnCancelClicked()
	{
		if (IsDialogOpen && ((Component)this).gameObject.activeSelf)
		{
			DebugLogger.Log("GroupNameDialog: Cancel clicked");
			SetActive(active: false);
			OnCancel?.Invoke();
		}
	}

	private void ClearInput()
	{
		if ((Object)(object)NameInput != (Object)null)
		{
			NameInput.text = "";
			NameInput.ActivateInputField();
			((Selectable)NameInput).Select();
		}
	}

	private void LockGameInput()
	{
		if (!_inputLocked)
		{
			IsDialogOpen = true;
			_inputLocked = true;
			DebugLogger.Log("GroupNameDialog: Game input locked (Harmony patches active)");
		}
	}

	private void UnlockGameInput()
	{
		if (_inputLocked)
		{
			IsDialogOpen = false;
			_inputLocked = false;
			DebugLogger.Log("GroupNameDialog: Game input unlocked");
		}
	}

	private void OnDestroy()
	{
		if (_inputLocked)
		{
			UnlockGameInput();
			DebugLogger.Warning("GroupNameDialog: Force-unlocked input on destroy");
		}
	}

	private void Update()
	{
		if (!((Component)this).gameObject.activeSelf)
		{
			return;
		}
		bool keyDown = Input.GetKeyDown((KeyCode)27);
		bool flag = Input.GetKeyDown((KeyCode)13) || Input.GetKeyDown((KeyCode)271);
		if (IsDialogOpen)
		{
			Input.ResetInputAxes();
			try
			{
				if (ZInput.instance != null)
				{
					ZInput.ResetButtonStatus("Forward");
					ZInput.ResetButtonStatus("Backward");
					ZInput.ResetButtonStatus("Left");
					ZInput.ResetButtonStatus("Right");
					ZInput.ResetButtonStatus("Jump");
					ZInput.ResetButtonStatus("Crouch");
					ZInput.ResetButtonStatus("Run");
					ZInput.ResetButtonStatus("Use");
					ZInput.ResetButtonStatus("Attack");
					ZInput.ResetButtonStatus("SecondAttack");
					ZInput.ResetButtonStatus("Block");
					ZInput.ResetButtonStatus("Inventory");
					ZInput.ResetButtonStatus("Hide");
					ZInput.ResetButtonStatus("Sit");
					ZInput.ResetButtonStatus("GPower");
					ZInput.ResetButtonStatus("Emote1");
					ZInput.ResetButtonStatus("Emote2");
				}
			}
			catch (Exception)
			{
			}
		}
		if (IsDialogOpen)
		{
			if (keyDown)
			{
				DebugLogger.Log("GroupNameDialog: Escape pressed, cancelling");
				OnCancelClicked();
			}
			else if (flag)
			{
				DebugLogger.Log("GroupNameDialog: Enter pressed, confirming");
				OnConfirmClicked();
			}
		}
	}
}
public class ConfirmDialog : MonoBehaviour
{
	public RectTransform DialogRect;

	public Image BgImage;

	public Image OverlayBg;

	public Text MessageText;

	public Button ConfirmButton;

	public Button CancelButton;

	public Action OnConfirm;

	public Action OnCancel;

	public static bool IsDialogOpen;

	private bool _listenersWired;

	public void SetActive(bool active)
	{
		((Component)this).gameObject.SetActive(active);
		IsDialogOpen = active;
	}

	public void Show(string message, Action onConfirm, Action onCancel = null)
	{
		OnConfirm = onConfirm;
		OnCancel = onCancel;
		if ((Object)(object)MessageText != (Object)null)
		{
			MessageText.text = message;
		}
		WireButtonListeners();
		((Component)this).transform.SetAsLastSibling();
		SetActive(active: true);
		DebugLogger.Log("ConfirmDialog shown: " + message);
	}

	private void WireButtonListeners()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Expected O, but got Unknown
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Expected O, but got Unknown
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Expected O, but got Unknown
		if (!_listenersWired)
		{
			if ((Object)(object)ConfirmButton != (Object)null)
			{
				((UnityEventBase)ConfirmButton.onClick).RemoveAllListeners();
				((UnityEvent)ConfirmButton.onClick).AddListener(new UnityAction(OnConfirmClicked));
				((UnityEvent)ConfirmButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
			}
			if ((Object)(object)CancelButton != (Object)null)
			{
				((UnityEventBase)CancelButton.onClick).RemoveAllListeners();
				((UnityEvent)CancelButton.onClick).AddListener(new UnityAction(OnCancelClicked));
				((UnityEvent)CancelButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
			}
			_listenersWired = true;
		}
	}

	private void OnConfirmClicked()
	{
		if (IsDialogOpen && ((Component)this).gameObject.activeSelf)
		{
			DebugLogger.Log("ConfirmDialog: Confirm clicked");
			SetActive(active: false);
			OnConfirm?.Invoke();
		}
	}

	private void OnCancelClicked()
	{
		if (IsDialogOpen && ((Component)this).gameObject.activeSelf)
		{
			DebugLogger.Log("ConfirmDialog: Cancel clicked");
			SetActive(active: false);
			OnCancel?.Invoke();
		}
	}

	private void Update()
	{
		if (!((Component)this).gameObject.activeSelf)
		{
			return;
		}
		bool keyDown = Input.GetKeyDown((KeyCode)27);
		bool flag = Input.GetKeyDown((KeyCode)13) || Input.GetKeyDown((KeyCode)271);
		Input.ResetInputAxes();
		try
		{
			if (ZInput.instance != null)
			{
				ZInput.ResetButtonStatus("Forward");
				ZInput.ResetButtonStatus("Backward");
				ZInput.ResetButtonStatus("Left");
				ZInput.ResetButtonStatus("Right");
				ZInput.ResetButtonStatus("Jump");
				ZInput.ResetButtonStatus("Crouch");
				ZInput.ResetButtonStatus("Run");
				ZInput.ResetButtonStatus("Use");
				ZInput.ResetButtonStatus("Attack");
				ZInput.ResetButtonStatus("SecondAttack");
				ZInput.ResetButtonStatus("Block");
				ZInput.ResetButtonStatus("Inventory");
				ZInput.ResetButtonStatus("Hide");
			}
		}
		catch (Exception)
		{
		}
		if (keyDown)
		{
			OnCancelClicked();
		}
		else if (flag)
		{
			OnConfirmClicked();
		}
	}

	private void OnDestroy()
	{
		if (IsDialogOpen)
		{
			IsDialogOpen = false;
			DebugLogger.Warning("ConfirmDialog: Force-closed on destroy");
		}
	}
}
public class ControlsInfoPanel : MonoBehaviour
{
	public Button CloseButton;

	public Transform RowsParent;

	public Button InfoButton;

	private Font _font;

	private Sprite _badgeSprite;

	private bool _listenersWired;

	public static ControlsInfoPanel Instance { get; private set; }

	public static bool IsOpen { get; private set; }

	private void Awake()
	{
		Instance = this;
	}

	private void OnDisable()
	{
		IsOpen = false;
	}

	private void OnDestroy()
	{
		if ((Object)(object)Instance == (Object)(object)this)
		{
			Instance = null;
		}
		IsOpen = false;
	}

	public void Initialize(Font font, Sprite badgeSprite)
	{
		_font = font;
		_badgeSprite = badgeSprite;
		WireListeners();
	}

	public void Show()
	{
		((Component)this).gameObject.SetActive(true);
		RefreshContent();
		if ((Object)(object)RowsParent != (Object)null)
		{
			LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)this).GetComponent<RectTransform>());
		}
		IsOpen = true;
		if ((Object)(object)InfoButton != (Object)null)
		{
			((Component)InfoButton).gameObject.SetActive(false);
		}
		DebugLogger.Log("ControlsInfoPanel: opened");
	}

	public void Hide()
	{
		((Component)this).gameObject.SetActive(false);
		IsOpen = false;
		if ((Object)(object)InfoButton != (Object)null)
		{
			((Component)InfoButton).gameObject.SetActive(true);
		}
		DebugLogger.Log("ControlsInfoPanel: closed");
	}

	private void WireListeners()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Expected O, but got Unknown
		if (!_listenersWired)
		{
			if ((Object)(object)CloseButton != (Object)null)
			{
				((UnityEventBase)CloseButton.onClick).RemoveAllListeners();
				((UnityEvent)CloseButton.onClick).AddListener(new UnityAction(Hide));
				((UnityEvent)CloseButton.onClick).AddListener(new UnityAction(UIBuilder.PlayButtonSFX));
			}
			_listenersWired = true;
		}
	}

	private void RefreshContent()
	{
		//IL_0025: 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_0091: 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_00c7: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)RowsParent == (Object)null)
		{
			return;
		}
		foreach (Transform item in RowsParent)
		{
			Object.Destroy((Object)(object)((Component)item).gameObject);
		}
		LocalizationManager localizationManager = RecipePinnerPlugin.Instance?.LocalizationMgr;
		ConfigEntry<KeyCode> hotkeyPin = RecipePinnerPlugin.HotkeyPin;
		string text = FormatKey((KeyCode)((hotkeyPin == null) ? 325 : ((int)hotkeyPin.Value)));
		ConfigEntry<KeyCode> hotkeyUnpin = RecipePinnerPlugin.HotkeyUnpin;
		string text2 = FormatKey((KeyCode)((hotkeyUnpin == null) ? 304 : ((int)hotkeyUnpin.Value)));
		ConfigEntry<KeyCode> hotkeyToggleVisibility = RecipePinnerPlugin.HotkeyToggleVisibility;
		string text3 = FormatKey((KeyCode)((hotkeyToggleVisibility == null) ? 288 : ((int)hotkeyToggleVisibility.Value)));
		ConfigEntry<KeyCode> hotkeyGatheringList = RecipePinnerPlugin.HotkeyGatheringList;
		string text4 = FormatKey((KeyCode)((hotkeyGatheringList == null) ? 289 : ((int)hotkeyGatheringList.Value)));
		ConfigEntry<KeyCode> hotkeyPageSwitch = RecipePinnerPlugin.HotkeyPageSwitch;
		string text5 = FormatKey((KeyCode)((hotkeyPageSwitch == null) ? 308 : ((int)hotkeyPageSwitch.Value)));
		ConfigEntry<KeyCode> hotkeyClearAll = RecipePinnerPlugin.HotkeyClearAll;
		string text6 = FormatKey((KeyCode)((hotkeyClearAll == null) ? 112 : ((int)hotkeyClearAll.Value)));
		CreateSectionHeader(localizationManager?.GetText("howto_header") ?? "HOW TO USE");
		CreateInstructionRow(string.Format(localizationManager?.GetText("howto_pin") ?? "Hover over a recipe in the crafting menu and press [{0}] to pin it.", text));
		CreateInstructionRow(string.Format(localizationManager?.GetText("howto_unpin") ?? "Hold [{0}] and press [{1}] to unpin a recipe.", text2, text));
		CreateInstructionRow(string.Format(localizationManager?.GetText("howto_toggle_hud") ?? "Press [{0}] to show or hide the pinned recipe overlay.", text3));
		CreateInstructionRow(string.Format(localizationManager?.GetText("howto_gathering") ?? "Press [{0}] to open or close the gathering list.", text4));
		CreateInstructionRow(string.Format(localizationManager?.GetText("howto_next_page") ?? "Press [{0}] to cycle through HUD pages.", text5));
		CreateInstructionRow(string.Format(localizationManager?.GetText("howto_clear_all") ?? "Press [{0}] to remove all pinned recipes.", text6));
		CreateSectionHeader(localizationManager?.GetText("keybindings_header") ?? "KEY BINDINGS");
		CreateRow(localizationManager?.GetText("ctrl_pin") ?? "Pin Recipe", text);
		CreateRow(localizationManager?.GetText("ctrl_unpin") ?? "Unpin  (hold + Pin key)", text2);
		CreateRow(localizationManager?.GetText("ctrl_toggle_hud") ?? "Toggle HUD Visibility", text3);
		CreateRow(localizationManager?.GetText("ctrl_gathering") ?? "Toggle Gathering List", text4);
		CreateRow(localizationManager?.GetText("ctrl_next_page") ?? "Next HUD Page", text5);
		CreateRow(localizationManager?.GetText("ctrl_clear_all") ?? "Clear All Pins", text6);
	}

	private void CreateSectionHeader(string text)
	{
		//IL_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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)
		if (!((Object)(object)_font == (Object)null))
		{
			GameObject val = new GameObject("SectionHeader", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val.transform.SetParent(RowsParent, false);
			Text obj = val.AddComponent<Text>();
			obj.text = text;
			obj.font = _font;
			obj.fontSize = 15;
			obj.fontStyle = (FontStyle)1;
			obj.alignment = (TextAnchor)3;
			((Graphic)obj).color = new Color(1f, 0.718f, 0.357f, 1f);
			((Graphic)obj).raycastTarget = false;
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.flexibleWidth = 1f;
			obj2.minHeight = 22f;
			obj2.preferredHeight = 22f;
		}
	}

	private void CreateInstructionRow(string text)
	{
		//IL_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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)
		if (!((Object)(object)_font == (Object)null))
		{
			GameObject val = new GameObject("InstructionRow", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val.transform.SetParent(RowsParent, false);
			Text obj = val.AddComponent<Text>();
			obj.text = "• " + text;
			obj.font = _font;
			obj.fontSize = 14;
			obj.fontStyle = (FontStyle)0;
			obj.alignment = (TextAnchor)0;
			((Graphic)obj).color = new Color(0.85f, 0.82f, 0.7f, 1f);
			((Graphic)obj).raycastTarget = false;
			obj.horizontalOverflow = (HorizontalWrapMode)0;
			obj.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.flexibleWidth = 1f;
			obj2.minHeight = 18f;
			obj2.preferredHeight = 42f;
		}
	}

	private void CreateRow(string label, string keyText)
	{
		//IL_0027: 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_0034: Expected O, but got Unknown
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Expected O, but got Unknown
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: 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_0108: 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_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Expected O, but got Unknown
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0210: Unknown result type (might be due to invalid IL or missing references)
		//IL_0217: Unknown result type (might be due to invalid IL or missing references)
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		//IL_0264: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_font == (Object)null))
		{
			GameObject val = new GameObject("ControlRow", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val.transform.SetParent(RowsParent, false);
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((LayoutGroup)obj).padding = new RectOffset(0, 0, 2, 2);
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.flexibleWidth = 1f;
			obj2.minHeight = 26f;
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val2.transform.SetParent(val.transform, false);
			Text obj3 = val2.AddComponent<Text>();
			obj3.text = label;
			obj3.font = _font;
			obj3.fontSize = 15;
			((Graphic)obj3).color = new Color(0.88f, 0.84f, 0.72f, 1f);
			obj3.alignment = (TextAnchor)3;
			((Graphic)obj3).raycastTarget = false;
			val2.AddComponent<LayoutElement>().flexibleWidth = 1f;
			GameObject val3 = new GameObject("KeyBadge", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val3.transform.SetParent(val.transform, false);
			Image val4 = val3.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.1f, 0.08f, 0.04f, 0.9f);
			((Graphic)val4).raycastTarget = false;
			if ((Object)(object)_badgeSprite != (Object)null)
			{
				val4.sprite = _badgeSprite;
				val4.type = (Type)((_badgeSprite.border != Vector4.zero) ? 1 : 0);
			}
			LayoutElement obj4 = val3.AddComponent<LayoutElement>();
			obj4.preferredWidth = 130f;
			obj4.flexibleWidth = 0f;
			obj4.minHeight = 22f;
			GameObject val5 = new GameObject("KeyText", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			val5.transform.SetParent(val3.transform, false);
			RectTransform component = val5.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(4f, 2f);
			component.offsetMax = new Vector2(-4f, -2f);
			Text obj5 = val5.AddComponent<Text>();
			obj5.text = keyText;
			obj5.font = _font;
			obj5.fontSize = 13;
			obj5.fontStyle = (FontStyle)1;
			((Graphic)obj5).color = new Color(1f, 0.78f, 0.38f, 1f);
			obj5.alignment = (TextAnchor)4;
			((Graphic)obj5).raycastTarget = false;
		}
	}

	public unsafe static string FormatKey(KeyCode key)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		//IL_004d: 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_00c1: Expected I4, but got Unknown
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Invalid comparison between Unknown and I4
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Invalid comparison between Unknown and I4
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Expected I4, but got Unknown
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Invalid comparison between Unknown and I4
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Invalid comparison between Unknown and I4
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Invalid comparison between Unknown and I4
		//IL_00e5: 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_0105: Expected I4, but got Unknown
		if ((int)key <= 27)
		{
			if ((int)key <= 9)
			{
				if ((int)key == 8)
				{
					return "Backspace";
				}
				if ((int)key == 9)
				{
					return "Tab";
				}
			}
			else
			{
				if ((int)key == 13)
				{
					return "Enter";
				}
				if ((int)key == 27)
				{
					return "Escape";
				}
			}
		}
		else if ((int)key <= 127)
		{
			if ((int)key == 32)
			{
				return "Space";
			}
			if ((int)key == 127)
			{
				return "Delete";
			}
		}
		else
		{
			switch (key - 256)
			{
			default:
				switch (key - 303)
				{
				case 1:
					return "Left Shift";
				case 0:
					return "Right Shift";
				case 5:
					return "Left Alt";
				case 4:
					return "Right Alt";
				case 3:
					return "Left Ctrl";
				case 2:
					return "Right Ctrl";
				}
				switch (key - 323)
				{
				case 0:
					return "Left Mouse";
				case 1:
					return "Right Mouse";
				case 2:
					return "Middle Mouse";
				case 3:
					return "Mouse 4";
				case 4:
					return "Mouse 5";
				}
				break;
			case 15:
				return "Numpad Enter";
			case 17:
				return "Up Arrow";
			case 18:
				return "Down Arrow";
			case 20:
				return "Left Arrow";
			case 19:
				return "Right Arrow";
			case 0:
				return "Numpad 0";
			case 1:
				return "Numpad 1";
			case 2:
				return "Numpad 2";
			case 3:
				return "Numpad 3";
			case 4:
				return "Numpad 4";
			case 5:
				return "Numpad 5";
			case 6:
				return "Numpad 6";
			case 7:
				return "Numpad 7";
			case 8:
				return "Numpad 8";
			case 9:
				return "Numpad 9";
			case 24:
				return "Page Up";
			case 25:
				return "Page Down";
			case 22:
				return "Home";
			case 23:
				return "End";
			case 21:
				return "Insert";
			case 10:
			case 11:
			case 12:
			case 13:
			case 14:
			case 16:
				break;
			}
		}
		return ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString();
	}
}
public class ScrollbarViewportFitter : MonoBehaviour
{
	public Scrollbar VerticalScrollbar;

	public RectTransform Viewport;

	public float ScrollbarWidth = 10f;

	private bool _lastVisible;

	private void LateUpdate()
	{
		//IL_005c: 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_0080: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)VerticalScrollbar == (Object)null) && !((Object)(object)Viewport == (Object)null))
		{
			bool flag = ((Component)VerticalScrollbar).gameObject.activeInHierarchy && VerticalScrollbar.size < 0.999f;
			if (flag != _lastVisible)
			{
				_lastVisible = flag;
				Vector2 offsetMax = Viewport.offsetMax;
				offsetMax.x = (flag ? (0f - ScrollbarWidth) : 0f);
				Viewport.offsetMax = offsetMax;
			}
		}
	}
}