using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DrakeRenameit.API;
using DrakeRenameit.Ext.UI;
using DrakeRenameit.Patches;
using DrakeRenameit.Permissions;
using DrakeRenameit.UI;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("DrakeRenameit")]
[assembly: AssemblyDescription("Manage your doors and chests better")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("DrakeMods")]
[assembly: AssemblyProduct("DrakeRenameit")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5DF97E86-BF46-46C5-894F-6B2D80EA6645")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DrakeRenameit
{
	public static class RenameitConfig
	{
		private const string SectionGeneral = "General";

		private const string SectionUI = "UI-NotSynced";

		private const string SectionExclusions = "Exclusions";

		private const string SectionLimits = "Limits";

		private const string SectionAdmin = "Admin";

		private const string SectionUnlock = "UnlockCost";

		private const string SectionCraftedBy = "CraftedBy";

		private static ConfigSync configSync = new ConfigSync("DrakesRenameit")
		{
			DisplayName = "DrakesRenameit",
			CurrentVersion = "0.9.1",
			MinimumRequiredVersion = "0.9.1"
		};

		private static ConfigEntry<bool> _lockToOwner;

		private static ConfigEntry<bool> _rewriteDescriptionsEnable;

		private static ConfigEntry<bool> _RenameEnable;

		private static ConfigEntry<bool> _nameClaimsOwner;

		private static ConfigEntry<bool> _allowAdminOverride;

		private static ConfigEntry<bool> _allowRenameResources;

		private static ConfigEntry<int> _nameCharLimit;

		private static ConfigEntry<int> _descCharLimit;

		private static ConfigEntry<int> _craftedByCharLimit;

		private static ConfigEntry<string> _vipList;

		private static ConfigEntry<string> _menuHintColor;

		private static ConfigEntry<string> _excludedNames;

		private static ConfigEntry<string> _excludedCategory;

		private static ConfigEntry<string> _renameAllowlist;

		private static ConfigEntry<bool> _vipOnlyOverride;

		private static ConfigEntry<bool> _showReason;

		private static ConfigEntry<bool> _separateStacks;

		private static ConfigEntry<bool> _separateStacksHardLock;

		private static ConfigEntry<bool> _craftedByLabelEnabled;

		private static ConfigEntry<bool> _craftedByLabelCustomizable;

		private static ConfigEntry<string> _craftedByAllowedLabels;

		private static ConfigEntry<string> _menuOpenModifier;

		private static ConfigEntry<bool> _unlockCostEnabled;

		private static ConfigEntry<string> _unlockCost;

		private static ConfigEntry<bool> _showItemStandItemNameWhenNoAccess;

		public static bool LockToOwner => _lockToOwner.Value;

		public static int DescCharLimit => _descCharLimit.Value;

		public static bool NameClaimsOwner => _nameClaimsOwner.Value;

		public static bool RewriteDescriptionsEnabled => _rewriteDescriptionsEnable.Value;

		public static bool RenameEnabled => _RenameEnable.Value;

		public static bool CraftedByLabelEnabled => _craftedByLabelEnabled.Value;

		public static bool CraftedByLabelCustomizable => _craftedByLabelCustomizable.Value;

		public static string CraftedByAllowedLabels => _craftedByAllowedLabels.Value;

		public static bool AllowRenameResources => _allowRenameResources.Value;

		public static bool AllowAdminOverride => _allowAdminOverride.Value;

		public static int NameCharLimit => _nameCharLimit.Value;

		public static int CraftedByCharLimit => _craftedByCharLimit.Value;

		public static string VipList => _vipList.Value;

		public static string MenuHintColor => _menuHintColor.Value;

		public static string ExcludedNames => _excludedNames.Value;

		public static string ExcludedCategory => _excludedCategory.Value;

		public static string RenameAllowlist => _renameAllowlist.Value;

		public static bool VipOnlyOverride => _vipOnlyOverride.Value;

		public static bool ShowReason => _showReason.Value;

		public static bool SeparateStacks => _separateStacks.Value;

		public static bool SeparateStacksHardLock => _separateStacksHardLock.Value;

		public static string MenuOpenModifier => _menuOpenModifier.Value;

		public static bool UnlockCostEnabled => _unlockCostEnabled.Value;

		public static string UnlockCost => _unlockCost.Value;

		public static bool ShowItemStandItemNameWhenNoAccess => _showItemStandItemNameWhenNoAccess.Value;

		public static bool MenuModifierIsShift => string.Equals(_menuOpenModifier.Value, "Shift", StringComparison.OrdinalIgnoreCase);

		public static List<string> GetCraftedByAllowedLabelsList()
		{
			string text = _craftedByAllowedLabels?.Value;
			if (string.IsNullOrWhiteSpace(text))
			{
				return new List<string> { "Crafted By", "Belongs To", "Return to" };
			}
			List<string> list = (from s in text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries)
				select s.Trim() into s
				where s.Length > 0
				select s).ToList();
			if (list.Count == 0)
			{
				return new List<string> { "Crafted By", "Belongs To", "Return to" };
			}
			List<string> list2 = new List<string>();
			foreach (string p in list)
			{
				if (!list2.Exists((string x) => string.Equals(x, p, StringComparison.Ordinal)))
				{
					list2.Add(p);
				}
			}
			return list2;
		}

		public static void Bind(ConfigFile config)
		{
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected O, but got Unknown
			_lockToOwner = config.BindSynced("General", "LockToOwner", defaultValue: true, "If true, only the crafter/owner can rename or edit description. Items with no crafter (raw resources, m_crafterID 0 and no crafter name) are not locked until someone claims them (NameClaimsOwner) or they are crafted.");
			_nameClaimsOwner = config.BindSynced("General", "NameClaimsOwner", defaultValue: true, "If true, renaming an unowned item assigns ownership to the renamer. Used in conjunction with LockToOwner, when you rename an unclaimed item, you will have laid claim to it.");
			_allowRenameResources = config.BindSynced("General", "AllowRenameResources", defaultValue: true, "If true, items with no crafter (picked-up / uncrafted stacks) can be renamed. This is NOT the same as ExcludedCategory Material: Material blocks by item type even for crafted items. If disabled, NameClaimsOwner cannot apply to those stacks.");
			_RenameEnable = config.BindSynced("General", "RenameEnabled", defaultValue: true, "If enabled, allows players to edit item names. Could be cycled to pre change some items in a world then block others from adding new ones.");
			_rewriteDescriptionsEnable = config.BindSynced("General", "RewriteDescriptionsEnabled", defaultValue: true, "If enabled, allows players to also edit descriptions of items. Could be turned off preplace items with descriptions.");
			_craftedByLabelEnabled = config.BindSynced("General", "CraftedByLabelEnabled", defaultValue: true, "If true, players may set a display-only override for the Crafted by line (real crafter id/name unchanged). Server-synced.");
			_showReason = config.BindSynced("General", "ShowReason", defaultValue: true, "If true, denied rename/description actions show specific reasons (ownership, exclusion, resources). If false, generic messages only. Server-synced so clients cannot override the server's disclosure policy.");
			_showItemStandItemNameWhenNoAccess = config.BindSynced("General", "ShowItemStandItemNameWhenNoAccess", defaultValue: true, "If true, item stands inside warded/private areas still show 'no access' but also append the stand's current item name to the hover label (display only; permissions unchanged).");
			_separateStacks = config.BindSynced("General", "SeparateStacks", defaultValue: true, "If true, stacks only combine when Drake custom name, description, and crafted-by display match (same identity). Renamed or customized stacks no longer absorb mismatched pickups automatically.");
			_separateStacksHardLock = config.BindSynced("General", "SeparateStacksHardLock", defaultValue: false, "Only applies when SeparateStacks is on. If true, mismatched stacks never merge — including manual drags. If false, auto pickup still will not combine mismatched stacks, but you can drag one stack onto another to merge immediately (no dialog; target stack keeps its custom name, description, and crafted-by display).");
			_unlockCostEnabled = config.BindSynced("UnlockCost", "UnlockCostEnabled", defaultValue: false, "If true, each item stack must be unlocked once (pay UnlockCost from your inventory) before rename, description, or crafted-by edits apply. After unlock, edits are free for that stack. Invalid/empty UnlockCost is ignored (no gate). Elevated players (AdminOverride) skip the cost.");
			_unlockCost = config.BindSynced("UnlockCost", "UnlockCost", "Coins:5", "Comma or semicolon separated: PrefabName:amount (e.g. Coins:4, Coal:10) or $item_token:amount. Uses player inventory. Paid once per stack via the Unlock button in the action menu.");
			_nameCharLimit = config.BindSynced("Limits", "NameCharacterLimit", 50, "Defines the limit for max characters in rename, be sure to account for <color=> tag codes etc.");
			_craftedByCharLimit = config.BindSynced("Limits", "CraftedByCharLimit", 50, "Defines the limit for max characters in crafted by: edit, be sure to account for <color=> tag codes etc.");
			_craftedByLabelCustomizable = config.BindSynced("CraftedBy", "LabelCustomizable", defaultValue: true, "If true, players who can edit crafted-by may choose a tooltip line label from AllowedLabels. If false, the label picker is greyed out for normal players (shows the default line only) while admins/VIPs can still change it. Separate from CraftedByLabelEnabled in General.");
			_craftedByAllowedLabels = config.BindSynced("CraftedBy", "AllowedLabels", "Crafted By, Belongs To, Return to", "Comma- or semicolon-separated labels shown before the crafter name (e.g. “Belongs To: Name”). The first entry is the default (vanilla localized “crafted by” line is used on the tooltip when that option is selected).");
			_descCharLimit = config.BindSynced("Limits", "DescriptionCharacterLimit", 1000, "Defines the limit for max characters description, be sure to account for <color=> tag codes etc.");
			_allowAdminOverride = config.BindSynced("Admin", "AllowAdminOverride", defaultValue: true, "If enabled anyone designated as admin or added to VIP list with api hook, will be able to edit names and descriptions regardless of ownership or enabled.");
			_vipList = config.BindSynced("Admin", "VipList", "", "Comma-separated player names or player IDs (same as API AddVIP). When AdminOverride is on, VIPs can bypass restrictions. If VipOnlyOverride is on, ONLY VIP/API users count as elevated (Valheim server admin is ignored for overrides).");
			_vipOnlyOverride = config.BindSynced("Admin", "VipOnlyOverride", defaultValue: false, "If true (and AdminOverride is on), only VIP list / AddVIP API users are treated as elevated for bypassing rules—Valheim server admin is NOT. Useful for testing VIP behavior locally. If false, Valheim admin OR VIP is elevated.");
			_menuHintColor = config.BindSynced("UI-NotSynced", "MenuHintColor", "yellow", "Color for the 'Modifier + Right Click for options' inventory tooltip hint. Accepts Unity color names (yellow, green, red, white) or hex values (#fff or #ffffff).", sync: false);
			_menuOpenModifier = config.Bind<string>("UI-NotSynced", "MenuOpenModifier", "Shift", new ConfigDescription("Which key + right-click opens the Drake menu (Rename / Description / Crafted by): Shift or Ctrl. The other modifier + right-click uses vanilla behavior.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "Shift", "Ctrl" }), Array.Empty<object>()));
			configSync.AddConfigEntry<string>(_menuOpenModifier).SynchronizedConfig = false;
			_excludedNames = config.BindSynced("Exclusions", "ExcludedNames", "", "Comma-separated entries: Jotunn item list Token column (m_shared.m_name, e.g. $item_axe_stone) OR Item column (spawn/prefab name, e.g. AxeStone, ShieldBronzeBuckler), OR localized display name (English Name column). List: https://valheim-modding.github.io/Jotunn/data/objects/item-list.html — Admins/VIP (when AdminOverride is on) ignore this. See also ExcludedCategory and RenameAllowlist.");
			_excludedCategory = config.BindSynced("Exclusions", "ExcludedCategory", "", "Comma-separated category tokens (non-elevated players). Examples: Swords,Armor,Material,Bows. Full lists of Skills.SkillType and ItemDrop.ItemData.ItemType names plus aliases are written to BepInEx/config/<this mod GUID>/ExcludedCategoryReference.txt on first run (or when the mod version changes). Does not bypass RenameEnabled when that is off. Elevated users ignore when AdminOverride is on.");
			_renameAllowlist = config.BindSynced("Exclusions", "RenameAllowlist", "", "Comma-separated entries: Jotunn Token ($item_...) or Item (spawn name) or English display name — same rules as ExcludedNames. When RenameEnabled / RewriteDescriptionsEnabled are ON, these items bypass ExcludedNames, ExcludedCategory, and the uncrafted (AllowRenameResources) rule. Does NOT bypass global RenameEnabled/RewriteDescriptionsEnabled when those are off (only elevated users can). Does not bypass LockToOwner ownership.");
		}

		private static ConfigEntry<T> BindSynced<T>(this ConfigFile config, string section, string key, T defaultValue, string description, bool sync = true)
		{
			ConfigEntry<T> val = config.Bind<T>(section, key, defaultValue, description);
			SyncedConfigEntry<T> syncedConfigEntry = configSync.AddConfigEntry<T>(val);
			syncedConfigEntry.SynchronizedConfig = sync;
			return val;
		}
	}
	internal static class RenameUnlockCost
	{
		private static ManualLogSource? _log;

		internal static void Init(ManualLogSource log)
		{
			_log = log;
		}

		internal static bool HasValidCostConfigured()
		{
			List<(string, int, string)> lines;
			string error;
			return TryBuildResolvedCost(out lines, out error);
		}

		internal static bool UnlockCostApplies()
		{
			return RenameitConfig.UnlockCostEnabled && HasValidCostConfigured();
		}

		internal static bool CanPlayerAfford(Player? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!TryBuildResolvedCost(out List<(string, int, string)> lines, out string _))
			{
				return true;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			foreach (var (text, num, _) in lines)
			{
				if (inventory.CountItems(text, -1, true) < num)
				{
					return false;
				}
			}
			return true;
		}

		internal static bool TryConsumeUnlockCost(Player? player, out string errorMessage)
		{
			errorMessage = "";
			if ((Object)(object)player == (Object)null)
			{
				errorMessage = "No local player.";
				return false;
			}
			if (!TryBuildResolvedCost(out List<(string, int, string)> lines, out string error))
			{
				errorMessage = error ?? "Unlock cost is not configured.";
				return false;
			}
			if (lines.Count == 0)
			{
				errorMessage = "Unlock cost is empty.";
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				errorMessage = "No inventory.";
				return false;
			}
			foreach (var (text, num, _) in lines)
			{
				if (inventory.CountItems(text, -1, true) < num)
				{
					errorMessage = "Not enough items to unlock (see tooltip / config).";
					return false;
				}
			}
			foreach (var (text2, num2, _) in lines)
			{
				inventory.RemoveItem(text2, num2, -1, true);
			}
			return true;
		}

		internal static string GetCostDisplayShort()
		{
			if (!TryBuildResolvedCost(out List<(string, int, string)> lines, out string _) || lines.Count == 0)
			{
				return "";
			}
			List<string> list = new List<string>();
			foreach (var item3 in lines)
			{
				string item = item3.Item1;
				int item2 = item3.Item2;
				string arg = item;
				if (Localization.instance != null)
				{
					arg = Localization.instance.Localize(item);
				}
				list.Add($"{item2}x {arg}");
			}
			return string.Join(", ", list);
		}

		internal static List<(string LocalizedName, int Amount, string PrefabName)> GetCostDisplayEntries()
		{
			List<(string, int, string)> list = new List<(string, int, string)>();
			if (!TryBuildResolvedCost(out List<(string, int, string)> lines, out string _) || lines.Count == 0)
			{
				return list;
			}
			foreach (var item5 in lines)
			{
				string item = item5.Item1;
				int item2 = item5.Item2;
				string item3 = item5.Item3;
				string item4 = item;
				if (Localization.instance != null)
				{
					item4 = Localization.instance.Localize(item);
				}
				list.Add((item4, item2, item3));
			}
			return list;
		}

		internal static string GetItemTokenPublic(string prefabName)
		{
			return ResolveItemSharedName(prefabName);
		}

		internal static Sprite? GetItemIconSprite(string configPrefabName)
		{
			if (string.IsNullOrWhiteSpace(configPrefabName) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(configPrefabName);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return null;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			object result;
			if (component == null)
			{
				result = null;
			}
			else
			{
				ItemData itemData = component.m_itemData;
				result = ((itemData != null) ? itemData.GetIcon() : null);
			}
			return (Sprite?)result;
		}

		private static bool TryBuildResolvedCost(out List<(string SharedName, int Amount, string ConfigKey)> lines, out string? error)
		{
			lines = new List<(string, int, string)>();
			error = null;
			string text = RenameitConfig.UnlockCost?.Trim() ?? "";
			if (string.IsNullOrEmpty(text))
			{
				error = "UnlockCost is empty.";
				return false;
			}
			string[] array = text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				string text3 = text2.Trim();
				if (string.IsNullOrEmpty(text3))
				{
					continue;
				}
				int num = text3.LastIndexOf(':');
				if (num <= 0 || num >= text3.Length - 1)
				{
					ManualLogSource? log = _log;
					if (log != null)
					{
						log.LogWarning((object)("[UnlockCost] Ignoring invalid segment (need Name:Amount): \"" + text3 + "\""));
					}
					continue;
				}
				string text4 = text3.Substring(0, num).Trim();
				string s = text3.Substring(num + 1).Trim();
				if (!int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result <= 0)
				{
					ManualLogSource? log2 = _log;
					if (log2 != null)
					{
						log2.LogWarning((object)("[UnlockCost] Ignoring invalid amount in: \"" + text3 + "\""));
					}
					continue;
				}
				string text5 = ResolveItemSharedName(text4);
				if (string.IsNullOrEmpty(text5))
				{
					ManualLogSource? log3 = _log;
					if (log3 != null)
					{
						log3.LogWarning((object)("[UnlockCost] Unknown item or token: \"" + text4 + "\""));
					}
				}
				else
				{
					lines.Add((text5, result, text4));
				}
			}
			if (lines.Count == 0)
			{
				error = "No valid UnlockCost entries (use Item prefab name or $item_ token, e.g. Coins:4).";
				return false;
			}
			return true;
		}

		private static string ResolveItemSharedName(string tokenOrPrefab)
		{
			if (string.IsNullOrWhiteSpace(tokenOrPrefab))
			{
				return "";
			}
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return tokenOrPrefab.StartsWith("$", StringComparison.Ordinal) ? tokenOrPrefab : "";
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(tokenOrPrefab);
			if ((Object)(object)itemPrefab != (Object)null)
			{
				string text = itemPrefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_name;
				if (!string.IsNullOrEmpty(text))
				{
					return text;
				}
			}
			if (tokenOrPrefab.StartsWith("$", StringComparison.Ordinal))
			{
				return tokenOrPrefab;
			}
			return "";
		}
	}
	[BepInPlugin("com.DrakeMods.DrakesRenameit", "DrakesRenameit", "0.9.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class DrakeRenameit : BaseUnityPlugin
	{
		public const string CompanyName = "DrakeMods";

		public const string ModName = "DrakesRenameit";

		public const string Version = "0.9.1";

		public const string GUID = "com.DrakeMods.DrakesRenameit";

		public const string DrakeNewName = "Drake_Rename";

		public const string DrakeNewDesc = "Drake_Rename_Desc";

		public const string DrakeCraftedByDisplay = "Drake_CraftedByDisplay";

		public const string DrakeCraftedByLineLabel = "Drake_CraftedByLineLabel";

		public const string DrakeRenameUnlocked = "Drake_RenameUnlocked";

		public const string TooltipUnlockCostLockedEmoji = "\ud83d\udd12";

		public const string TooltipDrakeEditableEmoji = "\ud83d\udd8a\ufe0f";

		private readonly Harmony harmony = new Harmony("drakesmod.DrakeRenameit");

		private Texture2D TestTex;

		private Sprite TestSprite;

		public static ItemData? CurrentItem { get; set; }

		public static bool IsItemInLocalPlayerInventory(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			return inventory != null && inventory.ContainsItem(item);
		}

		private void Awake()
		{
			RenameitConfig.Bind(((BaseUnityPlugin)this).Config);
			ExcludedCategoryReferenceWriter.EnsureGenerated();
			AddVip();
			RenamePermissionManager.Init(((BaseUnityPlugin)this).Logger);
			RenameUnlockCost.Init(((BaseUnityPlugin)this).Logger);
			InventoryStackPatches.Apply(harmony, ((BaseUnityPlugin)this).Logger);
			ItemTooltipPatches.Apply(harmony, ((BaseUnityPlugin)this).Logger);
			DropHudMessagePatches.ApplyDropItemPendingCapture(harmony, ((BaseUnityPlugin)this).Logger);
			harmony.PatchAll();
			DropHudMessagePatches.ApplyMessageHudShowMessage(harmony, ((BaseUnityPlugin)this).Logger);
		}

		private static void AddVip()
		{
			List<string> list = (from s in RenameitConfig.VipList.Split(new char[1] { ',' })
				select s.Trim().ToLowerInvariant() into s
				where !string.IsNullOrEmpty(s)
				select s).ToList();
			RenameitPermission.AddVIP(list);
		}

		public static string GetPropperName(ItemData? item)
		{
			return getPropperName(item, item.m_shared.m_name);
		}

		public static string GetDisplayNameForUi(ItemData? item, bool localize)
		{
			if (item?.m_shared == null)
			{
				return "";
			}
			string text = GetPropperName(item) ?? item.m_shared.m_name;
			string text2 = TooltipRichText.EnsureRichTextTagsClosedForTooltip(text);
			if (!localize || Localization.instance == null)
			{
				return text2;
			}
			return Localization.instance.Localize(text2);
		}

		public static bool hasNewDesc(ItemData? item)
		{
			if (item.m_customData == null)
			{
				return false;
			}
			string value;
			return item.m_customData.TryGetValue("Drake_Rename_Desc", out value);
		}

		public static bool hasNewName(ItemData? item)
		{
			if (item == null || item.m_customData == null)
			{
				return false;
			}
			string value;
			return item.m_customData.TryGetValue("Drake_Rename", out value);
		}

		public static bool HasAnyDrakeRenameCustomization(ItemData? item)
		{
			if (item?.m_customData == null)
			{
				return false;
			}
			if (hasNewName(item))
			{
				return true;
			}
			if (hasNewDesc(item))
			{
				return true;
			}
			if (HasCraftedByDisplayOverride(item))
			{
				return true;
			}
			return HasCraftedByLineLabelOverride(item);
		}

		private static bool ReadRenameUnlockedFlag(ItemData item)
		{
			if (!item.m_customData.TryGetValue("Drake_RenameUnlocked", out var value))
			{
				return false;
			}
			return value == "1" || string.Equals(value, "true", StringComparison.OrdinalIgnoreCase);
		}

		public static bool IsRenameUnlocked(ItemData? item)
		{
			if (item?.m_customData == null)
			{
				return false;
			}
			bool flag = ReadRenameUnlockedFlag(item);
			if (RenameUnlockCost.UnlockCostApplies())
			{
				if (!flag && HasAnyDrakeRenameCustomization(item))
				{
					SetRenameUnlocked(item);
					return true;
				}
				return flag;
			}
			return flag;
		}

		internal static void SetRenameUnlocked(ItemData item)
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			item.m_customData["Drake_RenameUnlocked"] = "1";
		}

		public static bool WouldHaveAnyDrakeEditIfUnlockIgnored(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			RenamePermissionManager.BeginIgnoreUnlockRequirement();
			try
			{
				return CanChangeName(item) || CanChangeDesc(item) || CanChangeCraftedByLabel(item);
			}
			finally
			{
				RenamePermissionManager.EndIgnoreUnlockRequirement();
			}
		}

		public static bool ShowUnlockButton(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			if (!RenameUnlockCost.UnlockCostApplies())
			{
				return false;
			}
			if (IsRenameUnlocked(item))
			{
				return false;
			}
			if (RenameitPermission.IsElevatedForOverrides(Player.m_localPlayer))
			{
				return false;
			}
			return WouldHaveAnyDrakeEditIfUnlockIgnored(item);
		}

		public static bool TryPayRenameUnlock(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			if (!IsItemInLocalPlayerInventory(item))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "That item is no longer in your inventory. Put it back, then unlock again.", 0, (Sprite)null);
				return false;
			}
			if (!RenameUnlockCost.UnlockCostApplies() || IsRenameUnlocked(item))
			{
				return false;
			}
			if (!WouldHaveAnyDrakeEditIfUnlockIgnored(item))
			{
				string menuBlockedReason = GetMenuBlockedReason(item);
				((Character)Player.m_localPlayer).Message((MessageType)2, string.IsNullOrEmpty(menuBlockedReason) ? "This item cannot be edited." : menuBlockedReason, 0, (Sprite)null);
				return false;
			}
			if (!RenameUnlockCost.TryConsumeUnlockCost(Player.m_localPlayer, out string errorMessage))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, errorMessage, 0, (Sprite)null);
				return false;
			}
			SetRenameUnlocked(item);
			((Character)Player.m_localPlayer).Message((MessageType)2, "Item unlocked for editing.", 0, (Sprite)null);
			return true;
		}

		public static bool HasCraftedByDisplayOverride(ItemData? item)
		{
			if (item?.m_customData == null)
			{
				return false;
			}
			string value;
			return item.m_customData.TryGetValue("Drake_CraftedByDisplay", out value) && !string.IsNullOrEmpty(value);
		}

		public static bool HasCraftedByLineLabelOverride(ItemData? item)
		{
			if (item?.m_customData == null)
			{
				return false;
			}
			string value;
			return item.m_customData.TryGetValue("Drake_CraftedByLineLabel", out value) && !string.IsNullOrEmpty(value);
		}

		public static bool CanResetAnyCustomization(ItemData? item)
		{
			if (item == null)
			{
				return false;
			}
			if (CanChangeName(item) && hasNewName(item))
			{
				return true;
			}
			if (CanChangeDesc(item) && hasNewDesc(item))
			{
				return true;
			}
			if (CanChangeCraftedByLabel(item) && (HasCraftedByDisplayOverride(item) || HasCraftedByLineLabelOverride(item)))
			{
				return true;
			}
			return false;
		}

		public static void ResetAllCustomizations(ItemData? item)
		{
			if (item == null)
			{
				return;
			}
			if (!IsItemInLocalPlayerInventory(item))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "That item is no longer in your inventory.", 0, (Sprite)null);
				}
				return;
			}
			if (CanChangeName(item) && hasNewName(item))
			{
				resetName(item);
			}
			if (CanChangeDesc(item) && hasNewDesc(item))
			{
				resetDesc(item);
			}
			if (CanChangeCraftedByLabel(item) && (HasCraftedByDisplayOverride(item) || HasCraftedByLineLabelOverride(item)) && item.m_customData != null)
			{
				string craftedByDisplay = getCraftedByDisplay(item);
				item.m_customData.Remove("Drake_CraftedByDisplay");
				item.m_customData.Remove("Drake_CraftedByLineLabel");
				string newDisplay = item.m_crafterName ?? "";
				RenameEvents.RaiseCraftedByDisplayChanged(Player.m_localPlayer, item, item.m_shared.m_name, craftedByDisplay, newDisplay);
			}
		}

		public static string resetName(ItemData? item)
		{
			if (item == null)
			{
				return "";
			}
			item.m_customData.Remove("Drake_Rename");
			return item.m_shared.m_name;
		}

		public static string resetDesc(ItemData? item)
		{
			if (item == null)
			{
				return "";
			}
			item.m_customData.Remove("Drake_Rename_Desc");
			return item.m_shared.m_name;
		}

		public static string getPropperName(ItemData? item)
		{
			return getPropperName(item, item.m_shared.m_name);
		}

		public static string getPropperName(ItemData? item, string defaultName)
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			string value;
			return item.m_customData.TryGetValue("Drake_Rename", out value) ? value : defaultName;
		}

		public static string getPropperDesc(ItemData? item)
		{
			return getPropperDesc(item, item.m_shared.m_description);
		}

		public static string getPropperDesc(ItemData? item, string defaultDesc)
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			string value;
			return item.m_customData.TryGetValue("Drake_Rename_Desc", out value) ? value : defaultDesc;
		}

		public static void OpenRename(ItemData? item)
		{
			if (!((Object)(object)InventoryGui.instance == (Object)null) && item != null)
			{
				CurrentItem = item;
				if ((Object)(object)UIPanels.InputNamePanel == (Object)null)
				{
					UIPanels.CreateRenameInput();
				}
				string propperName = GetPropperName(item);
				UIPanels.RenameNameInput.text = propperName;
				UIPanels.InputNamePanel.SetActive(true);
				UIPanels.EnsureInputBlocked();
			}
		}

		public static void OpenRewriteDesc(ItemData? item)
		{
			if (!((Object)(object)InventoryGui.instance == (Object)null) && item != null)
			{
				CurrentItem = item;
				if ((Object)(object)UIPanels.InputDescPanel == (Object)null)
				{
					UIPanels.CreateRenameDescInput();
				}
				string propperDesc = getPropperDesc(item);
				UIPanels.RenameDescInput.text = propperDesc;
				UIPanels.InputDescPanel.SetActive(true);
				UIPanels.EnsureInputBlocked();
			}
		}

		public static void RenameItem(string name)
		{
			if (CurrentItem == null)
			{
				return;
			}
			if (CurrentItem.m_customData == null)
			{
				CurrentItem.m_customData = new Dictionary<string, string>();
			}
			if (string.IsNullOrEmpty(name))
			{
				CurrentItem.m_customData.Remove("Drake_Rename");
			}
			else
			{
				CurrentItem.m_customData["Drake_Rename"] = name;
				RenameEvents.RaiseNameChanged(Player.m_localPlayer, CurrentItem, CurrentItem.m_shared.m_name, name);
			}
			if (RenameitConfig.NameClaimsOwner && (RenameitConfig.AllowRenameResources || RenameExclusionRules.MatchesRenameAllowlist(CurrentItem)) && string.IsNullOrEmpty(CurrentItem.m_crafterName))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					CurrentItem.m_crafterID = localPlayer.GetPlayerID();
					CurrentItem.m_crafterName = localPlayer.GetPlayerName();
				}
			}
		}

		public static void RewriteItemDesc(string name)
		{
			if (CurrentItem == null)
			{
				return;
			}
			if (CurrentItem.m_customData == null)
			{
				CurrentItem.m_customData = new Dictionary<string, string>();
			}
			if (string.IsNullOrEmpty(name))
			{
				CurrentItem.m_customData.Remove("Drake_Rename_Desc");
			}
			else
			{
				CurrentItem.m_customData["Drake_Rename_Desc"] = name;
				RenameEvents.RaiseDescriptionChanged(Player.m_localPlayer, CurrentItem, CurrentItem.m_shared.m_name, name);
			}
			if (RenameitConfig.NameClaimsOwner && (RenameitConfig.AllowRenameResources || RenameExclusionRules.MatchesRenameAllowlist(CurrentItem)) && string.IsNullOrEmpty(CurrentItem.m_crafterName))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					CurrentItem.m_crafterID = localPlayer.GetPlayerID();
					CurrentItem.m_crafterName = localPlayer.GetPlayerName();
				}
			}
		}

		public static void ApplyRewriteDesc(string newDesc)
		{
			if (CurrentItem == null)
			{
				return;
			}
			if (!IsItemInLocalPlayerInventory(CurrentItem))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "That item is no longer in your inventory. Put it back, then try again.", 0, (Sprite)null);
				}
				UIPanels.CloseAllRenameEditingUi();
			}
			else
			{
				RewriteItemDesc(newDesc);
				ItemData currentItem = CurrentItem;
				UIPanels.InputDescPanel.SetActive(false);
				UIPanels.OpenActionMenu(currentItem);
			}
		}

		public static void ApplyRename(string newName)
		{
			if (CurrentItem == null)
			{
				return;
			}
			if (!IsItemInLocalPlayerInventory(CurrentItem))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "That item is no longer in your inventory. Put it back, then try again.", 0, (Sprite)null);
				}
				UIPanels.CloseAllRenameEditingUi();
			}
			else
			{
				RenameItem(newName);
				ItemData currentItem = CurrentItem;
				UIPanels.InputNamePanel.SetActive(false);
				UIPanels.OpenActionMenu(currentItem);
			}
		}

		public static bool CanChangeName(ItemData? item, bool showError = false)
		{
			return RenamePermissionManager.Evaluate(RenamePermissionOperation.RenameItemName, item, Player.m_localPlayer, showError).Allowed;
		}

		public static bool CanChangeDesc(ItemData item, bool showError = false)
		{
			return RenamePermissionManager.Evaluate(RenamePermissionOperation.RewriteDescription, item, Player.m_localPlayer, showError).Allowed;
		}

		public static bool CanChangeCraftedByLabel(ItemData? item, bool showError = false)
		{
			if (item == null)
			{
				return false;
			}
			if (item.m_crafterID == 0L && string.IsNullOrEmpty(item.m_crafterName))
			{
				return false;
			}
			return RenamePermissionManager.Evaluate(RenamePermissionOperation.EditCraftedByLabel, item, Player.m_localPlayer, showError).Allowed;
		}

		public static bool AnyInventoryActionAvailable(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			if (!RenameUnlockCost.UnlockCostApplies() || IsRenameUnlocked(item))
			{
				return CanChangeName(item) || CanChangeDesc(item) || CanChangeCraftedByLabel(item);
			}
			if (RenameitPermission.IsElevatedForOverrides(Player.m_localPlayer))
			{
				return CanChangeName(item) || CanChangeDesc(item) || CanChangeCraftedByLabel(item);
			}
			return WouldHaveAnyDrakeEditIfUnlockIgnored(item);
		}

		public static bool IsMenuOpenModifierHeld()
		{
			return (!RenameitConfig.MenuModifierIsShift) ? (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) : (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303));
		}

		public static string GetMenuTooltipLockSuffix(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return "";
			}
			if (!RenameUnlockCost.UnlockCostApplies())
			{
				return "";
			}
			if (RenameitPermission.IsElevatedForOverrides(Player.m_localPlayer))
			{
				return " \ud83d\udd8a\ufe0f";
			}
			return IsRenameUnlocked(item) ? " \ud83d\udd8a\ufe0f" : " \ud83d\udd12";
		}

		public static string GetMenuBlockedReason(ItemData? item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return "";
			}
			List<string> list = new List<string>();
			RenamePermissionResult renamePermissionResult = RenamePermissionManager.TryGetDenial(RenamePermissionOperation.RenameItemName, item, Player.m_localPlayer);
			if (!renamePermissionResult.Allowed)
			{
				list.Add(RenamePermissionManager.FormatDenialForPlayer(RenamePermissionOperation.RenameItemName, renamePermissionResult.Reasons));
			}
			RenamePermissionResult renamePermissionResult2 = RenamePermissionManager.TryGetDenial(RenamePermissionOperation.RewriteDescription, item, Player.m_localPlayer);
			if (!renamePermissionResult2.Allowed && (list.Count == 0 || renamePermissionResult2.Reasons != renamePermissionResult.Reasons))
			{
				list.Add(RenamePermissionManager.FormatDenialForPlayer(RenamePermissionOperation.RewriteDescription, renamePermissionResult2.Reasons));
			}
			RenamePermissionResult renamePermissionResult3 = RenamePermissionManager.TryGetDenial(RenamePermissionOperation.EditCraftedByLabel, item, Player.m_localPlayer);
			if (!renamePermissionResult3.Allowed && (list.Count == 0 || (renamePermissionResult3.Reasons != renamePermissionResult.Reasons && renamePermissionResult3.Reasons != renamePermissionResult2.Reasons)))
			{
				list.Add(RenamePermissionManager.FormatDenialForPlayer(RenamePermissionOperation.EditCraftedByLabel, renamePermissionResult3.Reasons));
			}
			if (list.Count == 0)
			{
				return "This item cannot be edited.";
			}
			HashSet<string> hashSet = new HashSet<string>();
			List<string> list2 = new List<string>();
			foreach (string item2 in list)
			{
				if (hashSet.Add(item2))
				{
					list2.Add(item2);
				}
			}
			return string.Join(" | ", list2);
		}

		public static string getCraftedByDisplay(ItemData? item)
		{
			if (item?.m_customData == null)
			{
				return item?.m_crafterName ?? "";
			}
			if (item.m_customData.TryGetValue("Drake_CraftedByDisplay", out var value) && !string.IsNullOrEmpty(value))
			{
				return value;
			}
			return item.m_crafterName ?? "";
		}

		public static void OpenCraftedByEditor(ItemData? item)
		{
			if (!((Object)(object)InventoryGui.instance == (Object)null) && item != null)
			{
				CurrentItem = item;
				if ((Object)(object)UIPanels.InputCraftedByPanel == (Object)null)
				{
					UIPanels.CreateCraftedByInput();
				}
				UIPanels.RenameCraftedByInput.text = getCraftedByDisplay(item);
				UIPanels.RefreshCraftedByLineLabelPicker(item);
				UIPanels.InputCraftedByPanel.SetActive(true);
				UIPanels.EnsureInputBlocked();
			}
		}

		public static void ApplyCraftedByLabel(string display)
		{
			if (CurrentItem == null)
			{
				return;
			}
			if (!IsItemInLocalPlayerInventory(CurrentItem))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "That item is no longer in your inventory. Put it back, then try again.", 0, (Sprite)null);
				}
				UIPanels.CloseAllRenameEditingUi();
				return;
			}
			if (CurrentItem.m_customData == null)
			{
				CurrentItem.m_customData = new Dictionary<string, string>();
			}
			string craftedByDisplay = getCraftedByDisplay(CurrentItem);
			if (string.IsNullOrEmpty(display))
			{
				CurrentItem.m_customData.Remove("Drake_CraftedByDisplay");
			}
			else
			{
				CurrentItem.m_customData["Drake_CraftedByDisplay"] = display;
			}
			if (RenameitConfig.CraftedByLabelCustomizable || RenameitPermission.IsElevatedForOverrides(Player.m_localPlayer))
			{
				string craftedByLineLabelPendingToken = UIPanels.CraftedByLineLabelPendingToken;
				if (string.IsNullOrEmpty(craftedByLineLabelPendingToken))
				{
					CurrentItem.m_customData.Remove("Drake_CraftedByLineLabel");
				}
				else if (IsAllowedCustomCraftedByLineLabel(craftedByLineLabelPendingToken))
				{
					CurrentItem.m_customData["Drake_CraftedByLineLabel"] = craftedByLineLabelPendingToken;
				}
			}
			string newDisplay = (string.IsNullOrEmpty(display) ? (CurrentItem.m_crafterName ?? "") : display);
			RenameEvents.RaiseCraftedByDisplayChanged(Player.m_localPlayer, CurrentItem, CurrentItem.m_shared.m_name, craftedByDisplay, newDisplay);
			ItemData currentItem = CurrentItem;
			UIPanels.InputCraftedByPanel.SetActive(false);
			UIPanels.OpenActionMenu(currentItem);
		}

		public static bool IsExcluded(ItemData? item)
		{
			return RenameExclusionRules.IsExcludedFromConfig(item);
		}

		public static bool IsRenameAllowlisted(ItemData? item)
		{
			return RenameExclusionRules.MatchesRenameAllowlist(item);
		}

		private static bool IsAllowedCustomCraftedByLineLabel(string value)
		{
			List<string> craftedByAllowedLabelsList = RenameitConfig.GetCraftedByAllowedLabelsList();
			for (int i = 1; i < craftedByAllowedLabelsList.Count; i++)
			{
				if (string.Equals(craftedByAllowedLabelsList[i], value, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class StackIdentity
	{
		internal static string GetFingerprint(ItemData? item)
		{
			if (item?.m_customData == null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			Append(stringBuilder, item, "Drake_Rename");
			Append(stringBuilder, item, "Drake_Rename_Desc");
			Append(stringBuilder, item, "Drake_CraftedByDisplay");
			Append(stringBuilder, item, "Drake_CraftedByLineLabel");
			return stringBuilder.ToString();
		}

		private static void Append(StringBuilder sb, ItemData item, string key)
		{
			if (item.m_customData.TryGetValue(key, out var value) && !string.IsNullOrEmpty(value))
			{
				sb.Append('|').Append(value);
			}
			else
			{
				sb.Append('|');
			}
		}

		internal static bool SameDrakeStackIdentity(ItemData? a, ItemData? b)
		{
			if (a == null || b == null)
			{
				return false;
			}
			return string.Equals(GetFingerprint(a), GetFingerprint(b), StringComparison.Ordinal);
		}
	}
}
namespace DrakeRenameit.UI
{
	internal static class TooltipRichText
	{
		private enum RtKind
		{
			Color,
			Size
		}

		private static readonly Regex HexColorRegex = new Regex("^[0-9a-fA-F]{3,8}$", RegexOptions.Compiled);

		internal static string EnsureRichTextTagsClosedForTooltip(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text ?? "";
			}
			Stack<RtKind> stack = new Stack<RtKind>();
			int num = 0;
			while (num < text.Length)
			{
				if (text[num] != '<')
				{
					num++;
					continue;
				}
				int num2 = text.IndexOf('>', num);
				if (num2 < 0)
				{
					break;
				}
				string text2 = text.Substring(num, num2 - num + 1);
				if (text2.Length >= 2 && text2[1] == '/')
				{
					if (text2.StartsWith("</color", StringComparison.OrdinalIgnoreCase))
					{
						if (stack.Count > 0 && stack.Peek() == RtKind.Color)
						{
							stack.Pop();
						}
					}
					else if (text2.StartsWith("</size", StringComparison.OrdinalIgnoreCase) && stack.Count > 0 && stack.Peek() == RtKind.Size)
					{
						stack.Pop();
					}
				}
				else if (text2.StartsWith("<color", StringComparison.OrdinalIgnoreCase))
				{
					stack.Push(RtKind.Color);
				}
				else if (IsHashColorOpenTag(text2))
				{
					stack.Push(RtKind.Color);
				}
				else if (text2.StartsWith("<size", StringComparison.OrdinalIgnoreCase))
				{
					stack.Push(RtKind.Size);
				}
				num = num2 + 1;
			}
			if (stack.Count == 0)
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder(text, text.Length + stack.Count * 10);
			while (stack.Count > 0)
			{
				RtKind rtKind = stack.Pop();
				stringBuilder.Append((rtKind == RtKind.Color) ? "</color>" : "</size>");
			}
			return stringBuilder.ToString();
		}

		internal static string WrapCraftedByDisplayWithDefaultStatColorIfNeeded(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			if (HasExplicitColorMarkup(text))
			{
				return text;
			}
			return GetValheimTooltipStatColorOpenTag() + text + "</color>";
		}

		internal static bool HasExplicitColorMarkup(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.IndexOf("<color", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			for (int i = 0; i < text.Length - 3; i++)
			{
				if (text[i] == '<' && text[i + 1] == '#')
				{
					int j;
					for (j = i + 2; j < text.Length && IsHex(text[j]); j++)
					{
					}
					if (j != i + 2 && j - (i + 2) >= 3 && j - (i + 2) <= 8 && j < text.Length && text[j] == '>')
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsHex(char c)
		{
			switch (c)
			{
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
				return true;
			default:
				return false;
			}
		}

		private static string GetValheimTooltipStatColorOpenTag()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GUIManager instance = GUIManager.Instance;
				if (instance != null)
				{
					Color valheimOrange = instance.ValheimOrange;
					return "<color=#" + ColorUtility.ToHtmlStringRGB(valheimOrange) + ">";
				}
			}
			catch
			{
			}
			return "<color=#ff8800>";
		}

		private static bool IsHashColorOpenTag(string tag)
		{
			if (tag.Length < 5 || tag[0] != '<' || tag[1] != '#' || tag[tag.Length - 1] != '>')
			{
				return false;
			}
			string input = tag.Substring(2, tag.Length - 3);
			return HexColorRegex.IsMatch(input);
		}
	}
	public static class UIPanels
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__CloseActionMenuOnly;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__56_0;

			public static UnityAction <>9__56_1;

			public static UnityAction <>9__56_2;

			public static UnityAction <>9__56_3;

			public static UnityAction <>9__56_4;

			public static UnityAction <>9__64_0;

			public static UnityAction <>9__64_1;

			public static UnityAction <>9__66_0;

			public static UnityAction <>9__66_1;

			public static UnityAction <>9__67_0;

			public static UnityAction <>9__74_0;

			public static UnityAction <>9__74_1;

			public static UnityAction <>9__75_0;

			public static UnityAction <>9__75_1;

			internal void <EnsureActionMenu>b__56_0()
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				if (currentItem != null)
				{
					ActionMenuPanel.SetActive(false);
					OpenUnlockConfirmPanel(currentItem);
				}
			}

			internal void <EnsureActionMenu>b__56_1()
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				CloseActionMenuOnly();
				if (currentItem != null)
				{
					DrakeRenameit.OpenRename(currentItem);
				}
			}

			internal void <EnsureActionMenu>b__56_2()
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				CloseActionMenuOnly();
				if (currentItem != null)
				{
					DrakeRenameit.OpenRewriteDesc(currentItem);
				}
			}

			internal void <EnsureActionMenu>b__56_3()
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				CloseActionMenuOnly();
				if (currentItem != null)
				{
					DrakeRenameit.OpenCraftedByEditor(currentItem);
				}
			}

			internal void <EnsureActionMenu>b__56_4()
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				if (currentItem != null)
				{
					DrakeRenameit.ResetAllCustomizations(currentItem);
				}
				CloseActionMenuOnly();
			}

			internal void <EnsureUnlockConfirmPanel>b__64_0()
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				if (currentItem == null)
				{
					CloseUnlockConfirmPanel(reopenActionMenu: false);
				}
				else if (!DrakeRenameit.TryPayRenameUnlock(currentItem))
				{
					if (DrakeRenameit.CurrentItem == null || !DrakeRenameit.IsItemInLocalPlayerInventory(DrakeRenameit.CurrentItem))
					{
						CloseAllRenameEditingUi();
						return;
					}
					RefreshUnlockConfirmBody();
					((Selectable)_buttonConfirmUnlock).interactable = RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer);
				}
				else
				{
					CloseUnlockConfirmPanel(reopenActionMenu: true);
				}
			}

			internal void <EnsureUnlockConfirmPanel>b__64_1()
			{
				CloseUnlockConfirmPanel(reopenActionMenu: false);
			}

			internal void <CreateCraftedByInput>b__66_0()
			{
				DrakeRenameit.ApplyCraftedByLabel(RenameCraftedByInput.text.Trim());
			}

			internal void <CreateCraftedByInput>b__66_1()
			{
				if (DrakeRenameit.CurrentItem != null)
				{
					RenameCraftedByInput.text = DrakeRenameit.CurrentItem.m_crafterName ?? "";
				}
				List<string> craftedByAllowedLabelsList = RenameitConfig.GetCraftedByAllowedLabelsList();
				_craftedByLineLabelPendingToken = null;
				SetCraftedByLineLabelPickButtonText(craftedByAllowedLabelsList, 0);
				CloseCraftedByLineLabelPopover();
			}

			internal void <EnsureCraftedByLineLabelControls>b__67_0()
			{
				if (!((Object)(object)_buttonCraftedByLineLabelPick == (Object)null) && ((Selectable)_buttonCraftedByLineLabelPick).interactable)
				{
					ToggleCraftedByLineLabelPopover();
				}
			}

			internal void <CreateRenameInput>b__74_0()
			{
				DrakeRenameit.ApplyRename(RenameNameInput.text.Trim());
			}

			internal void <CreateRenameInput>b__74_1()
			{
				if (DrakeRenameit.CurrentItem != null)
				{
					RenameNameInput.text = DrakeRenameit.resetName(DrakeRenameit.CurrentItem);
				}
			}

			internal void <CreateRenameDescInput>b__75_0()
			{
				if (string.IsNullOrEmpty(RenameDescInput.text))
				{
					<CreateRenameDescInput>g__GetPlayerAndSendError|75_2("Description must not be empty!");
				}
				else
				{
					DrakeRenameit.ApplyRewriteDesc(RenameDescInput.text.Trim());
				}
			}

			internal void <CreateRenameDescInput>b__75_1()
			{
				RenameDescInput.text = DrakeRenameit.resetDesc(DrakeRenameit.CurrentItem);
			}
		}

		private const string RenameItemDescription = "Rewrite Item Desc";

		private static Button _buttonOkName;

		private static Button _buttonOkDesc;

		private static Button _buttonResetName;

		private static Button _buttonResetDesc;

		private static Button? _buttonMenuRename;

		private static Button? _buttonMenuDesc;

		private static Button? _buttonMenuCraftedBy;

		private static Button? _buttonMenuResetAll;

		private static Button? _buttonMenuUnlock;

		private static Button? _buttonMenuCancel;

		private static Button? _buttonOkCraftedBy;

		private static Button? _buttonResetCraftedBy;

		private static Button? _buttonCraftedByLineLabelPick;

		private static GameObject? _craftedByLineLabelPopover;

		private static string? _craftedByLineLabelPendingToken;

		private static GameObject? _unlockConfirmPanel;

		private static RectTransform? _unlockCostListRoot;

		private static Text? _unlockAffordWarning;

		private static Button? _buttonConfirmUnlock;

		private static Button? _buttonConfirmCancel;

		private static bool _inputBlocked;

		public static GameObject? InputNamePanel { get; private set; }

		public static GameObject? InputDescPanel { get; private set; }

		public static InputField? RenameNameInput { get; private set; }

		public static InputField? RenameDescInput { get; private set; }

		public static GameObject? ActionMenuPanel { get; private set; }

		public static GameObject? InputCraftedByPanel { get; private set; }

		public static InputField? RenameCraftedByInput { get; private set; }

		internal static string? CraftedByLineLabelPendingToken => _craftedByLineLabelPendingToken;

		internal static void EnsureInputBlocked()
		{
			if (!_inputBlocked)
			{
				GUIManager.BlockInput(true);
				_inputBlocked = true;
			}
		}

		internal static void EnsureInputUnblocked()
		{
			if (_inputBlocked)
			{
				GUIManager.BlockInput(false);
				_inputBlocked = false;
			}
		}

		public static void CloseAllRenameEditingUi()
		{
			if ((Object)(object)InputNamePanel != (Object)null)
			{
				InputNamePanel.SetActive(false);
			}
			if ((Object)(object)InputDescPanel != (Object)null)
			{
				InputDescPanel.SetActive(false);
			}
			if ((Object)(object)InputCraftedByPanel != (Object)null)
			{
				InputCraftedByPanel.SetActive(false);
			}
			CloseCraftedByLineLabelPopover();
			if ((Object)(object)ActionMenuPanel != (Object)null)
			{
				ActionMenuPanel.SetActive(false);
			}
			if ((Object)(object)_unlockConfirmPanel != (Object)null)
			{
				_unlockConfirmPanel.SetActive(false);
			}
			DrakeRenameit.CurrentItem = null;
			EnsureInputUnblocked();
		}

		public static void OpenActionMenu(ItemData item)
		{
			if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				return;
			}
			if (!DrakeRenameit.IsItemInLocalPlayerInventory(item))
			{
				CloseAllRenameEditingUi();
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "That item is no longer in your inventory.", 0, (Sprite)null);
				}
				return;
			}
			EnsureActionMenu();
			if ((Object)(object)ActionMenuPanel == (Object)null || (Object)(object)_buttonMenuRename == (Object)null || (Object)(object)_buttonMenuResetAll == (Object)null || (Object)(object)_buttonMenuUnlock == (Object)null)
			{
				return;
			}
			DrakeRenameit.CurrentItem = item;
			bool flag = DrakeRenameit.ShowUnlockButton(item);
			((Component)_buttonMenuUnlock).gameObject.SetActive(flag);
			if (flag)
			{
				Text componentInChildren = ((Component)_buttonMenuUnlock).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					string costDisplayShort = RenameUnlockCost.GetCostDisplayShort();
					componentInChildren.text = (string.IsNullOrEmpty(costDisplayShort) ? "\ud83d\udd12 Unlock" : ("\ud83d\udd12 Unlock (" + costDisplayShort + ")"));
				}
				((Selectable)_buttonMenuRename).interactable = false;
				((Selectable)_buttonMenuDesc).interactable = false;
				((Selectable)_buttonMenuCraftedBy).interactable = false;
				((Selectable)_buttonMenuResetAll).interactable = false;
				((Selectable)_buttonMenuUnlock).interactable = true;
			}
			else
			{
				((Selectable)_buttonMenuRename).interactable = DrakeRenameit.CanChangeName(item);
				((Selectable)_buttonMenuDesc).interactable = DrakeRenameit.CanChangeDesc(item);
				((Selectable)_buttonMenuCraftedBy).interactable = DrakeRenameit.CanChangeCraftedByLabel(item);
				((Selectable)_buttonMenuResetAll).interactable = DrakeRenameit.CanResetAnyCustomization(item);
			}
			ActionMenuPanel.SetActive(true);
			ActionMenuPanel.transform.SetAsLastSibling();
			EnsureInputBlocked();
		}

		private static void EnsureActionMenu()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00c3: 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_00df: 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_0122: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_022c: 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_024a: 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_0208: Expected O, but got Unknown
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: 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_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Expected O, but got Unknown
			if ((Object)(object)ActionMenuPanel != (Object)null || GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				return;
			}
			ActionMenuPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 320f, 280f, false);
			GUIManager.Instance.CreateText("DrakesRenameIt", ActionMenuPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -48f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 280f, 40f, false);
			_buttonMenuUnlock = GUIManager.Instance.CreateButton("\ud83d\udd12 Unlock", ActionMenuPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 72f), 220f, 30f).GetComponent<Button>();
			((Component)_buttonMenuUnlock).gameObject.SetActive(false);
			Button? buttonMenuUnlock = _buttonMenuUnlock;
			object obj = <>c.<>9__56_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					ItemData currentItem5 = DrakeRenameit.CurrentItem;
					if (currentItem5 != null)
					{
						ActionMenuPanel.SetActive(false);
						OpenUnlockConfirmPanel(currentItem5);
					}
				};
				<>c.<>9__56_0 = val;
				obj = (object)val;
			}
			buttonMenuUnlock.AddUniqueListener((UnityAction)obj);
			_buttonMenuRename = GUIManager.Instance.CreateButton("Rename", ActionMenuPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 40f), 200f, 32f).GetComponent<Button>();
			Button? buttonMenuRename = _buttonMenuRename;
			object obj2 = <>c.<>9__56_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					ItemData currentItem4 = DrakeRenameit.CurrentItem;
					CloseActionMenuOnly();
					if (currentItem4 != null)
					{
						DrakeRenameit.OpenRename(currentItem4);
					}
				};
				<>c.<>9__56_1 = val2;
				obj2 = (object)val2;
			}
			buttonMenuRename.AddUniqueListener((UnityAction)obj2);
			_buttonMenuDesc = GUIManager.Instance.CreateButton("Description", ActionMenuPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 200f, 32f).GetComponent<Button>();
			Button? buttonMenuDesc = _buttonMenuDesc;
			object obj3 = <>c.<>9__56_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					ItemData currentItem3 = DrakeRenameit.CurrentItem;
					CloseActionMenuOnly();
					if (currentItem3 != null)
					{
						DrakeRenameit.OpenRewriteDesc(currentItem3);
					}
				};
				<>c.<>9__56_2 = val3;
				obj3 = (object)val3;
			}
			buttonMenuDesc.AddUniqueListener((UnityAction)obj3);
			_buttonMenuCraftedBy = GUIManager.Instance.CreateButton("Crafted by", ActionMenuPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -40f), 200f, 32f).GetComponent<Button>();
			Button? buttonMenuCraftedBy = _buttonMenuCraftedBy;
			object obj4 = <>c.<>9__56_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					ItemData currentItem2 = DrakeRenameit.CurrentItem;
					CloseActionMenuOnly();
					if (currentItem2 != null)
					{
						DrakeRenameit.OpenCraftedByEditor(currentItem2);
					}
				};
				<>c.<>9__56_3 = val4;
				obj4 = (object)val4;
			}
			buttonMenuCraftedBy.AddUniqueListener((UnityAction)obj4);
			_buttonMenuResetAll = GUIManager.Instance.CreateButton("Reset all", ActionMenuPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-66f, -80f), 120f, 28f).GetComponent<Button>();
			Button? buttonMenuResetAll = _buttonMenuResetAll;
			object obj5 = <>c.<>9__56_4;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					ItemData currentItem = DrakeRenameit.CurrentItem;
					if (currentItem != null)
					{
						DrakeRenameit.ResetAllCustomizations(currentItem);
					}
					CloseActionMenuOnly();
				};
				<>c.<>9__56_4 = val5;
				obj5 = (object)val5;
			}
			buttonMenuResetAll.AddUniqueListener((UnityAction)obj5);
			_buttonMenuCancel = GUIManager.Instance.CreateButton("OK", ActionMenuPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(66f, -80f), 120f, 28f).GetComponent<Button>();
			Button? buttonMenuCancel = _buttonMenuCancel;
			object obj6 = <>O.<0>__CloseActionMenuOnly;
			if (obj6 == null)
			{
				UnityAction val6 = CloseActionMenuOnly;
				<>O.<0>__CloseActionMenuOnly = val6;
				obj6 = (object)val6;
			}
			buttonMenuCancel.AddUniqueListener((UnityAction)obj6);
		}

		private static void CloseActionMenuOnly()
		{
			if ((Object)(object)ActionMenuPanel != (Object)null)
			{
				ActionMenuPanel.SetActive(false);
			}
			EnsureInputUnblocked();
		}

		public static void OpenUnlockMenuFromInventory(ItemData item)
		{
			DrakeRenameit.CurrentItem = item;
			OpenUnlockConfirmPanel(item);
		}

		private static void OpenUnlockConfirmPanel(ItemData item)
		{
			if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				return;
			}
			if (!DrakeRenameit.IsItemInLocalPlayerInventory(item))
			{
				CloseAllRenameEditingUi();
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "That item is no longer in your inventory.", 0, (Sprite)null);
				}
				return;
			}
			EnsureUnlockConfirmPanel();
			if (!((Object)(object)_unlockConfirmPanel == (Object)null) && !((Object)(object)_unlockCostListRoot == (Object)null) && !((Object)(object)_buttonConfirmUnlock == (Object)null))
			{
				RefreshUnlockConfirmBody();
				bool interactable = RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer);
				((Selectable)_buttonConfirmUnlock).interactable = interactable;
				_unlockConfirmPanel.SetActive(true);
				_unlockConfirmPanel.transform.SetAsLastSibling();
				EnsureInputBlocked();
			}
		}

		private static void RefreshUnlockConfirmBody()
		{
			if ((Object)(object)_unlockCostListRoot == (Object)null)
			{
				return;
			}
			ClearUnlockCostListChildren();
			List<(string, int, string)> costDisplayEntries = RenameUnlockCost.GetCostDisplayEntries();
			bool flag = RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer);
			if (costDisplayEntries.Count == 0)
			{
				AddUnlockPlainLine(_unlockCostListRoot, "Unlock this item stack for editing?");
				if ((Object)(object)_unlockAffordWarning != (Object)null)
				{
					_unlockAffordWarning.text = "";
					((Component)_unlockAffordWarning).gameObject.SetActive(false);
				}
				return;
			}
			foreach (var item4 in costDisplayEntries)
			{
				string item = item4.Item1;
				int item2 = item4.Item2;
				string item3 = item4.Item3;
				string itemTokenPublic = RenameUnlockCost.GetItemTokenPublic(item3);
				int num;
				if (!((Object)(object)Player.m_localPlayer != (Object)null))
				{
					num = 0;
				}
				else
				{
					Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
					num = ((inventory != null) ? inventory.CountItems(itemTokenPublic, -1, true) : 0);
				}
				int num2 = num;
				string text = ((num2 >= item2) ? "lime" : "red");
				string richLine = $"{item2}x {item}  <color={text}>({num2} in inv)</color>";
				Sprite itemIconSprite = RenameUnlockCost.GetItemIconSprite(item3);
				CreateUnlockCostRow(_unlockCostListRoot, itemIconSprite, richLine);
			}
			if ((Object)(object)_unlockAffordWarning != (Object)null)
			{
				if (!flag)
				{
					_unlockAffordWarning.text = "<color=red>You don't have enough items to unlock.</color>";
					((Component)_unlockAffordWarning).gameObject.SetActive(true);
				}
				else
				{
					_unlockAffordWarning.text = "";
					((Component)_unlockAffordWarning).gameObject.SetActive(false);
				}
			}
		}

		private static void ClearUnlockCostListChildren()
		{
			if (!((Object)(object)_unlockCostListRoot == (Object)null))
			{
				for (int num = ((Transform)_unlockCostListRoot).childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)((Transform)_unlockCostListRoot).GetChild(num)).gameObject);
				}
			}
		}

		private static void AddUnlockPlainLine(RectTransform parent, string message)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0070: 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)
			GameObject val = new GameObject("PlainLine", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			Text component = val.GetComponent<Text>();
			component.text = message;
			if (GUIManager.Instance != null)
			{
				component.font = GUIManager.Instance.AveriaSerifBold;
			}
			component.fontSize = 14;
			((Graphic)component).color = Color.white;
			component.alignment = (TextAnchor)0;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			RectTransform component2 = val.GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(300f, 40f);
		}

		private static void CreateUnlockCostRow(RectTransform parent, Sprite? icon, string richLine)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00df: 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_0154: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("CostRow", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(300f, 38f);
			HorizontalLayoutGroup val2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val2).spacing = 10f;
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = true;
			((LayoutGroup)val2).padding = new RectOffset(2, 2, 2, 2);
			GameObject val3 = new GameObject("icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(val.transform, false);
			Image component2 = val3.GetComponent<Image>();
			component2.sprite = icon;
			component2.preserveAspect = true;
			((Graphic)component2).color = Color.white;
			((Behaviour)component2).enabled = (Object)(object)icon != (Object)null;
			LayoutElement val4 = val3.AddComponent<LayoutElement>();
			val4.preferredWidth = 32f;
			val4.preferredHeight = 32f;
			val4.minWidth = 32f;
			GameObject val5 = new GameObject("line", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val5.transform.SetParent(val.transform, false);
			Text component3 = val5.GetComponent<Text>();
			component3.text = richLine;
			if (GUIManager.Instance != null)
			{
				component3.font = GUIManager.Instance.AveriaSerifBold;
			}
			component3.fontSize = 14;
			((Graphic)component3).color = Color.white;
			component3.alignment = (TextAnchor)3;
			component3.supportRichText = true;
			component3.horizontalOverflow = (HorizontalWrapMode)0;
			LayoutElement val6 = val5.AddComponent<LayoutElement>();
			val6.flexibleWidth = 1f;
			val6.minWidth = 180f;
		}

		private static void EnsureUnlockConfirmPanel()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_00c4: 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_00e0: 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_0123: 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_0143: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Expected O, but got Unknown
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Expected O, but got Unknown
			if ((Object)(object)_unlockConfirmPanel != (Object)null || GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				return;
			}
			_unlockConfirmPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 360f, 280f, false);
			GUIManager.Instance.CreateText("\ud83d\udd12 Unlock Item", _unlockConfirmPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -44f), GUIManager.Instance.AveriaSerifBold, 20, GUIManager.Instance.ValheimOrange, true, Color.black, 300f, 36f, false);
			GUIManager.Instance.CreateText("Unlock cost:", _unlockConfirmPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -78f), GUIManager.Instance.AveriaSerifBold, 14, Color.white, true, Color.black, 300f, 22f, false);
			GameObject val = new GameObject("UnlockCostList", new Type[2]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup)
			});
			val.transform.SetParent(_unlockConfirmPanel.transform, false);
			_unlockCostListRoot = val.GetComponent<RectTransform>();
			_unlockCostListRoot.anchorMin = new Vector2(0.5f, 1f);
			_unlockCostListRoot.anchorMax = new Vector2(0.5f, 1f);
			_unlockCostListRoot.pivot = new Vector2(0.5f, 1f);
			_unlockCostListRoot.sizeDelta = new Vector2(320f, 150f);
			_unlockCostListRoot.anchoredPosition = new Vector2(0f, -102f);
			VerticalLayoutGroup component = val.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 6f;
			((LayoutGroup)component).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			GameObject val2 = GUIManager.Instance.CreateText("", _unlockConfirmPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 78f), GUIManager.Instance.AveriaSerifBold, 13, Color.red, true, Color.black, 310f, 36f, false);
			_unlockAffordWarning = val2.GetComponent<Text>();
			_unlockAffordWarning.supportRichText = true;
			((Component)_unlockAffordWarning).gameObject.SetActive(false);
			_buttonConfirmUnlock = GUIManager.Instance.CreateButton("\ud83d\udd12 Pay", _unlockConfirmPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-55f, 35f), 110f, 30f).GetComponent<Button>();
			Button? buttonConfirmUnlock = _buttonConfirmUnlock;
			object obj = <>c.<>9__64_0;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					ItemData currentItem = DrakeRenameit.CurrentItem;
					if (currentItem == null)
					{
						CloseUnlockConfirmPanel(reopenActionMenu: false);
					}
					else if (!DrakeRenameit.TryPayRenameUnlock(currentItem))
					{
						if (DrakeRenameit.CurrentItem == null || !DrakeRenameit.IsItemInLocalPlayerInventory(DrakeRenameit.CurrentItem))
						{
							CloseAllRenameEditingUi();
						}
						else
						{
							RefreshUnlockConfirmBody();
							((Selectable)_buttonConfirmUnlock).interactable = RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer);
						}
					}
					else
					{
						CloseUnlockConfirmPanel(reopenActionMenu: true);
					}
				};
				<>c.<>9__64_0 = val3;
				obj = (object)val3;
			}
			buttonConfirmUnlock.AddUniqueListener((UnityAction)obj);
			_buttonConfirmCancel = GUIManager.Instance.CreateButton("Cancel", _unlockConfirmPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(55f, 35f), 110f, 30f).GetComponent<Button>();
			Button? buttonConfirmCancel = _buttonConfirmCancel;
			object obj2 = <>c.<>9__64_1;
			if (obj2 == null)
			{
				UnityAction val4 = delegate
				{
					CloseUnlockConfirmPanel(reopenActionMenu: false);
				};
				<>c.<>9__64_1 = val4;
				obj2 = (object)val4;
			}
			buttonConfirmCancel.AddUniqueListener((UnityAction)obj2);
		}

		private static void CloseUnlockConfirmPanel(bool reopenActionMenu)
		{
			if ((Object)(object)_unlockConfirmPanel != (Object)null)
			{
				_unlockConfirmPanel.SetActive(false);
			}
			if (reopenActionMenu && DrakeRenameit.CurrentItem != null)
			{
				ItemData currentItem = DrakeRenameit.CurrentItem;
				GameObject? actionMenuPanel = ActionMenuPanel;
				if (actionMenuPanel != null)
				{
					actionMenuPanel.SetActive(false);
				}
				OpenActionMenu(currentItem);
			}
			else
			{
				if ((Object)(object)ActionMenuPanel != (Object)null)
				{
					ActionMenuPanel.SetActive(false);
				}
				DrakeRenameit.CurrentItem = null;
				EnsureInputUnblocked();
			}
		}

		public static void CreateCraftedByInput()
		{
			//IL_0089: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Expected O, but got Unknown
			if (GUIManager.Instance == null)
			{
				Debug.LogError((object)"GUIManager instance is null");
				return;
			}
			if (!Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				Debug.LogError((object)"GUIManager CustomGUI is null");
				return;
			}
			if (DrakeRenameit.CurrentItem == null)
			{
				Debug.LogError((object)"Current Item null");
				return;
			}
			if ((Object)(object)InputCraftedByPanel == (Object)null)
			{
				InputCraftedByPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 350f, 230f, false);
				GUIManager.Instance.CreateText("Crafted by (display)", InputCraftedByPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(15f, -56f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 300f, 60f, false);
			}
			InputCraftedByPanel.SetActive(true);
			InputCraftedByPanel.transform.SetAsLastSibling();
			EnsureCraftedByLineLabelControls();
			if ((Object)(object)RenameCraftedByInput == (Object)null)
			{
				RenameCraftedByInput = GUIManager.Instance.CreateInputField(InputCraftedByPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -28f), (ContentType)0, "Display name on tooltip…", 18, 300f, 30f).GetComponent<InputField>();
			}
			RenameCraftedByInput.characterLimit = RenameitConfig.CraftedByCharLimit;
			RenameCraftedByInput.text = DrakeRenameit.getCraftedByDisplay(DrakeRenameit.CurrentItem);
			if (DrakeRenameit.CurrentItem != null)
			{
				RefreshCraftedByLineLabelPicker(DrakeRenameit.CurrentItem);
			}
			if ((Object)(object)_buttonOkCraftedBy == (Object)null)
			{
				_buttonOkCraftedBy = GUIManager.Instance.CreateButton("OK", InputCraftedByPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-42f, 35f), 80f, 30f).GetComponent<Button>();
				Button? buttonOkCraftedBy = _buttonOkCraftedBy;
				object obj = <>c.<>9__66_0;
				if (obj == null)
				{
					UnityAction val = delegate
					{
						DrakeRenameit.ApplyCraftedByLabel(RenameCraftedByInput.text.Trim());
					};
					<>c.<>9__66_0 = val;
					obj = (object)val;
				}
				buttonOkCraftedBy.AddUniqueListener((UnityAction)obj);
			}
			if (!((Object)(object)_buttonResetCraftedBy == (Object)null))
			{
				return;
			}
			_buttonResetCraftedBy = GUIManager.Instance.CreateButton("Reset", InputCraftedByPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(42f, 35f), 80f, 30f).GetComponent<Button>();
			Button? buttonResetCraftedBy = _buttonResetCraftedBy;
			object obj2 = <>c.<>9__66_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					if (DrakeRenameit.CurrentItem != null)
					{
						RenameCraftedByInput.text = DrakeRenameit.CurrentItem.m_crafterName ?? "";
					}
					List<string> craftedByAllowedLabelsList = RenameitConfig.GetCraftedByAllowedLabelsList();
					_craftedByLineLabelPendingToken = null;
					SetCraftedByLineLabelPickButtonText(craftedByAllowedLabelsList, 0);
					CloseCraftedByLineLabelPopover();
				};
				<>c.<>9__66_1 = val2;
				obj2 = (object)val2;
			}
			buttonResetCraftedBy.AddUniqueListener((UnityAction)obj2);
		}

		private static void EnsureCraftedByLineLabelControls()
		{
			//IL_0037: 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_0097: 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_00c6: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			if ((Object)(object)InputCraftedByPanel == (Object)null || GUIManager.Instance == null)
			{
				return;
			}
			RectTransform component = InputCraftedByPanel.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null && component.sizeDelta.y < 220f)
			{
				component.sizeDelta = new Vector2(350f, 230f);
			}
			if ((Object)(object)_buttonCraftedByLineLabelPick != (Object)null)
			{
				return;
			}
			GUIManager.Instance.CreateText("Tooltip line", InputCraftedByPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-118f, -90f), GUIManager.Instance.AveriaSerifBold, 16, Color.white, true, Color.black, 100f, 28f, false);
			_buttonCraftedByLineLabelPick = GUIManager.Instance.CreateButton("…", InputCraftedByPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(32f, -90f), 210f, 28f).GetComponent<Button>();
			Button? buttonCraftedByLineLabelPick = _buttonCraftedByLineLabelPick;
			object obj = <>c.<>9__67_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					if (!((Object)(object)_buttonCraftedByLineLabelPick == (Object)null) && ((Selectable)_buttonCraftedByLineLabelPick).interactable)
					{
						ToggleCraftedByLineLabelPopover();
					}
				};
				<>c.<>9__67_0 = val;
				obj = (object)val;
			}
			buttonCraftedByLineLabelPick.AddUniqueListener((UnityAction)obj);
			_craftedByLineLabelPopover = GUIManager.Instance.CreateWoodpanel(InputCraftedByPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(24f, -118f), 226f, 48f, false);
			_craftedByLineLabelPopover.SetActive(false);
		}

		internal static void RefreshCraftedByLineLabelPicker(ItemData item)
		{
			EnsureCraftedByLineLabelControls();
			if ((Object)(object)_buttonCraftedByLineLabelPick == (Object)null)
			{
				return;
			}
			bool flag = RenameitConfig.CraftedByLabelCustomizable || RenameitPermission.IsElevatedForOverrides(Player.m_localPlayer);
			List<string> craftedByAllowedLabelsList = RenameitConfig.GetCraftedByAllowedLabelsList();
			string value;
			string text = ((item.m_customData != null && item.m_customData.TryGetValue("Drake_CraftedByLineLabel", out value) && !string.IsNullOrEmpty(value)) ? value : null);
			int idx = 0;
			string craftedByLineLabelPendingToken = null;
			if (flag && text != null)
			{
				for (int i = 1; i < craftedByAllowedLabelsList.Count; i++)
				{
					if (string.Equals(craftedByAllowedLabelsList[i], text, StringComparison.Ordinal))
					{
						idx = i;
						craftedByLineLabelPendingToken = text;
						break;
					}
				}
			}
			_craftedByLineLabelPendingToken = craftedByLineLabelPendingToken;
			SetCraftedByLineLabelPickButtonText(craftedByAllowedLabelsList, idx);
			((Selectable)_buttonCraftedByLineLabelPick).interactable = flag;
			CloseCraftedByLineLabelPopover();
		}

		private static void SetCraftedByLineLabelPickButtonText(List<string> options, int idx)
		{
			if (!((Object)(object)_buttonCraftedByLineLabelPick == (Object)null))
			{
				string text = ((idx <= 0 || idx >= options.Count) ? LocalizedDefaultCraftedByCaption() : options[idx]);
				Text componentInChildren = ((Component)_buttonCraftedByLineLabelPick).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = text + "  ▼";
				}
			}
		}

		private static string LocalizedDefaultCraftedByCaption()
		{
			if (Localization.instance != null)
			{
				string text = Localization.instance.Localize("$item_crafter");
				if (!string.IsNullOrEmpty(text))
				{
					return text;
				}
			}
			List<string> craftedByAllowedLabelsList = RenameitConfig.GetCraftedByAllowedLabelsList();
			return (craftedByAllowedLabelsList.Count > 0) ? craftedByAllowedLabelsList[0] : "Crafted by";
		}

		private static void ToggleCraftedByLineLabelPopover()
		{
			if (!((Object)(object)_craftedByLineLabelPopover == (Object)null))
			{
				if (_craftedByLineLabelPopover.activeSelf)
				{
					CloseCraftedByLineLabelPopover();
					return;
				}
				RebuildCraftedByLineLabelPopoverContent();
				_craftedByLineLabelPopover.SetActive(true);
				_craftedByLineLabelPopover.transform.SetAsLastSibling();
			}
		}

		private static void CloseCraftedByLineLabelPopover()
		{
			if ((Object)(object)_craftedByLineLabelPopover != (Object)null)
			{
				_craftedByLineLabelPopover.SetActive(false);
			}
		}

		private static void RebuildCraftedByLineLabelPopoverContent()
		{
			//IL_00b0: 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_0126: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			if ((Object)(object)_craftedByLineLabelPopover == (Object)null || GUIManager.Instance == null)
			{
				return;
			}
			for (int num = _craftedByLineLabelPopover.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)_craftedByLineLabelPopover.transform.GetChild(num)).gameObject);
			}
			List<string> options = RenameitConfig.GetCraftedByAllowedLabelsList();
			float num2 = 12f + (float)options.Count * 28f;
			RectTransform component = _craftedByLineLabelPopover.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.sizeDelta = new Vector2(220f, num2);
			}
			for (int i = 0; i < options.Count; i++)
			{
				int capture = i;
				string text = ((i == 0) ? LocalizedDefaultCraftedByCaption() : options[i]);
				Button component2 = GUIManager.Instance.CreateButton(text, _craftedByLineLabelPopover.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -6f - 28f * ((float)i + 0.5f)), 200f, 26f).GetComponent<Button>();
				component2.AddUniqueListener((UnityAction)delegate
				{
					_craftedByLineLabelPendingToken = ((capture == 0) ? null : options[capture]);
					SetCraftedByLineLabelPickButtonText(options, capture);
					CloseCraftedByLineLabelPopover();
				});
			}
		}

		public static void CreateRenameInput()
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0130: 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_0088: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_0197: 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_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Expected O, but got Unknown
			//IL_0332: 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_033d: Expected O, but got Unknown
			if (GUIManager.Instance == null)
			{
				Debug.LogError((object)"GUIManager instance is null");
				return;
			}
			if (!Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				Debug.LogError((object)"GUIManager CustomGUI is null");
				return;
			}
			if (DrakeRenameit.CurrentItem == null)
			{
				Debug.LogError((object)"Current Item null");
				return;
			}
			if (!Object.op_Implicit((Object)(object)InputNamePanel))
			{
				InputNamePanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 350f, 150f, false);
			}
			InputNamePanel.SetActive(true);
			InputNamePanel.transform.SetAsLastSibling();
			GUIManager.Instance.CreateText("Rename Item", InputNamePanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(15f, -65f), GUIManager.Instance.AveriaSerifBold, 24, GUIManager.Instance.ValheimOrange, true, Color.black, 200f, 100f, false);
			if (!Object.op_Implicit((Object)(object)RenameNameInput))
			{
				RenameNameInput = GUIManager.Instance.CreateInputField(InputNamePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), (ContentType)0, "Enter new name...", 18, 300f, 30f).GetComponent<InputField>();
			}
			RenameNameInput.characterLimit = RenameitConfig.NameCharLimit;
			RenameNameInput.text = DrakeRenameit.GetPropperName(DrakeRenameit.CurrentItem);
			if ((Object)(object)_buttonOkName == (Object)null)
			{
				_buttonOkName = GUIManager.Instance.CreateButton("OK", InputNamePanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-42f, 35f), 80f, 30f).GetComponent<Button>();
				((Component)_buttonOkName).gameObject.SetActive(true);
				Button component = ((Component)_buttonOkName).GetComponent<Button>();
				object obj = <>c.<>9__74_0;
				if (obj == null)
				{
					UnityAction val = delegate
					{
						DrakeRenameit.ApplyRename(RenameNameInput.text.Trim());
					};
					<>c.<>9__74_0 = val;
					obj = (object)val;
				}
				component.AddUniqueListener((UnityAction)obj);
			}
			if (!((Object)(object)_buttonResetName == (Object)null))
			{
				return;
			}
			_buttonResetName = GUIManager.Instance.CreateButton("Reset", InputNamePanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(42f, 35f), 80f, 30f).GetComponent<Button>();
			((Component)_buttonResetName).gameObject.SetActive(true);
			Button component2 = ((Component)_buttonResetName).GetComponent<Button>();
			object obj2 = <>c.<>9__74_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					if (DrakeRenameit.CurrentItem != null)
					{
						RenameNameInput.text = DrakeRenameit.resetName(DrakeRenameit.CurrentItem);
					}
				};
				<>c.<>9__74_1 = val2;
				obj2 = (object)val2;
			}
			component2.AddUniqueListener((UnityAction)obj2);
		}

		public static void CreateRenameDescInput()
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0130: 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_0088: 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_00a6: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: 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_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: 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_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			if (GUIManager.Instance == null)
			{
				Debug.LogError((object)"GUIManager instance is null");
				return;
			}
			if (!Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				Debug.LogError((object)"GUIManager CustomGUI is null");
				return;
			}
			if (DrakeRenameit.CurrentItem == null)
			{
				Debug.LogError((object)"Current Item null");
				return;
			}
			if (!Object.op_Implicit((Object)(object)InputDescPanel))
			{
				InputDescPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 275f, 375f, false);
			}
			InputDescPanel.SetActive(true);
			InputDescPanel.transform.SetAsLastSibling();
			GUIManager.Instance.CreateText("Rewrite Item Desc", InputDescPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(15f, -65f), GUIManager.Instance.AveriaSerifBold, 24, GUIManager.Instance.ValheimOrange, true, Color.black, 250f, 80f, false);
			if (!Object.op_Implicit((Object)(object)RenameDescInput))
			{
				RenameDescInput = GUIManager.Instance.CreateInputField(InputDescPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), (ContentType)0, "Enter new desc", 16, 225f, 240f).GetComponent<InputField>();
				RenameDescInput.contentType = (ContentType)0;
				RenameDescInput.lineType = (LineType)2;
				RenameDescInput.text = DrakeRenameit.getPropperDesc(DrakeRenameit.CurrentItem);
			}
			RenameDescInput.characterLimit = RenameitConfig.DescCharLimit;
			if ((Object)(object)_buttonOkDesc == (Object)null)
			{
				_buttonOkDesc = GUIManager.Instance.CreateButton("OK", InputDescPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-42f, 35f), 80f, 30f).GetComponent<Button>();
				((Component)_buttonOkDesc).gameObject.SetActive(true);
				Button buttonOkDesc = _buttonOkDesc;
				object obj = <>c.<>9__75_0;
				if (obj == null)
				{
					UnityAction val = delegate
					{
						if (string.IsNullOrEmpty(RenameDescInput.text))
						{
							GetPlayerAndSendError("Description must not be empty!");
						}
						else
						{
							DrakeRenameit.ApplyRewriteDesc(RenameDescInput.text.Trim());
						}
					};
					<>c.<>9__75_0 = val;
					obj = (object)val;
				}
				buttonOkDesc.AddUniqueListener((UnityAction)obj);
			}
			if (!((Object)(object)_buttonResetDesc == (Object)null))
			{
				return;
			}
			_buttonResetDesc = GUIManager.Instance.CreateButton("Reset", InputDescPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(42f, 35f), 80f, 30f).GetComponent<Button>();
			((Component)_buttonResetDesc).gameObject.SetActive(true);
			Button component = ((Component)_buttonResetDesc).GetComponent<Button>();
			object obj2 = <>c.<>9__75_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					RenameDescInput.text = DrakeRenameit.resetDesc(DrakeRenameit.CurrentItem);
				};
				<>c.<>9__75_1 = val2;
				obj2 = (object)val2;
			}
			component.AddUniqueListener((UnityAction)obj2);
			static void GetPlayerAndSendError(string msg)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					((Character)localPlayer).Message((MessageType)2, msg, 0, (Sprite)null);
				}
			}
		}

		[CompilerGenerated]
		internal static void <CreateRenameDescInput>g__GetPlayerAndSendError|75_2(string msg)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				((Character)localPlayer).Message((MessageType)2, msg, 0, (Sprite)null);
			}
		}
	}
}
namespace DrakeRenameit.Patches
{
	internal static class InventoryStackPatches
	{
		internal static ItemData? IncomingStackItem;

		internal static void Apply(Harmony harmony, ManualLogSource log)
		{
			//IL_0072: 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_0094: Expected O, but got Unknown
			//IL_0094: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			Type typeFromHandle = typeof(Inventory);
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeFromHandle, "AddItem", new Type[1] { typeof(ItemData) }, (Type[])null) ?? AccessTools.Method(typeFromHandle, "AddItem", new Type[1] { typeof(ItemData) }, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(InventoryStackPatches), "AddItem_IncomingPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(InventoryStackPatches), "AddItem_IncomingCleanup", (Type[])null), (HarmonyMethod)null);
			}
			else
			{
				log.LogWarning((object)"[DrakesRenameIt] SeparateStacks: AddItem(ItemData) not found — incoming stack tracking disabled.");
			}
			MethodInfo methodInfo2 = null;
			MethodInfo[] methods = typeFromHandle.GetMethods(bindingAttr);
			foreach (MethodInfo methodInfo3 in methods)
			{
				if (!(methodInfo3.Name != "FindFreeStackItem"))
				{
					ParameterInfo[] parameters = methodInfo3.GetParameters();
					if (parameters.Length >= 2 && !(parameters[0].ParameterType != typeof(string)) && !(parameters[1].ParameterType != typeof(int)))
					{
						methodInfo2 = methodInfo3;
						break;
					}
				}
			}
			if (methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(InventoryStackPatches), "FindFreeStackItem_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				log.LogWarning((object)"[DrakesRenameIt] SeparateStacks: FindFreeStackItem not found — merge-from-pickup may ignore identity.");
			}
			MethodInfo methodInfo4 = null;
			MethodInfo[] methods2 = typeFromHandle.GetMethods(bindingAttr);
			foreach (MethodInfo methodInfo5 in methods2)
			{
				if (!(methodInfo5.Name != "AddItem"))
				{
					ParameterInfo[] parameters2 = methodInfo5.GetParameters();
					if (parameters2.Length >= 4 && !(parameters2[0].ParameterType != typeof(ItemData)) && !(parameters2[1].ParameterType != typeof(int)) && !(parameters2[2].ParameterType != typeof(int)) && !(parameters2[3].ParameterType != typeof(int)))
					{
						methodInfo4 = methodInfo5;
						break;
					}
				}
			}
			if (methodInfo4 != null)
			{
				harmony.Patch((MethodBase)methodInfo4, new HarmonyMethod(typeof(InventoryStackPatches), "AddItemAtCell_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				log.LogWarning((object)"[DrakesRenameIt] SeparateStacks: AddItem(ItemData,int,int,int...) not found — cell merge guard disabled.");
			}
		}

		internal static void AddItem_IncomingPrefix(ItemData item)
		{
			IncomingStackItem = item;
		}

		internal static void AddItem_IncomingCleanup(Exception? __exception)
		{
			IncomingStackItem = null;
		}

		internal static bool FindFreeStackItem_Prefix(Inventory __instance, string name, int quality, ref ItemData __result)
		{
			if (!RenameitConfig.SeparateStacks || IncomingStackItem == null)
			{
				return true;
			}
			__result = null;
			foreach (ItemData allItem in __instance.GetAllItems())
			{
				if (TryPickStackSlot(IncomingStackItem, name, quality, allItem, ref __result))
				{
					continue;
				}
				break;
			}
			return false;
		}

		private static bool TryPickStackSlot(ItemData incoming, string name, int quality, ItemData? itemData, ref ItemData __result)
		{
			if (itemData?.m_shared == null)
			{
				return true;
			}
			if (itemData.m_shared.m_name != name || itemData.m_quality != quality)
			{
				return true;
			}
			if (itemData.m_stack >= itemData.m_shared.m_maxStackSize)
			{
				return true;
			}
			if (!StackIdentity.SameDrakeStackIdentity(incoming, itemData))
			{
				return true;
			}
			__result = itemData;
			return false;
		}

		internal static bool AddItemAtCell_Prefix(ItemData item, int amount, int x, int y, Inventory __instance, ref bool __result)
		{
			if (!RenameitConfig.SeparateStacks)
			{
				return true;
			}
			ItemData itemAt = __instance.GetItemAt(x, y);
			if (itemAt == null)
			{
				return true;
			}
			if (itemAt.m_shared.m_name != item.m_shared.m_name)
			{
				return true;
			}
			if (itemAt.m_shared.m_maxQuality > 1 && itemAt.m_quality != item.m_quality)
			{
				return true;
			}
			if (!StackIdentity.SameDrakeStackIdentity(item, itemAt))
			{
				if (!RenameitConfig.SeparateStacksHardLock)
				{
					return true;
				}
				__result = false;
				return false;
			}
			return true;
		}
	}
	internal static class ItemTooltipPatches
	{
		internal static void Apply(Harmony harmony, ManualLogSource log)
		{
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			Type typeFromHandle = typeof(ItemData);
			Type[] array = new Type[3]
			{
				typeof(ItemData),
				typeof(int),
				typeof(bool)
			};
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeFromHandle, "GetTooltip", array, (Type[])null) ?? AccessTools.Method(typeFromHandle, "GetTooltip", array, (Type[])null);
			if (methodInfo == null)
			{
				MethodInfo[] methods = typeFromHandle.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo2 in methods)
				{
					if (!(methodInfo2.Name != "GetTooltip") && methodInfo2.IsStatic)
					{
						ParameterInfo[] parameters = methodInfo2.GetParameters();
						if (parameters.Length == 3 && parameters[0].ParameterType == typeof(ItemData) && parameters[1].ParameterType == typeof(int) && parameters[2].ParameterType == typeof(bool))
						{
							methodInfo = methodInfo2;
							break;
						}
					}
				}
			}
			if (methodInfo == null)
			{
				log.LogWarning((object)"[DrakesRenameIt] Crafted-by display: static GetTooltip(ItemData,int,bool) not found — tooltip override disabled.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemTooltipPatches), "CraftedByDisplayPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		internal static void CraftedByDisplayPostfix(ItemData item, int qualityLevel, bool crafting, ref string __result)
		{
			__result = ApplyCraftedByDisplayToTooltipText(__result, item);
		}

		internal static string ApplyCraftedByDisplayToTooltipText(string text, ItemData item)
		{
			if (string.IsNullOrEmpty(text) || item?.m_customData == null)
			{
				return text;
			}
			if (item.m_crafterID == 0)
			{
				return text;
			}
			string text2 = item.m_crafterName ?? "";
			if (string.IsNullOrEmpty(text2))
			{
				return text;
			}
			string value;
			bool flag = item.m_customData.TryGetValue("Drake_CraftedByDisplay", out value) && !string.IsNullOrEmpty(value);
			string value2;
			bool flag2 = item.m_customData.TryGetValue("Drake_CraftedByLineLabel", out value2) && !string.IsNullOrEmpty(value2);
			if (!flag && !flag2)
			{
				return text;
			}
			string text3 = (flag ? value : text2);
			if (flag)
			{
				text3 = TooltipRichText.EnsureRichTextTagsClosedForTooltip(text3);
				text3 = TooltipRichText.WrapCraftedByDisplayWithDefaultStatColorIfNeeded(text3);
			}
			string lineLabelOverride = (flag2 ? value2 : null);
			return ReplaceCraftedBySegment(text, text2, text3, lineLabelOverride);
		}

		internal static string ReplaceCraftedBySegment(string text, string oldName, string newDisplay, string? lineLabelOverride = null)
		{
			string newDisplay2 = newDisplay;
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(oldName))
			{
				return text;
			}
			if (!string.IsNullOrEmpty(lineLabelOverride))
			{
				string text2 = TryReplaceCraftedByWithCustomLineLabel(text, oldName, newDisplay2, lineLabelOverride);
				if (text2 != null)
				{
					return text2;
				}
			}
			string text3 = "\n$item_crafter: " + oldName + " ";
			if (text.Contains(text3))
			{
				return text.Replace(text3, "\n$item_crafter: " + newDisplay2 + " ");
			}
			string text4 = "\n$item_crafter: " + oldName;
			if (text.Contains(text4))
			{
				return text.Replace(text4, "\n$item_crafter: " + newDisplay2);
			}
			string text5 = "Crafted by";
			if (Localization.instance != null)
			{
				string text6 = Localization.instance.Localize("$item_crafter");
				if (!string.IsNullOrEmpty(text6))
				{
					text5 = text6;
				}
			}
			string[] array = new string[2] { " ", "" };
			foreach (string text7 in array)
			{
				string text8 = "\n" + text5 + ": " + oldName + text7;
				if (text.Contains(text8))
				{
					return text.Replace(text8, "\n" + text5 + ": " + newDisplay2 + ((text7 == " ") ? " " : ""));
				}
			}
			try
			{
				string text9 = Regex.Escape(text5);
				string text10 = Regex.Escape(oldName);
				Regex regex = new Regex("(?<prefix>\\n[^\\n]*?" + text9 + "\\s*:\\s*)(?:<color[^>]*>)?" + text10 + "(?:</color>)?", RegexOptions.None, TimeSpan.FromMilliseconds(250.0));
				if (regex.IsMatch(text))
				{
					return regex.Replace(text, (Match m) => m.Groups["prefix"].Value + newDisplay2);
				}
			}
			catch (RegexMatchTimeoutException)
			{
			}
			try
			{
				Regex regex2 = new Regex("(?<prefix>\\n[^\\n]*?\\$item_crafter\\s*:\\s*)(?:<color[^>]*>)?" + Regex.Escape(oldName) + "(?:</color>)?", RegexOptions.None, TimeSpan.FromMilliseconds(250.0));
				if (regex2.IsMatch(text))
				{
					return regex2.Replace(text, (Match m) => m.Groups["prefix"].Value + newDisplay2);
				}
			}
			catch (RegexMatchTimeoutException)
			{
			}
			string[] array2 = text.Split(new string[2] { "\r\n", "\n" }, StringSplitOptions.None);
			for (int j = 0; j < array2.Length; j++)
			{
				string text11 = array2[j];
				if ((text11.IndexOf("$item_crafter", StringComparison.OrdinalIgnoreCase) >= 0 || text11.IndexOf(text5, StringComparison.OrdinalIgnoreCase) >= 0) && text11.IndexOf(oldName, StringComparison.Ordinal) >= 0)
				{
					int startIndex = text11.IndexOf(oldName, StringComparison.Ordinal);
					array2[j] = text11.Remove(startIndex, oldName.Length).Insert(startIndex, newDisplay2);
					return string.Join("\n", array2);
				}
			}
			return text;
		}

		private static string? TryReplaceCraftedByWithCustomLineLabel(string text, string oldName, string newDisplay, string lineLabelOverride)
		{
			string lineLabelOverride2 = lineLabelOverride;
			string newDisplay2 = newDisplay;
			string text2 = "\n$item_crafter: " + oldName + " ";
			if (text.Contains(text2))
			{
				return text.Replace(text2, "\n" + lineLabelOverride2 + ": " + newDisplay2 + " ");
			}
			string text3 = "\n$item_crafter: " + oldName;
			if (text.Contains(text3))
			{
				return text.Replace(text3, "\n" + lineLabelOverride2 + ": " + newDisplay2);
			}
			string text4 = "Crafted by";
			if (Localization.instance != null)
			{
				string text5 = Localization.instance.Localize("$item_crafter");
				if (!string.IsNullOrEmpty(text5))
				{
					text4 = text5;
				}
			}
			string[] array = new string[2] { " ", "" };
			foreach (string text6 in array)
			{
				string text7 = "\n" + text4 + ": " + oldName + text6;
				if (text.Contains(text7))
				{
					return text.Replace(text7, "\n" + lineLabelOverride2 + ": " + newDisplay2 + ((text6 == " ") ? " " : ""));
				}
			}
			try
			{
				string text8 = Regex.Escape(text4);
				string text9 = Regex.Escape(oldName);
				Regex regex = new Regex("(?<whole>\\n[^\\n]*?" + text8 + "\\s*:\\s*)(?:<color[^>]*>)?" + text9 + "(?:</color>)?", RegexOptions.None, TimeSpan.FromMilliseconds(250.0));
				if (regex.IsMatch(text))
				{
					return regex.Replace(text, (Match _) => "\n" + lineLabelOverride2 + ": " + newDisplay2);
				}
			}
			catch (RegexMatchTimeoutException)
			{
			}
			try
			{
				Regex regex2 = new Regex("(?<whole>\\n[^\\n]*?\\$item_crafter\\s*:\\s*)(?:<color[^>]*>)?" + Regex.Escape(oldName) + "(?:</color>)?", RegexOptions.None, TimeSpan.FromMilliseconds(250.0));
				if (regex2.IsMatch(text))
				{
					return regex2.Replace(text, (Match _) => "\n" + lineLabelOverride2 + ": " + newDisplay2);
				}
			}
			catch (RegexMatchTimeoutException)
			{
			}
			string[] array2 = text.Split(new string[2] { "\r\n", "\n" }, StringSplitOptions.None);
			for (int j = 0; j < array2.Length; j++)
			{
				string text10 = array2[j];
				if ((text10.IndexOf("$item_crafter", StringComparison.OrdinalIgnoreCase) >= 0 || text10.IndexOf(text4, StringComparison.OrdinalIgnoreCase) >= 0) && text10.IndexOf(oldName, StringComparison.Ordinal) >= 0)
				{
					array2[j] = lineLabelOverride2 + ": " + newDisplay2;
					return string.Join("\n", array2);
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	internal static class ItemDataDecoratedNameLikePatch
	{
		private static bool _loggedMissing;

		private static MethodBase? TargetMethod()
		{
			Type typeFromHandle = typeof(ItemData);
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			string[] array = new string[3] { "GetDecoratedName", "GetDecoratedNameWithQuality", "GetName" };
			foreach (string text in array)
			{
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeFromHandle, text, (Type[])null, (Type[])null) ?? AccessTools.Method(typeFromHandle, text, (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo.ReturnType == typeof(string) && !methodInfo.IsStatic)
				{
					return methodInfo;
				}
			}
			MethodInfo[] methods = typeFromHandle.GetMethods(bindingAttr);
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (!methodInfo2.IsStatic && !(methodInfo2.ReturnType != typeof(string)))
				{
					string text2 = methodInfo2.Name ?? "";
					if (text2.IndexOf("Decor", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("Name", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return methodInfo2;
					}
				}
			}
			if (!_loggedMissing)
			{
				_loggedMissing = true;
				Debug.LogWarning((object)"[DrakesRenameIt] Upgrade list rename: no suitable ItemData decorated-name method found; upgrade tab names may remain vanilla.");
			}
			return null;
		}

		[HarmonyPostfix]
		private static void Postfix(ItemData __instance, ref string __result)
		{
			if (__instance?.m_shared == null || string.IsNullOrEmpty(__result) || !DrakeRenameit.hasNewName(__instance))
			{
				return;
			}
			string text = ((Localization.instance != null) ? Localization.instance.Localize(__instance.m_shared.m_name) : __instance.m_shared.m_name);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string displayNameForUi = DrakeRenameit.GetDisplayNameForUi(__instance, localize: true);
			if (!string.IsNullOrEmpty(displayNameForUi))
			{
				if (__result.Contains(text))
				{
					__result = __result.Replace(text, displayNameForUi);
				}
				else if (!string.IsNullOrEmpty(__instance.m_shared.m_name) && __result.Contains(__instance.m_shared.m_name))
				{
					__result = __result.Replace(__instance.m_shared.m_name, displayNameForUi);
				}
			}
		}
	}
	internal static class HoverRenameHelper
	{
		internal static void ApplyRenameToHoverResult(ref string __result, ItemData item)
		{
			if (item?.m_shared == null || string.IsNullOrEmpty(__result) || !DrakeRenameit.hasNewName(item))
			{
				return;
			}
			string displayNameForUi = DrakeRenameit.GetDisplayNameForUi(item, localize: false);
			if (displayNameForUi == null || item.m_shared.m_name == null)
			{
				return;
			}
			if (Localization.instance == null)
			{
				__result = __result.Replace(item.m_shared.m_name, displayNameForUi);
				return;
			}
			string text = Localization.instance.Localize(item.m_shared.m_name);
			string newValue = Localization.instance.Localize(displayNameForUi);
			if (__result.Contains(text))
			{
				__result = __result.Replace(text, newValue);
			}
		}
	}
	internal static class PickupHudMessageHelper
	{
		internal static bool TryGetLocalizedCustomNameForHud(ItemData? item, out string localizedName)
		{
			localizedName = "";
			if (item?.m_shared == null || !DrakeRenameit.hasNewName(item))
			{
				return false;
			}
			localizedName = DrakeRenameit.GetDisplayNameForUi(item, localize: true);
			if (string.IsNullOrEmpty(localizedName))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "ShowPickupMessage")]
	internal static class CharacterShowPickupMessagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance, ItemData item, int amount)
		{
			if (!PickupHudMessageHelper.TryGetLocalizedCustomNameForHud(item, out string localizedName))
			{
				return true;
			}
			__instance.Message((MessageType)1, "$msg_added " + localizedName, amount, item.GetIcon());
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "ShowRemovedMessage")]
	internal static class CharacterShowRemovedMessagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance, ItemData item, int amount)
		{
			if (!PickupHudMessageHelper.TryGetLocalizedCustomNameForHud(item, out string localizedName))
			{
				return true;
			}
			__instance.Message((MessageType)1, "$msg_removed " + localizedName, amount, item.GetIcon());
			return false;
		}
	}
	public static class Patches
	{
		[HarmonyPatch(typeof(ItemDrop))]
		public static class HoverTextPatch
		{
			[HarmonyPatch("GetHoverText")]
			[HarmonyPostfix]
			private static void FixHoverText(ItemDrop __instance, ref string __result)
			{
				ItemData itemData = __instance.m_itemData;
				if (itemData != null && __instance?.m_itemData?.m_shared != null && !string.IsNullOrEmpty(__result))
				{
					HoverRenameHelper.ApplyRenameToHoverResult(ref __result, itemData);
				}
			}

			[HarmonyPatch(typeof(ItemDrop), "GetHoverName")]
			[HarmonyPostfix]
			private static void FixHoverName(ItemDrop __instance, ref string __result)
			{
				ItemData val = __instance?.m_itemData;
				if (val != null && DrakeRenameit.hasNewName(val))
				{
					string displayNameForUi = DrakeRenameit.GetDisplayNameForUi(val, localize: false);
					if (!string.IsNullOrEmpty(displayNameForUi))
					{
						__result = displayNameForUi;
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui))]
		public static class PatchInventoryGuiAwake
		{
			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			private static void RenameGrab(InventoryGui __instance)
			{
				Action<InventoryGrid, ItemData, Vector2i> original = __instance.m_playerGrid.m_onRightClick;
				__instance.m_playerGrid.m_onRightClick = delegate(InventoryGrid grid, ItemData item, Vector2i pos)
				{
					//IL_0074: Unknown result type (might be due to invalid IL or missing references)
					if (item != null && DrakeRenameit.IsMenuOpenModifierHeld())
					{
						if (DrakeRenameit.ShowUnlockButton(item))
						{
							UIPanels.OpenUnlockMenuFromInventory(item);
						}
						else if (DrakeRenameit.AnyInventoryActionAvailable(item))
						{
							UIPanels.OpenActionMenu(item);
						}
						else
						{
							string menuBlockedReason = DrakeRenameit.GetMenuBlockedReason(item);
							if (!string.IsNullOrEmpty(menuBlockedReason))
							{
								Player localPlayer = Player.m_localPlayer;
								if (localPlayer != null)
								{
									((Character)localPlayer).Message((MessageType)2, menuBlockedReason, 0, (Sprite)null);
								}
							}
						}
					}
					else
					{
						original?.Invoke(grid, item, pos);
					}
				};
			}

			[HarmonyPatch("DoCrafting")]
			[HarmonyPostfix]
			private static void FixCrafting(InventoryGui __instance, Player player)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				object? obj = AccessTools.Field(typeof(InventoryGui), "m_craftRecipe")?.GetValue(__instance);
				Recipe val = (Recipe)((obj is Recipe) ? obj : null);
				ItemData oldItem = (ItemData)AccessTools.Field(typeof(InventoryGui), "m_craftUpgradeItem").GetValue(__instance);
				if ((Object)(object)val == (Object)null || oldItem == null)
				{
					return;
				}
				Inventory inventory = ((Humanoid)player).GetInventory();
				ItemData val2 = inventory.GetItemAt(oldItem.m_gridPos.x, oldItem.m_gridPos.y);
				if (val2 == null)
				{
					val2 = ((IEnumerable<ItemData>)inventory.GetAllItems()).LastOrDefault((Func<ItemData, bool>)((ItemData i) => i.m_shared.m_name == oldItem.m_shared.m_name && i.m_quality > oldItem.m_quality));
				}
				if (val2 == null)
				{
					return;
				}
				foreach (KeyValuePair<string, string> customDatum in oldItem.m_customData)
				{
					val2.m_customData[customDatum.Key] = customDatum.Value;
				}
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip")]
	public static class InventoryGridTooltipPatch
	{
		[HarmonyPostfix]
		private static void UpdateToolTip(InventoryGrid __instance, ItemData? item, UITooltip tooltip)
		{
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			if (item?.m_shared == null || (Object)(object)tooltip == (Object)null)
			{
				return;
			}
			string text = TooltipRichText.EnsureRichTextTagsClosedForTooltip(DrakeRenameit.GetPropperName(item) ?? item.m_shared.m_name);
			string tooltip2 = item.GetTooltip(-1);
			tooltip2 = ItemTooltipPatches.ApplyCraftedByDisplayToTooltipText(tooltip2, item);
			tooltip2 = UpdateDescription(item, tooltip2);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("\n");
			string menuHintColor = RenameitConfig.MenuHintColor;
			string text2 = (RenameitConfig.MenuModifierIsShift ? "Shift" : "Ctrl");
			string menuTooltipLockSuffix = DrakeRenameit.GetMenuTooltipLockSuffix(item);
			bool flag = DrakeRenameit.AnyInventoryActionAvailable(item);
			bool flag2 = (Object)(object)Player.m_localPlayer != (Object)null && RenameitPermission.IsElevatedForOverrides(Player.m_localPlayer);
			if (flag)
			{
				stringBuilder.AppendLine("<color=" + menuHintColor + "><b>" + text2 + " + Right Click for options" + menuTooltipLockSuffix + "</b></color>");
			}
			else if (flag2)
			{
				stringBuilder.AppendLine("<color=" + menuHintColor + "><b>" + text2 + " + Right Click for options" + menuTooltipLockSuffix + "</b></color><color=blue> Elevated override</color>");
			}
			else
			{
				string text3 = BuildNoDrakeMenuHint(item);
				stringBuilder.AppendLine("<color=red><s>" + text2 + " + Right Click for options" + menuTooltipLockSuffix + "</s></color>");
				if (!string.IsNullOrEmpty(text3))
				{
					stringBuilder.AppendLine("<color=red>" + text3 + "</color>");
				}
			}
			tooltip.Set(text, tooltip2 + stringBuilder, __instance.m_tooltipAnchor, default(Vector2));
		}

		private static string BuildNoDrakeMenuHint(ItemData item)
		{
			List<string> list = new List<string>();
			if (!DrakeRenameit.CanChangeName(item))
			{
				list.Add(RenamePermissionManager.GetTooltipDisabledHint(RenamePermissionOperation.RenameItemName, item));
			}
			if (!DrakeRenameit.CanChangeDesc(item))
			{
				list.Add(RenamePermissionManager.GetTooltipDisabledHint(RenamePermissionOperation.RewriteDescription, item));
			}
			if (!DrakeRenameit.CanChangeCraftedByLabel(item))
			{
				list.Add(RenamePermissionManager.GetTooltipDisabledHint(RenamePermissionOperation.EditCraftedByLabel, item));
			}
			return string.Join("<br>", list.Distinct());
		}

		private static string UpdateDescription(ItemData? item, string currentText)
		{
			if (item?.m_shared == null)
			{
				return currentText;
			}
			if (DrakeRenameit.hasNewDesc(item))
			{
				string newValue = TooltipRichText.EnsureRichTextTagsClosedForTooltip(DrakeRenameit.getPropperDesc(item, item.m_shared.m_description));
				string description = item.m_shared.m_description;
				if (!string.IsNullOrEmpty(description) && currentText.Contains(description))
				{
					currentText = currentText.Replace(description, newValue);
				}
			}
			return currentText;
		}
	}
	[HarmonyPatch(typeof(ItemStand))]
	public static class ItemStandPatch
	{
		private const string ItemStandRenameZdoKey = "DrakeRenameIt_CustomName";

		private static ItemData? TryGetStandOccupantItem(ItemStand stand)
		{
			if ((Object)(object)stand == (Object)null)
			{
				return null;
			}
			ItemData val = TryGetFirstContainerItem(stand);
			if (val?.m_shared != null)
			{
				return val;
			}
			object? obj = AccessTools.Method(typeof(ItemStand), "GetAttachedItem", Type.EmptyTypes, (Type[])null)?.Invoke(stand, null);
			ItemData val2 = (ItemData)((obj is ItemData) ? obj : null);
			if (val2 != null && val2.m_shared != null)
			{
				return val2;
			}
			return null;
		}

		private static void SyncItemStandRenameZdoFromOccupant(ItemStand stand, ZDO zdo, string itemName)
		{
			if (string.IsNullOrEmpty(itemName))
			{
				zdo.Set("DrakeRenameIt_CustomName", string.Empty);
				return;
			}
			ItemData val = TryGetStandOccupantItem(stand);
			if (val?.m_shared != null && DrakeRenameit.hasNewName(val))
			{
				string displayNameForUi = DrakeRenameit.GetDisplayNameForUi(val, localize: false);
				zdo.Set("DrakeRenameIt_CustomName", TooltipRichText.EnsureRichTextTagsClosedForTooltip(displayNameForUi));
			}
		}

		private static bool ItemStandHadVisualBeforeUse(ItemStand stand)
		{
			if ((Object)(object)stand == (Object)null)
			{
				return false;
			}
			string value = AccessTools.Field(typeof(ItemStand), "m_visualName")?.GetValue(stand) as string;
			return !string.IsNullOrEmpty(value);
		}

		private static string TryGetStandCustomNameFromZdo(ItemStand stand)
		{
			if ((Object)(object)stand == (Object)null)
			{
				return "";
			}
			object? obj = AccessTools.Field(typeof(ItemStand), "m_nview")?.GetValue(stand);
			ZNetView val = (ZNetView)((obj is ZNetView) ? obj : null);
			ZDO val2 = ((val != null) ? val.GetZDO() : null);
			if (val2 == null)
			{
				return "";
			}
			string @string = val2.GetString("DrakeRenameIt_CustomName", "");
			if (string.IsNullOrWhiteSpace(@string))
			{
				return "";
			}
			string text = TooltipRichText.EnsureRichTextTagsClosedForTooltip(@string);
			return (Localization.instance != null) ? Localization.instance.Localize(text) : text;
		}

		private static string TryGetStandCurrentItemName(ItemStand stand)
		{
			if ((Object)(object)stand == (Object)null)
			{
				return "";
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(ItemStand), "m_currentItemName");
			if (fieldInfo == null)
			{
				return "";
			}
			string text = fieldInfo.GetValue(stand) as string;
			if (string.IsNullOrWhiteSpace(text))
			{
				return "";
			}
			string text2 = TooltipRichText.EnsureRichTextTagsClosedForTooltip(text);
			return (Localization.instance != null) ? Localization.instance.Localize(text2) : text2;
		}

		private static bool HoverTextContainsNoAccess(string hoverText)
		{
			if (string.IsNullOrEmpty(hoverText))
			{
				return false;
			}
			if (hoverText.Contains("$piece_noaccess"))
			{
				return true;
			}
			if (Localization.instance == null)
			{
				return false;
			}
			string value = Localization.instance.Localize("$piece_noaccess");
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			return hoverText.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static ItemData? TryGetFirstContainerItem(ItemStand stand)
		{
			Container component = ((Component)stand).GetComponent<Container>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			Inventory inventory = component.GetInventory();
			if (inventory == null)
			{
				return null;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			if (allItems == null || allItems.Count == 0)
			{
				return null;
			}
			return allItems[0];
		}

		private static string TryGetBestStandLabel(ItemStand stand)
		{
			string text = TryGetStandCurrentItemName(stand);
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			text = TryGetStandCustomNameFromZdo(stand);
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			ItemData val = TryGetFirstContainerItem(stand);
			if (val?.m_shared == null)
			{
				return "";
			}
			return DrakeRenameit.GetDisplayNameForUi(val, localize: true);
		}

		[HarmonyPatch("GetHoverText")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void FixItemStandHoverText(ItemStand __instance, ref string __result)
		{
			if ((Object)(object)__instance == (Object)null || string.IsNullOrEmpty(__result))
			{
				return;
			}
			if (HoverTextContainsNoAccess(__result))
			{
				if (RenameitConfig.ShowItemStandItemNameWhenNoAccess)
				{
					string text = TryGetBestStandLabel(__instance);
					if (!string.IsNullOrEmpty(text) && __result.IndexOf(text, StringComparison.Ordinal) < 0)
					{
						__result = text + "\n" + __result;
					}
				}
			}
			else
			{
				ItemData val = TryGetFirstContainerItem(__instance);
				if (val?.m_shared != null && DrakeRenameit.hasNewName(val))
				{
					HoverRenameHelper.ApplyRenameToHoverResult(ref __result, val);
				}
			}
		}

		[HarmonyPatch("UseItem")]
		[HarmonyPrefix]
		private static void UseItem_Prefix(ItemStand __instance, out bool __state)
		{
			__state = ItemStandHadVisualBeforeUse(__instance);
		}

		[HarmonyPatch("UseItem")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void GrabItem(ItemStand __instance, Humanoid user, ItemData? item, bool __state)
		{
			if (item?.m_shared == null)
			{
				return;
			}
			object? obj = AccessTools.Field(typeof(ItemStand), "m_nview")?.GetValue(__instance);
			ZNetView val = (ZNetView)((obj is ZNetView) ? obj : null);
			ZDO val2 = ((val != null) ? val.GetZDO() : null);
			if (val2 == null)
			{
				return;
			}
			Inventory val3 = ((user != null) ? user.GetInventory() : null);
			if (__state && val3 != null && val3.ContainsItem(item))
			{
				val2.Set("DrakeRenameIt_CustomName", string.Empty);
				return;
			}
			string displayNameForUi = DrakeRenameit.GetDisplayNameForUi(item, localize: false);
			if (DrakeRenameit.hasNewName(item) || displayNameForUi != item.m_shared.m_name)
			{
				val2.Set("DrakeRenameIt_CustomName", TooltipRichText.EnsureRichTextTagsClosedForTooltip(displayNameForUi));
			}
			else
			{
				val2.Set("DrakeRenameIt_CustomName", string.Empty);
			}
		}

		[HarmonyPatch("SetVisualItem")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void FixStandText(ItemStand __instance, string itemName, int variant, int quality)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			object obj = AccessTools.Field(typeof(ItemStand), "m_nview")?.GetValue(__instance);
			ZNetView val = (ZNetView)((obj is ZNetView) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			ZDO zDO = val.GetZDO();
			if (zDO != null)
			{
				SyncItemStandRenameZdoFromOccupant(__instance, zDO, itemName);
				string value = TooltipRichText.EnsureRichTextTagsClosedForTooltip(zDO.GetString("DrakeRenameIt_CustomName", ""));
				if (!string.IsNullOrEmpty(value))
				{
					AccessTools.Field(typeof(ItemStand), "m_currentItemName")?.SetValue(__instance, value);
				}
			}
		}
	}
	internal static class DropHudMessagePatches
	{
		private static ItemData? PendingDroppedItem;

		private static float PendingDroppedItemSetAt;

		private const float PendingDroppedItemTtlSeconds = 2.5f;

		internal static void ApplyDropItemPendingCapture(Harmony harmony, ManualLogSource log)
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			try
			{
				Type[] array = new Type[3]
				{
					typeof(Inventory),
					typeof(ItemData),
					typeof(int)
				};
				MethodInfo methodInfo = AccessTools.Method(typeof(Humanoid), "DropItem", array, (Type[])null) ?? AccessTools.DeclaredMethod(typeof(Humanoid), "DropItem", array, (Type[])null);
				if (methodInfo == null)
				{
					MethodInfo[] methods = typeof(Humanoid).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo2 in methods)
					{
						if (!(methodInfo2.Name != "DropItem"))
						{
							ParameterInfo[] parameters = methodInfo2.GetParameters();
							if (parameters.Length == 3 && parameters[0].ParameterType == typeof(Inventory) && parameters[1].ParameterType == typeof(ItemData) && parameters[2].ParameterType == typeof(int))
							{
								methodInfo = methodInfo2;
								break;
							}
						}
					}
				}
				if (methodInfo == null)
				{
					log.LogWarning((object)"[DrakesRenameIt] Drop HUD: Humanoid.DropItem(Inventory,ItemData,int) not found.");
					return;
				}
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(DropHudMessagePatches), "HumanoidDropItemTypedPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				log.LogInfo((object)("[DrakesRenameIt] Drop HUD: patched typed " + methodInfo.DeclaringType?.Name + "." + methodInfo.Name));
			}
			catch (Exception ex)
			{
				log.LogError((object)("[DrakesRenameIt] Drop HUD: typed DropItem patch failed: " + ex));
			}
		}

		private static void HumanoidDropItemTypedPrefix(Inventory inventory, ItemData item, int amount)
		{
			PendingDroppedItem = item;
			PendingDroppedItemSetAt = Time.time;
		}

		internal static void TryRewriteDroppedMessage(ref string msg)
		{
			ItemData pendingDroppedItem = PendingDroppedItem;
			if (pendingDroppedItem?.m_shared == null || string.IsNullOrEmpty(msg))
			{
				return;
			}
			float num = Time.time - PendingDroppedItemSetAt;
			if (num > 2.5f)
			{
				PendingDroppedItem = null;
				return;
			}
			string text = "$msg_dropped";
			string text2 = ((Localization.instance != null) ? Localization.instance.Localize(text) : text);
			bool flag = msg.IndexOf(text, StringComparison.Ordinal) >= 0;
			bool flag2 = msg.IndexOf(text2, StringComparison.OrdinalIgnoreCase) >= 0;
			bool flag3 = DrakeRenameit.hasNewName(pendingDroppedItem) && msg.IndexOf("drop", StringComparison.OrdinalIgnoreCase) >= 0 && msg.Length < 280;
			if (!flag && !flag2 && !flag3)
			{
				return;
			}
			string text3 = ((Localization.instance != null) ? Localization.instance.Localize(pendingDroppedItem.m_shared.m_name) : pendingDroppedItem.m_shared.m_name);
			string displayNameLocalized = (DrakeRenameit.hasNewName(pendingDroppedItem) ? DrakeRenameit.GetDisplayNameForUi(pendingDroppedItem, localize: true) : ((Localization.instance != null) ? Localization.instance.Localize(TooltipRichText.EnsureRichTextTagsClosedForTooltip(pendingDroppedItem.m_shared.m_name)) : TooltipRichText.EnsureRichTextTagsClosedForTooltip(pendingDroppedItem.m_shared.m_name)));
			if (string.IsNullOrEmpty(displayNameLocalized))
			{
				return;
			}
			if (DrakeRenameit.hasNewName(pendingDroppedItem) && msg.StartsWith("$msg_dropped ", StringComparison.Ordinal) && !string.IsNullOrEmpty(pendingDroppedItem.m_shared.m_name))
			{
				string a = msg.Substring("$msg_dropped ".Length).TrimStart(Array.Empty<char>());
				if (string.Equals(a, pendingDroppedItem.m_shared.m_name, StringComparison.Ordinal))
				{
					msg = "$msg_dropped " + displayNameLocalized;
					PendingDroppedItem = null;
					return;
				}
			}
			if (!string.IsNullOrEmpty(text3))
			{
				try
				{
					Regex regex = new Regex(Regex.Escape(text3), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, TimeSpan.FromMilliseconds(250.0));
					if (regex.IsMatch(msg))
					{
						msg = regex.Replace(msg, (Match _) => displayNameLocalized, 1);
						PendingDroppedItem = null;
						return;
					}
				}
				catch (RegexMatchTimeoutException)
				{
				}
			}
			if (!string.IsNullOrEmpty(pendingDroppedItem.m_shared.m_name))
			{
				try
				{
					Regex regex2 = new Regex(Regex.Escape(pendingDroppedItem.m_shared.m_name), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, TimeSpan.FromMilliseconds(250.0));
					if (regex2.IsMatch(msg))
					{
						msg = regex2.Replace(msg, (Match _) => displayNameLocalized, 1);
						PendingDroppedItem = null;
						return;
					}
				}
				catch (RegexMatchTimeoutException)
				{
				}
			}
			if (string.Equals(msg, text, StringComparison.Ordinal) || string.Equals(msg, text2, StringComparison.OrdinalIgnoreCase))
			{
				msg = (string.Equals(msg, text, StringComparison.Ordinal) ? (text + " " + displayNameLocalized) : (text2 + " " + displayNameLocalized));
				PendingDroppedItem = null;
			}
		}

		internal static void ApplyMessageHudShowMessage(Harmony harmony, ManualLogSource log)
		{
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			try
			{
				Type typeFromHandle = typeof(MessageHud);
				Type type = AccessTools.Inner(typeFromHandle, "MessageType") ?? typeFromHandle.GetNestedType("MessageType", BindingFlags.Public | BindingFlags.NonPublic);
				if (type == null)
				{
					log.LogWarning((object)"[DrakesRenameIt] Drop HUD: MessageHud.MessageType nested type not found.");
					return;
				}
				MethodBase methodBase = null;
				MethodInfo[] methods = typeFromHandle.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.Name != "ShowMessage")
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length >= 2 && !(parameters[0].ParameterType != type) && !(parameters[1].ParameterType != typeof(string)))
					{
						if (parameters.Length == 4 && parameters[2].ParameterType == typeof(int) && parameters[3].ParameterType == typeof(Sprite))
						{
							methodBase = methodInfo;
							break;
						}
						if ((object)methodBase == null)
						{
							methodBase = methodInfo;
						}
					}
				}
				if (methodBase == null)
				{
					log.LogWarning((object)"[DrakesRenameIt] Drop HUD: no suitable MessageHud.ShowMessage overload found.");
					return;
				}
				int num = -1;
				ParameterInfo[] parameters2 = methodBase.GetParameters();
				for (int j = 0; j < parameters2.Length; j++)
				{
					if (parameters2[j].ParameterType == typeof(string))
					{
						num = j;
						break;
					}
				}
				if (num < 0)
				{
					log.LogWarning((object)("[DrakesRenameIt] Drop HUD: ShowMessage overload has no string parameter: " + methodBase));
					return;
				}
				HarmonyMethod val = ((num == 0) ? new HarmonyMethod(typeof(DropHudMessagePatches), "MessageHudShowMessageStringArg0", (Type[])null) : new HarmonyMethod(typeof(DropHudMessagePatches), "MessageHudShowMessageStringArg1", (Type[])null));
				harmony.Patch(methodBase, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				log.LogInfo((object)("[DrakesRenameIt] Drop HUD: patched MessageHud." + methodBase.Name + " stringArg=" + num + " :: " + methodBase));
			}
			catch (Exception ex)
			{
				log.LogError((object)("[DrakesRenameIt] Drop HUD: MessageHud patch failed: " + ex));
			}
		}

		private static void MessageHudShowMessageStringArg0(ref string __0)
		{
			TryRewriteDroppedMessage(ref __0);
		}

		private static void MessageHudShowMessageStringArg1(ref string __1)
		{
			TryRewriteDroppedMessage(ref __1);
		}

		[HarmonyPatch(typeof(Character), "Message", new Type[]
		{
			typeof(MessageType),
			typeof(string),
			typeof(int),
			typeof(Sprite)
		})]
		[HarmonyPrefix]
		private static void CharacterMessagePrefix(MessageType type, ref string msg)
		{
			TryRewriteDroppedMessage(ref msg);
		}

		[HarmonyPatch(typeof(Player), "Message", new Type[]
		{
			typeof(MessageType),
			typeof(string),
			typeof(int),
			typeof(Sprite)
		})]
		[HarmonyPrefix]
		private static void PlayerMessagePrefix(MessageType type, ref string msg)
		{
			TryRewriteDroppedMessage(ref msg);
		}
	}
}
namespace DrakeRenameit.Permissions
{
	public static class ExcludedCategoryAliases
	{
		public static readonly string[] AllKeys = new string[8] { "armor", "weapons", "tools", "ranged", "melee", "shields", "ammo", "fish" };
	}
	internal static class ExcludedCategoryReferenceWriter
	{
		private const string FileName = "ExcludedCategoryReference.txt";

		internal static void EnsureGenerated()
		{
			try
			{
				string text = Path.Combine(Paths.ConfigPath, "com.DrakeMods.DrakesRenameit");
				Directory.CreateDirectory(text);
				string path = Path.Combine(text, "ExcludedCategoryReference.txt");
				string value = "# DrakeRenameit 0.9.1";
				if (File.Exists(path))
				{
					try
					{
						string text2 = File.ReadAllText(path);
						if (text2.Length > 2048)
						{
							text2 = text2.Substring(0, 2048);
						}
						if (text2.IndexOf(value, StringComparison.Ordinal) >= 0)
						{
							return;
						}
					}
					catch
					{
					}
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine(value);
				stringBuilder.AppendLine("# Auto-generated. Lists valid ExcludedCategory tokens: SkillType, ItemType, and aliases.");
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("## Skills.SkillType");
				foreach (string item in Enum.GetNames(typeof(SkillType)).OrderBy<string, string>((string n) => n, StringComparer.Ordinal))
				{
					stringBuilder.AppendLine(item);
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("## ItemDrop.ItemData.ItemType");
				foreach (string item2 in Enum.GetNames(typeof(ItemType)).OrderBy<string, string>((string n) => n, StringComparer.Ordinal))
				{
					stringBuilder.AppendLine(item2);
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("## Aliases (see ExcludedCategoryAliases)");
				foreach (string item3 in ExcludedCategoryAliases.AllKeys.OrderBy<string, string>((string k) => k, StringComparer.OrdinalIgnoreCase))
				{
					stringBuilder.AppendLine(item3);
				}
				File.WriteAllText(path, stringBuilder.ToString(), Encoding.UTF8);
			}
			catch
			{
			}
		}
	}
	internal static class RenameExclusionRules
	{
		[CompilerGenerated]
		private sealed class <SplitList>d__5 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string csv;

			public string <>3__csv;

			private string[] <>s__1;

			private int <>s__2;

			private string <part>5__3;

			private string <t>5__4;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SplitList>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = null;
				<part>5__3 = null;
				<t>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00ae;
				}
				<>1__state = -1;
				if (string.IsNullOrWhiteSpace(csv))
				{
					return false;
				}
				<>s__1 = csv.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				<>s__2 = 0;
				goto IL_00cb;
				IL_00ae:
				<t>5__4 = null;
				<part>5__3 = null;
				<>s__2++;
				goto IL_00cb;
				IL_00cb:
				if (<>s__2 < <>s__1.Length)
				{
					<part>5__3 = <>s__1[<>s__2];
					<t>5__4 = <part>5__3.Trim();
					if (<t>5__4.Length > 0)
					{
						<>2__current = <t>5__4;
						<>1__state = 1;
						return true;
					}
					goto IL_00ae;
				}
				<>s__1 = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<SplitList>d__5 <SplitList>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SplitList>d__ = this;
				}
				else
				{
					<SplitList>d__ = new <SplitList>d__5(0);
				}
				<SplitList>d__.csv = <>3__csv;
				return <SplitList>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		public static bool MatchesRenameAllowlist(ItemData? item)
		{
			ItemData item2 = item;
			if (item2?.m_shared == null)
			{
				return false;
			}
			return SplitList(RenameitConfig.RenameAllowlist).Any((string token) => TokenMatchesItemName(item2, token));
		}

		public static bool MatchesExcludedName(ItemData? item)
		{
			ItemData item2 = item;
			if (item2?.m_shared == null)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(RenameitConfig.ExcludedNames))
			{
				return false;
			}
			return SplitList(RenameitConfig.ExcludedNames).Any((string token) => TokenMatchesItemName(item2, token));
		}

		private static bool TokenMatchesItemName(ItemData item, string token)
		{
			if (item.m_shared == null)
			{
				return false;
			}
			string name = item.m_shared.m_name;
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (name.Equals(token, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null && !string.IsNullOrEmpty(((Object)item.m_dropPrefab).name) && ((Object)item.m_dropPrefab).name.Equals(token, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (Localization.instance != null)
			{
				string text = Localization.instance.Localize(name);
				if (!string.IsNullOrEmpty(text) && text.Equals(token, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static bool MatchesExcludedCategory(ItemData? item)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(RenameitConfig.ExcludedCategory))
			{
				return false;
			}
			string[] array = RenameitConfig.ExcludedCategory.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length != 0 && MatchesCategoryToken(item, text2))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsExcludedFromConfig(ItemData? item)
		{
			return MatchesExcludedName(item) || MatchesExcludedCategory(item);
		}

		[IteratorStateMachine(typeof(<SplitList>d__5))]
		private static IEnumerable<string> SplitList(string? csv)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SplitList>d__5(-2)
			{
				<>3__csv = csv
			};
		}

		private static bool MatchesCategoryToken(ItemData item, string token)
		{
			//IL_003b: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			if (item.m_shared == null)
			{
				return false;
			}
			if (TryAlias(item, token))
			{
				return true;
			}
			if (Enum.TryParse<SkillType>(token, ignoreCase: true, out SkillType result) && Enum.IsDefined(typeof(SkillType), result) && item.m_shared.m_skillType == result)
			{
				return true;
			}
			if (Enum.TryParse<ItemType>(token, ignoreCase: true, out ItemType result2) && Enum.IsDefined(typeof(ItemType), result2) && item.m_shared.m_itemType == result2)
			{
				return true;
			}
			return false;
		}

		private static bool TryAlias(ItemData item, string token)
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Invalid comparison between Unknown and I4
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Invalid comparison between Unknown and I4
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Invalid comparison between Unknown and I4
			if (item.m_shared == null)
			{
				return false;
			}
			return token.Trim().ToLowerInvariant() switch
			{
				"armor" => IsArmor(item), 
				"weapons" => IsWeapon(item), 
				"tools" => IsTools(item), 
				"ranged" => IsRanged(item), 
				"melee" => IsMelee(item), 
				"shields" => (int)item.m_shared.m_itemType == 5, 
				"ammo" => (int)item.m_shared.m_itemType == 9, 
				"fish" => (int)item.m_shared.m_itemType == 21, 
				_ => false, 
			};
		}

		private static bool IsArmor(ItemData item)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			ItemType itemType = item.m_shared.m_itemType;
			if (itemType - 6 <= 1 || (int)itemType == 11 || (int)itemType == 17)
			{
				return true;
			}
			return false;
		}

		private static bool IsWeapon(ItemData item)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			ItemType itemType = item.m_shared.m_itemType;
			if (itemType - 3 <= 1 || (int)itemType == 14 || (int)itemType == 22)
			{
				return true;
			}
			return false;
		}

		private static bool IsRanged(ItemData item)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			SharedData shared = item.m_shared;
			ItemType itemType = shared.m_itemType;
			bool flag = (((int)itemType == 4 || (int)itemType == 9) ? true : false);
			bool flag2 = flag;
			bool flag3 = flag2;
			if (!flag3)
			{
				SkillType skillType = shared.m_skillType;
				bool flag4 = (((int)skillType == 8 || (int)skillType == 14) ? true : false);
				flag3 = flag4;
			}
			return flag3;
		}

		private static bool IsMelee(ItemData item)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected I4, but got Unknown
			SkillType skillType = item.m_shared.m_skillType;
			switch (skillType - 1)
			{
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 6:
			case 10:
			case 11:
				return true;
			default:
				return false;
			}
		}

		private static bool IsTools(ItemData item)
		{
			//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_000d: 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_0012: Invalid comparison between Unknown and I4
			SkillType skillType = item.m_shared.m_skillType;
			if (skillType - 12 <= 1)
			{
				return true;
			}
			return false;
		}
	}
	[Flags]
	public enum RenameDenialReason
	{
		None = 0,
		GlobalRenameDisabled = 1,
		GlobalDescDisabled = 2,
		NotOwner = 4,
		UncraftedResourceBlocked = 8,
		ExcludedByName = 0x10,
		ExcludedByCategory = 0x20,
		GlobalCraftedByDisabled = 0x40,
		UnlockCostRequired = 0x80
	}
	public enum RenamePermissionOperation
	{
		RenameItemName,
		RewriteDescription,
		EditCraftedByLabel
	}
	public readonly struct RenamePermissionResult
	{
		public readonly bool Allowed;

		public readonly RenameDenialReason Reasons;

		public RenamePermissionResult(bool allowed, RenameDenialReason reasons)
		{
			Allowed = allowed;
			Reasons = reasons;
		}
	}
	public static class RenamePermissionManager
	{
		private static ManualLogSource? _log;

		private static int _ignoreUnlockRequirementDepth;

		internal static void Init(ManualLogSource logSource)
		{
			_log = logSource;
		}

		internal static void BeginIgnoreUnlockRequirement()
		{
			_ignoreUnlockRequirementDepth++;
		}

		internal static void EndIgnoreUnlockRequirement()
		{
			if (_ignoreUnlockRequirementDepth > 0)
			{
				_ignoreUnlockRequirementDepth--;
			}
		}

		public static RenamePermissionResult TryGetDenial(RenamePermissionOperation op, ItemData? item, Player? local, bool logDenied = false)
		{
			if ((Object)(object)local == (Object)null)
			{
				if (logDenied)
				{
					LogDenied(op, item, RenameDenialReason.None, "No local player.");
				}
				return new RenamePermissionResult(allowed: false, RenameDenialReason.None);
			}
			if (RenameitPermission.IsElevatedForOverrides(local))
			{
				LogAllowed(op, item, "Elevated (admin/VIP per config).");
				return new RenamePermissionResult(allowed: true, RenameDenialReason.None);
			}
			switch (op)
			{
			case RenamePermissionOperation.RenameItemName:
				if (!RenameitConfig.RenameEnabled)
				{
					RenameDenialReason reasons3 = RenameDenialReason.GlobalRenameDisabled;
					if (logDenied)
					{
						LogDenied(op, item, reasons3, "RenameEnabled is false and player is not elevated.");
					}
					return new RenamePermissionResult(allowed: false, reasons3);
				}
				break;
			case RenamePermissionOperation.RewriteDescription:
				if (!RenameitConfig.RewriteDescriptionsEnabled)
				{
					RenameDenialReason reasons2 = RenameDenialReason.GlobalDescDisabled;
					if (logDenied)
					{
						LogDenied(op, item, reasons2, "RewriteDescriptionsEnabled is false and player is not elevated.");
					}
					return new RenamePermissionResult(allowed: false, reasons2);
				}
				break;
			case RenamePermissionOperation.EditCraftedByLabel:
				if (!RenameitConfig.CraftedByLabelEnabled)
				{
					RenameDenialReason reasons = RenameDenialReason.GlobalCraftedByDisabled;
					if (logDenied)
					{
						LogDenied(op, item, reasons, "CraftedByLabelEnabled is false and player is not elevated.");
					}
					return new RenamePermissionResult(allowed: false, reasons);
				}
				break;
			}
			return EvaluateItemRules(op, item, local, logDenied);
		}

		public static RenamePermissionResult Evaluate(RenamePermissionOperation op, ItemData? item, Player? local, bool showErrorToPlayer)
		{
			RenamePermissionResult result = TryGetDenial(op, item, local, showErrorToPlayer);
			if (!result.Allowed && showErrorToPlayer && (Object)(object)local != (Object)null)
			{
				((Character)local).Message((MessageType)2, FormatDenialForPlayer(op, result.Reasons), 0, (Sprite)null);
			}
			return result;
		}

		private static RenamePermissionResult EvaluateItemRules(RenamePermissionOperation op, ItemData? item, Player local, bool logDenied)
		{
			if (item?.m_shared == null)
			{
				if (logDenied)
				{
					LogDenied(op, item, RenameDenialReason.None, "Item or shared data null.");
				}
				return new RenamePermissionResult(allowed: false, RenameDenialReason.None);
			}
			if (RenameitConfig.LockToOwner && !PassesOwnerLock(item, local))
			{
				RenameDenialReason reasons = RenameDenialReason.NotOwner;
				if (logDenied)
				{
					LogDenied(op, item, reasons, $"Owner lock: crafterID={item.m_crafterID} crafterName={item.m_crafterName} local={local.GetPlayerID()}.");
				}
				return new RenamePermissionResult(allowed: false, reasons);
			}
			if (RenameExclusionRules.MatchesRenameAllowlist(item))
			{
				LogAllowed(op, item, "On RenameAllowlist; skipping exclusions / resource rule.");
				return new RenamePermissionResult(allowed: true, RenameDenialReason.None);
			}
			if (RenameExclusionRules.MatchesExcludedName(item))
			{
				RenameDenialReason reasons2 = RenameDenialReason.ExcludedByName;
				if (logDenied)
				{
					LogDenied(op, item, reasons2, "Excluded by name. Item=" + item.m_shared.m_name);
				}
				return new RenamePermissionResult(allowed: false, reasons2);
			}
			if (RenameExclusionRules.MatchesExcludedCategory(item))
			{
				RenameDenialReason reasons3 = RenameDenialReason.ExcludedByCategory;
				if (logDenied)
				{
					LogDenied(op, item, reasons3, "Excluded by category. Item=" + item.m_shared.m_name);
				}
				return new RenamePermissionResult(allowed: false, reasons3);
			}
			if (!RenameitConfig.AllowRenameResources && IsUnownedResourceStack(item))
			{
				RenameDenialReason reasons4 = RenameDenialReason.UncraftedResourceBlocked;
				if (logDenied)
				{
					LogDenied(op, item, reasons4, "Uncrafted/resource blocked (AllowRenameResources false).");
				}
				return new RenamePermissionResult(allowed: false, reasons4);
			}
			if (_ignoreUnlockRequirementDepth == 0 && RenameUnlockCost.UnlockCostApplies() && !DrakeRenameit.IsRenameUnlocked(item))
			{
				RenameDenialReason reasons5 = RenameDenialReason.UnlockCostRequired;
				if (logDenied)
				{
					LogDenied(op, item, reasons5, "Stack not unlocked for editing (UnlockCost).");
				}
				return new RenamePermissionResult(allowed: false, reasons5);
			}
			LogAllowed(op, item, "Item rules passed.");
			return new RenamePermissionResult(allowed: true, RenameDenialReason.None);
		}

		private static bool IsUnownedResourceStack(ItemData item)
		{
			return item.m_crafterID == 0L && string.IsNullOrEmpty(item.m_crafterName);
		}

		private static bool PassesOwnerLock(ItemData item, Player local)
		{
			if (item.m_crafterID != 0)
			{
				return item.m_crafterID == local.GetPlayerID();
			}
			if (!string.IsNullOrEmpty(item.m_crafterName))
			{
				return item.m_crafterName.Equals(local.GetPlayerName(), StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static void LogAllowed(RenamePermissionOperation op, ItemData? item, string detail)
		{
			string arg = item?.m_shared?.m_name ?? "?";
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogDebug((object)$"[Permission] ALLOW {op} item={arg} — {detail}");
			}
		}

		private static void LogDenied(RenamePermissionOperation op, ItemData? item, RenameDenialReason reasons, string detail)
		{
			string text = item?.m_shared?.m_name ?? "?";
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogInfo((object)$"[Permission] DENY {op} item={text} reasons={reasons} — {detail}");
			}
		}

		public static string FormatDenialForPlayer(RenamePermissionOperation op, RenameDenialReason reasons)
		{
			if (!RenameitConfig.ShowReason)
			{
				if ((reasons & RenameDenialReason.GlobalRenameDisabled) != 0)
				{
					return "Renaming is disabled.";
				}
				if ((reasons & RenameDenialReason.GlobalDescDisabled) != 0)
				{
					return "Description editing is disabled.";
				}
				if ((reasons & RenameDenialReason.GlobalCraftedByDisabled) != 0)
				{
					return "Crafted-by label editing is disabled.";
				}
				if ((reasons & RenameDenialReason.UnlockCostRequired) != 0)
				{
					if ((Object)(object)Player.m_localPlayer != (Object)null && RenameUnlockCost.UnlockCostApplies() && !RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer))
					{
						return "Not enough items to unlock.";
					}
					return "Unlock this stack first (action menu).";
				}
				return GenericDeniedLine(op);
			}
			if ((reasons & RenameDenialReason.GlobalRenameDisabled) != 0)
			{
				return "Renaming is disabled for this world (config).";
			}
			if ((reasons & RenameDenialReason.GlobalDescDisabled) != 0)
			{
				return "Description editing is disabled for this world (config).";
			}
			if ((reasons & RenameDenialReason.GlobalCraftedByDisabled) != 0)
			{
				return "Crafted-by label editing is disabled for this world (config).";
			}
			if ((reasons & RenameDenialReason.UnlockCostRequired) != 0)
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null && RenameUnlockCost.UnlockCostApplies() && !RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer))
				{
					return "Not enough items in inventory to unlock this stack for editing.";
				}
				return "Pay the unlock cost in the action menu (Unlock) before editing this stack.";
			}
			StringBuilder stringBuilder = new StringBuilder();
			if ((reasons & RenameDenialReason.ExcludedByName) != 0)
			{
				stringBuilder.Append("Excluded by name. ");
			}
			if ((reasons & RenameDenialReason.ExcludedByCategory) != 0)
			{
				stringBuilder.Append("Excluded by category. ");
			}
			if ((reasons & RenameDenialReason.UncraftedResourceBlocked) != 0)
			{
				stringBuilder.Append("Uncrafted resources cannot be changed (config). ");
			}
			if ((reasons & RenameDenialReason.NotOwner) != 0)
			{
				stringBuilder.Append("You don't own this item. ");
			}
			if (stringBuilder.Length > 0)
			{
				return stringBuilder.ToString().Trim();
			}
			return GenericDeniedLine(op);
		}

		private static string GenericDeniedLine(RenamePermissionOperation op)
		{
			if (1 == 0)
			{
			}
			string result = op switch
			{
				RenamePermissionOperation.RenameItemName => "This item cannot be renamed.", 
				RenamePermissionOperation.RewriteDescription => "This item's description cannot be changed.", 
				RenamePermissionOperation.EditCraftedByLabel => "This item's crafted-by label cannot be changed.", 
				_ => "Action not allowed.", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string BuildPlayerMessage(RenamePermissionOperation op, RenameDenialReason reasons)
		{
			return FormatDenialForPlayer(op, reasons);
		}

		public static string GetTooltipDisabledHint(RenamePermissionOperation op, ItemData? item)
		{
			RenamePermissionResult renamePermissionResult = TryGetDenial(op, item, Player.m_localPlayer);
			if (renamePermissionResult.Allowed)
			{
				return "";
			}
			if (!RenameitConfig.ShowReason)
			{
				if ((renamePermissionResult.Reasons & RenameDenialReason.UnlockCostRequired) != 0)
				{
					if ((Object)(object)Player.m_localPlayer != (Object)null && RenameUnlockCost.UnlockCostApplies() && !RenameUnlockCost.CanPlayerAfford(Player.m_localPlayer))
					{
						return "Not enough resources to unlock.";
					}
					return "Unlock this stack first (action menu).";
				}
				if (1 == 0)
				{
				}
				string result = op switch
				{
					RenamePermissionOperation.RenameItemName => "Cannot rename this item.", 
					RenamePermissionOperation.RewriteDescription => "Cannot edit description.", 
					RenamePermissionOperation.EditCraftedByLabel => "Cannot edit crafted-by label.", 
					_ => "Not allowed.", 
				};
				if (1 == 0)
				{
				}
				return result;
			}
			return FormatDenialForPlayer(op, renamePermissionResult.Reasons);
		}
	}
}
namespace DrakeRenameit.Ext.UI
{
	public static class ButtonExtensions
	{
		public static bool HasListener(this Button button, UnityAction call)
		{
			if ((Object)(object)button == (Object)null || button.onClick == null)
			{
				return false;
			}
			return ((UnityEventBase)button.onClick).GetPersistentEventCount() > 0;
		}

		public static void AddUniqueListener(this Button button, UnityAction call)
		{
			if (!button.HasListener(call))
			{
				((UnityEvent)button.onClick).AddListener(call);
			}
		}
	}
}
namespace DrakeRenameit.API
{
	public static class RenameEvents
	{
		public static event Action<Player, ItemData, string, string>? OnItemNameChanged;

		public static event Action<Player, ItemData, string, string>? OnItemDescriptionChanged;

		public static event Action<Player, ItemData, string, string, string>? OnCraftedByDisplayChanged;

		internal static void RaiseNameChanged(Player player, ItemData item, string oldName, string newName)
		{
			RenameEvents.OnItemNameChanged?.Invoke(player, item, oldName, newName);
		}

		internal static void RaiseDescriptionChanged(Player player, ItemData item, string oldDesc, string newDesc)
		{
			RenameEvents.OnItemDescriptionChanged?.Invoke(player, item, oldDesc, newDesc);
		}

		internal static void RaiseCraftedByDisplayChanged(Player player, ItemData item, string itemPrefabName, string oldDisplay, string newDisplay)
		{
			RenameEvents.OnCraftedByDisplayChanged?.Invoke(player, item, itemPrefabName, oldDisplay, newDisplay);
		}
	}
	public static class RenameitPermission
	{
		private static readonly HashSet<string> vipList = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static bool IsAdminOrVIP()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				return IsElevatedForOverrides(localPlayer);
			}
			return false;
		}

		public static bool IsAdminOrVIP(Player player)
		{
			return IsElevatedForOverrides(player);
		}

		public static bool IsElevatedForOverrides(Player? player)
		{
			if (!RenameitConfig.AllowAdminOverride || (Object)(object)player == (Object)null)
			{
				return false;
			}
			string item = player.GetPlayerID().ToString();
			string playerName = player.GetPlayerName();
			if (vipList.Contains(playerName) || vipList.Contains(item))
			{
				return true;
			}
			if (RenameitConfig.VipOnlyOverride)
			{
				return false;
			}
			return IsValheimAdmin(player);
		}

		public static bool IsValheimAdmin(Player? player)
		{
			return IsAdminSafe(player);
		}

		public static void AddVIP(string nameOrId)
		{
			if (!string.IsNullOrEmpty(nameOrId))
			{
				vipList.Add(nameOrId);
			}
		}

		public static void AddVIP(List<string> list)
		{
			if (list.Count <= 0)
			{
				return;
			}
			foreach (string item in list)
			{
				vipList.Add(item);
			}
		}

		public static void RemoveVIP(string nameOrId)
		{
			if (!string.IsNullOrEmpty(nameOrId))
			{
				vipList.Remove(nameOrId);
			}
		}

		public static IEnumerable<string> GetVIPs()
		{
			return vipList;
		}

		public static bool IsAdminSafe(Player? player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return SynchronizationManager.Instance != null && SynchronizationManager.Instance.PlayerIsAdmin;
			}
			return IsValheimAdminForRemotePlayer(player);
		}

		private static bool IsValheimAdminForRemotePlayer(Player player)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (ZNet.instance.m_adminList == null)
				{
					return false;
				}
				ZDOID zDOID = ((Character)player).GetZDOID();
				foreach (ZNetPeer peer in ZNet.instance.GetPeers())
				{
					if (!peer.IsReady() || peer.m_characterID != zDOID)
					{
						continue;
					}
					string text = ((peer.m_socket != null) ? peer.m_socket.GetHostName() : null);
					if (string.IsNullOrEmpty(text))
					{
						return false;
					}
					return ZNet.instance.ListContainsId(ZNet.instance.m_adminList, text);
				}
			}
			catch
			{
				return false;
			}
			return false;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: 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)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}