using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Runic.Foundation.Core;
using RunicStorage.Engine;
using RunicStorage.Runtime;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Runic Storage")]
[assembly: AssemblyDescription("Secure cached chest hover and player-directed authorized storage tools for Valheim.")]
[assembly: AssemblyCompany("Chazman")]
[assembly: AssemblyProduct("Runic Storage")]
[assembly: ComVisible(false)]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Runic.Foundation.Core
{
	public static class RunicIdentifier
	{
		public static bool IsValid(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length > 128)
			{
				return false;
			}
			bool flag = false;
			bool flag2 = false;
			foreach (char c in value)
			{
				if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9'))
				{
					flag = true;
					flag2 = false;
					continue;
				}
				switch (c)
				{
				case '-':
					if (!flag || flag2)
					{
						return false;
					}
					flag2 = true;
					break;
				case '.':
					if (!flag || flag2)
					{
						return false;
					}
					flag = false;
					flag2 = false;
					break;
				default:
					return false;
				}
			}
			if (flag)
			{
				return !flag2;
			}
			return false;
		}

		public static string Require(string value, string parameterName)
		{
			if (!IsValid(value))
			{
				throw new ArgumentException("Runic identifiers must be lowercase dot-separated tokens containing only ASCII letters, digits, and internal hyphens.", parameterName);
			}
			return value;
		}
	}
	public sealed class InputChord : IEquatable<InputChord>
	{
		private readonly IReadOnlyList<string> _modifiers;

		public string DeviceId { get; }

		public string PrimaryControl { get; }

		public IReadOnlyList<string> Modifiers => _modifiers;

		public string CanonicalId { get; }

		public InputChord(string deviceId, string primaryControl, IEnumerable<string> modifiers = null)
		{
			DeviceId = RunicIdentifier.Require(deviceId, "deviceId");
			PrimaryControl = RequireControl(primaryControl, "primaryControl");
			string text = CanonicalizeControl(PrimaryControl);
			SortedDictionary<string, string> sortedDictionary = new SortedDictionary<string, string>(StringComparer.Ordinal);
			if (modifiers != null)
			{
				foreach (string modifier in modifiers)
				{
					string text2 = RequireControl(modifier, "modifiers");
					string text3 = CanonicalizeControl(text2);
					if (string.Equals(text3, text, StringComparison.Ordinal))
					{
						throw new ArgumentException("The primary control cannot also be a modifier.", "modifiers");
					}
					if (sortedDictionary.ContainsKey(text3))
					{
						throw new ArgumentException("Duplicate input modifier: " + text2, "modifiers");
					}
					sortedDictionary.Add(text3, text2);
				}
			}
			string[] array = new string[sortedDictionary.Count];
			int num = 0;
			foreach (string value in sortedDictionary.Values)
			{
				array[num++] = value;
			}
			_modifiers = Array.AsReadOnly(array);
			StringBuilder stringBuilder = new StringBuilder(DeviceId).Append(':');
			foreach (string key in sortedDictionary.Keys)
			{
				stringBuilder.Append(key).Append('+');
			}
			stringBuilder.Append(text);
			CanonicalId = stringBuilder.ToString();
		}

		public bool Equals(InputChord other)
		{
			if (other != null)
			{
				return string.Equals(CanonicalId, other.CanonicalId, StringComparison.Ordinal);
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as InputChord);
		}

		public override int GetHashCode()
		{
			return StringComparer.Ordinal.GetHashCode(CanonicalId);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < _modifiers.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(" + ");
				}
				stringBuilder.Append(_modifiers[i]);
			}
			if (_modifiers.Count > 0)
			{
				stringBuilder.Append(" + ");
			}
			return stringBuilder.Append(PrimaryControl).Append(" [").Append(DeviceId)
				.Append(']')
				.ToString();
		}

		private static string RequireControl(string value, string parameterName)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				throw new ArgumentException("An input control name is required.", parameterName);
			}
			string text = value.Trim();
			if (text.Length > 64)
			{
				throw new ArgumentException("Input control names cannot exceed 64 characters.", parameterName);
			}
			string text2 = text;
			foreach (char c in text2)
			{
				if (char.IsControl(c) || c == ':' || c == '+' || c == '|')
				{
					throw new ArgumentException("The input control name contains a reserved character.", parameterName);
				}
			}
			if (CanonicalizeControl(text).Length == 0)
			{
				throw new ArgumentException("The input control name has no canonical characters.", parameterName);
			}
			return text;
		}

		private static string CanonicalizeControl(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				if (!char.IsWhiteSpace(c) && c != '_' && c != '-')
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class KeybindingDescriptor
	{
		public string ModuleId { get; }

		public string BindingId { get; }

		public string QualifiedId => ModuleId + "/" + BindingId;

		public string DisplayName { get; }

		public InputChord Chord { get; }

		public string Context { get; }

		public KeybindingDescriptor(string moduleId, string bindingId, string displayName, InputChord chord, string context = "gameplay")
		{
			ModuleId = RunicIdentifier.Require(moduleId, "moduleId");
			BindingId = RunicIdentifier.Require(bindingId, "bindingId");
			Context = RunicIdentifier.Require(context, "context");
			if (string.IsNullOrWhiteSpace(displayName))
			{
				throw new ArgumentException("A keybinding display name is required.", "displayName");
			}
			Chord = chord ?? throw new ArgumentNullException("chord");
			DisplayName = displayName.Trim();
		}
	}
	public sealed class KeybindingConflict
	{
		public InputChord Chord { get; }

		public IReadOnlyList<KeybindingDescriptor> Bindings { get; }

		internal KeybindingConflict(InputChord chord, IReadOnlyList<KeybindingDescriptor> bindings)
		{
			Chord = chord;
			Bindings = bindings;
		}
	}
	public enum KeybindingChangeKind
	{
		Registered,
		Unregistered
	}
	public sealed class KeybindingsChangedEventArgs : EventArgs
	{
		public KeybindingChangeKind Kind { get; }

		public KeybindingDescriptor Binding { get; }

		public KeybindingConflict Conflict { get; }

		internal KeybindingsChangedEventArgs(KeybindingChangeKind kind, KeybindingDescriptor binding, KeybindingConflict conflict)
		{
			Kind = kind;
			Binding = binding;
			Conflict = conflict;
		}
	}
	public sealed class KeybindingConflictRegistry
	{
		private sealed class BindingEntry
		{
			internal KeybindingDescriptor Binding { get; }

			internal long Token { get; }

			internal BindingEntry(KeybindingDescriptor binding, long token)
			{
				Binding = binding;
				Token = token;
			}
		}

		private readonly object _sync = new object();

		private readonly Dictionary<string, BindingEntry> _byQualifiedId = new Dictionary<string, BindingEntry>(StringComparer.Ordinal);

		private readonly Dictionary<string, List<BindingEntry>> _byChord = new Dictionary<string, List<BindingEntry>>(StringComparer.Ordinal);

		private long _nextToken;

		public event EventHandler<KeybindingsChangedEventArgs> Changed;

		public KeybindingRegistration Register(KeybindingDescriptor binding)
		{
			if (binding == null)
			{
				throw new ArgumentNullException("binding");
			}
			long token;
			KeybindingConflict conflict;
			lock (_sync)
			{
				if (_byQualifiedId.ContainsKey(binding.QualifiedId))
				{
					throw new InvalidOperationException("A keybinding is already registered as '" + binding.QualifiedId + "'.");
				}
				if (_nextToken == long.MaxValue)
				{
					throw new InvalidOperationException("The keybinding registration token space is exhausted.");
				}
				token = ++_nextToken;
				BindingEntry bindingEntry = new BindingEntry(binding, token);
				_byQualifiedId.Add(binding.QualifiedId, bindingEntry);
				if (!_byChord.TryGetValue(binding.Chord.CanonicalId, out var value))
				{
					value = new List<BindingEntry>();
					_byChord.Add(binding.Chord.CanonicalId, value);
				}
				value.Add(bindingEntry);
				conflict = CreateConflictLocked(binding.Chord.CanonicalId);
			}
			RaiseChanged(new KeybindingsChangedEventArgs(KeybindingChangeKind.Registered, binding, conflict));
			return new KeybindingRegistration(this, binding, token);
		}

		public bool Unregister(string moduleId, string bindingId)
		{
			RunicIdentifier.Require(moduleId, "moduleId");
			RunicIdentifier.Require(bindingId, "bindingId");
			return Unregister(moduleId + "/" + bindingId, (long?)null);
		}

		public bool TryGetBinding(string moduleId, string bindingId, out KeybindingDescriptor binding)
		{
			binding = null;
			if (!RunicIdentifier.IsValid(moduleId) || !RunicIdentifier.IsValid(bindingId))
			{
				return false;
			}
			lock (_sync)
			{
				if (!_byQualifiedId.TryGetValue(moduleId + "/" + bindingId, out var value))
				{
					return false;
				}
				binding = value.Binding;
				return true;
			}
		}

		public IReadOnlyList<KeybindingDescriptor> GetBindings()
		{
			lock (_sync)
			{
				List<KeybindingDescriptor> list = new List<KeybindingDescriptor>(_byQualifiedId.Count);
				foreach (BindingEntry value in _byQualifiedId.Values)
				{
					list.Add(value.Binding);
				}
				list.Sort((KeybindingDescriptor left, KeybindingDescriptor right) => StringComparer.Ordinal.Compare(left.QualifiedId, right.QualifiedId));
				return list.AsReadOnly();
			}
		}

		public IReadOnlyList<KeybindingConflict> GetConflicts()
		{
			lock (_sync)
			{
				List<KeybindingConflict> list = new List<KeybindingConflict>();
				foreach (string key in _byChord.Keys)
				{
					KeybindingConflict keybindingConflict = CreateConflictLocked(key);
					if (keybindingConflict != null)
					{
						list.Add(keybindingConflict);
					}
				}
				list.Sort((KeybindingConflict left, KeybindingConflict right) => StringComparer.Ordinal.Compare(left.Chord.CanonicalId, right.Chord.CanonicalId));
				return list.AsReadOnly();
			}
		}

		public IReadOnlyList<KeybindingConflict> GetConflictsFor(string moduleId)
		{
			RunicIdentifier.Require(moduleId, "moduleId");
			IReadOnlyList<KeybindingConflict> conflicts = GetConflicts();
			List<KeybindingConflict> list = new List<KeybindingConflict>();
			foreach (KeybindingConflict item in conflicts)
			{
				foreach (KeybindingDescriptor binding in item.Bindings)
				{
					if (string.Equals(binding.ModuleId, moduleId, StringComparison.Ordinal))
					{
						list.Add(item);
						break;
					}
				}
			}
			return list.AsReadOnly();
		}

		internal bool IsActive(string qualifiedId, long token)
		{
			lock (_sync)
			{
				BindingEntry value;
				return _byQualifiedId.TryGetValue(qualifiedId, out value) && value.Token == token;
			}
		}

		internal bool Unregister(string qualifiedId, long? requiredToken)
		{
			KeybindingDescriptor binding;
			KeybindingConflict conflict;
			lock (_sync)
			{
				if (!_byQualifiedId.TryGetValue(qualifiedId, out var entry) || (requiredToken.HasValue && entry.Token != requiredToken.Value))
				{
					return false;
				}
				binding = entry.Binding;
				_byQualifiedId.Remove(qualifiedId);
				List<BindingEntry> list = _byChord[binding.Chord.CanonicalId];
				list.RemoveAll((BindingEntry candidate) => candidate.Token == entry.Token);
				if (list.Count == 0)
				{
					_byChord.Remove(binding.Chord.CanonicalId);
				}
				conflict = CreateConflictLocked(binding.Chord.CanonicalId);
			}
			RaiseChanged(new KeybindingsChangedEventArgs(KeybindingChangeKind.Unregistered, binding, conflict));
			return true;
		}

		private KeybindingConflict CreateConflictLocked(string chordId)
		{
			if (!_byChord.TryGetValue(chordId, out var value) || value.Count < 2)
			{
				return null;
			}
			List<KeybindingDescriptor> list = new List<KeybindingDescriptor>(value.Count);
			foreach (BindingEntry item in value)
			{
				list.Add(item.Binding);
			}
			list.Sort((KeybindingDescriptor left, KeybindingDescriptor right) => StringComparer.Ordinal.Compare(left.QualifiedId, right.QualifiedId));
			return new KeybindingConflict(list[0].Chord, list.AsReadOnly());
		}

		private void RaiseChanged(KeybindingsChangedEventArgs arguments)
		{
			EventHandler<KeybindingsChangedEventArgs> eventHandler = this.Changed;
			if (eventHandler == null)
			{
				return;
			}
			Delegate[] invocationList = eventHandler.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				EventHandler<KeybindingsChangedEventArgs> eventHandler2 = (EventHandler<KeybindingsChangedEventArgs>)invocationList[i];
				try
				{
					eventHandler2(this, arguments);
				}
				catch (Exception)
				{
				}
			}
		}
	}
	public sealed class KeybindingRegistration : IDisposable
	{
		private readonly KeybindingConflictRegistry _registry;

		private readonly long _token;

		public KeybindingDescriptor Binding { get; }

		public bool IsActive => _registry.IsActive(Binding.QualifiedId, _token);

		internal KeybindingRegistration(KeybindingConflictRegistry registry, KeybindingDescriptor binding, long token)
		{
			_registry = registry;
			Binding = binding;
			_token = token;
		}

		public void Dispose()
		{
			_registry.Unregister(Binding.QualifiedId, _token);
		}
	}
}
namespace RunicStorage
{
	[BepInPlugin("chazman.RunicStorage", "Runic Storage", "1.0.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Guid = "chazman.RunicStorage";

		public const string Name = "Runic Storage";

		public const string Version = "1.0.0";

		private readonly List<KeybindingRegistration> _keybindingRegistrations = new List<KeybindingRegistration>();

		private readonly KeybindingConflictRegistry _keybindings = new KeybindingConflictRegistry();

		private static readonly FieldInfo DragItemField = AccessTools.Field(typeof(InventoryGui), "m_dragItem");

		private static readonly FieldInfo CurrentContainerField = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");

		private readonly Harmony _harmony = new Harmony("chazman.RunicStorage");

		private readonly StorageInputReader _inputReader = new StorageInputReader();

		private StorageActions _actions;

		private StorageSearchPanel _searchPanel;

		private bool _readyMessageShown;

		internal static ContainerIndex Index { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		private static StorageSearchPanel ActiveSearchPanel { get; set; }

		internal static bool SearchPanelOpen => ActiveSearchPanel?.IsOpen ?? false;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			PluginConfig.Bind(((BaseUnityPlugin)this).Config);
			try
			{
				((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
				ZInput.OnInputLayoutChanged += OnInputLayoutChanged;
				Localization.OnLanguageChange = (Action)Delegate.Combine(Localization.OnLanguageChange, new Action(ContainerHoverContents.InvalidateConfiguration));
				Index = new ContainerIndex();
				_searchPanel = new StorageSearchPanel();
				ActiveSearchPanel = _searchPanel;
				_actions = new StorageActions(Index, _searchPanel);
				RegisterKeybindings();
				_harmony.PatchAll(typeof(Plugin).Assembly);
				Index.RefreshLoadedContainers();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Runic Storage v1.0.0 ready: chest hover, Quick Stack, Restock, Search, Sort, Store All, and Consolidate use native local ownership.");
				if (!ContainerHoverContents.IsSupported)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Chest-content hover is unavailable because its installed Container/PrivateArea adapter signatures did not match. Other Storage features remain enabled.");
				}
				LogConfigurationSummary("startup");
			}
			catch (Exception arg)
			{
				Shutdown();
				((BaseUnityPlugin)this).Logger.LogError((object)string.Format("{0} failed closed during startup: {1}", "Runic Storage", arg));
			}
		}

		private void Update()
		{
			if (_actions == null)
			{
				return;
			}
			try
			{
				ShowReadyMessage();
				_searchPanel?.Tick();
				StorageSearchPanel searchPanel = _searchPanel;
				if (searchPanel != null && searchPanel.IsOpen)
				{
					return;
				}
				StorageRouteContext context = CaptureRouteContext();
				StorageActionEdges num = _inputReader.ReadKeyboardEdges();
				StorageActionEdges storageActionEdges = _inputReader.ReadControllerEdges(context);
				StorageActionEdges edges = num | storageActionEdges;
				StorageActionRequest request = StorageActionRouter.Select(edges);
				if (!request.IsPresent)
				{
					return;
				}
				StorageRouteDecision storageRouteDecision = StorageActionRouter.Route(request, context);
				if (PluginConfig.DebugTransfers.Value)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("input-detected edges=" + StorageInputReader.DescribeEdges(edges) + " selected=" + StorageActionDiagnostics.ActionCode(request.Action) + " source=" + StorageActionDiagnostics.OriginCode(request.Origin) + " route=" + storageRouteDecision.Outcome.ToString().ToLowerInvariant() + " reason=" + StorageActionDiagnostics.RouteReasonCode(storageRouteDecision.Reason)));
				}
				if (storageRouteDecision.Outcome != StorageRouteOutcome.Execute)
				{
					string text = StorageActionDiagnostics.RouteFeedback(storageRouteDecision.Reason);
					if (text.Length != 0)
					{
						Player localPlayer = Player.m_localPlayer;
						if ((Object)(object)localPlayer != (Object)null)
						{
							((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
						}
					}
					return;
				}
				switch (request.Action)
				{
				case StorageActionKind.QuickStack:
					_actions.QuickStack();
					break;
				case StorageActionKind.StoreAllOpenedContainer:
					_actions.StoreAllOpenedContainer();
					break;
				case StorageActionKind.Restock:
					_actions.Restock();
					break;
				case StorageActionKind.SortOpenedContainer:
					_actions.SortOpenedContainer();
					break;
				case StorageActionKind.Consolidate:
					_actions.ConsolidateCarriedStacks();
					break;
				case StorageActionKind.Search:
					_actions.Search();
					break;
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Runic Storage action stopped after restoring the in-flight item move; earlier completed moves, if any, remain applied: " + ex));
				Player localPlayer2 = Player.m_localPlayer;
				if ((Object)(object)localPlayer2 != (Object)null)
				{
					((Character)localPlayer2).Message((MessageType)2, "Runic Storage stopped safely; completed moves may remain. Check BepInEx/LogOutput.log.", 0, (Sprite)null);
				}
			}
		}

		private void OnGUI()
		{
			try
			{
				_searchPanel?.Draw();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Storage search list closed after a UI error: " + ex.Message));
				_searchPanel?.Close();
			}
		}

		private void OnDestroy()
		{
			Shutdown();
		}

		private void RegisterKeybindings()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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)
			DisposeKeybindings();
			RegisterKey("quick-stack", "Quick Stack", PluginConfig.QuickStackKey.Value);
			RegisterKey("restock", "Restock", PluginConfig.RestockKey.Value);
			RegisterKey("sort", "Sort Opened Container", PluginConfig.SortOpenedContainerKey.Value);
			RegisterKey("store-all", "Store All Into Opened Container", PluginConfig.StoreAllOpenedContainerKey.Value);
			RegisterKey("consolidate", "Consolidate Carried Stacks", PluginConfig.ConsolidateKey.Value);
			RegisterKey("search", "Search Nearby Storage", PluginConfig.SearchKey.Value);
			if (PluginConfig.ControllerShortcuts.Value)
			{
				RegisterControllerKey("controller-quick-stack", "Quick Stack (Controller)", PluginConfig.ControllerQuickStack.Value);
				RegisterControllerKey("controller-restock", "Restock (Controller)", PluginConfig.ControllerRestock.Value);
				RegisterControllerKey("controller-sort", "Sort Opened Container (Controller)", PluginConfig.ControllerSort.Value);
				RegisterControllerKey("controller-consolidate", "Consolidate (Controller)", PluginConfig.ControllerConsolidate.Value);
				RegisterControllerKey("controller-search", "Search (Controller)", PluginConfig.ControllerSearch.Value);
			}
		}

		private void RegisterKey(string bindingId, string displayName, KeyboardShortcut shortcut)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				list.Add(((object)modifier).ToString());
			}
			_keybindingRegistrations.Add(_keybindings.Register(new KeybindingDescriptor("runic.storage", bindingId, displayName, new InputChord("keyboard", ((object)((KeyboardShortcut)(ref shortcut)).MainKey).ToString(), list))));
		}

		private void RegisterControllerKey(string bindingId, string displayName, string action)
		{
			string text = (action ?? string.Empty).Trim();
			string text2 = (PluginConfig.ControllerModifier.Value ?? string.Empty).Trim();
			if (text.Length == 0 || text2.Length == 0 || string.Equals(text, text2, StringComparison.Ordinal))
			{
				return;
			}
			try
			{
				_keybindingRegistrations.Add(_keybindings.Register(new KeybindingDescriptor("runic.storage", bindingId, displayName, new InputChord("controller", text, new string[1] { text2 }))));
			}
			catch (ArgumentException ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Controller keybinding " + displayName + " was not registered: " + ex.Message));
			}
		}

		private void OnSettingChanged(object sender, SettingChangedEventArgs arguments)
		{
			ContainerHoverContents.InvalidateConfiguration();
			_inputReader.InvalidateControllerBindings();
			StorageControllerCollisionGuard.Reset();
			try
			{
				RegisterKeybindings();
				LogConfigurationSummary("configuration-changed");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Storage keybinding refresh failed: " + ex.Message));
			}
		}

		private void OnInputLayoutChanged()
		{
			_inputReader.InvalidateControllerBindings();
			StorageControllerCollisionGuard.Reset();
			ConfigEntry<bool> debugTransfers = PluginConfig.DebugTransfers;
			if (debugTransfers != null && debugTransfers.Value)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Controller input layout changed; Storage controller bindings will be re-resolved once.");
			}
		}

		private void DisposeKeybindings()
		{
			for (int num = _keybindingRegistrations.Count - 1; num >= 0; num--)
			{
				try
				{
					_keybindingRegistrations[num].Dispose();
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not unregister a storage keybinding cleanly: " + ex.Message));
				}
			}
			_keybindingRegistrations.Clear();
		}

		internal static StorageRouteContext CaptureRouteContext()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_002f: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			bool flag = InventoryGui.IsVisible();
			bool flag2 = (Object)localPlayer != (Object)null && (Object)localPlayer == (Object)Player.m_localPlayer && ((Character)localPlayer).IsOwner();
			return new StorageRouteContext(PluginConfig.Enabled?.Value ?? false, (Object)localPlayer == (Object)null || InputBlocked(), HasDraggedItem(), flag, flag && HasOpenedContainer(), StoreGui.IsVisible(), Minimap.IsOpen(), flag2, flag2);
		}

		private static bool InputBlocked()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			if (Console.IsVisible() || Menu.IsVisible() || TextInput.IsVisible())
			{
				return true;
			}
			if ((Object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return true;
			}
			if ((Object)TextViewer.instance != (Object)null && TextViewer.instance.IsVisible())
			{
				return true;
			}
			if (Hud.InRadial() || Hud.IsPieceSelectionVisible() || GameCamera.InFreeFly() || PlayerCustomizaton.IsBarberGuiVisible())
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)localPlayer == (Object)null) && !((Character)localPlayer).IsDead() && !((Character)localPlayer).InCutscene())
			{
				return ((Character)localPlayer).IsTeleporting();
			}
			return true;
		}

		private static bool HasDraggedItem()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)InventoryGui.instance != (Object)null)
			{
				return DragItemField?.GetValue(InventoryGui.instance) is ItemData;
			}
			return false;
		}

		private static bool HasOpenedContainer()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)InventoryGui.instance != (Object)null)
			{
				return CurrentContainerField?.GetValue(InventoryGui.instance) is Container;
			}
			return false;
		}

		private void ShowReadyMessage()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (!_readyMessageShown && PluginConfig.Enabled.Value && PluginConfig.ShowReadyMessage.Value && !((Object)Player.m_localPlayer == (Object)null) && !((Object)MessageHud.instance == (Object)null))
			{
				_readyMessageShown = true;
				string text = (PluginConfig.ControllerShortcuts.Value ? (" Controller: hold " + PluginConfig.ControllerModifier.Value + "; see config for routes.") : string.Empty);
				((Character)Player.m_localPlayer).Message((MessageType)1, "Runic Storage ready — " + ShortcutLabel(PluginConfig.QuickStackKey.Value) + " Quick Stack; " + ShortcutLabel(PluginConfig.RestockKey.Value) + " Restock; " + ShortcutLabel(PluginConfig.SearchKey.Value) + " Search; " + ShortcutLabel(PluginConfig.ConsolidateKey.Value) + " Consolidate; open a chest and use " + ShortcutLabel(PluginConfig.SortOpenedContainerKey.Value) + " to Sort or " + ShortcutLabel(PluginConfig.StoreAllOpenedContainerKey.Value) + " to Store All." + text, 0, (Sprite)null);
			}
		}

		private void LogConfigurationSummary(string reason)
		{
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			string text = (PluginConfig.ControllerShortcuts.Value ? ("hold " + PluginConfig.ControllerModifier.Value + ": quick=" + PluginConfig.ControllerQuickStack.Value + ", restock=" + PluginConfig.ControllerRestock.Value + ", sort=" + PluginConfig.ControllerSort.Value + ", consolidate=" + PluginConfig.ControllerConsolidate.Value + ", search=" + PluginConfig.ControllerSearch.Value) : "disabled");
			((BaseUnityPlugin)this).Logger.LogInfo((object)($"Storage configuration ({reason}): Enabled={PluginConfig.Enabled.Value}; " + $"Range={PluginConfig.RangeMeters.Value:0.##}m; MaxCandidates={PluginConfig.MaximumCandidates.Value}; " + $"ProtectHotbar={PluginConfig.ProtectHotbar.Value}; DebugTransfers={PluginConfig.DebugTransfers.Value}; " + $"Hover=[enabled={PluginConfig.ShowContentsOnHover.Value}, kinds={PluginConfig.HoverMaximumItemKinds.Value}, " + $"perLine={PluginConfig.HoverItemsPerLine.Value}, characters={PluginConfig.HoverMaximumCharacters.Value}, " + $"stacks={PluginConfig.HoverMaximumStacksExamined.Value}, " + $"snapshotCharacters={PluginConfig.HoverMaximumSnapshotCharacters.Value}, " + string.Format("retry={0:0.##}s, signatures={1}]; ", PluginConfig.HoverRefreshIntervalSeconds.Value, ContainerHoverContents.IsSupported ? "ready" : "unavailable") + "keyboard=[quick " + ShortcutLabel(PluginConfig.QuickStackKey.Value) + ", restock " + ShortcutLabel(PluginConfig.RestockKey.Value) + ", sort " + ShortcutLabel(PluginConfig.SortOpenedContainerKey.Value) + ", store-all " + ShortcutLabel(PluginConfig.StoreAllOpenedContainerKey.Value) + ", consolidate " + ShortcutLabel(PluginConfig.ConsolidateKey.Value) + ", search " + ShortcutLabel(PluginConfig.SearchKey.Value) + "]; controller=[" + text + "]; controller-validation=" + _inputReader.ControllerStatusSummary() + "."));
		}

		private static string ShortcutLabel(KeyboardShortcut shortcut)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				list.Add(((object)modifier).ToString());
			}
			list.Add(((object)((KeyboardShortcut)(ref shortcut)).MainKey).ToString());
			return string.Join("+", list);
		}

		private void Shutdown()
		{
			((BaseUnityPlugin)this).Config.SettingChanged -= OnSettingChanged;
			ZInput.OnInputLayoutChanged -= OnInputLayoutChanged;
			Localization.OnLanguageChange = (Action)Delegate.Remove(Localization.OnLanguageChange, new Action(ContainerHoverContents.InvalidateConfiguration));
			_inputReader.InvalidateControllerBindings();
			StorageControllerCollisionGuard.Reset();
			StorageSearchGameplayInputGuard.Reset();
			ContainerHoverContents.Reset();
			try
			{
				_harmony.UnpatchSelf();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not unpatch Runic Storage cleanly: " + ex.Message));
			}
			DisposeKeybindings();
			_actions = null;
			_searchPanel?.Dispose();
			_searchPanel = null;
			ActiveSearchPanel = null;
			Index = null;
			Log = null;
		}
	}
	internal static class PluginConfig
	{
		internal static ConfigEntry<bool> Enabled { get; private set; }

		internal static ConfigEntry<bool> ShowReadyMessage { get; private set; }

		internal static ConfigEntry<float> RangeMeters { get; private set; }

		internal static ConfigEntry<int> MaximumCandidates { get; private set; }

		internal static ConfigEntry<bool> ProtectHotbar { get; private set; }

		internal static ConfigEntry<bool> ShowContentsOnHover { get; private set; }

		internal static ConfigEntry<int> HoverMaximumItemKinds { get; private set; }

		internal static ConfigEntry<int> HoverItemsPerLine { get; private set; }

		internal static ConfigEntry<int> HoverMaximumCharacters { get; private set; }

		internal static ConfigEntry<int> HoverMaximumStacksExamined { get; private set; }

		internal static ConfigEntry<int> HoverMaximumSnapshotCharacters { get; private set; }

		internal static ConfigEntry<float> HoverRefreshIntervalSeconds { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> QuickStackKey { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> RestockKey { get; private set; }

		internal static ConfigEntry<string> RestockTargets { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> SortOpenedContainerKey { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> StoreAllOpenedContainerKey { get; private set; }

		internal static ConfigEntry<string> LockedContainerSlots { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> ConsolidateKey { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> SearchKey { get; private set; }

		internal static ConfigEntry<string> SearchItem { get; private set; }

		internal static ConfigEntry<int> SearchMenuFontSize { get; private set; }

		internal static ConfigEntry<StorageSearchMenuFontColor> SearchMenuFontColor { get; private set; }

		internal static ConfigEntry<bool> ControllerShortcuts { get; private set; }

		internal static ConfigEntry<string> ControllerModifier { get; private set; }

		internal static ConfigEntry<string> ControllerQuickStack { get; private set; }

		internal static ConfigEntry<string> ControllerRestock { get; private set; }

		internal static ConfigEntry<string> ControllerSort { get; private set; }

		internal static ConfigEntry<string> ControllerConsolidate { get; private set; }

		internal static ConfigEntry<string> ControllerSearch { get; private set; }

		internal static ConfigEntry<bool> DebugTransfers { get; private set; }

		internal static void Bind(ConfigFile config)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: 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_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Expected O, but got Unknown
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable Runic Storage gameplay actions.");
			ShowReadyMessage = config.Bind<bool>("General", "ShowReadyMessage", true, "Show a one-time in-world control reminder after the local player loads.");
			RangeMeters = config.Bind<float>("Discovery", "RangeMeters", 20f, new ConfigDescription("Nearby storage radius. Hard limited to 50 meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			MaximumCandidates = config.Bind<int>("Discovery", "MaximumCandidates", 64, new ConfigDescription("Maximum cached containers examined per action.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 256), Array.Empty<object>()));
			ProtectHotbar = config.Bind<bool>("Safety", "ProtectHotbar", true, "Never quick-stack, store-all, or consolidate items in the top-row hotbar.");
			ShowContentsOnHover = config.Bind<bool>("Hover", "ShowContents", true, "List a closed authorized container's synchronized contents in its hover text. Private, busy, unsynchronized, or Runic-reserved containers retain vanilla text only.");
			HoverMaximumItemKinds = config.Bind<int>("Hover", "MaximumItemKinds", 8, new ConfigDescription("Maximum distinct item kinds shown in one hover summary.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 24), Array.Empty<object>()));
			HoverItemsPerLine = config.Bind<int>("Hover", "ItemsPerLine", 3, new ConfigDescription("Maximum item kinds placed on each summary line.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4), Array.Empty<object>()));
			HoverMaximumCharacters = config.Bind<int>("Hover", "MaximumCharacters", 320, new ConfigDescription("Hard character ceiling for the complete generated contents suffix, including formatting tags.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 1024), Array.Empty<object>()));
			HoverMaximumStacksExamined = config.Bind<int>("Hover", "MaximumStacksExamined", 256, new ConfigDescription("Maximum inventory stacks examined when rebuilding one changed summary. Additional stacks are reported as unscanned.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(16, 1024), Array.Empty<object>()));
			HoverMaximumSnapshotCharacters = config.Bind<int>("Hover", "MaximumSnapshotCharacters", 262144, new ConfigDescription("Maximum persisted Base64 inventory characters accepted for an exact hover snapshot. Oversized third-party containers retain vanilla text.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(16384, 1048576), Array.Empty<object>()));
			HoverRefreshIntervalSeconds = config.Bind<float>("Hover", "FailedRefreshRetrySeconds", 0.5f, new ConfigDescription("Retry delay after a container cannot prove an exact synchronized inventory snapshot. Stable summaries remain cached by exact persisted item-payload evidence.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()));
			QuickStackKey = config.Bind<KeyboardShortcut>("Keys", "QuickStack", new KeyboardShortcut((KeyCode)113, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Deposit eligible carried stacks into authorized nearby containers already holding that item.");
			RestockKey = config.Bind<KeyboardShortcut>("Keys", "Restock", new KeyboardShortcut((KeyCode)114, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Restock configured carried targets from authorized nearby storage.");
			RestockTargets = config.Bind<string>("Restock", "Targets", "Wood=50,Stone=50", "Comma-separated prefab/name targets, for example Wood=50,Stone=50.");
			SortOpenedContainerKey = config.Bind<KeyboardShortcut>("Keys", "SortOpenedContainer", new KeyboardShortcut((KeyCode)115, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Sort the currently opened authorized container by category, name, quality, then weight.");
			StoreAllOpenedContainerKey = config.Bind<KeyboardShortcut>("Keys", "StoreAllOpenedContainer", new KeyboardShortcut((KeyCode)97, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Store every eligible carried item in the currently opened authorized locally owned container.");
			LockedContainerSlots = config.Bind<string>("Sort", "LockedSlots", string.Empty, "Semicolon-separated zero-based slots to leave fixed, for example 0,0;1,0.");
			ConsolidateKey = config.Bind<KeyboardShortcut>("Keys", "ConsolidateCarriedStacks", new KeyboardShortcut((KeyCode)99, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Safely consolidate compatible carried stacks while respecting protected slots and equipment.");
			SearchKey = config.Bind<KeyboardShortcut>("Keys", "Search", new KeyboardShortcut((KeyCode)102, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Open a selectable list of item kinds in authorized nearby containers and highlight every matching chest.");
			SearchItem = config.Bind<string>("Search", "SearchItem", "Wood", "Legacy setting retained for configuration compatibility; Alt+F now opens the complete nearby-item list.");
			SearchMenuFontSize = config.Bind<int>("Search", "MenuFontSize", 14, new ConfigDescription("Font size for every title, label, text field, and button in the Alt+F nearby-item window.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 32), Array.Empty<object>()));
			StorageSearchMenuFontColor migrated;
			bool num = TryReadAndRemoveLegacySearchMenuFontColor(config, out migrated);
			SearchMenuFontColor = config.Bind<StorageSearchMenuFontColor>("Search", "MenuFontColor", StorageSearchMenuFontColor.LightGray, "Named font color for the complete Alt+F nearby-item window. Configuration Manager presents the available colors as a dropdown.");
			if (num)
			{
				SearchMenuFontColor.Value = migrated;
			}
			ControllerShortcuts = config.Bind<bool>("Controller", "Enabled", true, "Enable controller chords resolved through Valheim's current ZInput action map.");
			ControllerModifier = config.Bind<string>("Controller", "ModifierAction", "JoyAltKeys", "Valheim ZInput action held as the controller modifier. Change only to an existing action name.");
			ControllerQuickStack = config.Bind<string>("Controller", "QuickStackAction", "JoyDPadDown", "Valheim ZInput action pressed with ModifierAction to Quick Stack.");
			ControllerRestock = config.Bind<string>("Controller", "RestockAction", "JoyDPadUp", "Valheim ZInput action pressed with ModifierAction to Restock.");
			ControllerSort = config.Bind<string>("Controller", "SortOpenedContainerAction", "JoyRStick", "Valheim ZInput action pressed with ModifierAction to sort the opened container.");
			ControllerConsolidate = config.Bind<string>("Controller", "ConsolidateAction", "JoyDPadLeft", "Valheim ZInput action pressed with ModifierAction to consolidate carried stacks.");
			ControllerSearch = config.Bind<string>("Controller", "SearchAction", "JoyDPadRight", "Valheim ZInput action pressed with ModifierAction to search nearby storage.");
			DebugTransfers = config.Bind<bool>("Diagnostics", "DebugTransfers", false, "Log detected controls, routing decisions, discovery counts, action summaries, transfer legs, and stable no-op/denial codes.");
		}

		private static bool TryReadAndRemoveLegacySearchMenuFontColor(ConfigFile config, out StorageSearchMenuFontColor migrated)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			ConfigDefinition val = new ConfigDefinition("Search", "MenuFontColor");
			bool result = HasOrphanedValue(config, val);
			ConfigEntry<string> val2 = config.Bind<string>(val, StorageSearchMenuFontColor.LightGray.ToString(), new ConfigDescription("Legacy Alt+F menu color migration entry.", (AcceptableValueBase)null, Array.Empty<object>()));
			migrated = StorageSearchMenuAppearance.NormalizeFontColorConfigValue(val2.Value);
			if (!config.Remove(val))
			{
				throw new InvalidOperationException("Runic Storage could not replace its legacy MenuFontColor setting.");
			}
			return result;
		}

		private static bool HasOrphanedValue(ConfigFile config, ConfigDefinition definition)
		{
			object obj = typeof(ConfigFile).GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(config, null);
			if (obj == null)
			{
				obj = typeof(ConfigFile).GetField("<OrphanedEntries>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(config);
			}
			if (obj is IDictionary<ConfigDefinition, string> dictionary)
			{
				return dictionary.ContainsKey(definition);
			}
			return false;
		}
	}
}
namespace RunicStorage.Runtime
{
	internal static class ContainerHoverContents
	{
		private delegate bool CheckAccessDelegate(Container container, long playerId);

		private delegate string TranslateDelegate(Localization localization, string key);

		private delegate bool WardStateDelegate(PrivateArea area);

		private delegate bool WardContainsDelegate(PrivateArea area, Vector3 point, float radius);

		private sealed class CacheEntry
		{
			private WeakReference<string> _persistedReference;

			internal HoverPersistedEvidence Evidence;

			internal bool HasEvidence;

			internal long ConfigurationGeneration;

			internal float NextRetryAt;

			internal bool Verified;

			internal string Suffix;

			internal string BaseHoverText;

			internal string CombinedHoverText;

			internal long LastAccess;

			internal bool TryGetPersistedReference(out string persisted)
			{
				persisted = null;
				if (_persistedReference != null)
				{
					return _persistedReference.TryGetTarget(out persisted);
				}
				return false;
			}

			internal void SetPersistedReference(string persisted)
			{
				if (persisted == null)
				{
					_persistedReference = null;
				}
				else if (_persistedReference == null)
				{
					_persistedReference = new WeakReference<string>(persisted);
				}
				else
				{
					_persistedReference.SetTarget(persisted);
				}
			}
		}

		private const int MaximumCacheEntries = 512;

		private const int MaximumWardAreasExamined = 4096;

		private static readonly CheckAccessDelegate CheckAccess = ResolveCheckAccess();

		private static readonly TranslateDelegate Translate = ResolveTranslate();

		private static readonly FieldRef<Container, bool> Loading = ResolveLoading();

		private static readonly List<PrivateArea> WardAreas = ResolveWardAreas();

		private static readonly WardStateDelegate WardEnabled = ResolveWardState("IsEnabled");

		private static readonly WardStateDelegate WardLocalAccess = ResolveWardState("HaveLocalAccess");

		private static readonly WardContainsDelegate WardContains = ResolveWardContains();

		private static readonly Dictionary<Container, CacheEntry> Cache = new Dictionary<Container, CacheEntry>();

		private static long _configurationGeneration = 1L;

		private static long _accessSequence;

		internal static bool IsSupported
		{
			get
			{
				if (CheckAccess != null && Translate != null && Loading != null && WardAreas != null && WardEnabled != null && WardLocalAccess != null)
				{
					return WardContains != null;
				}
				return false;
			}
		}

		internal static void Append(Container container, ref string hoverText)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (!IsSupported || (Object)container == (Object)null || !HoverBaseTextPolicy.Allows(hoverText))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			ConfigEntry<bool> enabled = PluginConfig.Enabled;
			bool flag = enabled != null && enabled.Value && (PluginConfig.ShowContentsOnHover?.Value ?? false);
			if (!flag || (Object)localPlayer == (Object)null || !((Behaviour)container).isActiveAndEnabled || (int)container.m_privacy == 0 || IsBusy(container, null))
			{
				return;
			}
			ZNetView val = ValheimContainerIdentity.NetworkView(container);
			ZDO val2 = (((Object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
			if (val2 == null || Loading.Invoke(container) || IsBusy(container, val2))
			{
				return;
			}
			Vector3 position = ((Component)container).transform.position;
			Vector3 val3 = position - ((Component)localPlayer).transform.position;
			bool flag2 = HoverRangePolicy.IsWithinPhysicalReach(((Vector3)(ref val3)).sqrMagnitude, localPlayer.m_maxInteractDistance);
			if (!flag2)
			{
				return;
			}
			bool flag3 = !container.m_checkGuardStone || HasStrictWardAccess(position);
			if (!flag3)
			{
				return;
			}
			long playerID = localPlayer.GetPlayerID();
			bool flag4;
			try
			{
				flag4 = CheckAccess(container, playerID);
			}
			catch
			{
				return;
			}
			if (!flag4)
			{
				return;
			}
			bool durableClaimAbsent = true;
			if (!HoverDisclosurePolicy.AllowsBeforeSynchronization(new HoverDisclosureFacts(flag, localPlayerAvailable: true, containerActive: true, networkObjectValid: true, nonPrivate: true, flag3, flag4, flag2, closed: true, mutationIdle: true, durableClaimAbsent, synchronized: false)))
			{
				return;
			}
			CacheEntry orCreate = GetOrCreate(container);
			orCreate.LastAccess = ++_accessSequence;
			string text = val2.GetString(ZDOVars.s_items, string.Empty);
			bool samePersistedEvidence;
			HoverPersistedEvidence expectedEvidence = CaptureEvidence(orCreate, text, out samePersistedEvidence);
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			switch (HoverCachePolicy.Decide(orCreate.Verified, samePersistedEvidence, orCreate.ConfigurationGeneration, _configurationGeneration, orCreate.NextRetryAt, realtimeSinceStartup))
			{
			case HoverCacheDecision.SuppressUntilRetry:
				return;
			case HoverCacheDecision.Refresh:
				if (!TryRefresh(container, val, val2, text, expectedEvidence, realtimeSinceStartup, orCreate, localPlayer, playerID))
				{
					return;
				}
				break;
			}
			if (HoverDisclosurePolicy.Allows(new HoverDisclosureFacts(flag, localPlayerAvailable: true, containerActive: true, networkObjectValid: true, nonPrivate: true, flag3, flag4, flag2, closed: true, mutationIdle: true, durableClaimAbsent, orCreate.Verified)) && !string.IsNullOrEmpty(orCreate.Suffix))
			{
				if (!string.Equals(orCreate.BaseHoverText, hoverText, StringComparison.Ordinal))
				{
					orCreate.BaseHoverText = hoverText;
					orCreate.CombinedHoverText = hoverText + orCreate.Suffix;
				}
				hoverText = orCreate.CombinedHoverText;
			}
		}

		internal static void Invalidate(Container container)
		{
			if ((Object)(object)container != (Object)null)
			{
				Cache.Remove(container);
			}
		}

		internal static void InvalidateConfiguration()
		{
			_configurationGeneration++;
			if (_configurationGeneration == 0L)
			{
				_configurationGeneration = 1L;
			}
		}

		internal static void Reset()
		{
			Cache.Clear();
			_configurationGeneration = 1L;
			_accessSequence = 0L;
		}

		internal static bool TryGetSynchronizedReadSnapshot(Container container, out Inventory inventory, out long revision)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			inventory = null;
			revision = 0L;
			if ((Object)container == (Object)null || Loading == null)
			{
				return false;
			}
			try
			{
				ZNetView val = ValheimContainerIdentity.NetworkView(container);
				ZDO val2 = (((Object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
				if (val2 == null || Loading.Invoke(container) || IsBusy(container, val2))
				{
					return false;
				}
				string text = val2.GetString(ZDOVars.s_items, string.Empty);
				HoverPersistedEvidence evidence = HoverPersistedEvidence.Capture(text, PluginConfig.HoverMaximumSnapshotCharacters.Value);
				if (!TryGetExactInventory(container, text, evidence, out var inventory2))
				{
					return false;
				}
				ZNetView val3 = ValheimContainerIdentity.NetworkView(container);
				ZDO val4 = (((Object)val3 != (Object)null && val3.IsValid()) ? val3.GetZDO() : null);
				string a = ((val4 != null) ? val4.GetString(ZDOVars.s_items, string.Empty) : null);
				if ((Object)(object)val3 != (Object)(object)val || val4 != val2 || val4 == null || Loading.Invoke(container) || IsBusy(container, val4) || !string.Equals(a, text, StringComparison.Ordinal))
				{
					return false;
				}
				inventory = inventory2;
				revision = val4.DataRevision;
				return true;
			}
			catch
			{
				inventory = null;
				revision = 0L;
				return false;
			}
		}

		private static bool TryRefresh(Container container, ZNetView expectedView, ZDO expectedZdo, string expectedPersistedItems, HoverPersistedEvidence expectedEvidence, float now, CacheEntry entry, Player expectedPlayer, long expectedPlayerId)
		{
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_0249: 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_025a: Expected O, but got Unknown
			//IL_025a: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			entry.Verified = false;
			entry.Evidence = expectedEvidence;
			entry.HasEvidence = true;
			entry.SetPersistedReference(expectedEvidence.IsAdmissible ? expectedPersistedItems : null);
			entry.ConfigurationGeneration = _configurationGeneration;
			entry.NextRetryAt = now + Mathf.Clamp(PluginConfig.HoverRefreshIntervalSeconds.Value, 0.1f, 5f);
			entry.Suffix = string.Empty;
			entry.BaseHoverText = null;
			entry.CombinedHoverText = null;
			try
			{
				if (!expectedEvidence.IsAdmissible || !TryGetExactInventory(container, expectedPersistedItems, expectedEvidence, out var inventory))
				{
					return false;
				}
				List<ItemData> allItems = inventory.GetAllItems();
				int num = Math.Min(allItems.Count, Mathf.Clamp(PluginConfig.HoverMaximumStacksExamined.Value, 16, 1024));
				int num2 = allItems.Count - num;
				List<HoverContentEntry> list = new List<HoverContentEntry>(num);
				for (int i = 0; i < num; i++)
				{
					ItemData val = allItems[i];
					if (val != null && val.m_stack > 0)
					{
						string text = ValheimContainerIdentity.ResourceId(val);
						if (text.Length == 0 || text.Length > 256)
						{
							num2++;
						}
						else
						{
							list.Add(new HoverContentEntry(text, DisplayName(val, text), val.m_stack));
						}
					}
				}
				string suffix = ContainerHoverSummaryFormatter.Format(list, Mathf.Clamp(PluginConfig.HoverMaximumItemKinds.Value, 1, 24), Mathf.Clamp(PluginConfig.HoverItemsPerLine.Value, 1, 4), Mathf.Clamp(PluginConfig.HoverMaximumCharacters.Value, 64, 1024), num2);
				ZNetView val2 = ValheimContainerIdentity.NetworkView(container);
				ZDO val3 = (((Object)val2 != (Object)null && val2.IsValid()) ? val2.GetZDO() : null);
				string text2 = ((val3 != null) ? val3.GetString(ZDOVars.s_items, string.Empty) : null);
				HoverPersistedEvidence hoverPersistedEvidence = HoverPersistedEvidence.Capture(text2, PluginConfig.HoverMaximumSnapshotCharacters.Value);
				if ((Object)(object)val2 == (Object)(object)expectedView && val3 == expectedZdo && val3 != null && hoverPersistedEvidence.Equals(expectedEvidence) && string.Equals(text2, expectedPersistedItems, StringComparison.Ordinal))
				{
					ConfigEntry<bool> enabled = PluginConfig.Enabled;
					if (enabled != null && enabled.Value)
					{
						ConfigEntry<bool> showContentsOnHover = PluginConfig.ShowContentsOnHover;
						if (showContentsOnHover != null && showContentsOnHover.Value && !((Object)Player.m_localPlayer != (Object)expectedPlayer) && !((Object)expectedPlayer == (Object)null) && ((Behaviour)container).isActiveAndEnabled && (int)container.m_privacy != 0 && !Loading.Invoke(container) && !IsBusy(container, val3))
						{
							Vector3 position = ((Component)container).transform.position;
							Vector3 val4 = position - ((Component)expectedPlayer).transform.position;
							if (!HoverRangePolicy.IsWithinPhysicalReach(((Vector3)(ref val4)).sqrMagnitude, expectedPlayer.m_maxInteractDistance) || (container.m_checkGuardStone && !HasStrictWardAccess(position)) || !CheckAccess(container, expectedPlayerId))
							{
								return false;
							}
							entry.Suffix = suffix;
							entry.Verified = true;
							entry.NextRetryAt = 0f;
							return true;
						}
					}
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetExactInventory(Container container, string persisted, HoverPersistedEvidence evidence, out Inventory inventory)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			inventory = null;
			if ((Object)container == (Object)null || !evidence.IsAdmissible || Loading.Invoke(container))
			{
				return false;
			}
			inventory = container.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			if (string.IsNullOrEmpty(persisted))
			{
				return allItems.Count == 0;
			}
			if (!HoverSnapshotBounds.AllowsEnvelope(allItems.Count, persisted.Length, PluginConfig.HoverMaximumSnapshotCharacters.Value))
			{
				return false;
			}
			int maximumSerializedBytes = HoverSnapshotBounds.SerializedByteCeiling(PluginConfig.HoverMaximumSnapshotCharacters.Value);
			if (!HasBoundedSerializedShape(allItems, maximumSerializedBytes))
			{
				return false;
			}
			ZPackage val = new ZPackage();
			inventory.Save(val);
			if (!HoverSnapshotBounds.MatchesExactSerializedSize(val.Size(), persisted.Length, PluginConfig.HoverMaximumSnapshotCharacters.Value))
			{
				return false;
			}
			return string.Equals(val.GetBase64(), persisted, StringComparison.Ordinal);
		}

		private static bool IsBusy(Container container, ZDO zdo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if ((Object)container == (Object)null || container.IsInUse() || ((Object)container.m_wagon != (Object)null && container.m_wagon.InUse()))
			{
				return true;
			}
			if (zdo != null)
			{
				return zdo.GetBool(ZDOVars.s_inUse, false);
			}
			return false;
		}

		private static bool HasBoundedSerializedShape(List<ItemData> items, int maximumSerializedBytes)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			if (items == null || items.Count > 1024 || maximumSerializedBytes <= 0)
			{
				return false;
			}
			long nextBytes = 8L;
			int num = 0;
			for (int i = 0; i < items.Count; i++)
			{
				ItemData val = items[i];
				if (val == null || (Object)val.m_dropPrefab == (Object)null)
				{
					return false;
				}
				nextBytes += 64;
				if (!HoverSnapshotBounds.TryAddStringEstimate(nextBytes, ((Object)val.m_dropPrefab).name?.Length ?? 0, maximumSerializedBytes, out nextBytes) || !HoverSnapshotBounds.TryAddStringEstimate(nextBytes, val.m_crafterName?.Length ?? 0, maximumSerializedBytes, out nextBytes))
				{
					return false;
				}
				Dictionary<string, string> customData = val.m_customData;
				int num2 = customData?.Count ?? 0;
				if (!HoverSnapshotBounds.AllowsCustomDataAddition(num, num2))
				{
					return false;
				}
				num += num2;
				if (customData == null)
				{
					continue;
				}
				foreach (KeyValuePair<string, string> item in customData)
				{
					if (!HoverSnapshotBounds.TryAddStringEstimate(nextBytes, item.Key?.Length ?? 0, maximumSerializedBytes, out nextBytes) || !HoverSnapshotBounds.TryAddStringEstimate(nextBytes, item.Value?.Length ?? 0, maximumSerializedBytes, out nextBytes))
					{
						return false;
					}
				}
			}
			return nextBytes <= maximumSerializedBytes;
		}

		private static bool HasStrictWardAccess(Vector3 position)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int count = WardAreas.Count;
				if (count > 4096)
				{
					return false;
				}
				for (int i = 0; i < count; i++)
				{
					PrivateArea val = WardAreas[i];
					if (!((Object)val == (Object)null))
					{
						bool num = WardEnabled(val);
						bool flag = num && WardContains(val, position, 0f);
						bool localAccess = !flag || WardLocalAccess(val);
						if (StrictWardDisclosurePolicy.IsHostileOverlap(num, flag, localAccess))
						{
							return false;
						}
					}
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string DisplayName(ItemData item, string fallback)
		{
			if (!HoverLabelPolicy.TryPrepareLocalizationToken(item?.m_shared?.m_name, out var token))
			{
				return HoverLabelPolicy.NormalizeDisplayLabel(fallback, "Item");
			}
			try
			{
				Localization instance = Localization.instance;
				string key;
				return HoverLabelPolicy.NormalizeDisplayLabel((instance != null && HoverLabelPolicy.TryGetTranslationKey(token, out key)) ? Translate(instance, key) : HoverLabelPolicy.WithoutLocalizationMarker(token), fallback);
			}
			catch
			{
				return HoverLabelPolicy.NormalizeDisplayLabel(HoverLabelPolicy.WithoutLocalizationMarker(token), fallback);
			}
		}

		private static HoverPersistedEvidence CaptureEvidence(CacheEntry entry, string persisted, out bool samePersistedEvidence)
		{
			if (persisted == null)
			{
				persisted = string.Empty;
			}
			string persisted2 = null;
			if (entry.HasEvidence && entry.TryGetPersistedReference(out persisted2) && (object)persisted2 == persisted)
			{
				samePersistedEvidence = true;
				return entry.Evidence;
			}
			HoverPersistedEvidence hoverPersistedEvidence = HoverPersistedEvidence.Capture(persisted, PluginConfig.HoverMaximumSnapshotCharacters.Value);
			samePersistedEvidence = entry.HasEvidence && entry.Evidence.Equals(hoverPersistedEvidence);
			if (samePersistedEvidence && hoverPersistedEvidence.IsAdmissible)
			{
				samePersistedEvidence = persisted2 != null && string.Equals(persisted2, persisted, StringComparison.Ordinal);
			}
			if (samePersistedEvidence && hoverPersistedEvidence.IsAdmissible)
			{
				entry.SetPersistedReference(persisted);
			}
			return hoverPersistedEvidence;
		}

		private static CacheEntry GetOrCreate(Container container)
		{
			if (Cache.TryGetValue(container, out var value))
			{
				return value;
			}
			if (Cache.Count >= 512)
			{
				EvictOldest();
			}
			value = new CacheEntry();
			Cache.Add(container, value);
			return value;
		}

		private static void EvictOldest()
		{
			Container val = null;
			long num = long.MaxValue;
			foreach (KeyValuePair<Container, CacheEntry> item in Cache)
			{
				if (item.Value.LastAccess < num)
				{
					val = item.Key;
					num = item.Value.LastAccess;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				Cache.Remove(val);
			}
		}

		private static CheckAccessDelegate ResolveCheckAccess()
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Container), "CheckAccess", new Type[1] { typeof(long) }, (Type[])null);
				return (methodInfo == null) ? null : AccessTools.MethodDelegate<CheckAccessDelegate>(methodInfo, (object)null, true);
			}
			catch
			{
				return null;
			}
		}

		private static TranslateDelegate ResolveTranslate()
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Localization), "Translate", new Type[1] { typeof(string) }, (Type[])null);
				return (methodInfo == null || methodInfo.IsStatic || methodInfo.ReturnType != typeof(string)) ? null : AccessTools.MethodDelegate<TranslateDelegate>(methodInfo, (object)null, true);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<Container, bool> ResolveLoading()
		{
			try
			{
				return AccessTools.FieldRefAccess<Container, bool>("m_loading");
			}
			catch
			{
				return null;
			}
		}

		private static List<PrivateArea> ResolveWardAreas()
		{
			try
			{
				return AccessTools.Field(typeof(PrivateArea), "m_allAreas")?.GetValue(null) as List<PrivateArea>;
			}
			catch
			{
				return null;
			}
		}

		private static WardStateDelegate ResolveWardState(string methodName)
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(PrivateArea), methodName, Type.EmptyTypes, (Type[])null);
				return (methodInfo == null) ? null : AccessTools.MethodDelegate<WardStateDelegate>(methodInfo, (object)null, true);
			}
			catch
			{
				return null;
			}
		}

		private static WardContainsDelegate ResolveWardContains()
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(PrivateArea), "IsInside", new Type[2]
				{
					typeof(Vector3),
					typeof(float)
				}, (Type[])null);
				return (methodInfo == null) ? null : AccessTools.MethodDelegate<WardContainsDelegate>(methodInfo, (object)null, true);
			}
			catch
			{
				return null;
			}
		}
	}
	internal sealed class ContainerIndex
	{
		private readonly struct CellKey : IEquatable<CellKey>
		{
			internal int X { get; }

			internal int Z { get; }

			internal CellKey(int x, int z)
			{
				X = x;
				Z = z;
			}

			internal static CellKey From(Vector3 value)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return new CellKey(ContainerSpatialPolicy.CellCoordinate(value.x), ContainerSpatialPolicy.CellCoordinate(value.z));
			}

			public bool Equals(CellKey other)
			{
				if (X == other.X)
				{
					return Z == other.Z;
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is CellKey other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (X * 397) ^ Z;
			}
		}

		private readonly struct Entry
		{
			internal int InstanceId { get; }

			internal Container Container { get; }

			internal Entry(int instanceId, Container container)
			{
				InstanceId = instanceId;
				Container = container;
			}
		}

		private readonly struct Membership
		{
			internal CellKey Cell { get; }

			internal string EndpointId { get; }

			internal Container Container { get; }

			internal Membership(CellKey cell, string endpointId, Container container)
			{
				Cell = cell;
				EndpointId = endpointId ?? string.Empty;
				Container = container;
			}
		}

		private readonly struct Candidate
		{
			internal SpatialCandidateKey Key { get; }

			internal Container Container { get; }

			internal Candidate(SpatialCandidateKey key, Container container)
			{
				Key = key;
				Container = container;
			}
		}

		private sealed class CandidateComparer : IComparer<Candidate>
		{
			internal static CandidateComparer Instance { get; } = new CandidateComparer();

			public int Compare(Candidate left, Candidate right)
			{
				return left.Key.CompareTo(right.Key);
			}
		}

		private readonly object _gate = new object();

		private readonly Dictionary<CellKey, List<Entry>> _cells = new Dictionary<CellKey, List<Entry>>();

		private readonly Dictionary<int, Membership> _membership = new Dictionary<int, Membership>();

		private readonly Dictionary<string, HashSet<int>> _endpointMembers = new Dictionary<string, HashSet<int>>(StringComparer.Ordinal);

		internal void Add(Container container)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			int instanceID;
			Vector3 position;
			try
			{
				instanceID = ((Object)container).GetInstanceID();
				position = ((Component)container).transform.position;
			}
			catch
			{
				return;
			}
			lock (_gate)
			{
				if (!Finite(position))
				{
					RemoveLocked(instanceID, container);
					return;
				}
				CellKey cellKey = CellKey.From(position);
				Membership value;
				bool num = _membership.TryGetValue(instanceID, out value);
				bool flag = num && value.Cell.Equals(cellKey);
				if (ContainerSpatialPolicy.CanRetain(exactContainerPresent: flag && _cells.TryGetValue(value.Cell, out var value2) && ContainsExact(value2, instanceID, container), membershipExists: num, cellUnchanged: flag, endpointUnchanged: !string.IsNullOrEmpty(value.EndpointId)))
				{
					return;
				}
				string endpointId;
				try
				{
					endpointId = ValheimContainerIdentity.EndpointId(container);
				}
				catch
				{
					return;
				}
				RemoveLocked(instanceID, container);
				if (ContainerSpatialPolicy.CanIndexEndpoint(endpointId))
				{
					if (!_cells.TryGetValue(cellKey, out value2))
					{
						value2 = new List<Entry>();
						_cells.Add(cellKey, value2);
					}
					value2.Add(new Entry(instanceID, container));
					_membership.Add(instanceID, new Membership(cellKey, endpointId, container));
					AddEndpoint(endpointId, instanceID);
				}
			}
		}

		internal int RefreshLoadedContainers()
		{
			Container[] array;
			try
			{
				array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
			}
			catch
			{
				return 0;
			}
			for (int i = 0; i < array.Length; i++)
			{
				Add(array[i]);
			}
			return array.Length;
		}

		internal void Remove(Container container)
		{
			if (container == null)
			{
				return;
			}
			int instanceID;
			try
			{
				instanceID = ((Object)container).GetInstanceID();
			}
			catch
			{
				return;
			}
			lock (_gate)
			{
				RemoveLocked(instanceID, container);
			}
		}

		internal IReadOnlyList<Container> Nearest(Vector3 origin, float radius, int maximum, out bool truncated)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0148: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			if (maximum <= 0)
			{
				throw new ArgumentOutOfRangeException("maximum");
			}
			if (!Finite(origin) || float.IsNaN(radius) || float.IsInfinity(radius) || radius <= 0f)
			{
				truncated = false;
				return Array.Empty<Container>();
			}
			radius = Math.Min(50f, radius);
			maximum = Math.Min(256, maximum);
			float num = radius * radius;
			CellKey cellKey = CellKey.From(origin - new Vector3(radius, 0f, radius));
			CellKey cellKey2 = CellKey.From(origin + new Vector3(radius, 0f, radius));
			SortedSet<Candidate> sortedSet = new SortedSet<Candidate>(CandidateComparer.Instance);
			int num2 = 0;
			lock (_gate)
			{
				for (int i = cellKey.X; i <= cellKey2.X; i++)
				{
					for (int j = cellKey.Z; j <= cellKey2.Z; j++)
					{
						CellKey key = new CellKey(i, j);
						if (!_cells.TryGetValue(key, out var value))
						{
							continue;
						}
						for (int num3 = value.Count - 1; num3 >= 0; num3--)
						{
							Entry entry = value[num3];
							Container container = entry.Container;
							if ((Object)(object)container == (Object)null)
							{
								value.RemoveAt(num3);
								RemoveIndexesLocked(entry.InstanceId);
							}
							else
							{
								try
								{
									if (((Behaviour)container).isActiveAndEnabled)
									{
										Vector3 val = ((Component)container).transform.position - origin;
										float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
										if (!float.IsNaN(sqrMagnitude) && !float.IsInfinity(sqrMagnitude) && !(sqrMagnitude > num) && _membership.TryGetValue(entry.InstanceId, out var value2) && ContainerSpatialPolicy.CanIndexEndpoint(value2.EndpointId) && _endpointMembers.TryGetValue(value2.EndpointId, out var value3) && ContainerSpatialPolicy.IsUniqueEndpointMemberCount(value3.Count))
										{
											if (num2 < int.MaxValue)
											{
												num2++;
											}
											string endpointId = value2.EndpointId;
											sortedSet.Add(new Candidate(new SpatialCandidateKey(sqrMagnitude, endpointId, entry.InstanceId), container));
											if (sortedSet.Count > maximum)
											{
												sortedSet.Remove(sortedSet.Max);
											}
										}
									}
								}
								catch
								{
								}
							}
						}
						if (value.Count == 0)
						{
							_cells.Remove(key);
						}
					}
				}
			}
			List<Container> list = new List<Container>(sortedSet.Count);
			foreach (Candidate item in sortedSet)
			{
				list.Add(item.Container);
			}
			truncated = num2 > maximum;
			return list.AsReadOnly();
		}

		internal bool TryGet(string endpointId, out Container container)
		{
			container = null;
			if (string.IsNullOrEmpty(endpointId))
			{
				return false;
			}
			lock (_gate)
			{
				if (!_endpointMembers.TryGetValue(endpointId, out var value) || !ContainerSpatialPolicy.IsUniqueEndpointMemberCount(value.Count))
				{
					return false;
				}
				using HashSet<int>.Enumerator enumerator = value.GetEnumerator();
				if (enumerator.MoveNext())
				{
					int current = enumerator.Current;
					if (!_membership.TryGetValue(current, out var value2) || !string.Equals(value2.EndpointId, endpointId, StringComparison.Ordinal) || (Object)(object)value2.Container == (Object)null)
					{
						RemoveIndexesLocked(current);
						return false;
					}
					container = value2.Container;
					return true;
				}
			}
			return false;
		}

		private void RemoveLocked(int instanceId, Container container)
		{
			if (!_membership.TryGetValue(instanceId, out var value))
			{
				return;
			}
			if (_cells.TryGetValue(value.Cell, out var value2))
			{
				for (int num = value2.Count - 1; num >= 0; num--)
				{
					if (value2[num].InstanceId == instanceId || value2[num].Container == container)
					{
						value2.RemoveAt(num);
					}
				}
				if (value2.Count == 0)
				{
					_cells.Remove(value.Cell);
				}
			}
			RemoveIndexesLocked(instanceId);
		}

		private void RemoveIndexesLocked(int instanceId)
		{
			if (!_membership.TryGetValue(instanceId, out var value))
			{
				return;
			}
			_membership.Remove(instanceId);
			if (!string.IsNullOrEmpty(value.EndpointId) && _endpointMembers.TryGetValue(value.EndpointId, out var value2))
			{
				value2.Remove(instanceId);
				if (value2.Count == 0)
				{
					_endpointMembers.Remove(value.EndpointId);
				}
			}
		}

		private void AddEndpoint(string endpointId, int instanceId)
		{
			if (!string.IsNullOrEmpty(endpointId))
			{
				if (!_endpointMembers.TryGetValue(endpointId, out var value))
				{
					value = new HashSet<int>();
					_endpointMembers.Add(endpointId, value);
				}
				value.Add(instanceId);
			}
		}

		private static bool ContainsExact(List<Entry> entries, int instanceId, Container container)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].InstanceId == instanceId && entries[i].Container == container)
				{
					return true;
				}
			}
			return false;
		}

		private static bool Finite(Vector3 value)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!float.IsNaN(value.x) && !float.IsInfinity(value.x) && !float.IsNaN(value.y) && !float.IsInfinity(value.y) && !float.IsNaN(value.z))
			{
				return !float.IsInfinity(value.z);
			}
			return false;
		}
	}
	internal static class ValheimContainerIdentity
	{
		internal unsafe static string EndpointId(Container container)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null)
			{
				return string.Empty;
			}
			ZNetView val = NetworkView(container);
			ZDO val2 = (((Object)(object)val != (Object)null && val.IsValid()) ? val.GetZDO() : null);
			if (val2 != null)
			{
				ZDOID uid = val2.m_uid;
				return "valheim.zdo:" + ((object)(*(ZDOID*)(&uid))/*cast due to .constrained prefix*/).ToString();
			}
			return string.Empty;
		}

		internal static ZNetView NetworkView(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return null;
			}
			if (!((Object)(object)container.m_rootObjectOverride != (Object)null))
			{
				return ((Component)container).GetComponent<ZNetView>();
			}
			return container.m_rootObjectOverride;
		}

		internal static string TypeId(Container container)
		{
			string text = (((Object)(object)container == (Object)null) ? "container" : ((Object)((Component)container).gameObject).name);
			if (text.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length);
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text.Trim();
			}
			return "container";
		}

		internal static string ResourceId(ItemData item)
		{
			if (item == null)
			{
				return string.Empty;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null && !string.IsNullOrWhiteSpace(((Object)item.m_dropPrefab).name))
			{
				string text = ((Object)item.m_dropPrefab).name;
				if (text.EndsWith("(Clone)", StringComparison.Ordinal))
				{
					text = text.Substring(0, text.Length - "(Clone)".Length);
				}
				return text.Trim();
			}
			if (item.m_shared != null && !string.IsNullOrWhiteSpace(item.m_shared.m_name))
			{
				return item.m_shared.m_name.Trim();
			}
			return string.Empty;
		}
	}
	[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
	internal static class StorageSearchCursorLeasePatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix()
		{
			StorageSearchPanel.RenewCursorLease();
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class StorageSearchInputGatePatch
	{
		[HarmonyAfter(new string[] { "chazman.RunicBuildCamera" })]
		private static void Postfix(Player __instance, ref bool __result)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && Plugin.SearchPanelOpen)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	internal static class ContainerAwakePatch
	{
		private static void Postfix(Container __instance)
		{
			ContainerHoverContents.Invalidate(__instance);
			Plugin.Index?.Add(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "OnDestroyed")]
	internal static class ContainerDestroyPatch
	{
		private static void Postfix(Container __instance, bool __runOriginal)
		{
			if (__runOriginal)
			{
				ContainerHoverContents.Invalidate(__instance);
				Plugin.Index?.Remove(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Container), "CheckForChanges")]
	internal static class ContainerSpatialRefreshPatch
	{
		private static void Postfix(Container __instance)
		{
			Plugin.Index?.Add(__instance);
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText", new Type[] { })]
	internal static class ContainerHoverTextPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Container __instance, ref string __result)
		{
			try
			{
				ContainerHoverContents.Append(__instance, ref __result);
			}
			catch
			{
			}
		}
	}
	internal sealed class ControllerBindingState
	{
		internal string Signature { get; }

		internal string ModifierName { get; }

		internal string QuickStackName { get; }

		internal string RestockName { get; }

		internal string SortName { get; }

		internal string ConsolidateName { get; }

		internal string SearchName { get; }

		internal ButtonDef Modifier { get; }

		internal ButtonDef QuickStack { get; }

		internal ButtonDef Restock { get; }

		internal ButtonDef Sort { get; }

		internal ButtonDef Consolidate { get; }

		internal ButtonDef Search { get; }

		internal bool ModifierValid => Modifier != null;

		internal bool QuickStackValid => QuickStack != null;

		internal bool RestockValid => Restock != null;

		internal bool SortValid => Sort != null;

		internal bool ConsolidateValid => Consolidate != null;

		internal bool SearchValid => Search != null;

		internal int ValidRouteCount => (QuickStackValid ? 1 : 0) + (RestockValid ? 1 : 0) + (SortValid ? 1 : 0) + (ConsolidateValid ? 1 : 0) + (SearchValid ? 1 : 0);

		internal ControllerBindingState(string signature, string modifierName, string quickStackName, string restockName, string sortName, string consolidateName, string searchName, ButtonDef modifier, ButtonDef quickStack, ButtonDef restock, ButtonDef sort, ButtonDef consolidate, ButtonDef search)
		{
			Signature = signature;
			ModifierName = modifierName;
			QuickStackName = quickStackName;
			RestockName = restockName;
			SortName = sortName;
			ConsolidateName = consolidateName;
			SearchName = searchName;
			Modifier = modifier;
			QuickStack = quickStack;
			Restock = restock;
			Sort = sort;
			Consolidate = consolidate;
			Search = search;
		}
	}
	internal static class StorageControllerCollisionGuard
	{
		private static StorageActionEdges _pendingEdge;

		private static ButtonDef _latchedModifier;

		private static ControllerBindingState _sessionBindings;

		private static ControllerSessionPaths _sessionPaths;

		private static int _releasedFrame = -1;

		private static int _capturedFrame = -1;

		private static int _lastProbeFrame = -1;

		internal static StorageActionEdges ObserveAndConsume(ControllerBindingState bindings, StorageRouteContext context)
		{
			Observe(bindings, context);
			return ConsumePendingEdge();
		}

		internal static StorageActionEdges ConsumePendingEdge()
		{
			StorageActionEdges pendingEdge = _pendingEdge;
			_pendingEdge = StorageActionEdges.None;
			return pendingEdge;
		}

		internal static bool ShouldSuppress(string buttonName)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Invalid comparison between Unknown and I4
			ConfigEntry<bool> enabled = PluginConfig.Enabled;
			if (enabled == null || !enabled.Value)
			{
				return false;
			}
			UpdateReleaseState();
			ConfigEntry<bool> controllerShortcuts = PluginConfig.ControllerShortcuts;
			if (controllerShortcuts != null && controllerShortcuts.Value && ZInput.instance != null)
			{
				bool flag;
				if (_latchedModifier != null)
				{
					flag = _latchedModifier.Held;
				}
				else
				{
					string text = (PluginConfig.ControllerModifier?.Value ?? string.Empty).Trim();
					ButtonDef val = ((text.Length == 0) ? null : ZInput.instance.GetButtonDef(text));
					flag = val != null && val.Held;
				}
				if (flag && _lastProbeFrame != Time.frameCount)
				{
					_lastProbeFrame = Time.frameCount;
					Observe(_sessionBindings ?? StorageControllerBindings.Resolve(), Plugin.CaptureRouteContext());
				}
			}
			if (_latchedModifier == null || ZInput.instance == null)
			{
				return false;
			}
			ButtonDef buttonDef = ZInput.instance.GetButtonDef(buttonName);
			if (buttonDef == null || (int)buttonDef.Source != 180)
			{
				return false;
			}
			string actionPath = buttonDef.GetActionPath(true);
			if (actionPath != null)
			{
				return _sessionPaths.Contains(actionPath);
			}
			return false;
		}

		internal static void Reset()
		{
			_pendingEdge = StorageActionEdges.None;
			_latchedModifier = null;
			_sessionBindings = null;
			_sessionPaths = default(ControllerSessionPaths);
			_releasedFrame = -1;
			_capturedFrame = -1;
			_lastProbeFrame = -1;
		}

		private static void Observe(ControllerBindingState bindings, StorageRouteContext context)
		{
			UpdateReleaseState();
			if (bindings == null || !bindings.ModifierValid || !bindings.Modifier.Held || _capturedFrame == Time.frameCount)
			{
				return;
			}
			StorageActionEdges storageActionEdges = StorageActionEdges.None;
			if (bindings.SortValid && bindings.Sort.Pressed)
			{
				storageActionEdges = StorageActionEdges.ControllerSort;
			}
			else if (bindings.QuickStackValid && bindings.QuickStack.Pressed)
			{
				storageActionEdges = StorageActionEdges.ControllerQuickStack;
			}
			else if (bindings.RestockValid && bindings.Restock.Pressed)
			{
				storageActionEdges = StorageActionEdges.ControllerRestock;
			}
			else if (bindings.ConsolidateValid && bindings.Consolidate.Pressed)
			{
				storageActionEdges = StorageActionEdges.ControllerConsolidate;
			}
			else if (bindings.SearchValid && bindings.Search.Pressed)
			{
				storageActionEdges = StorageActionEdges.ControllerSearch;
			}
			if (storageActionEdges == StorageActionEdges.None)
			{
				return;
			}
			_capturedFrame = Time.frameCount;
			_pendingEdge = storageActionEdges;
			StorageActionRequest request = StorageActionRouter.Select(storageActionEdges);
			StorageRouteDecision decision = StorageActionRouter.Route(request, context);
			bool flag = _latchedModifier != null;
			if (ControllerChordSessionPolicy.Decide(flag, decision) == ControllerChordDisposition.ReportWithoutConsume)
			{
				return;
			}
			if (!flag)
			{
				StartSession(bindings);
			}
			_releasedFrame = -1;
			if (PluginConfig.DebugTransfers.Value)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("input-consumed source=controller action=" + StorageActionDiagnostics.ActionCode(request.Action) + " result=" + ((decision.Outcome == StorageRouteOutcome.Execute) ? "authorized" : "blocked-in-owned-session") + " modifier-session=active configured-button-aliases=suppressed-until-full-release"));
				}
			}
		}

		private static void UpdateReleaseState()
		{
			if (_latchedModifier != null)
			{
				if (_latchedModifier.Held || AnySessionPrimaryHeld())
				{
					_releasedFrame = -1;
				}
				else if (_releasedFrame < 0)
				{
					_releasedFrame = Time.frameCount;
				}
				else if (_releasedFrame != Time.frameCount)
				{
					_latchedModifier = null;
					_sessionBindings = null;
					_sessionPaths = default(ControllerSessionPaths);
					_releasedFrame = -1;
				}
			}
		}

		private static void StartSession(ControllerBindingState bindings)
		{
			_latchedModifier = bindings.Modifier;
			_sessionBindings = bindings;
			_sessionPaths = new ControllerSessionPaths(Path(bindings.Modifier), Path(bindings.QuickStack), Path(bindings.Restock), Path(bindings.Sort), Path(bindings.Consolidate), Path(bindings.Search));
		}

		private static bool AnySessionPrimaryHeld()
		{
			if (!IsHeld(_sessionBindings?.QuickStack) && !IsHeld(_sessionBindings?.Restock) && !IsHeld(_sessionBindings?.Sort) && !IsHeld(_sessionBindings?.Consolidate))
			{
				return IsHeld(_sessionBindings?.Search);
			}
			return true;
		}

		private static bool IsHeld(ButtonDef definition)
		{
			if (definition != null)
			{
				return definition.Held;
			}
			return false;
		}

		private static string Path(ButtonDef definition)
		{
			return ((definition != null) ? definition.GetActionPath(true) : null) ?? string.Empty;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButton", new Type[] { typeof(string) })]
	internal static class StorageControllerGetButtonPatch
	{
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "chazman.RunicAgriculture", "chazman.RunicInventory" })]
		private static bool Prefix(string name, ref bool __result)
		{
			return AllowOrConsume(name, ref __result);
		}

		private static bool AllowOrConsume(string name, ref bool result)
		{
			if (StorageSearchGameplayInputGuard.ShouldSuppressPrimaryAttack(name))
			{
				result = false;
				return false;
			}
			if (!StorageControllerCollisionGuard.ShouldSuppress(name))
			{
				return true;
			}
			result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonDown", new Type[] { typeof(string) })]
	internal static class StorageControllerGetButtonDownPatch
	{
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "chazman.RunicAgriculture", "chazman.RunicInventory" })]
		private static bool Prefix(string name, ref bool __result)
		{
			if (StorageSearchGameplayInputGuard.ShouldSuppressPrimaryAttack(name))
			{
				__result = false;
				return false;
			}
			if (!StorageControllerCollisionGuard.ShouldSuppress(name))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonUp", new Type[] { typeof(string) })]
	internal static class StorageControllerGetButtonUpPatch
	{
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "chazman.RunicAgriculture", "chazman.RunicInventory" })]
		private static bool Prefix(string name, ref bool __result)
		{
			if (StorageSearchGameplayInputGuard.ShouldSuppressPrimaryAttack(name))
			{
				__result = false;
				return false;
			}
			if (!StorageControllerCollisionGuard.ShouldSuppress(name))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonPressedTimer", new Type[] { typeof(string) })]
	internal static class StorageControllerPressedTimerPatch
	{
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "chazman.RunicAgriculture", "chazman.RunicInventory" })]
		private static bool Prefix(string name, ref float __result)
		{
			if (StorageSearchGameplayInputGuard.ShouldSuppressPrimaryAttack(name))
			{
				__result = 0f;
				return false;
			}
			if (!StorageControllerCollisionGuard.ShouldSuppress(name))
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonLastPressedTimer", new Type[] { typeof(string) })]
	internal static class StorageControllerLastPressedTimerPatch
	{
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "chazman.RunicAgriculture", "chazman.RunicInventory" })]
		private static bool Prefix(string name, ref float __result)
		{
			if (StorageSearchGameplayInputGuard.ShouldSuppressPrimaryAttack(name))
			{
				__result = 0f;
				return false;
			}
			if (!StorageControllerCollisionGuard.ShouldSuppress(name))
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetKeyDown", new Type[]
	{
		typeof(KeyCode),
		typeof(bool)
	})]
	internal static class StorageSearchEscapeKeyPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(KeyCode key, ref bool __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!StorageSearchGameplayInputGuard.ShouldSuppressEscape(key))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	internal sealed class RaycastHitDistanceComparer : IComparer<RaycastHit>
	{
		internal static readonly RaycastHitDistanceComparer Instance = new RaycastHitDistanceComparer();

		public int Compare(RaycastHit left, RaycastHit right)
		{
			return ((RaycastHit)(ref left)).distance.CompareTo(((RaycastHit)(ref right)).distance);
		}
	}
	internal sealed class StorageActions
	{
		private sealed class SearchAccumulator
		{
			private readonly List<Container> _containers = new List<Container>();

			internal string ResourceId { get; }

			internal string DisplayName { get; }

			internal int Quantity { get; set; }

			internal SearchAccumulator(string resourceId, string displayName)
			{
				ResourceId = resourceId;
				DisplayName = displayName;
			}

			internal void AddContainer(Container container)
			{
				if ((Object)(object)container != (Object)null && !_containers.Contains(container))
				{
					_containers.Add(container);
				}
			}

			internal StorageSearchEntry ToEntry()
			{
				return new StorageSearchEntry(ResourceId, DisplayName, Quantity, _containers.AsReadOnly());
			}
		}

		private static readonly FieldInfo CurrentContainerField = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");

		private static readonly MethodInfo InventoryChangedMethod = AccessTools.Method(typeof(Inventory), "Changed", (Type[])null, (Type[])null);

		private readonly ContainerIndex _index;

		private readonly StorageSearchPanel _searchPanel;

		internal StorageActions(ContainerIndex index, StorageSearchPanel searchPanel)
		{
			_index = index ?? throw new ArgumentNullException("index");
			_searchPanel = searchPanel ?? throw new ArgumentNullException("searchPanel");
		}

		internal void QuickStack()
		{
			if (!TryBeginMutation("Quick Stack", out var player, out var mutationLease))
			{
				return;
			}
			using (mutationLease)
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				IReadOnlyList<Container> readOnlyList = Nearby(player, requireWritable: true, "quick-stack");
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				int num6 = 0;
				int num7 = 0;
				int num8 = 0;
				Dictionary<Container, Inventory> dictionary = new Dictionary<Container, Inventory>();
				HashSet<Container> hashSet = new HashSet<Container>();
				List<ItemData> list = new List<ItemData>(inventory.GetAllItems());
				list.Sort(CompareGridPosition);
				if (!TryCaptureProtection(list, out var snapshot, out var failureCode))
				{
					Message(player, "Runic Storage: carried-item protection could not be proven; Quick Stack changed nothing.");
					LogAction("quick-stack", failureCode, $"stacks={list.Count} moved=0");
					return;
				}
				int num9 = 0;
				for (int i = 0; i < list.Count; i++)
				{
					ItemData val = list[i];
					StorageProtectionState storageProtectionState = snapshot.StateAt(i);
					if (IsProtected(player, val, storageProtectionState))
					{
						num4++;
						if (storageProtectionState == StorageProtectionState.Locked)
						{
							num9++;
						}
						if (val != null && (val.m_equipped || ((Humanoid)player).IsItemEquiped(val)))
						{
							num6++;
						}
						else if (val != null && PluginConfig.ProtectHotbar.Value && val.m_gridPos.y == 0)
						{
							num5++;
						}
						continue;
					}
					string text = ValheimContainerIdentity.ResourceId(val);
					if (text.Length == 0)
					{
						continue;
					}
					num3++;
					int stack = val.m_stack;
					bool flag = false;
					foreach (Container item in readOnlyList)
					{
						if (val.m_stack <= 0)
						{
							break;
						}
						if (!dictionary.TryGetValue(item, out var value))
						{
							if (hashSet.Contains(item))
							{
								continue;
							}
							if (!StorageContainerAuthority.TryGetSynchronizedServerInventory(item, out value))
							{
								hashSet.Add(item);
								num8++;
								LogTransfer(PlayerEndpointId(player), ValheimContainerIdentity.EndpointId(item), text, 0, "ownership.denied");
								continue;
							}
							dictionary[item] = value;
						}
						if (ContainsResource(value, text))
						{
							if (!flag)
							{
								num2 = AddSaturated(num2, stack);
								num7++;
								flag = true;
							}
							int stack2 = val.m_stack;
							int num10 = ValheimContainerService.MoveUpTo(inventory, value, val, stack2, player, mutationLease, null, item);
							num = AddSaturated(num, num10);
							LogTransfer(PlayerEndpointId(player), ValheimContainerIdentity.EndpointId(item), text, num10, (num10 > 0) ? "ok" : "destination.full");
							if (num10 >= stack2)
							{
								break;
							}
						}
					}
				}
				QuickStackNoOpReason reason = QuickStackDiagnostics.Classify(new QuickStackObservation(list.Count, num3, num4, readOnlyList.Count, num7, num));
				int num11 = Math.Max(0, num2 - num);
				string text2 = ((num > 0) ? $"Runic Storage: moved {num} item(s); {num11} matching item(s) remained." : QuickStackNoOpFeedback(reason, num5, num6, num9));
				Message(player, text2);
				LogAction("quick-stack", (num > 0) ? "ok" : QuickStackDiagnostics.ReasonCode(reason), $"carriedStacks={list.Count} eligibleStacks={num3} protectedStacks={num4} " + $"hotbarProtected={num5} equippedProtected={num6} itemLockProtected={num9} " + $"authorizedContainers={readOnlyList.Count} matchedStacks={num7} " + $"ownershipDenied={num8} moved={num} remainder={num11}");
			}
		}

		internal void StoreAllOpenedContainer()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryBeginMutation("Store All", out var player, out var mutationLease))
			{
				return;
			}
			using (mutationLease)
			{
				Container val = (Container)(((Object)InventoryGui.instance == (Object)null || CurrentContainerField == null) ? null : /*isinst with value type is only supported in some contexts*/);
				if ((Object)val == (Object)null)
				{
					Message(player, "Runic Storage: open a container before using Store All.");
					LogAction("store-all-opened-container", "ui.open-container-required", "container=false moved=0");
					return;
				}
				if ((int)val.m_privacy == 0 || !ValheimContainerService.CanDiscover(val, player.GetPlayerID(), requireWritable: true, allowCurrentUse: true))
				{
					Message(player, "Runic Storage: that container is personal, busy, or denied; Store All changed nothing.");
					LogAction("store-all-opened-container", "container.denied", "authorized=false moved=0");
					return;
				}
				if (!StorageContainerAuthority.TryGetExactOpenedLocalOwnerInventory(val, player, out var inventory))
				{
					Message(player, "Runic Storage: ownership changed before Store All; nothing was changed.");
					LogAction("store-all-opened-container", "ownership.denied", "owner=false moved=0");
					return;
				}
				Inventory inventory2 = ((Humanoid)player).GetInventory();
				List<ItemData> list = new List<ItemData>(inventory2.GetAllItems());
				list.Sort(CompareGridPosition);
				if (!TryCaptureProtection(list, out var snapshot, out var failureCode))
				{
					Message(player, "Runic Storage: carried-item protection could not be proven; Store All changed nothing.");
					LogAction("store-all-opened-container", failureCode, $"stacks={list.Count} moved=0");
					return;
				}
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				for (int i = 0; i < list.Count; i++)
				{
					ItemData val2 = list[i];
					if (val2 != null && val2.m_stack > 0)
					{
						if (val2.m_shared != null && val2.m_shared.m_questItem)
						{
							num4++;
							continue;
						}
						if (IsProtected(player, val2, snapshot.StateAt(i)))
						{
							num3++;
							continue;
						}
						num2 = AddSaturated(num2, val2.m_stack);
						int stack = val2.m_stack;
						int num5 = ValheimContainerService.MoveUpTo(inventory2, inventory, val2, stack, player, mutationLease, null, val);
						num = AddSaturated(num, num5);
						LogTransfer(PlayerEndpointId(player), ValheimContainerIdentity.EndpointId(val), ValheimContainerIdentity.ResourceId(val2), num5, (num5 > 0) ? "ok" : "destination.full");
					}
				}
				int num6 = Math.Max(0, num2 - num);
				string result;
				string text;
				if (num > 0)
				{
					result = ((num6 == 0) ? "ok" : "partial");
					text = ((num6 == 0) ? $"Runic Storage: stored {num} item(s); protected, hotbar, equipped, and quest items were kept." : $"Runic Storage: stored {num} item(s); {num6} eligible item(s) could not fit.");
				}
				else if (list.Count == 0)
				{
					result = "inventory.empty";
					text = "Runic Storage: your carried inventory is empty.";
				}
				else if (num2 == 0)
				{
					result = "inventory.all-protected";
					text = "Runic Storage: every carried stack is protected, equipped, on the protected hotbar, or a quest item.";
				}
				else
				{
					result = "destination.full";
					text = "Runic Storage: the opened container has no room for eligible carried items.";
				}
				Message(player, text);
				LogAction("store-all-opened-container", result, $"stacks={list.Count} eligibleQuantity={num2} protectedStacks={num3} questStacks={num4} moved={num} remainder={num6}");
			}
		}

		internal void Restock()
		{
			if (!TryBeginMutation("Restock", out var player, out var mutationLease))
			{
				return;
			}
			using (mutationLease)
			{
				Dictionary<string, int> dictionary = ParseTargets(PluginConfig.RestockTargets.Value);
				if (dictionary.Count == 0)
				{
					Message(player, "Runic Storage: Restock.Targets has no valid Item=Amount entries.");
					LogAction("restock", "config.targets-invalid", "targets=0");
					return;
				}
				Inventory inventory = ((Humanoid)player).GetInventory();
				List<ItemData> list = new List<ItemData>(inventory.GetAllItems());
				list.Sort(CompareGridPosition);
				if (!TryCaptureProtection(list, out var snapshot, out var failureCode))
				{
					Message(player, "Runic Storage: carried-item protection could not be proven; Restock changed nothing.");
					LogAction("restock", failureCode, $"stacks={list.Count} moved=0");
					return;
				}
				int num = 0;
				foreach (KeyValuePair<string, int> item in dictionary)
				{
					num = AddSaturated(num, Math.Max(0, item.Value - CountMatching(inventory, item.Key)));
				}
				if (num == 0)
				{
					Message(player, "Runic Storage: every configured restock target is already met.");
					LogAction("restock", "targets.already-met", $"targets={dictionary.Count} requested=0");
					return;
				}
				foreach (KeyValuePair<string, int> item2 in dictionary)
				{
					if (Math.Max(0, item2.Value - CountMatching(inventory, item2.Key)) > 0 && HasProtectedPartialMatch(player, list, in snapshot, item2.Key))
					{
						Message(player, "Runic Storage: Restock would modify a protected partial target stack; nothing was changed.");
						LogAction("restock", "protection.target-partial", "target=" + SafeLogValue(item2.Key) + " moved=0");
						return;
					}
				}
				IReadOnlyList<Container> readOnlyList = Nearby(player, requireWritable: true, "restock", allowCurrentUse: true);
				if (readOnlyList.Count == 0)
				{
					Message(player, "Runic Storage: no authorized public container is available in range for restocking.");
					LogAction("restock", "discovery.none-authorized", $"targets={dictionary.Count} requested={num}");
					return;
				}
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				Dictionary<Container, Inventory> dictionary2 = new Dictionary<Container, Inventory>();
				HashSet<Container> hashSet = new HashSet<Container>();
				foreach (KeyValuePair<string, int> item3 in dictionary)
				{
					int num6 = CountMatching(inventory, item3.Key);
					int num7 = Math.Max(0, item3.Value - num6);
					foreach (Container item4 in readOnlyList)
					{
						if (num7 == 0)
						{
							break;
						}
						if (!dictionary2.TryGetValue(item4, out var value))
						{
							if (hashSet.Contains(item4))
							{
								continue;
							}
							if (!TryGetWritableInventory(item4, player, out value))
							{
								hashSet.Add(item4);
								num3++;
								continue;
							}
							dictionary2[item4] = value;
						}
						foreach (ItemData item5 in new List<ItemData>(value.GetAllItems()))
						{
							if (num7 == 0)
							{
								break;
							}
							if (Matches(item5, item3.Key))
							{
								num4++;
								int maximumQuantity = Math.Min(num7, item5.m_stack);
								int num8 = ValheimContainerService.MoveUpTo(value, inventory, item5, maximumQuantity, player, mutationLease, item4);
								num7 -= num8;
								num2 = AddSaturated(num2, num8);
								LogTransfer(ValheimContainerIdentity.EndpointId(item4), PlayerEndpointId(player), item3.Key, num8, (num8 > 0) ? "ok" : "player.full");
								if (num8 == 0)
								{
									break;
								}
							}
						}
					}
					num5 = AddSaturated(num5, num7);
				}
				string result;
				string text;
				if (num2 > 0)
				{
					result = ((num5 == 0) ? "ok" : "partial");
					text = ((num5 == 0) ? $"Runic Storage: restocked {num2} item(s); all configured targets are met." : $"Runic Storage: restocked {num2} item(s); {num5} target item(s) remain unavailable or could not fit.");
				}
				else if (num4 == 0)
				{
					result = "resource.targets-unavailable";
					text = "Runic Storage: the missing configured target items were not found in authorized nearby containers.";
				}
				else
				{
					result = "player.full-or-ownership-unavailable";
					text = "Runic Storage: matching items were found, but your inventory was full or container ownership changed.";
				}
				Message(player, text);
				LogAction("restock", result, $"targets={dictionary.Count} requested={num} sources={readOnlyList.Count} " + $"matchingStacks={num4} ownershipDenied={num3} moved={num2} unmet={num5}");
			}
		}

		internal void Search()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				LogAction("search", "player.unavailable", "player=false");
				return;
			}
			IReadOnlyList<Container> readOnlyList = Nearby(localPlayer, requireWritable: false, "search", allowCurrentUse: true);
			if (readOnlyList.Count == 0)
			{
				Message(localPlayer, "Runic Storage: no authorized public container is visible in the configured range.");
				LogAction("search", "discovery.none-authorized", "containers=0");
				return;
			}
			Dictionary<string, SearchAccumulator> dictionary = new Dictionary<string, SearchAccumulator>(StringComparer.Ordinal);
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				Container container = readOnlyList[i];
				if (!TryGetSearchInventory(container, localPlayer, out var inventory))
				{
					num++;
					continue;
				}
				List<ItemData> allItems = inventory.GetAllItems();
				for (int j = 0; j < allItems.Count && num2 < 8192; j++)
				{
					num2++;
					ItemData val = allItems[j];
					string text = ValheimContainerIdentity.ResourceId(val);
					if (text.Length == 0 || val == null || val.m_stack <= 0)
					{
						continue;
					}
					if (!dictionary.TryGetValue(text, out var value))
					{
						if (dictionary.Count >= StorageSearchPanel.EntryLimit)
						{
							continue;
						}
						value = new SearchAccumulator(text, FriendlyItemName(val));
						dictionary.Add(text, value);
					}
					value.Quantity = AddSaturated(value.Quantity, val.m_stack);
					value.AddContainer(container);
				}
			}
			List<StorageSearchEntry> list = new List<StorageSearchEntry>(dictionary.Count);
			foreach (SearchAccumulator value2 in dictionary.Values)
			{
				list.Add(value2.ToEntry());
			}
			list.Sort(delegate(StorageSearchEntry left, StorageSearchEntry right)
			{
				int num3 = StringComparer.OrdinalIgnoreCase.Compare(left.DisplayName, right.DisplayName);
				return (num3 == 0) ? StringComparer.Ordinal.Compare(left.ResourceId, right.ResourceId) : num3;
			});
			if (list.Count == 0)
			{
				Message(localPlayer, "Runic Storage: the nearby synchronized containers are empty.");
				LogAction("search", "inventory.empty", $"containers={readOnlyList.Count} unsynchronized={num}");
				return;
			}
			_searchPanel.Open(list);
			Message(localPlayer, "Runic Storage: choose an item from the nearby-chest list.");
			LogAction("search", "ok", $"containers={readOnlyList.Count} unsynchronized={num} kinds={list.Count} stacks={num2}");
		}

		internal void SortOpenedContainer()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: 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_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryBeginMutation("Sort", out var player, out var mutationLease))
			{
				return;
			}
			using (mutationLease)
			{
				Container val = (Container)(((Object)InventoryGui.instance == (Object)null || CurrentContainerField == null) ? null : /*isinst with value type is only supported in some contexts*/);
				if ((Object)val == (Object)null)
				{
					Message(player, "Runic Storage: open a container before sorting.");
					LogAction("sort-opened-container", "ui.open-container-required", "container=false");
					return;
				}
				if ((int)val.m_privacy == 0 || !ValheimContainerService.CanDiscover(val, player.GetPlayerID(), requireWritable: true, allowCurrentUse: true))
				{
					Message(player, "Runic Storage: that container is personal, busy, or denied.");
					LogAction("sort-opened-container", "container.denied", "authorized=false");
					return;
				}
				if (!StorageContainerAuthority.TryGetExactOpenedServerOwnerInventory(val, player, out var inventory))
				{
					Message(player, "Runic Storage: ownership changed before the sort; nothing was changed.");
					LogAction("sort-opened-container", "ownership.denied", "owner=false");
					return;
				}
				if (!ValheimContainerService.CanRoundTrip(inventory))
				{
					Message(player, "Runic Storage: this container contains an item that cannot be restored exactly under the current item definitions; sort was safely skipped.");
					LogAction("sort-opened-container", "inventory.not-roundtrippable", "changed=false");
					return;
				}
				ZPackage backup = ValheimContainerService.SaveInventory(inventory);
				HashSet<string> hashSet = ParseLockedSlots(PluginConfig.LockedContainerSlots.Value, inventory.GetWidth(), inventory.GetHeight());
				List<ItemData> list = new List<ItemData>();
				List<Vector2i> list2 = new List<Vector2i>();
				List<ItemData> list3 = new List<ItemData>(inventory.GetAllItems());
				if (list3.Count == 0)
				{
					Message(player, "Runic Storage: the opened container is already empty.");
					LogAction("sort-opened-container", "inventory.empty", $"lockedSlots={hashSet.Count}");
					return;
				}
				foreach (ItemData item in list3)
				{
					if (!hashSet.Contains(SlotKey(item.m_gridPos.x, item.m_gridPos.y)))
					{
						list.Add(item);
					}
				}
				for (int i = 0; i < inventory.GetHeight(); i++)
				{
					for (int j = 0; j < inventory.GetWidth(); j++)
					{
						if (!hashSet.Contains(SlotKey(j, i)))
						{
							list2.Add(new Vector2i(j, i));
						}
					}
				}
				if (list.Count == 0)
				{
					Message(player, "Runic Storage: every occupied slot is locked; nothing was moved.");
					LogAction("sort-opened-container", "inventory.all-locked", $"stacks={list3.Count} lockedSlots={hashSet.Count}");
					return;
				}
				bool flag = false;
				try
				{
					Inventory obj = ValheimContainerService.CloneInventory(inventory);
					ApplySortExact(obj, hashSet);
					string @base = ValheimContainerService.SaveInventory(obj).GetBase64();
					list.Sort(CompareItems);
					for (int k = 0; k < list.Count && k < list2.Count; k++)
					{
						if (list[k].m_gridPos.x != list2[k].x || list[k].m_gridPos.y != list2[k].y)
						{
							flag = true;
						}
						list[k].m_gridPos = list2[k];
					}
					if (flag)
					{
						InventoryChangedMethod.Invoke(inventory, null);
					}
					if (!string.Equals(ValheimContainerService.SaveInventory(inventory).GetBase64(), @base, StringComparison.Ordinal))
					{
						throw new InvalidOperationException("The opened container changed during nonthrowing sort publication.");
					}
				}
				catch (Exception ex)
				{
					try
					{
						ValheimContainerService.RestoreInventory(inventory, backup);
					}
					catch (Exception ex2)
					{
						throw new AggregateException("The opened-container sort failed and its exact rollback failed.", ex, ex2);
					}
					throw;
				}
				Message(player, flag ? $"Runic Storage: sorted {list.Count} stack(s); {hashSet.Count} slot(s) locked." : $"Runic Storage: {list.Count} movable stack(s) were already sorted; nothing changed.");
				LogAction("sort-opened-container", flag ? "ok" : "inventory.already-sorted", $"stacks={list3.Count} movable={list.Count} lockedSlots={hashSet.Count} changed={flag}");
			}
		}

		internal void ConsolidateCarriedStacks()
		{
			if (!TryBeginMutation("Consolidate", out var player, out var mutationLease))
			{
				return;
			}
			using (mutationLease)
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				List<ItemData> list = new List<ItemData>(inventory.GetAllItems());
				list.Sort(CompareGridPosition);
				if (!TryCaptureProtection(list, out var snapshot, out var failureCode))
				{
					Message(player, "Runic Storage: carried-item protection could not be proven; consolidation changed nothing.");
					LogAction("consolidate", failureCode, $"stacks={list.Count} changed=false");
					return;
				}
				if (!ValheimContainerService.CanRoundTrip(inventory))
				{
					Message(player, "Runic Storage: your inventory contains an item that cannot be restored exactly under the current item definitions; consolidation was safely skipped.");
					LogAction("consolidate", "inventory.not-roundtrippable", "changed=false");
					return;
				}
				ZPackage backup = ValheimContainerService.SaveInventory(inventory);
				if (list.Count == 0)
				{
					Message(player, "Runic Storage: your carried inventory is empty.");
					LogAction("consolidate", "inventory.empty", "stacks=0");
					return;
				}
				int num = 0;
				for (int i = 0; i < list.Count; i++)
				{
					if (IsProtected(player, list[i], snapshot.StateAt(i)))
					{
						num++;
					}
				}
				if (num == list.Count)
				{
					Message(player, "Runic Storage: every carried stack is equipped or in a protected hotbar slot.");
					LogAction("consolidate", "inventory.all-protected", $"stacks={list.Count} protectedStacks={num}");
					return;
				}
				int num2 = 0;
				try
				{
					Inventory obj = ValheimContainerService.CloneInventory(inventory);
					int num3 = ApplyConsolidation(obj, player, in snapshot);
					string @base = ValheimContainerService.SaveInventory(obj).GetBase64();
					num2 = ApplyConsolidation(inventory, player, in snapshot);
					if (num2 != num3)
					{
						throw new InvalidOperationException("The carried inventory changed after consolidation preflight.");
					}
					if (num2 > 0)
					{
						InventoryChangedMethod.Invoke(inventory, null);
					}
					if (!string.Equals(ValheimContainerService.SaveInventory(inventory).GetBase64(), @base, StringComparison.Ordinal))
					{
						throw new InvalidOperationException("The carried inventory changed during nonthrowing consolidation publication.");
					}
				}
				catch (Exception ex)
				{
					try
					{
						ValheimContainerService.RestoreInventory(inventory, backup, player, mutationLease);
					}
					catch (Exception ex2)
					{
						throw new AggregateException("Carried-stack consolidation and its exact rollback both failed.", ex, ex2);
					}
					throw;
				}
				Message(player, (num2 > 0) ? $"Runic Storage: consolidated {num2} item(s) into compatible stacks." : "Runic Storage: no compatible partial backpack stacks needed consolidation; protected/equipped or metadata-different stacks were left alone.");
				LogAction("consolidate", (num2 > 0) ? "ok" : "inventory.no-compatible-stacks", $"stacks={list.Count} protectedStacks={num} moved={num2}");
			}
		}

		private static int ApplyConsolidation(Inventory inventory, Player player, in StorageProtectionSnapshot protection)
		{
			List<ItemData> list = new List<ItemData>(inventory.GetAllItems());
			list.Sort(CompareGridPosition);
			if (protection.Count != 0 && list.Count != protection.Count)
			{
				throw new InvalidOperationException("The carried inventory shape changed after protection capture.");
			}
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				ItemData val = list[i];
				if (val == null || val.m_stack <= 0 || IsProtected(player, val, protection.StateAt(i)))
				{
					continue;
				}
				int num2 = ((val.m_shared == null) ? val.m_stack : val.m_shared.m_maxStackSize);
				for (int j = i + 1; j < list.Count; j++)
				{
					if (val.m_stack >= num2)
					{
						break;
					}
					ItemData val2 = list[j];
					if (val2 != null && val2.m_stack > 0 && !IsProtected(player, val2, protection.StateAt(j)) && CanMerge(val, val2))
					{
						int num3 = Math.Min(num2 - val.m_stack, val2.m_stack);
						val.m_stack += num3;
						val2.m_stack -= num3;
						num = AddSaturated(num, num3);
						if (val2.m_stack == 0 && !inventory.RemoveItem(val2))
						{
							throw new InvalidOperationException("A consolidation source changed during mutation.");
						}
					}
				}
			}
			return num;
		}

		private static bool ApplySortExact(Inventory inventory, HashSet<string> lockedSlots)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			List<ItemData> list = new List<ItemData>();
			List<Vector2i> list2 = new List<Vector2i>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (!lockedSlots.Contains(SlotKey(allItem.m_gridPos.x, allItem.m_gridPos.y)))
				{
					list.Add(allItem);
				}
			}
			for (int i = 0; i < inventory.GetHeight(); i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					if (!lockedSlots.Contains(SlotKey(j, i)))
					{
						list2.Add(new Vector2i(j, i));
					}
				}
			}
			list.Sort(CompareItems);
			bool flag = false;
			for (int k = 0; k < list.Count && k < list2.Count; k++)
			{
				flag |= list[k].m_gridPos.x != list2[k].x || list[k].m_gridPos.y != list2[k].y;
				list[k].m_gridPos = list2[k];
			}
			return flag;
		}

		private IReadOnlyList<Container> Nearby(Player player, bool requireWritable, string action, bool allowCurrentUse = false)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(PluginConfig.RangeMeters.Value, 1f, 50f);
			int num2 = Mathf.Clamp(PluginConfig.MaximumCandidates.Value, 1, 256);
			int num3 = _index.RefreshLoadedContainers();
			bool truncated;
			IReadOnlyList<Container> readOnlyList = _index.Nearest(((Component)player).transform.position, num, num2, out truncated);
			List<Container> list = new List<Container>();
			int num4 = 0;
			int num5 = 0;
			foreach (Container item in readOnlyList)
			{
				if ((int)item.m_privacy == 0)
				{
					num4++;
				}
				else if (!ValheimContainerService.CanDiscover(item, player.GetPlayerID(), requireWritable, allowCurrentUse))
				{
					num5++;
				}
				else
				{
					list.Add(item);
				}
			}
			if (PluginConfig.DebugTransfers.Value)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)($"action={action} phase=discovery rangeMeters={num:0.##} maximumCandidates={num2} " + $"loadedRefresh={num3} indexed={readOnlyList.Count} authorized={list.Count} personalExcluded={num4} " + $"deniedOrBusy={num5} truncated={truncated}"));
				}
				if (truncated)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("action=" + action + " result=discovery.truncated remedy=increase-MaximumCandidates-or-reduce-range"));
					}
				}
			}
			return list.AsReadOnly();
		}

		private static bool TryGetWritableInventory(Container container, Player player, out Inventory inventory)
		{
			if ((Object)(object)InventoryGui.instance != (Object)null && CurrentContainerField != null && CurrentContainerField.GetValue(InventoryGui.instance) == container && StorageContainerAuthority.TryGetExactOpenedLocalOwnerInventory(container, player, out inventory))
			{
				return true;
			}
			return StorageContainerAuthority.TryGetSynchronizedServerInventory(container, out inventory);
		}

		private static bool TryGetSearchInventory(Container container, Player player, out Inventory inventory)
		{
			if ((Object)(object)InventoryGui.instance != (Object)null && CurrentContainerField != null && CurrentContainerField.GetValue(InventoryGui.instance) == container && StorageContainerAuthority.TryGetExactOpenedLocalOwnerInventory(container, player, out inventory))
			{
				return true;
			}
			long revision;
			return ContainerHoverContents.TryGetSynchronizedReadSnapshot(container, out inventory, out revision);
		}

		private static string FriendlyItemName(ItemData item)
		{
			string text = item?.m_shared?.m_name ?? ValheimContainerIdentity.ResourceId(item);
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(text))
				{
					text = Localization.instance.Localize(text);
				}
			}
			catch
			{
			}
			text = (text ?? string.Empty).Replace("<", string.Empty).Replace(">", string.Empty).Replace("\r", string.Empty)
				.Replace("\n", string.Empty)
				.Trim();
			if (text.Length == 0)
			{
				text = ValheimContainerIdentity.ResourceId(item);
			}
			if (text.Length > 64)
			{
				return text.Substring(0, 64);
			}
			return text;
		}

		private static bool TryBeginMutation(string action, out Player player, out StorageMutationLease mutationLease)
		{
			mutationLease = null;
			if (!TryResolveOwnedLocalPlayer(action, out player))
			{
				return false;
			}
			if (StorageMutationLease.TryBegin(player, out mutationLease))
			{
				return true;
			}
			Message(player, "Runic Storage: another Storage action is already in progress.");
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)(action + " denied with storage.operation-active."));
			}
			return false;
		}

		private static bool TryResolveOwnedLocalPlayer(string action, out Player player)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0048: Expected O, but got Unknown
			player = Player.m_localPlayer;
			if ((Object)player == (Object)null)
			{
				return false;
			}
			if (!PluginConfig.Enabled.Value)
			{
				Message(player, "Runic Storage is disabled in configuration.");
				return false;
			}
			if ((Object)player == (Object)Player.m_localPlayer && ((Character)player).IsOwner())
			{
				return true;
			}
			Message(player, "Runic Storage: " + action + " requires the owning local player; no carried items were changed.");
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)(action + " denied with authority.local-player-owner-required."));
			}
			return false;
		}

		private static bool IsProtected(Player player, ItemData item, StorageProtectionState typedState = StorageProtectionState.NotApplicable)
		{
			if (item != null && !item.m_equipped && !((Humanoid)player).IsItemEquiped(item) && (!PluginConfig.ProtectHotbar.Value || item.m_gridPos.y != 0))
			{
				return typedState == StorageProtectionState.Locked;
			}
			return true;
		}

		private static bool TryCaptureProtection<T>(IReadOnlyList<T> items, out StorageProtectionSnapshot snapshot, out string failureCode) where T : class
		{
			return StorageItemProtection.TryCapture(items, out snapshot, out failureCode);
		}

		private static bool HasProtectedPartialMatch(Player player, IReadOnlyList<ItemData> items, in StorageProtectionSnapshot protection, string query)
		{
			for (int i = 0; i < items.Count; i++)
			{
				ItemData val = items[i];
				if (Matches(val, query) && IsProtected(player, val, protection.StateAt(i)))
				{
					int num = val?.m_shared?.m_maxStackSize ?? val?.m_stack ?? 0;
					if (val != null && val.m_stack > 0 && val.m_stack < num)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool ContainsResource(Inventory inventory, string resourceId)
		{
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (string.Equals(ValheimContainerIdentity.ResourceId(allItem), resourceId, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static int CountMatching(Inventory inventory, string query)
		{
			int num = 0;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (Matches(allItem, query))
				{
					num = AddSaturated(num, Math.Max(0, allItem.m_stack));
				}
			}
			return num;
		}

		private static bool Matches(ItemData item, string query)
		{
			if (item == null)
			{
				return false;
			}
			if (string.Equals(ValheimContainerIdentity.ResourceId(item), query, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals((item.m_shared?.m_name ?? string.Empty).TrimStart('$'), query.TrimStart('$'), StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		private static bool CanMerge(ItemData left, ItemData right)
		{
			if (left.m_shared != right.m_shared || !string.Equals(ValheimContainerIdentity.ResourceId(left), ValheimContainerIdentity.ResourceId(right), StringComparison.Ordinal) || left.m_quality != right.m_quality || left.m_variant != right.m_variant || left.m_worldLevel != right.m_worldLevel || left.m_crafterID != right.m_crafterID || !string.Equals(left.m_crafterName ?? string.Empty, right.m_crafterName ?? string.Empty, StringComparison.Ordinal) || left.m_pickedUp != right.m_pickedUp || left.m_equipped != right.m_equipped || !left.m_durability.Equals(right.m_durability))
			{
				return false;
			}
			return DictionaryEquals(left.m_customData, right.m_customData);
		}

		private static bool DictionaryEquals(IDictionary<string, string> left, IDictionary<string, string> right)
		{
			int num = left?.Count ?? 0;
			if (num != (right?.Count ?? 0))
			{
				return false;
			}
			if (num == 0)
			{
				return true;
			}
			foreach (KeyValuePair<string, string> item in left)
			{
				if (!right.TryGetValue(item.Key, out var value) || !string.Equals(item.Value, value, StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		private static int CompareItems(ItemData left, ItemData right)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			int num = ((left.m_shared == null) ? int.MaxValue : ((int)left.m_shared.m_itemType));
			int value = ((right.m_shared == null) ? int.MaxValue : ((int)right.m_shared.m_itemType));
			int num2 = num.CompareTo(value);
			if (num2 != 0)
			{
				return num2;
			}
			string x = left.m_shared?.m_name ?? ValheimContainerIdentity.ResourceId(left);
			string y = right.m_shared?.m_name ?? ValheimContainerIdentity.ResourceId(right);
			int num3 = StringComparer.OrdinalIgnoreCase.Compare(x, y);
			if (num3 != 0)
			{
				return num3;
			}
			int num4 = right.m_quality.CompareTo(left.m_quality);
			if (num4 != 0)
			{
				return num4;
			}
			float num5 = ((left.m_shared == null) ? 0f : left.GetWeight(left.m_stack));
			float value2 = ((right.m_shared == null) ? 0f : right.GetWeight(right.m_stack));
			return num5.CompareTo(value2);
		}

		private static int CompareGridPosition(ItemData left, ItemData right)
		{
			int num = left.m_gridPos.y.CompareTo(right.m_gridPos.y);
			if (num == 0)
			{
				return left.m_gridPos.x.CompareTo(right.m_gridPos.x);
			}
			return num;
		}

		private static Dictionary<string, int> ParseTargets(string value)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			string[] array = (value ?? string.Empty).Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split('=');
				if (array2.Length == 2 && int.TryParse(array2[1].Trim(), out var result) && result >= 0)
				{
					string text = array2[0].Trim();
					if (text.Length != 0)
					{
						dictionary[text] = result;
					}
				}
			}
			return dictionary;
		}

		private static HashSet<string> ParseLockedSlots(string value, int width, int height)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			string[] array = (value ?? string.Empty).Split(';');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(',');
				if (array2.Length == 2 && int.TryParse(array2[0], out var result) && int.TryParse(array2[1], out var result2) && result >= 0 && result < width && result2 >= 0 && result2 < height)
				{
					hashSet.Add(SlotKey(result, result2));
				}
			}
			return hashSet;
		}

		private static string SlotKey(int x, int y)
		{
			return x + "," + y;
		}

		private static string CompassDirection(Vector3 delta)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Atan2(delta.x, delta.z) * 57.29578f;
			if (num < 0f)
			{
				num += 360f;
			}
			string[] array = new string[8] { "north", "northeast", "east", "southeast", "south", "southwest", "west", "northwest" };
			return array[Mathf.RoundToInt(num / 45f) % array.Length];
		}

		private static void Message(Player player, string text)
		{
			if ((Object)(object)player != (Object)null)
			{
				((Character)player).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static int AddSaturated(int left, int right)
		{
			if (left <= int.MaxValue - right)
			{
				return left + right;
			}
			return int.MaxValue;
		}

		private static string PlayerEndpointId(Player player)
		{
			return "valheim.player:" + player.GetPlayerID().ToString(CultureInfo.InvariantCulture);
		}

		private static void LogTransfer(string source, string destination, string resource, int quantity, string result)
		{
			if (PluginConfig.DebugTransfers.Value)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"transfer source={source} destination={destination} resource={resource} quantity={quantity} result={result}");
				}
			}
		}

		private static string QuickStackNoOpFeedback(QuickStackNoOpReason reason, int hotbarProtected, int equippedProtected, int itemLockProtected)
		{
			return reason switch
			{
				QuickStackNoOpReason.InventoryEmpty => "Runic Storage: your carried inventory is empty.", 
				QuickStackNoOpReason.AllStacksProtected => $"Runic Storage: no backpack stack is eligible; {hotbarProtected} hotbar, {equippedProtected} equipped, and {itemLockProtected} typed-lock stack(s) are protected.", 
				QuickStackNoOpReason.NoAuthorizedContainers => $"Runic Storage: no authorized public container is available within {Mathf.Clamp(PluginConfig.RangeMeters.Value, 1f, 50f):0.#} m.", 
				QuickStackNoOpReason.NoMatchingResources => "Runic Storage: no eligible backpack item matches an item already stored in an authorized nearby container.", 
				_ => "Runic Storage: matching containers were full or ownership changed; nothing moved.", 
			};
		}

		private static void LogAction(string action, string result, string details)
		{
			if (PluginConfig.DebugTransfers.Value)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("action=" + action + " result=" + result + " " + details));
				}
			}
		}

		private static string SafeLogValue(string value)
		{
			string text = (value ?? string.Empty).Replace('\r', ' ').Replace('\n', ' ').Trim();
			if (text.Length > 64)
			{
				text = text.Substring(0, 64);
			}
			return text.Replace(' ', '_');
		}
	}
	internal static class StorageContainerAuthority
	{
		internal const string ContainerLoadMethodName = "Load";

		internal const string ContainerLoadingFieldName = "m_loading";

		private static readonly MethodInfo LoadMethod = AccessTools.Method(typeof(Container), "Load", (Type[])null, (Type[])null) ?? throw new MissingMethodException(typeof(Container).FullName, "Load");

		private static readonly FieldInfo LoadingField = AccessTools.Field(typeof(Container), "m_loading") ?? throw new MissingFieldException(typeof(Container).FullName, "m_loading");

		private static readonly FieldInfo CurrentContainerField = AccessTools.Field(typeof(InventoryGui), "m_currentContainer") ?? throw new MissingFieldException(typeof(InventoryGui).FullName, "m_currentContainer");

		private static readonly FieldInfo DragItemField = AccessTools.Field(typeof(InventoryGui), "m_dragItem") ?? throw new MissingFieldException(typeof(InventoryGui).FullName, "m_dragItem");

		internal static bool TryGetSynchronizedServerInventory(Container container, out Inventory inventory)
		{
			return TryGetOwnedInventory(container, allowInUse: false, out inventory);
		}

		internal static bool TryGetExactOpenedServerOwnerInventory(Container container, Player player, out Inventory inventory)
		{
			return TryGetExactOpenedLocalOwnerInventory(container, player, out inventory);
		}

		internal static bool TryGetExactOpenedLocalOwnerInventory(Container container, Player player, out Inventory inventory)
		{
			inventory = null;
			if ((Object)(object)container == (Object)null || (Object)(object)player == (Object)null || player != Player.m_localPlayer || !((Character)player).IsOwner() || (Object)(object)InventoryGui.instance == (Object)null || CurrentContainerField.GetValue(InventoryGui.instance) != container || DragItemField.GetValue(InventoryGui.instance) != null || !((Behaviour)container).isActiveAndEnabled || !container.IsInUse() || ((Object)(object)container.m_wagon != (Object)null && container.m_wagon.InUse()))
			{
				return false;
			}
			return TryGetOwnedInventory(container, allowInUse: true, out inventory);
		}

		private static bool TryGetOwnedInventory(Container container, bool allowInUse, out Inventory inventory)
		{
			inventory = null;
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)container == (Object)null || !((Behaviour)container).isActiveAndEnabled || !container.IsOwner() || (!allowInUse && (container.IsInUse() || ((Object)(object)container.m_wagon != (Object)null && container.m_wagon.InUse()))) || (bool)LoadingField.GetValue(container))
			{
				return false;
			}
			ZNetView val = ValheimContainerIdentity.NetworkView(container);
			ZDO val2 = (((Object)(object)val != (Object)null && val.IsValid() && val.IsOwner()) ? val.GetZDO() : null);
			if (val2 == null || val2.GetOwner() != ZNet.GetUID())
			{
				return false;
			}
			if (allowInUse && !val2.GetBool(ZDOVars.s_inUse, false))
			{
				return false;
			}
			try
			{
				LoadMethod.Invoke(container, Array.Empty<object>());
				inventory = container.GetInventory();
				if (inventory == null)
				{
					return false;
				}
				string text = val2.GetString(ZDOVars.s_items, string.Empty);
				return string.IsNullOrEmpty(text) ? (inventory.GetAllItems().Count == 0) : string.Equals(ValheimContainerService.SaveInventory(inventory).GetBase64(), text, StringComparison.Ordinal);
			}
			catch
			{
				inventory = null;
				return false;
			}
		}
	}
	internal static class StorageControllerBindings
	{
		private static bool _hasCachedState;

		private static ControllerBindingCacheKey _cachedKey;

		private static ControllerBindingState _cachedState;

		internal static ControllerBindingState Resolve()
		{
			string text = Name(PluginConfig.ControllerModifier);
			string text2 = Name(PluginConfig.ControllerQuickStack);
			string text3 = Name(PluginConfig.ControllerRestock);
			string text4 = Name(PluginConfig.ControllerSort);
			string text5 = Name(PluginConfig.ControllerConsolidate);
			string text6 = Name(PluginConfig.ControllerSearch);
			ControllerBindingCacheKey controllerBindingCacheKey = new ControllerBindingCacheKey(ZInput.instance, text, text2, text3, text4, text5, text6);
			if (_hasCachedState && _cachedKey.Equals(controllerBindingCacheKey))
			{
				return _cachedState;
			}
			ButtonDef val = ResolveGamepad(text);
			HashSet<string> usedNames = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> usedPaths = new HashSet<string>(StringComparer.Ordinal);
			if (val != null && !Register(text, val, usedNames, usedPaths))
			{
				val = null;
			}
			ButtonDef val2 = ResolveUnique(text2, usedNames, usedPaths);
			ButtonDef val3 = ResolveUnique(text3, usedNames, usedPaths);
			ButtonDef val4 = ResolveUnique(text4, usedNames, usedPaths);
			ButtonDef val5 = ResolveUnique(text5, usedNames, usedPaths);
			ButtonDef val6 = ResolveUnique(text6, usedNames, usedPaths);
			ControllerBindingState controllerBindingState = new ControllerBindingState(string.Join("|", text, Path(val), text2, Path(val2), text3, Path(val3), text4, Path(val4), text5, Path(val5), text6, Path(val6)), text, text2, text3, text4, text5, text6, val, val2, val3, val4, val5, val6);
			_cachedKey = controllerBindingCacheKey;
			_cachedState = controllerBindingState;
			_hasCachedState = true;
			return controllerBindingState;
		}

		internal static void Invalidate()
		{
			_hasCachedState = false;
			_cachedKey = default(ControllerBindingCacheKey);
			_cachedState = null;
		}

		private static ButtonDef ResolveUnique(string action, ISet<string> usedNames, ISet<string> usedPaths)
		{
			ButtonDef val = ResolveGamepad(action);
			if (val != null && Register(action, val, usedNames, usedPaths))
			{
				return val;
			}
			return null;
		}

		private static ButtonDef ResolveGamepad(string action)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			if (action.Length == 0 || action.Length > 64 || !action.StartsWith("Joy", StringComparison.Ordinal) || ZInput.instance == null)
			{
				return null;
			}
			ButtonDef buttonDef = ZInput.instance.GetButtonDef(action);
			if (buttonDef != null && (int)buttonDef.Source == 180 && !string.IsNullOrEmpty(buttonDef.GetActionPath(true)))
			{
				return buttonDef;
			}
			return null;
		}

		private static bool Register(string action, ButtonDef definition, ISet<string> usedNames, ISet<string> usedPaths)
		{
			string text = Path(definition);
			if (text.Length == 0 || usedNames.Contains(action) || usedPaths.Contains(text))
			{
				return false;
			}
			usedNames.Add(action);
			usedPaths.Add(text);
			return true;
		}

		private static string Path(ButtonDef definition)
		{
			return ((definition != null) ? definition.GetActionPath(true) : null) ?? string.Empty;
		}

		private static string Name(ConfigEntry<string> entry)
		{
			return (entry?.Value ?? string.Empty).Trim();
		}
	}
	internal sealed class StorageInputReader
	{
		private string _loggedControllerSignature = string.Empty;

		internal StorageActionEdges ReadKeyboardEdges()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			StorageActionEdges storageActionEdges = StorageActionEdges.None;
			if (ShortcutDown(PluginConfig.SortOpenedContainerKey.Value))
			{
				storageActionEdges |= StorageActionEdges.KeyboardSort;
			}
			if (ShortcutDown(PluginConfig.StoreAllOpenedContainerKey.Value))
			{
				storageActionEdges |= StorageActionEdges.KeyboardStoreAll;
			}
			if (ShortcutDown(PluginConfig.QuickStackKey.Value))
			{
				storageActionEdges |= StorageActionEdges.KeyboardQuickStack;
			}
			if (ShortcutDown(PluginConfig.RestockKey.Value))
			{
				storageActionEdges |= StorageActionEdges.KeyboardRestock;
			}
			if (ShortcutDown(PluginConfig.ConsolidateKey.Value))
			{
				storageActionEdges |= StorageActionEdges.KeyboardConsolidate;
			}
			if (ShortcutDown(PluginConfig.SearchKey.Value))
			{
				storageActionEdges |= StorageActionEdges.KeyboardSearch;
			}
			return storageActionEdges;
		}

		internal StorageActionEdges ReadControllerEdges(StorageRouteContext context)
		{
			if (!PluginConfig.ControllerShortcuts.Value || ZInput.instance == null)
			{
				return StorageActionEdges.None;
			}
			StorageActionEdges storageActionEdges = StorageControllerCollisionGuard.ConsumePendingEdge();
			if (storageActionEdges != StorageActionEdges.None)
			{
				return storageActionEdges;
			}
			if (_loggedControllerSignature.Length != 0)
			{
				string text = (PluginConfig.ControllerModifier.Value ?? string.Empty).Trim();
				ButtonDef val = ((text.Length == 0) ? null : ZInput.instance.GetButtonDef(text));
				if (val == null || !val.Held)
				{
					return StorageActionEdges.None;
				}
			}
			ControllerBindingState bindings = StorageControllerBindings.Resolve();
			LogControllerStatus(bindings);
			return StorageControllerCollisionGuard.ObserveAndConsume(bindings, context);
		}

		internal void InvalidateControllerBindings()
		{
			_loggedControllerSignature = string.Empty;
			StorageControllerBindings.Invalidate();
		}

		internal string ControllerStatusSummary()
		{
			if (!PluginConfig.ControllerShortcuts.Value)
			{
				return "disabled";
			}
			if (ZInput.instance == null)
			{
				return "waiting-for-zinput";
			}
			ControllerBindingState controllerBindingState = StorageControllerBindings.Resolve();
			if (!controllerBindingState.ModifierValid)
			{
				return "invalid-modifier";
			}
			return controllerBindingState.ValidRouteCount + "/5-routes-valid";
		}

		internal static string DescribeEdges(StorageActionEdges edges)
		{
			if (edges == StorageActionEdges.None)
			{
				return "none";
			}
			List<string> values = new List<string>();
			Add(values, edges, StorageActionEdges.KeyboardSort, "keyboard:sort-opened-container");
			Add(values, edges, StorageActionEdges.KeyboardStoreAll, "keyboard:store-all-opened-container");
			Add(values, edges, StorageActionEdges.KeyboardQuickStack, "keyboard:quick-stack");
			Add(values, edges, StorageActionEdges.KeyboardRestock, "keyboard:restock");
			Add(values, edges, StorageActionEdges.KeyboardConsolidate, "keyboard:consolidate");
			Add(values, edges, StorageActionEdges.KeyboardSearch, "keyboard:search");
			Add(values, edges, StorageActionEdges.ControllerSort, "controller:sort-opened-container");
			Add(values, edges, StorageActionEdges.ControllerQuickStack, "controller:quick-stack");
			Add(values, edges, StorageActionEdges.ControllerRestock, "controller:restock");
			Add(values, edges, StorageActionEdges.ControllerConsolidate, "controller:consolidate");
			Add(values, edges, StorageActionEdges.ControllerSearch, "controller:search");
			return string.Join(",", values);
		}

		private void LogControllerStatus(ControllerBindingState bindings)
		{
			if (string.Equals(_loggedControllerSignature, bindings.Signature, StringComparison.Ordinal))
			{
				return;
			}
			_loggedControllerSignature = bindings.Signature;
			if (!bindings.ModifierValid)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Controller shortcuts are unavailable: ModifierAction '" + bindings.ModifierName + "' is not an existing Joy* ZInput action."));
				}
				return;
			}
			LogRouteStatus("QuickStack", bindings.QuickStackName, bindings.QuickStackValid);
			LogRouteStatus("Restock", bindings.RestockName, bindings.RestockValid);
			LogRouteStatus("SortOpenedContainer", bindings.SortName, bindings.SortValid);
			LogRouteStatus("Consolidate", bindings.ConsolidateName, bindings.ConsolidateValid);
			LogRouteStatus("Search", bindings.SearchName, bindings.SearchValid);
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)($"Controller controls (validation={bindings.ValidRouteCount}/5-routes-valid): hold {bindings.ModifierName}; " + "QuickStack=" + bindings.QuickStackName + ", Restock=" + bindings.RestockName + ", SortOpenedContainer=" + bindings.SortName + ", Consolidate=" + bindings.ConsolidateName + ", Search=" + bindings.SearchName + ". An authorized chord owns its modifier plus all configured Storage primary paths until full release."));
			}
		}

		private static void LogRouteStatus(string route, string action, bool valid)
		{
			if (!valid)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Controller route " + route + " is disabled: '" + action + "' is missing, non-gamepad, duplicates the modifier, or duplicates an earlier route."));
				}
			}
		}

		private static bool ShortcutDown(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0 || !ZInput.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey, false))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if ((int)modifier == 0 || !ZInput.GetKey(modifier, false))
				{
					return false;
				}
			}
			return true;
		}

		private static void Add(ICollection<string> values, StorageActionEdges edges, StorageActionEdges expected, string label)
		{
			if ((edges & expected) != StorageActionEdges.None)
			{
				values.Add(label);
			}
		}
	}
	internal sealed class StorageMutationLease : IDisposable
	{
		private static int _active;

		private int _owned;

		internal Player Player { get; }

		internal Inventory Inventory { get; }

		private StorageMutationLease(Player player)
		{
			Player = player;
			Inventory = ((Humanoid)player).GetInventory();
			_owned = 1;
		}

		internal static bool TryBegin(Player player, out StorageMutationLease lease)
		{
			lease = null;
			if ((Object)(object)player == (Object)null || player != Player.m_localPlayer || !((Character)player).IsOwner() || Interlocked.CompareExchange(ref _active, 1, 0) != 0)
			{
				return false;
			}
			lease = new StorageMutationLease(player);
			return true;
		}

		internal bool Covers(Player player, Inventory inventory)
		{
			if (Volatile.Read(in _owned) == 1 && Player == player)
			{
				return Inventory == inventory;
			}
			return false;
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref _owned, 0) == 1)
			{
				Volatile.Write(ref _active, 0);
			}
		}
	}
	internal static class StorageSearchGameplayInputGuard
	{
		private static readonly StorageSearchAttackSuppression AttackSuppression = new StorageSearchAttackSuppression();

		private static bool _pollingPickerEscape;

		private static int _pickerEscapeFrame = -1;

		internal static bool PollPickerEscape()
		{
			_pollingPickerEscape = true;
			try
			{
				bool keyDown = ZInput.GetKeyDown((KeyCode)27, false);
				if (keyDown)
				{
					_pickerEscapeFrame = Time.frameCount;
				}
				return keyDown;
			}
			finally
			{
				_pollingPickerEscape = false;
			}
		}

		internal static bool ShouldSuppressEscape(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)key != 27 || _pollingPickerEscape)
			{
				return false;
			}
			if (!Plugin.SearchPanelOpen)
			{
				return Time.frameCount == _pickerEscapeFrame;
			}
			return true;
		}

		internal static void CaptureGuiPointer(Event current)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if (current != null && current.button == 0 && ((int)current.type == 0 || (int)current.type == 1 || (int)current.type == 3))
			{
				AttackSuppression.CapturePrimaryPointer();
			}
		}

		internal static bool ShouldSuppressPrimaryAttack(string actionName)
		{
			if (!StorageSearchAttackSuppression.IsPrimaryAttack(actionName))
			{
				return false;
			}
			bool primaryAttackHeld = false;
			try
			{
				ZInput instance = ZInput.instance;
				if (instance != null)
				{
					ButtonDef buttonDef = instance.GetButtonDef("Attack");
					primaryAttackHeld = buttonDef != null && buttonDef.Held;
				}
			}
			catch
			{
				primaryAttackHeld = false;
			}
			return AttackSuppression.ShouldSuppress(actionName, Plugin.SearchPanelOpen, primaryAttackHeld, Time.frameCount);
		}

		internal static void Reset()
		{
			AttackSuppression.Reset();
			_pollingPickerEscape = false;
			_pickerEscapeFrame = -1;
		}
	}
	internal sealed class StorageSearchEntry
	{
		internal string ResourceId { get; }

		internal string DisplayName { get; }

		internal int Quantity { get; }

		internal IReadOnlyList<Container> Containers { get; }

		internal StorageSearchEntry(string resourceId, string displayName, int quantity, IReadOnlyList<Container> containers)
		{
			ResourceId = resourceId ?? string.Empty;
			DisplayName = displayName ?? string.Empty;
			Quantity = Math.Max(0, quantity);
			Containers = containers ?? Array.Empty<Container>();
		}
	}
	internal sealed class StorageSearchPanel : IDisposable
	{
		private const int MaximumEntries = 256;

		private readonly List<StorageSearchEntry> _entries = new List<StorageSearchEntry>();

		private string _filter = string.Empty;

		private bool _open;

		private bool _focusFilter;

		private bool _cursorVisible;

		private CursorLockMode _cursorLock;

		private GameObject _canvasObject;

		private RectTransform _panelRect;

		private RectTransform _entryContent;

		private ScrollRect _scrollRect;

		private TMP_InputField _filterInput;

		private StorageSearchVanillaTheme _theme;

		private int _themeSourceToken = int.MinValue;

		private int _appearanceFontSize = -1;

		private StorageSearchMenuColor _appearanceFontColor;

		private float _savedScrollPosition = 1f;

		private float _nextThemeSourceCheck;

		internal bool IsOpen => _open;

		internal static int EntryLimit => 256;

		internal void Open(IReadOnlyList<StorageSearchEntry> entries)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Close();
			_entries.Clear();
			if (entries != null)
			{
				for (int i = 0; i < entries.Count; i++)
				{
					if (_entries.Count >= 256)
					{
						break;
					}
					if (entries[i] != null)
					{
						_entries.Add(entries[i]);
					}
				}
			}
			_filter = string.Empty;
			_savedScrollPosition = 1f;
			_cursorVisible = Cursor.visible;
			_cursorLock = Cursor.lockState;
			_open = true;
			_focusFilter = true;
			RenewCursorLease();
			EnsureNativeView(force: true);
		}

		internal void Tick()
		{
			if (_open)
			{
				RenewCursorLease();
				EnsureNativeView(force: false);
				if (_focusFilter && Object.op_Implicit((Object)(object)_filterInput))
				{
					((Selectable)_filterInput).Select();
					_filterInput.ActivateInputField();
					_focusFilter = false;
				}
				if (StorageSearchGameplayInputGuard.PollPickerEscape())
				{
					Close();
				}
			}
		}

		internal void Draw()
		{
			if (_open)
			{
				RenewCursorLease();
				StorageSearchGameplayInputGuard.CaptureGuiPointer(Event.current);
			}
		}

		internal static void RenewCursorLease()
		{
			if (Plugin.SearchPanelOpen)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}

		internal void Close()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (_open)
			{
				_open = false;
				_focusFilter = false;
				if (Object.op_Implicit((Object)(object)_filterInput))
				{
					_filterInput.DeactivateInputField(false);
				}
				DestroyNativeView();
				Cursor.visible = _cursorVisible;
				Cursor.lockState = _cursorLock;
			}
		}

		public void Dispose()
		{
			Close();
			DestroyNativeView();
			_entries.Clear();
			StorageSearchHighlight.ClearAll();
		}

		private void EnsureNativeView(bool force)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			int num = _themeSourceToken;
			if (force || !Object.op_Implicit((Object)(object)_canvasObject) || Time.unscaledTime >= _nextThemeSourceCheck)
			{
				num = StorageSearchVanillaTheme.CurrentSourceToken();
				_nextThemeSourceCheck = Time.unscaledTime + 1f;
			}
			int num2 = PluginConfig.SearchMenuFontSize?.Value ?? 14;
			StorageSearchMenuColor storageSearchMenuColor = StorageSearchMenuAppearance.ResolveFontColor(PluginConfig.SearchMenuFontColor?.Value ?? StorageSearchMenuFontColor.LightGray);
			if (!force && Object.op_Implicit((Object)(object)_canvasObject) && _themeSourceToken == num && _appearanceFontSize == num2 && _appearanceFontColor.Equals(storageSearchMenuColor))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)_scrollRect))
			{
				_savedScrollPosition = _scrollRect.verticalNormalizedPosition;
			}
			DestroyNativeView();
			_themeSourceToken = num;
			_appearanceFontSize = num2;
			_appearanceFontColor = storageSearchMenuColor;
			_theme = StorageSearchVanillaTheme.Create();
			StorageSearchMenuLayout layout = StorageSearchMenuAppearance.LayoutFor(num2);
			Color textColor = ToColor(storageSearchMenuColor);
			try
			{
				BuildNativeView(layout, textColor);
			}
			catch (Exception ex)
			{
				DestroyNativeView();
				_themeSourceToken = num;
				_theme = StorageSearchVanillaTheme.CreateFallback();
				try
				{
					BuildNativeView(layout, textColor);
				}
				catch (Exception ex2)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogError((object)("Runic Storage could not create the native Alt+F menu; search closed safely. Native=" + ex.Message + "; fallback=" + ex2.Message));
					}
					Close();
				}
			}
		}

		private void BuildNativeView(StorageSearchMenuLayout layout, Color textColor)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: 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_03d1: Expected O, but got Unknown
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Expected O, but got Unknown
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			_canvasObject = new GameObject("RunicStorageNativeSearchCanvas", new Type[4]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			((Object)_canvasObject).hideFlags = (HideFlags)61;
			Canvas component = _canvasObject.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			Canvas val = (Object.op_Implicit((Object)(object)InventoryGui.instance) ? ((Component)InventoryGui.instance).GetComponentInParent<Canvas>() : null);
			component.sortingOrder = (Object.op_Implicit((Object)(object)val) ? (val.sortingOrder + 100) : 1000);
			CopyCanvasScale(_theme.SourceScaler, _canvasObject.GetComponent<CanvasScaler>());
			RectTransform component2 = _canvasObject.GetComponent<RectTransform>();
			Stretch(component2);
			Stretch(((Graphic)CreateImage("SceneScrim", (Transform)(object)component2, null, (Type)0, new Color(0f, 0f, 0f, 0.68f))).rectTransform);
			Image val2 = CreateImage("ValheimSearchPanel", (Transform)(object)component2, _theme.PanelSprite, _theme.PanelType, _theme.HasNativePanel ? _theme.PanelColor : Color32.op_Implicit(new Color32((byte)60, (byte)42, (byte)29, byte.MaxValue)));
			if (Object.op_Implicit((Object)(object)_theme.PanelMaterial))
			{
				((Graphic)val2).material = _theme.PanelMaterial;
			}
			_panelRect = ((Graphic)val2).rectTransform;
			RectTransform panelRect = _panelRect;
			RectTransform panelRect2 = _panelRect;
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			panelRect2.anchorMax = val3;
			panelRect.anchorMin = val3;
			_panelRect.pivot = new Vector2(0.5f, 0.5f);
			_panelRect.anchoredPosition = Vector2.zero;
			_panelRect.sizeDelta = new Vector2((float)layout.PreferredWindowWidth, (float)layout.PreferredWindowHeight);
			VerticalLayoutGroup obj = ((Component)val2).gameObject.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(28, 28, 34, 26);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 7f;
			((LayoutGroup)obj).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			SetHeight(((Component)CreateText(((Component)val2).transform, "Runic Storage — Nearby Items", layout.FontSize, textColor, (TextAlignmentOptions)514)).gameObject, layout.FontSize + 18);
			SetHeight(((Component)CreateText(((Component)val2).transform, "Select an item to mark every nearby chest that contains it.", layout.FontSize, textColor, (TextAlignmentOptions)513)).gameObject, layout.FontSize * 2 + 10);
			RectTransform val4 = CreateRect("FilterRow", ((Component)val2).transform);
			SetHeight(((Component)val4).gameObject, Math.Max(layout.ControlHeight, _theme.ControlHeight));
			HorizontalLayoutGroup obj2 = ((Component)val4).gameObject.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 8f;
			((LayoutGroup)obj2).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			SetWidth(((Component)CreateText((Transform)(object)val4, "Filter", layout.FontSize, textColor, (TextAlignmentOptions)4097)).gameObject, Math.Max(52f, (float)layout.FontSize * 4f));
			_filterInput = CreateInput((Transform)(object)val4, layout, textColor);
			LayoutElement obj3 = ((Component)_filterInput).gameObject.AddComponent<LayoutElement>();
			obj3.flexibleWidth = 1f;
			obj3.minWidth = 120f;
			((UnityEvent)CreateButton((Transform)(object)val4, "Clear", layout, textColor).onClick).AddListener(new UnityAction(ClearFilter));
			((UnityEvent)CreateButton((Transform)(object)val4, "Close", layout, textColor).onClick).AddListener(new UnityAction(Close));
			_scrollRect = CreateScrollView(((Component)val2).transform);
			LayoutElement obj4 = ((Component)_scrollRect).gameObject.AddComponent<LayoutElement>();
			obj4.flexibleHeight = 1f;
			obj4.minHeight = 140f;
			RebuildEntryRows(layout, textColor);
			Canvas.ForceUpdateCanvases();
			_scrollRect.verticalNormalizedPosition = Mathf.Clamp01(_savedScrollPosition);
			_focusFilter = true;
		}

		private TMP_InputField CreateInput(Transform parent, StorageSearchMenuLayout layout, Color textColor)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			Image val = CreateImage("FilterInput", parent, _theme.InputSprite, _theme.InputType, Object.op_Implicit((Object)(object)_theme.InputSprite) ? _theme.InputColor : Color32.op_Implicit(new Color32((byte)37, (byte)24, (byte)16, byte.MaxValue)));
			if (Object.op_Implicit((Object)(object)_theme.InputMaterial))
			{
				((Graphic)val).material = _theme.InputMaterial;
			}
			TMP_InputField obj = ((Component)val).gameObject.AddComponent<TMP_InputField>();
			((Selectable)obj).targetGraphic = (Graphic)(object)val;
			obj.characterLimit = 64;
			obj.lineType = (LineType)0;
			((Selectable)obj).transition = (Transition)1;
			obj.customCaretColor = true;
			obj.caretColor = textColor;
			obj.selectionColor = new Color(textColor.r, textColor.g, textColor.b, 0.38f);
			RectTransform val2 = CreateRect("Text Area", ((Component)val).transform);
			Stretch(val2, 9f, 9f, 3f, 3f);
			((Component)val2).gameObject.AddComponent<RectMask2D>();
			TMP_Text val3 = CreateText((Transform)(object)val2, _filter, layout.FontSize, textColor, (TextAlignmentOptions)4097);
			Stretch(val3.rectTransform);
			TMP_Text val4 = CreateText((Transform)(object)val2, "type to filter…", layout.FontSize, new Color(textColor.r, textColor.g, textColor.b, 0.52f), (TextAlignmentOptions)4097);
			Stretch(val4.rectTransform);
			val4.fontStyle = (FontStyles)2;
			obj.textViewport = val2;
			obj.textComponent = val3;
			obj.placeholder = (Graphic)(object)val4;
			obj.SetTextWithoutNotify(_filter);
			((UnityEvent<string>)(object)obj.onValueChanged).AddListener((UnityAction<string>)OnFilterChanged);
			return obj;
		}

		private ScrollRect CreateScrollView(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			Image val = CreateImage("NearbyItems", parent, _theme.InsetSprite, _theme.InsetType, Object.op_Implicit((Object)(object)_theme.InsetSprite) ? _theme.InsetColor : Color32.op_Implicit(new Color32((byte)24, (byte)16, (byte)11, (byte)242)));
			if (Object.op_Implicit((Object)(object)_theme.InsetMaterial))
			{
				((Graphic)val).material = _theme.InsetMaterial;
			}
			ScrollRect obj = ((Component)val).gameObject.AddComponent<ScrollRect>();
			obj.horizontal = false;
			obj.vertical = true;
			obj.movementType = (MovementType)2;
			obj.scrollSensitivity = 34f;
			RectTransform val2 = CreateRect("Viewport", ((Component)val).transform);
			Stretch(val2, 6f, 25f, 6f, 6f);
			((Component)val2).gameObject.AddComponent<RectMask2D>();
			_entryContent = CreateRect("Content", (Transform)(object)val2);
			_entryContent.anchorMin = new Vector2(0f, 1f);
			_entryContent.anchorMax = new Vector2(1f, 1f);
			_entryContent.pivot = new Vector2(0.5f, 1f);
			_entryContent.anchoredPosition = Vector2.zero;
			_entryContent.sizeDelta = Vector2.zero;
			VerticalLayoutGroup obj2 = ((Component)_entryContent).gameObject.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj2).padding = new RectOffset(3, 3, 3, 3);
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 5f;
			((LayoutGroup)obj2).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((Component)_entryContent).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			obj.viewport = val2;
			obj.content = _entryContent;
			Scrollbar verticalScrollbar = CreateScrollbar(((Component)val).transform);
			obj.verticalScrollbar = verticalScrollbar;
			obj.verticalScrollbarVisibility = (ScrollbarVisibility)1;
			obj.verticalScrollbarSpacing = 4f;
			return obj;
		}

		private Scrollbar CreateScrollbar(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			Image val = CreateImage("Scrollbar", parent, _theme.ScrollbarSprite, _theme.ScrollbarType, Object.op_Implicit((Object)(object)_theme.ScrollbarSprite) ? _theme.ScrollbarColor : Color32.op_Implicit(new Color32((byte)32, (byte)21, (byte)14, (byte)245)));
			if (Object.op_Implicit((Object)(object)_theme.ScrollbarMaterial))
			{
				((Graphic)val).material = _theme.ScrollbarMaterial;
			}
			RectTransform rectTransform = ((Graphic)val).rectTransform;
			rectTransform.anchorMin = new Vector2(1f, 0f);
			rectTransform.anchorMax = Vector2.one;
			rectTransform.pivot = new Vector2(1f, 0.5f);
			rectTransform.offsetMin = new Vector2(-20f, 5f);
			rectTransform.offsetMax = new Vector2(-4f, -5f);
			Scrollbar obj = ((Component)val).gameObject.AddComponent<Scrollbar>();
			RectTransform val2 = CreateRect("Sliding Area", (Transform)(object)rectTransform);
			Stretch(val2, 2f, 2f, 2f, 2f);
			Image val3 = CreateImage("Handle", (Transform)(object)val2, _theme.ScrollbarHandleSprite, _theme.ScrollbarHandleType, Object.op_Implicit((Object)(object)_theme.ScrollbarHandleSprite) ? _theme.ScrollbarHandleColor : Color32.op_Implicit(new Color32((byte)183, (byte)122, (byte)53, byte.MaxValue)));
			if (Object.op_Implicit((Object)(object)_theme.ScrollbarHandleMaterial))
			{
				((Graphic)val3).material = _theme.ScrollbarHandleMaterial;
			}
			((Graphic)val3).rectTransform.anchorMin = Vector2.zero;
			((Graphic)val3).rectTransform.anchorMax = Vector2.one;
			((Graphic)val3).rectTransform.offsetMin = Vector2.zero;
			((Graphic)val3).rectTransform.offsetMax = Vector2.zero;
			obj.handleRect = ((Graphic)val3).rectTransform;
			((Selectable)obj).targetGraphic = (Graphic)(object)val3;
			obj.direction = (Direction)2;
			((Selectable)obj).transition = (Transition)1;
			((Selectable)obj).colors = _theme.ButtonColors;
			obj.value = 1f;
			return obj;
		}

		private void RebuildEntryRows(StorageSearchMenuLayout layout, Color textColor)
		{
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)_entryContent))
			{
				return;
			}
			for (int num = ((Transform)_entryContent).childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)((Transform)_entryContent).GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.Destroy((Object)(object)gameObject);
			}
			int num2 = 0;
			for (int i = 0; i < _entries.Count; i++)
			{
				StorageSearchEntry storageSearchEntry = _entries[i];
				if (MatchesFilter(storageSearchEntry, _filter))
				{
					num2++;
					string label = storageSearchEntry.DisplayName + "  ×" + storageSearchEntry.Quantity + "  —  " + storageSearchEntry.Containers.Count + ((storageSearchEntry.Containers.Count == 1) ? " chest" : " chests");
					Button obj = CreateButton((Transform)(object)_entryContent, label, layout, textColor, Math.Max(layout.ItemHeight, _theme.ControlHeight));
					StorageSearchEntry selected = storageSearchEntry;
					((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
					{
						Select(selected);
					});
				}
			}
			if (num2 == 0)
			{
				SetHeight(((Component)CreateText((Transform)(object)_entryContent, "No nearby item matches that filter.", layout.FontSize, textColor, (TextAlignmentOptions)514)).gameObject, Math.Max(layout.ItemHeight * 2, 60));
			}
		}

		private Button CreateButton(Transform parent, string label, StorageSearchMenuLayout layout, Color textColor, float height = -1f)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			Image val = CreateImage("Button_" + label, parent, _theme.ButtonSprite, _theme.ButtonImageType, _theme.HasNativeButton ? _theme.ButtonImageColor : Color32.op_Implicit(new Color32((byte)74, (byte)47, (byte)30, byte.MaxValue)));
			if (Object.op_Implicit((Object)(object)_theme.ButtonMaterial))
			{
				((Graphic)val).material = _theme.ButtonMaterial;
			}
			Button val2 = ((Component)val).gameObject.AddComponent<Button>();
			((Selectable)val2).targetGraphic = (Graphic)(object)val;
			((Selectable)val2).colors = _theme.ButtonColors;
			((Selectable)val2).spriteState = _theme.ButtonSprites;
			((Selectable)val2).transition = (Transition)(((int)_theme.ButtonTransition == 3) ? 1 : ((int)_theme.ButtonTransition));
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)val2).navigation = navigation;
			TMP_Text obj = CreateText(((Component)val2).transform, label, layout.FontSize, textColor, (TextAlignmentOptions)514);
			Stretch(obj.rectTransform, 8f, 8f, 2f, 2f);
			((Graphic)obj).raycastTarget = false;
			LayoutElement val3 = ((Component)val).gameObject.AddComponent<LayoutElement>();
			val3.preferredHeight = ((height > 0f) ? height : ((float)Math.Max(layout.ControlHeight, _theme.ControlHeight)));
			if (height < 0f)
			{
				val3.preferredWidth = layout.ActionButtonWidth;
				val3.minWidth = layout.ActionButtonWidth;
			}
			return val2;
		}

		private TMP_Text CreateText(Transform parent, string value, int fontSize, Color color, TextAlignmentOptions alignment)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = ((Component)CreateRect("Text", parent)).gameObject.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val).text = value ?? string.Empty;
			if (_theme != null && Object.op_Implicit((Object)(object)_theme.Font))
			{
				((TMP_Text)val).font = _theme.Font;
			}
			((TMP_Text)val).fontSize = fontSize;
			((Graphic)val).color = color;
			((TMP_Text)val).alignment = alignment;
			((TMP_Text)val).overflowMode = (TextOverflowModes)1;
			((Graphic)val).raycastTarget = false;
			return (TMP_Text)(object)val;
		}

		private void OnFilterChanged(string value)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			_filter = value ?? string.Empty;
			StorageSearchMenuLayout layout = StorageSearchMenuAppearance.LayoutFor(PluginConfig.SearchMenuFontSize?.Value ?? 14);
			RebuildEntryRows(layout, ToColor(_appearanceFontColor));
			if (Object.op_Implicit((Object)(object)_scrollRect))
			{
				_scrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private void ClearFilter()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			_filter = string.Empty;
			if (Object.op_Implicit((Object)(object)_filterInput))
			{
				_filterInput.SetTextWithoutNotify(string.Empty);
				((Selectable)_filterInput).Select();
				_filterInput.ActivateInputField();
			}
			RebuildEntryRows(StorageSearchMenuAppearance.LayoutFor(_appearanceFontSize), ToColor(_appearanceFontColor));
			if (Object.op_Implicit((Object)(object)_scrollRect))
			{
				_scrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private void DestroyNativeView()
		{
			_filterInput = null;
			_scrollRect = null;
			_entryContent = null;
			_panelRect = null;
			_theme = null;
			if (Object.op_Implicit((Object)(object)_canvasObject))
			{
				_canvasObject.SetActive(false);
				Object.Destroy((Object)(object)_canvasObject);
			}
			_canvasObject = null;
			_themeSourceToken = int.MinValue;
		}

		private static Image CreateImage(string name, Transform parent, Sprite sprite, Type type, Color color)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Image obj = ((Component)CreateRect(name, parent)).gameObject.AddComponent<Image>();
			obj.sprite = sprite;
			obj.type = (Type)(Object.op_Implicit((Object)(object)sprite) ? ((int)type) : 0);
			((Graphic)obj).color = color;
			return obj;
		}

		private static RectTransform CreateRect(string name, Transform parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) })
			{
				hideFlags = (HideFlags)61
			}.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			return component;
		}

		private static void Stretch(RectTransform rect, float left = 0f, float right = 0f, float top = 0f, float bottom = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}

		private static void SetHeight(GameObject target, float height)
		{
			LayoutElement obj = target.GetComponent<LayoutElement>() ?? target.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.minHeight = height;
		}

		private static void SetWidth(GameObject target, float width)
		{
			LayoutElement obj = target.GetComponent<LayoutElement>() ?? target.AddComponent<LayoutElement>();
			obj.preferredWidth = width;
			obj.minWidth = width;
		}

		private static void CopyCanvasScale(CanvasScaler source, CanvasScaler target)
		{
			//IL_003b: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)target))
			{
				if (!Object.op_Implicit((Object)(object)source))
				{
					target.uiScaleMode = (ScaleMode)1;
					target.referenceResolution = new Vector2(1920f, 1080f);
					target.matchWidthOrHeight = 0.5f;
					return;
				}
				target.uiScaleMode = source.uiScaleMode;
				target.referencePixelsPerUnit = source.referencePixelsPerUnit;
				target.scaleFactor = source.scaleFactor;
				target.referenceResolution = source.referenceResolution;
				target.screenMatchMode = source.screenMatchMode;
				target.matchWidthOrHeight = source.matchWidthOrHeight;
				target.physicalUnit = source.physicalUnit;
				target.fallbackScreenDPI = source.fallbackScreenDPI;
				target.defaultSpriteDPI = source.defaultSpriteDPI;
				target.dynamicPixelsPerUnit = source.dynamicPixelsPerUnit;
			}
		}

		private static Color ToColor(StorageSearchMenuColor value)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Color32.op_Implicit(new Color32(value.Red, value.Green, value.Blue, value.Alpha));
		}

		private void Select(StorageSearchEntry entry)
		{
			StorageSearchHighlight.ClearAll();
			int num = 0;
			for (int i = 0; i < entry.Containers.Count; i++)
			{
				Container val = entry.Containers[i];
				if (Object.op_Implicit((Object)(object)val) && ((Behaviour)val).isActiveAndEnabled)
				{
					(((Component)val).GetComponent<StorageSearchHighlight>() ?? ((Component)val).gameObject.AddComponent<StorageSearchHighlight>()).Activate();
					num++;
				}
			}
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer))
			{
				((Character)localPlayer).Message((MessageType)2, "Runic Storage: highlighted " + num + " chest(s) containing " + entry.DisplayName + ".", 0, (Sprite)null);
			}
			Close();
		}

		private static bool MatchesFilter(StorageSearchEntry entry, string filter)
		{
			string text = (filter ?? string.Empty).Trim();
			if (text.Length != 0 && entry.DisplayName.IndexOf(text, StringComparison.OrdinalIgnoreCase) < 0)
			{
				return entry.ResourceId.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}
	}
	internal sealed class StorageSearchHighlight : MonoBehaviour
	{
		private const float LifetimeSeconds = 15f;

		private const int Segments = 48;

		private GameObject _visualRoot;

		private LineRenderer[] _rings;

		private Material _material;

		private Light _light;

		private Vector3 _center;

		private float _radius;

		private float _height;

		private float _expiresAt;

		private bool _stopping;

		internal void Activate()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_010a: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			if (_stopping)
			{
				return;
			}
			_expiresAt = Time.unscaledTime + 15f;
			if (Object.op_Implicit((Object)(object)_visualRoot))
			{
				if (!VisualsAreValid())
				{
					StopHighlight();
				}
				return;
			}
			Bounds bounds = default(Bounds);
			((Bounds)(ref bounds))..ctor(((Component)this).transform.position, Vector3.one);
			Renderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>();
			bool flag = false;
			foreach (Renderer val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val) && !(val is LineRenderer))
				{
					if (!flag)
					{
						bounds = val.bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(val.bounds);
					}
				}
			}
			_center = ((Bounds)(ref bounds)).center;
			_radius = Math.Max(0.75f, Math.Max(((Bounds)(ref bounds)).extents.x, ((Bounds)(ref bounds)).extents.z) * 1.35f);
			_height = Math.Max(0.6f, ((Bounds)(ref bounds)).size.y);
			_visualRoot = new GameObject("RunicStorageSearchGlow");
			_visualRoot.transform.SetParent(((Component)this).transform, true);
			_visualRoot.transform.position = _center;
			Shader val2 = Shader.Find("Sprites/Default") ?? Shader.Find("UI/Default");
			if ((Object)(object)val2 != (Object)null)
			{
				_material = new Material(val2);
			}
			_rings = (LineRenderer[])(object)new LineRenderer[2];
			for (int j = 0; j < _rings.Length; j++)
			{
				GameObject val3 = new GameObject("RunicStorageSearchRing" + j);
				val3.transform.SetParent(_visualRoot.transform, false);
				LineRenderer val4 = val3.AddComponent<LineRenderer>();
				if (!Object.op_Implicit((Object)(object)val4))
				{
					StopHighlight();
					return;
				}
				val4.useWorldSpace = true;
				val4.loop = true;
				val4.positionCount = 48;
				val4.widthMultiplier = 0.075f;
				if (!ApplyColor(val4, new Color(1f, 0.8f, 0.05f, 1f), new Color(1f, 0.95f, 0.3f, 1f)))
				{
					StopHighlight();
					return;
				}
				if ((Object)(object)_material != (Object)null)
				{
					((Renderer)val4).sharedMaterial = _material;
				}
				_rings[j] = val4;
			}
			if (!Object.op_Implicit((Object)(object)_visualRoot))
			{
				StopHighlight();
				return;
			}
			_light = _visualRoot.AddComponent<Light>();
			if (!Object.op_Implicit((Object)(object)_light))
			{
				StopHighlight();
				return;
			}
			_light.type = (LightType)2;
			_light.color = new Color(1f, 0.72f, 0.05f);
			_light.range = _radius * 3f;
			_light.shadows = (LightShadows)0;
			if (!TryUpdateVisuals())
			{
				StopHighlight();
			}
		}

		private void Update()
		{
			if (!_stopping)
			{
				if (Time.unscaledTime >= _expiresAt)
				{
					StopHighlight();
				}
				else if (!TryUpdateVisuals())
				{
					StopHighlight();
				}
			}
		}

		private bool TryUpdateVisuals()
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			if (!VisualsAreValid())
			{
				return false;
			}
			try
			{
				float unscaledTime = Time.unscaledTime;
				for (int i = 0; i < _rings.Length; i++)
				{
					if (!Object.op_Implicit((Object)(object)_visualRoot))
					{
						return false;
					}
					LineRenderer val = _rings[i];
					if (!Object.op_Implicit((Object)(object)val))
					{
						return false;
					}
					float num = ((i == 0) ? 1f : (-1f));
					float num2 = unscaledTime * (1.8f + (float)i * 0.45f) * num;
					float num3 = _center.y - _height * 0.35f + (float)i * _height * 0.7f;
					for (int j = 0; j < 48; j++)
					{
						float num4 = (float)j * MathF.PI * 2f / 48f + num2;
						float num5 = Mathf.Sin(num4 * 3f + unscaledTime * 4f) * 0.08f;
						val.SetPosition(j, new Vector3(_center.x + Mathf.Cos(num4) * (_radius + num5), num3 + Mathf.Sin(num4 * 2f + unscaledTime * 3f) * 0.08f, _center.z + Mathf.Sin(num4) * (_radius + num5)));
					}
				}
				if (!Object.op_Implicit((Object)(object)_light))
				{
					return false;
				}
				_light.intensity = 1.7f + Mathf.Sin(unscaledTime * 5f) * 0.45f;
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private bool VisualsAreValid()
		{
			if (!Object.op_Implicit((Object)(object)_visualRoot) || _rings == null || _rings.Length != 2 || !Object.op_Implicit((Object)(object)_light))
			{
				return false;
			}
			for (int i = 0; i < _rings.Length; i++)
			{
				if (!Object.op_Implicit((Object)(object)_rings[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool ApplyColor(LineRenderer ring, Color start, Color end)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ring))
			{
				return false;
			}
			try
			{
				ring.startColor = start;
				ring.endColor = end;
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private void StopHighlight()
		{
			if (!_stopping)
			{
				_stopping = true;
				((Behaviour)this).enabled = false;
				Object.Destroy((Object)(object)this);
			}
		}

		private void OnDestroy()
		{
			_stopping = true;
			((Behaviour)this).enabled = false;
			if (Object.op_Implicit((Object)(object)_visualRoot))
			{
				Object.Destroy((Object)(object)_visualRoot);
			}
			if (Object.op_Implicit((Object)(object)_material))
			{
				Object.Destroy((Object)(object)_material);
			}
			_visualRoot = null;
			_rings = null;
			_light = null;
			_material = null;
		}

		internal static void ClearAll()
		{
			StorageSearchHighlight[] array = Object.FindObjectsByType<StorageSearchHighlight>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)array[i]))
				{
					array[i].StopHighlight();
				}
			}
		}
	}
	internal sealed class StorageSearchVanillaTheme
	{
		internal Sprite PanelSprite { get; private set; }

		internal Material PanelMaterial { get; private set; }

		internal Type PanelType { get; private set; } = (Type)1;

		internal Color PanelColor { get; private set; }

		internal Sprite InsetSprite { get; private set; }

		internal Material InsetMaterial { get; private set; }

		internal Type InsetType { get; private set; } = (Type)1;

		internal Color InsetColor { get; private set; }

		internal Sprite InputSprite { get; private set; }

		internal Material InputMaterial { get; private set; }

		internal Type InputType { get; private set; } = (Type)1;

		internal Color InputColor { get; private set; }

		internal Sprite ButtonSprite { get; private set; }

		internal Material ButtonMaterial { get; private set; }

		internal Type ButtonImageType { get; private set; } = (Type)1;

		internal Color ButtonImageColor { get; private set; }

		internal SpriteState ButtonSprites { get; private set; }

		internal ColorBlock ButtonColors { get; private set; }

		internal Transition ButtonTransition { get; private set; }

		internal Sprite ScrollbarSprite { get; private set; }

		internal Material ScrollbarMaterial { get; private set; }

		internal Type ScrollbarType { get; private set; } = (Type)1;

		internal Color ScrollbarColor { get; private set; }

		internal Sprite ScrollbarHandleSprite { get; private set; }

		internal Material ScrollbarHandleMaterial { get; private set; }

		internal Type ScrollbarHandleType { get; private set; } = (Type)1;

		internal Color ScrollbarHandleColor { get; private set; }

		internal TMP_FontAsset Font { get; private set; }

		internal CanvasScaler SourceScaler { get; private set; }

		internal int ControlHeight { get; private set; }

		internal bool HasNativePanel => Object.op_Implicit((Object)(object)PanelSprite);

		internal bool HasNativeButton => Object.op_Implicit((Object)(object)ButtonSprite);

		internal bool HasNativeFont => Object.op_Implicit((Object)(object)Font);

		private StorageSearchVanillaTheme()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			ButtonColors = ColorBlock.defaultColorBlock;
			ButtonTransition = (Transition)1;
			PanelColor = Color.white;
			InsetColor = Color32.op_Implicit(new Color32((byte)22, (byte)16, (byte)12, (byte)240));
			InputColor = Color32.op_Implicit(new Color32((byte)36, (byte)24, (byte)16, byte.MaxValue));
			ButtonImageColor = Color.white;
			ScrollbarColor = Color32.op_Implicit(new Color32((byte)33, (byte)22, (byte)15, (byte)240));
			ScrollbarHandleColor = Color.white;
			ControlHeight = 36;
		}

		internal static StorageSearchVanillaTheme Create()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			StorageSearchVanillaTheme storageSearchVanillaTheme = new StorageSearchVanillaTheme();
			try
			{
				InventoryGui instance = InventoryGui.instance;
				if (!Object.op_Implicit((Object)(object)instance))
				{
					return storageSearchVanillaTheme;
				}
				storageSearchVanillaTheme.SourceScaler = ((Component)instance).GetComponentInParent<CanvasScaler>();
				TMP_Text val = PreferredText(instance);
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.font))
				{
					storageSearchVanillaTheme.Font = val.font;
				}
				Image val2 = FindBestPanelImage(instance);
				if (Usable(val2))
				{
					storageSearchVanillaTheme.PanelSprite = val2.sprite;
					storageSearchVanillaTheme.PanelMaterial = ((Graphic)val2).material;
					storageSearchVanillaTheme.PanelType = SafeImageType(val2);
					storageSearchVanillaTheme.PanelColor = ((Graphic)val2).color;
				}
				Image val3 = FindBestInsetImage(instance, val2);
				if (Usable(val3))
				{
					storageSearchVanillaTheme.InsetSprite = val3.sprite;
					storageSearchVanillaTheme.InsetMaterial = ((Graphic)val3).material;
					storageSearchVanillaTheme.InsetType = SafeImageType(val3);
					storageSearchVanillaTheme.InsetColor = ((Graphic)val3).color;
				}
				TryAdoptInput(storageSearchVanillaTheme);
				TryAdoptButton(storageSearchVanillaTheme, PreferredButton(instance));
				TryAdoptScrollbar(storageSearchVanillaTheme, PreferredScrollbar(instance));
			}
			catch
			{
			}
			return storageSearchVanillaTheme;
		}

		internal static StorageSearchVanillaTheme CreateFallback()
		{
			return new StorageSearchVanillaTheme();
		}

		internal static int CurrentSourceToken()
		{
			try
			{
				InventoryGui instance = InventoryGui.instance;
				if (!Object.op_Implicit((Object)(object)instance))
				{
					return 0;
				}
				int num = ((Object)instance).GetInstanceID();
				Image val = FindBestPanelImage(instance);
				if (Usable(val))
				{
					num = (num * 397) ^ ((Object)val.sprite).GetInstanceID();
				}
				Button val2 = PreferredButton(instance);
				if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)((Selectable)val2).image) && Object.op_Implicit((Object)(object)((Selectable)val2).image.sprite))
				{
					num = (num * 397) ^ ((Object)((Selectable)val2).image.sprite).GetInstanceID();
				}
				TextInput instance2 = TextInput.instance;
				Image val3 = ((Object.op_Implicit((Object)(object)instance2) && Object.op_Implicit((Object)(object)instance2.m_inputField)) ? ((Component)instance2.m_inputField).GetComponent<Image>() : null);
				if (Usable(val3))
				{
					num = (num * 397) ^ ((Object)val3.sprite).GetInstanceID();
				}
				Scrollbar val4 = PreferredScrollbar(instance);
				if (Object.op_Implicit((Object)(object)val4) && Object.op_Implicit((Object)(object)val4.handleRect))
				{
					Image component = ((Component)val4.handleRect).GetComponent<Image>();
					if (Usable(component))
					{
						num = (num * 397) ^ ((Object)component.sprite).GetInstanceID();
					}
				}
				TMP_Text val5 = PreferredText(instance);
				if (Object.op_Implicit((Object)(object)val5) && Object.op_Implicit((Object)(object)val5.font))
				{
					num = (num * 397) ^ ((Object)val5.font).GetInstanceID();
				}
				return num;
			}
			catch
			{
				return 0;
			}
		}

		private static void TryAdoptButton(StorageSearchVanillaTheme theme, Button source)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)source) && Object.op_Implicit((Object)(object)((Selectable)source).image) && Object.op_Implicit((Object)(object)((Selectable)source).image.sprite))
			{
				theme.ButtonSprite = ((Selectable)source).image.sprite;
				theme.ButtonMaterial = ((Graphic)((Selectable)source).image).material;
				theme.ButtonImageType = SafeImageType(((Selectable)source).image);
				theme.ButtonImageColor = ((Graphic)((Selectable)source).image).color;
				theme.ButtonSprites = ((Selectable)source).spriteState;
				theme.ButtonColors = ((Selectable)source).colors;
				theme.ButtonTransition = ((Selectable)source).transition;
				RectTransform component = ((Component)source).GetComponent<RectTransform>();
				if (Object.op_Implicit((Object)(object)component))
				{
					Rect rect = component.rect;
					theme.ControlHeight = Mathf.Clamp(Mathf.RoundToInt(((Rect)(ref rect)).height), 28, 56);
				}
			}
		}

		private static void TryAdoptInput(StorageSearchVanillaTheme theme)
		{
			//IL_004b: 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)
			TextInput instance = TextInput.instance;
			if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.m_inputField))
			{
				Image component = ((Component)instance.m_inputField).GetComponent<Image>();
				if (Usable(component))
				{
					theme.InputSprite = component.sprite;
					theme.InputMaterial = ((Graphic)component).material;
					theme.InputType = SafeImageType(component);
					theme.InputColor = ((Graphic)component).color;
				}
			}
		}

		private static void TryAdoptScrollbar(StorageSearchVanillaTheme theme, Scrollbar source)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)source))
			{
				Image component = ((Component)source).GetComponent<Image>();
				if (Usable(component))
				{
					theme.ScrollbarSprite = component.sprite;
					theme.ScrollbarMaterial = ((Graphic)component).material;
					theme.ScrollbarType = SafeImageType(component);
					theme.ScrollbarColor = ((Graphic)component).color;
				}
				Image val = (Object.op_Implicit((Object)(object)source.handleRect) ? ((Component)source.handleRect).GetComponent<Image>() : null);
				if (Usable(val))
				{
					theme.ScrollbarHandleSprite = val.sprite;
					theme.ScrollbarHandleMaterial = ((Graphic)val).material;
					theme.ScrollbarHandleType = SafeImageType(val);
					theme.ScrollbarHandleColor = ((Graphic)val).color;
				}
			}
		}

		private static Image FindBestPanelImage(InventoryGui inventory)
		{
			Image best = null;
			int bestScore = int.MinValue;
			ScoreImages(inventory.m_splitPanel, 180, ref best, ref bestScore);
			ScoreImages(Object.op_Implicit((Object)(object)inventory.m_textsDialog) ? ((Component)inventory.m_textsDialog).transform : null, 120, ref best, ref bestScore);
			ScoreImages((Transform)(object)inventory.m_player, 80, ref best, ref bestScore);
			ScoreImages((Transform)(object)inventory.m_container, 60, ref best, ref bestScore);
			ScoreImages((Transform)(object)inventory.m_crafting, 40, ref best, ref bestScore);
			return best;
		}

		private static Image FindBestInsetImage(InventoryGui inventory, Image panel)
		{
			Image best = null;
			int bestScore = int.MinValue;
			ScoreImages((Transform)(object)(Object.op_Implicit((Object)(object)inventory.m_textsDialog) ? inventory.m_textsDialog.m_listRoot : null), 120, ref best, ref bestScore, panel);
			ScoreImages((Transform)(object)inventory.m_recipeListRoot, 80, ref best, ref bestScore, panel);
			ScoreImages((Transform)(object)inventory.m_player, 0, ref best, ref bestScore, panel, preferSmall: true);
			return best;
		}

		private static void ScoreImages(Transform root, int rootBonus, ref Image best, ref int bestScore, Image excluded = null, bool preferSmall = false)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)root))
			{
				return;
			}
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!Usable(val) || (Object)(object)val == (Object)(object)excluded)
				{
					continue;
				}
				Rect rect = ((Graphic)val).rectTransform.rect;
				float num = Mathf.Abs(((Rect)(ref rect)).width * ((Rect)(ref rect)).height);
				if (!(num < 1600f))
				{
					int num2 = rootBonus;
					if ((int)val.type == 1)
					{
						num2 += 90;
					}
					Vector4 border = val.sprite.border;
					if (((Vector4)(ref border)).sqrMagnitude > 0f)
					{
						num2 += 60;
					}
					string text = ((((Object)val).name ?? string.Empty) + " " + (((Object)val.sprite).name ?? string.Empty)).ToLowerInvariant();
					if (text.Contains("background") || text.Contains("panel") || text.Contains("bkg") || text.Contains("wood"))
					{
						num2 += 100;
					}
					if (text.Contains("icon") || text.Contains("glow") || text.Contains("selection"))
					{
						num2 -= 150;
					}
					num2 = ((!preferSmall) ? (num2 + ((num >= 80000f) ? 35 : 0)) : (num2 + ((num <= 250000f) ? 40 : (-40))));
					if (num2 > bestScore)
					{
						best = val;
						bestScore = num2;
					}
				}
			}
		}

		private static TMP_Text PreferredText(InventoryGui inventory)
		{
			if (!Object.op_Implicit((Object)(object)inventory) || !Object.op_Implicit((Object)(object)inventory.m_playerName))
			{
				if (!Object.op_Implicit((Object)(object)inventory))
				{
					return null;
				}
				return inventory.m_containerName;
			}
			return inventory.m_playerName;
		}

		private static Button PreferredButton(InventoryGui inventory)
		{
			if (!Object.op_Implicit((Object)(object)inventory) || !Object.op_Implicit((Object)(object)inventory.m_takeAllButton))
			{
				if (!Object.op_Implicit((Object)(object)inventory))
				{
					return null;
				}
				return inventory.m_craftButton;
			}
			return inventory.m_takeAllButton;
		}

		private static Scrollbar PreferredScrollbar(InventoryGui inventory)
		{
			if (!Object.op_Implicit((Object)(object)inventory) || !Object.op_Implicit((Object)(object)inventory.m_trophyListScroll))
			{
				if (!Object.op_Implicit((Object)(object)inventory))
				{
					return null;
				}
				return inventory.m_recipeListScroll;
			}
			return inventory.m_trophyListScroll;
		}

		private static bool Usable(Image image)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)image) && Object.op_Implicit((Object)(object)image.sprite))
			{
				return ((Graphic)image).color.a > 0.02f;
			}
			return false;
		}

		private static Type SafeImageType(Image source)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)source) && Object.op_Implicit((Object)(object)source.sprite))
			{
				Vector4 border = source.sprite.border;
				if (((Vector4)(ref border)).sqrMagnitude > 0f)
				{
					return (Type)1;
				}
			}
			if (!Object.op_Implicit((Object)(object)source))
			{
				return (Type)0;
			}
			return source.type;
		}
	}
	internal static class ValheimContainerService
	{
		private static readonly MethodInfo CheckAccessMethod = AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null);

		private static readonly MethodInfo InventoryChangedMethod = AccessTools.Method(typeof(Inventory), "Changed", (Type[])null, (Type[])null);

		private static readonly MethodInfo InventoryAddAtMethod = AccessTools.Method(typeof(Inventory), "AddItem", new Type[4]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		}, (Type[])null);

		internal static bool CanDiscover(Container container, long playerId, bool requireWritable, bool allowCurrentUse = false)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null || !((Behaviour)container).isActiveAndEnabled || container.GetInventory() == null)
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.GetPlayerID() != playerId)
			{
				return false;
			}
			if (container.m_checkGuardStone && !PrivateArea.CheckAccess(((Component)container).transform.position, 0f, false, false))
			{
				return false;
			}
			if (requireWritable && !container.IsOwner())
			{
				return false;
			}
			if (requireWritable && !allowCurrentUse && (container.IsInUse() || ((Object)(object)container.m_wagon != (Object)null && container.m_wagon.InUse())))
			{
				return false;
			}
			try
			{
				return CheckAccessMethod != null && (bool)CheckAccessMethod.Invoke(container, new object[1] { playerId });
			}
			catch
			{
				return false;
			}
		}

		internal static int MoveUpTo(Inventory source, Inventory destination, ItemData sourceItem, int maximumQuantity, Player playerInventoryOwner = null, StorageMutationLease playerMutationLease = null, Container sourceContainer = null, Container destinationContainer = null)
		{
			if (source == null || destination == null || sourceItem == null || source == destination || maximumQuantity <= 0 || sourceItem.m_stack <= 0)
			{
				return 0;
			}
			Inventory val = ((playerInventoryOwner != null) ? ((Humanoid)playerInventoryOwner).GetInventory() : null);
			if ((source == val || destination == val) && ((Object)(object)playerInventoryOwner == (Object)null || playerInventoryOwner != Player.m_localPlayer || !((Character)playerInventoryOwner).IsOwner() || playerMutationLease == null || !playerMutationLease.Covers(playerInventoryOwner, val)))
			{
				throw new InvalidOperationException("A player inventory move requires its exact local owner lease.");
			}
			if (!StillOwned(sourceContainer) || !StillOwned(destinationContainer))
			{
				return 0;
			}
			int val2 = Math.Min(maximumQuantity, sourceItem.m_stack);
			int num = Math.Max(1, sourceItem.m_shared?.m_maxStackSize ?? 1);
			int num2 = 0;
			foreach (ItemData allItem in destination.GetAllItems())
			{
				if (CanMergeExact(sourceItem, allItem) && allItem.m_stack < num)
				{
					num2 = AddSaturated(num2, num - allItem.m_stack);
				}
			}
			for (int i = 0; i < destination.GetHeight(); i++)
			{
				for (int j = 0; j < destination.GetWidth(); j++)
				{
					if (destination.GetItemAt(j, i) == null)
					{
						num2 = AddSaturated(num2, num);
					}
				}
			}
			int num3 = Math.Min(val2, num2);
			if (num3 <= 0 || !CanRoundTrip(source) || !CanRoundTrip(destination))
			{
				return 0;
			}
			ZPackage backup = SaveInventory(source);
			ZPackage backup2 = SaveInventory(destination);
			try
			{
				Inventory obj = CloneInventory(source);
				Inventory val3 = CloneInventory(destination);
				ItemData itemAt = obj.GetItemAt(sourceItem.m_gridPos.x, sourceItem.m_gridPos.y);
				if (itemAt == null)
				{
					throw new InvalidOperationException("The source stack changed before publication.");
				}
				ApplyExactMove(obj, val3, itemAt, num3);
				string @base = SaveInventory(obj).GetBase64();
				string base2 = SaveInventory(val3).GetBase64();
				ApplyExactMove(source, destination, sourceItem, num3);
				if (!StillOwned(sourceContainer) || !StillOwned(destinationContainer) || !string.Equals(SaveInventory(source).GetBase64(), @base, StringComparison.Ordinal) || !string.Equals(SaveInventory(destination).GetBase64(), base2, StringComparison.Ordinal))
				{
					throw new InvalidOperationException("An endpoint changed during Storage publication.");
				}
				return num3;
			}
			catch (Exception item)
			{
				List<Exception> list = new List<Exception> { item };
				try
				{
					RestoreInventory(source, backup, playerInventoryOwner, playerMutationLease);
				}
				catch (Exception item2)
				{
					list.Add(item2);
				}
				try
				{
					RestoreInventory(destination, backup2, playerInventoryOwner, playerMutationLease);
				}
				catch (Exception item3)
				{
					list.Add(item3);
				}
				if (list.Count > 1)
				{
					throw new AggregateException("A Storage move failed and one or more exact rollbacks failed.", list);
				}
				throw;
			}
		}

		internal static void RestoreInventory(Inventory inventory, ZPackage backup, Player inventoryOwner = null, StorageMutationLease playerMutationLease = null)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (inventory == null)
			{
				throw new ArgumentNullException("inventory");
			}
			if (backup == null)
			{
				throw new ArgumentNullException("backup");
			}
			if ((Object)(object)inventoryOwner != (Object)null && (playerMutationLease == null || !playerMutationLease.Covers(inventoryOwner, inventory)))
			{
				throw new InvalidOperationException("The player restore lease is unavailable.");
			}
			byte[] array = backup.GetArray();
			string text = Convert.ToBase64String(array);
			LoadExactShadow(inventory, array, text);
			byte[] array2 = SaveInventory(inventory).GetArray();
			string text2 = Convert.ToBase64String(array2);
			LoadExactShadow(inventory, array2, text2);
			Action onChanged = inventory.m_onChanged;
			inventory.m_onChanged = null;
			try
			{
				inventory.Load(new ZPackage(array));
				if (!string.Equals(SaveInventory(inventory).GetBase64(), text, StringComparison.Ordinal))
				{
					throw new InvalidOperationException("The Storage snapshot did not round-trip.");
				}
			}
			catch (Exception ex)
			{
				try
				{
					inventory.Load(new ZPackage(array2));
					if (!string.Equals(SaveInventory(inventory).GetBase64(), text2, StringComparison.Ordinal))
					{
						throw new InvalidOperationException("The original Storage inventory did not restore.");
					}
				}
				catch (Exception ex2)
				{
					throw new InvalidOperationException("Storage snapshot application and rollback both failed.", new AggregateException(ex, ex2));
				}
				throw new InvalidOperationException("Storage snapshot application was rejected and restored.", ex);
			}
			finally
			{
				inventory.m_onChanged = onChanged;
			}
			InventoryChangedMethod?.Invoke(inventory, Array.Empty<object>());
			if (!string.Equals(SaveInventory(inventory).GetBase64(), text, StringComparison.Ordinal))
			{
				throw new InvalidOperationException("The restored Storage inventory changed during publication.");
			}
		}

		internal static Inventory CloneInventory(Inventory source)
		{
			byte[] array = SaveInventory(source).GetArray();
			return LoadExactShadow(source, array, Convert.ToBase64String(array));
		}

		internal static Inventory LoadExactShadow(Inventory shape, byte[] payload, string expected)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0061: Expected O, but got Unknown
			if (shape == null || payload == null || payload.Length == 0 || string.IsNullOrEmpty(expected))
			{
				throw new InvalidOperationException("An exact Storage snapshot is unavailable.");
			}
			Inventory val = new Inventory(shape.GetName(), (Sprite)null, shape.GetWidth(), shape.GetHeight());
			val.Load(new ZPackage(payload));
			if (!string.Equals(SaveInventory(val).GetBase64(), expected, StringComparison.Ordinal))
			{
				throw new InvalidOperationException("A Storage snapshot is not an exact round trip.");
			}
			return val;
		}

		internal static ZPackage SaveInventory(Inventory source)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			source.Save(val);
			return val;
		}

		internal static bool CanRoundTrip(Inventory inventory)
		{
			try
			{
				CloneInventory(inventory);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static void ApplyExactMove(Inventory source, Inventory destination, ItemData sourceItem, int quantity)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			if (source.GetItemAt(sourceItem.m_gridPos.x, sourceItem.m_gridPos.y) != sourceItem || sourceItem.m_stack < quantity)
			{
				throw new InvalidOperationException("The source changed during an exact move.");
			}
			int num = Math.Max(1, sourceItem.m_shared?.m_maxStackSize ?? 1);
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData allItem in destination.GetAllItems())
			{
				if (CanMergeExact(sourceItem, allItem) && allItem.m_stack < num)
				{
					list.Add(allItem);
				}
			}
			list.Sort(CompareItemSlots);
			int num2 = quantity;
			foreach (ItemData item in list)
			{
				if (num2 == 0)
				{
					break;
				}
				int num3 = Math.Min(num2, num - item.m_stack);
				AddAt(destination, sourceItem, num3, item.m_gridPos);
				num2 -= num3;
			}
			for (int i = 0; i < destination.GetHeight(); i++)
			{
				if (num2 <= 0)
				{
					break;
				}
				for (int j = 0; j < destination.GetWidth(); j++)
				{
					if (num2 <= 0)
					{
						break;
					}
					if (destination.GetItemAt(j, i) == null)
					{
						int num4 = Math.Min(num2, num);
						AddAt(destination, sourceItem, num4, new Vector2i(j, i));
						num2 -= num4;
					}
				}
			}
			if (num2 != 0 || !source.RemoveItem(sourceItem, quantity))
			{
				throw new InvalidOperationException("The source changed during an exact move.");
			}
		}

		private static void AddAt(Inventory destination, ItemData template, int quantity, Vector2i slot)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			ItemData val = template.Clone();
			val.m_stack = quantity;
			if (InventoryAddAtMethod == null || !(bool)InventoryAddAtMethod.Invoke(destination, new object[4] { val, quantity, slot.x, slot.y }) || val.m_stack != 0)
			{
				throw new InvalidOperationException("The destination changed during an exact move.");
			}
		}

		private static bool CanMergeExact(ItemData left, ItemData right)
		{
			if (left != null && right != null && string.Equals(ValheimContainerIdentity.ResourceId(left), ValheimContainerIdentity.ResourceId(right), StringComparison.Ordinal) && left.m_quality == right.m_quality && left.m_variant == right.m_variant && left.m_worldLevel == right.m_worldLevel && left.m_crafterID == right.m_crafterID && string.Equals(left.m_crafterName ?? string.Empty, right.m_crafterName ?? string.Empty, StringComparison.Ordinal) && left.m_pickedUp == right.m_pickedUp && left.m_equipped == right.m_equipped && left.m_durability.Equals(right.m_durability))
			{
				return DictionaryEquals(left.m_customData, right.m_customData);
			}
			return false;
		}

		private static bool DictionaryEquals(IDictionary<string, string> left, IDictionary<string, string> right)
		{
			if ((left?.Count ?? 0) != (right?.Count ?? 0))
			{
				return false;
			}
			if (left == null || left.Count == 0)
			{
				return true;
			}
			foreach (KeyValuePair<string, string> item in left)
			{
				if (right == null || !right.TryGetValue(item.Key, out var value) || !string.Equals(item.Value, value, StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		private static int CompareItemSlots(ItemData left, ItemData right)
		{
			int num = left.m_gridPos.y.CompareTo(right.m_gridPos.y);
			if (num == 0)
			{
				return left.m_gridPos.x.CompareTo(right.m_gridPos.x);
			}
			return num;
		}

		private static bool StillOwned(Container container)
		{
			if (!((Object)(object)container == (Object)null))
			{
				if (((Behaviour)container).isActiveAndEnabled)
				{
					return container.IsOwner();
				}
				return false;
			}
			return true;
		}

		private static int AddSaturated(int left, int right)
		{
			if (left <= int.MaxValue - right)
			{
				return left + right;
			}
			return int.MaxValue;
		}
	}
}
namespace RunicStorage.Engine
{
	internal readonly struct HoverDisclosureFacts
	{
		internal bool FeatureEnabled { get; }

		internal bool LocalPlayerAvailable { get; }

		internal bool ContainerActive { get; }

		internal bool NetworkObjectValid { get; }

		internal bool NonPrivate { get; }

		internal bool WardAccess { get; }

		internal bool ContainerAccess { get; }

		internal bool WithinPhysicalReach { get; }

		internal bool Closed { get; }

		internal bool MutationIdle { get; }

		internal bool DurableClaimAbsent { get; }

		internal bool Synchronized { get; }

		internal HoverDisclosureFacts(bool featureEnabled, bool localPlayerAvailable, bool containerActive, bool networkObjectValid, bool nonPrivate, bool wardAccess, bool containerAccess, bool withinPhysicalReach, bool closed, bool mutationIdle, bool durableClaimAbsent, bool synchronized)
		{
			FeatureEnabled = featureEnabled;
			LocalPlayerAvailable = localPlayerAvailable;
			ContainerActive = containerActive;
			NetworkObjectValid = networkObjectValid;
			NonPrivate = nonPrivate;
			WardAccess = wardAccess;
			ContainerAccess = containerAccess;
			WithinPhysicalReach = withinPhysicalReach;
			Closed = closed;
			MutationIdle = mutationIdle;
			DurableClaimAbsent = durableClaimAbsent;
			Synchronized = synchronized;
		}
	}
	internal static class HoverDisclosurePolicy
	{
		internal static bool AllowsBeforeSynchronization(HoverDisclosureFacts facts)
		{
			if (facts.FeatureEnabled && facts.LocalPlayerAvailable && facts.ContainerActive && facts.NetworkObjectValid && facts.NonPrivate && facts.WardAccess && facts.ContainerAccess && facts.WithinPhysicalReach && facts.Closed && facts.MutationIdle)
			{
				return facts.DurableClaimAbsent;
			}
			return false;
		}

		internal static bool Allows(HoverDisclosureFacts facts)
		{
			if (AllowsBeforeSynchronization(facts))
			{
				return facts.Synchronized;
			}
			return false;
		}
	}
	internal static class StrictWardDisclosurePolicy
	{
		internal static bool IsHostileOverlap(bool enabled, bool containsTarget, bool localAccess)
		{
			if (enabled && containsTarget)
			{
				return !localAccess;
			}
			return false;
		}
	}
	internal static class HoverRangePolicy
	{
		internal const float HardMaximumPhysicalReachMeters = 10f;

		internal static bool IsWithinPhysicalReach(float squaredDistance, float vanillaMaximumInteractDistance)
		{
			if (float.IsNaN(squaredDistance) || float.IsInfinity(squaredDistance) || float.IsNaN(vanillaMaximumInteractDistance) || float.IsInfinity(vanillaMaximumInteractDistance) || squaredDistance < 0f || vanillaMaximumInteractDistance <= 0f)
			{
				return false;
			}
			float num = Math.Min(vanillaMaximumInteractDistance, 10f);
			return squaredDistance <= num * num;
		}
	}
	internal static class HoverSnapshotBounds
	{
		internal const int MaximumStacks = 1024;

		internal const int MaximumCustomDataEntries = 4096;

		internal const int MinimumEncodedCharacters = 16384;

		internal const int MaximumEncodedCharacters = 1048576;

		internal static bool AllowsEnvelope(int stackCount, int persistedEncodedCharacters, int configuredEncodedCharacterLimit)
		{
			if (stackCount < 0 || stackCount > 1024 || persistedEncodedCharacters < 0 || persistedEncodedCharacters % 4 != 0)
			{
				return false;
			}
			int num = Math.Max(16384, Math.Min(1048576, configuredEncodedCharacterLimit));
			return persistedEncodedCharacters <= num;
		}

		internal static int SerializedByteCeiling(int configuredEncodedCharacterLimit)
		{
			return Math.Max(16384, Math.Min(1048576, configuredEncodedCharacterLimit)) / 4 * 3;
		}

		internal static int EncodedCharacterCeiling(int configuredEncodedCharacterLimit)
		{
			return Math.Max(16384, Math.Min(1048576, configuredEncodedCharacterLimit));
		}

		internal static int EncodedLengthForBytes(int serializedBytes)
		{
			if (serializedBytes < 0)
			{
				return -1;
			}
			long num = ((long)serializedBytes + 2L) / 3 * 4;
			if (num <= int.MaxValue)
			{
				return (int)num;
			}
			return -1;
		}

		internal static bool MatchesExactSerializedSize(int serializedBytes, int persistedEncodedCharacters, int configuredEncodedCharacterLimit)
		{
			if (serializedBytes >= 0 && serializedBytes <= SerializedByteCeiling(configuredEncodedCharacterLimit))
			{
				return EncodedLengthForBytes(serializedBytes) == persistedEncodedCharacters;
			}
			return false;
		}

		internal static bool AllowsCustomDataAddition(int currentEntries, int additionalEntries)
		{
			if (currentEntries >= 0 && additionalEntries >= 0)
			{
				return currentEntries <= 4096 - additionalEntries;
			}
			return false;
		}

		internal static bool TryAddStringEstimate(long currentBytes, int utf16Characters, int maximumSerializedBytes, out long nextBytes)
		{
			nextBytes = currentBytes;
			if (currentBytes < 0 || utf16Characters < 0 || maximumSerializedBytes <= 0 || currentBytes > maximumSerializedBytes || utf16Characters > maximumSerializedBytes)
			{
				return false;
			}
			long num = currentBytes + 8 + (long)utf16Characters * 4L;
			if (num > maximumSerializedBytes)
			{
				return false;
			}
			nextBytes = num;
			return true;
		}
	}
	internal readonly struct HoverPersistedEvidence : IEquatable<HoverPersistedEvidence>
	{
		private const ulong FnvOffset = 14695981039346656037uL;

		private const ulong FnvPrime = 1099511628211uL;

		private const ulong SecondSeed = 7809847782465536322uL;

		internal int EncodedCharacters { get; }

		internal bool IsAdmissible { get; }

		internal ulong FirstDigest { get; }

		internal ulong SecondDigest { get; }

		private HoverPersistedEvidence(int encodedCharacters, bool admissible, ulong firstDigest, ulong secondDigest)
		{
			EncodedCharacters = encodedCharacters;
			IsAdmissible = admissible;
			FirstDigest = firstDigest;
			SecondDigest = secondDigest;
		}

		internal static HoverPersistedEvidence Capture(string persisted, int configuredEncodedCharacterLimit)
		{
			if (persisted == null)
			{
				persisted = string.Empty;
			}
			int length = persisted.Length;
			int num = HoverSnapshotBounds.EncodedCharacterCeiling(configuredEncodedCharacterLimit);
			if (length > num || length % 4 != 0)
			{
				return new HoverPersistedEvidence(length, admissible: false, 0uL, 0uL);
			}
			ulong num2 = 14695981039346656037uL;
			ulong num3 = 7809847782465536322uL;
			for (int i = 0; i < length; i++)
			{
				ushort num4 = persisted[i];
				num2 = Mix(num2, (byte)num4);
				num2 = Mix(num2, (byte)(num4 >> 8));
				num3 = Mix(num3, (byte)(num4 >> 8));
				num3 = Mix(num3, (byte)num4);
			}
			return new HoverPersistedEvidence(length, admissible: true, num2, num3);
		}

		public bool Equals(HoverPersistedEvidence other)
		{
			if (EncodedCharacters == other.EncodedCharacters && IsAdmissible == other.IsAdmissible)
			{
				if (IsAdmissible)
				{
					if (FirstDigest == other.FirstDigest)
					{
						return SecondDigest == other.SecondDigest;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is HoverPersistedEvidence other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(EncodedCharacters, IsAdmissible, FirstDigest, SecondDigest);
		}

		private static ulong Mix(ulong current, byte value)
		{
			return (current ^ value) * 1099511628211L;
		}
	}
	internal enum HoverCacheDecision
	{
		Reuse,
		SuppressUntilRetry,
		Refresh
	}
	internal static class HoverCachePolicy
	{
		internal static HoverCacheDecision Decide(bool verified, bool samePersistedEvidence, long cachedConfigurationGeneration, long currentConfigurationGeneration, float nextRetryAt, float now)
		{
			bool flag = samePersistedEvidence && cachedConfigurationGeneration == currentConfigurationGeneration;
			if (verified && flag)
			{
				return HoverCacheDecision.Reuse;
			}
			if (!flag || !(now < nextRetryAt))
			{
				return HoverCacheDecision.Refresh;
			}
			return HoverCacheDecision.SuppressUntilRetry;
		}
	}
	internal static class HoverLabelPolicy
	{
		internal const int MaximumLocalizationTokenCharacters = 128;

		internal const int MaximumDisplayLabelCharacters = 48;

		private const int MaximumDisplaySourceInspectionCharacters = 256;

		internal static bool TryPrepareLocalizationToken(string value, out string token)
		{
			token = null;
			if (string.IsNullOrEmpty(value) || value.Length > 128)
			{
				return false;
			}
			bool flag = false;
			foreach (char c in value)
			{
				UnicodeCategory unicodeCategory = char.GetUnicodeCategory(c);
				if (char.IsControl(c) || char.IsSurrogate(c) || unicodeCategory == UnicodeCategory.Format || c == '<' || c == '>')
				{
					return false;
				}
				if (!char.IsWhiteSpace(c))
				{
					flag = true;
				}
			}
			if (!flag)
			{
				return false;
			}
			token = value;
			return true;
		}

		internal static string WithoutLocalizationMarker(string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return string.Empty;
			}
			int i;
			for (i = 0; i < token.Length && token[i] == '$'; i++)
			{
			}
			if (i != 0)
			{
				return token.Substring(i);
			}
			return token;
		}

		internal static bool TryGetTranslationKey(string token, out string key)
		{
			key = null;
			if (string.IsNullOrEmpty(token) || token.Length < 2 || token[0] != '$')
			{
				return false;
			}
			int i;
			for (i = 1; i < token.Length && token[i] == '$'; i++)
			{
			}
			if (i == token.Length)
			{
				return false;
			}
			key = token.Substring(i);
			if (key.StartsWith("KEY_", StringComparison.Ordinal))
			{
				key = null;
				return false;
			}
			return true;
		}

		internal static string NormalizeDisplayLabel(string value, string fallback)
		{
			string text = (string.IsNullOrEmpty(value) ? fallback : value);
			if (string.IsNullOrEmpty(text))
			{
				return "Item";
			}
			int num = Math.Min(text.Length, 256);
			StringBuilder stringBuilder = new StringBuilder(Math.Min(num, 48));
			bool flag = false;
			for (int i = 0; i < num; i++)
			{
				if (stringBuilder.Length >= 48)
				{
					break;
				}
				char c = text[i];
				if (char.IsWhiteSpace(c) || char.IsControl(c) || char.IsSurrogate(c) || char.GetUnicodeCategory(c) == UnicodeCategory.Format)
				{
					if (stringBuilder.Length != 0 && !flag)
					{
						stringBuilder.Append(' ');
					}
					flag = true;
				}
				else
				{
					flag = false;
					stringBuilder.Append(c switch
					{
						'>' => '›', 
						'<' => '‹', 
						_ => c, 
					});
				}
			}
			while (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] == ' ')
			{
				stringBuilder.Length--;
			}
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString();
			}
			if ((object)text == fallback)
			{
				return "Item";
			}
			return NormalizeDisplayLabel(fallback, null);
		}
	}
	internal static class HoverBaseTextPolicy
	{
		internal const int MaximumBaseHoverCharacters = 8192;

		internal static bool Allows(string hoverText)
		{
			if (!string.IsNullOrEmpty(hoverText))
			{
				return hoverText.Length <= 8192;
			}
			return false;
		}
	}
	internal readonly struct HoverContentEntry
	{
		internal string ResourceId { get; }

		internal string DisplayName { get; }

		internal int Quantity { get; }

		internal HoverContentEntry(string resourceId, string displayName, int quantity)
		{
			ResourceId = resourceId ?? string.Empty;
			DisplayName = displayName ?? string.Empty;
			Quantity = quantity;
		}
	}
	internal static class ContainerHoverSummaryFormatter
	{
		private sealed class AggregatedKind
		{
			internal string ResourceId { get; }

			internal string DisplayName { get; set; }

			internal int Quantity { get; set; }

			internal AggregatedKind(string resourceId, string displayName, int quantity)
			{
				ResourceId = resourceId;
				DisplayName = displayName;
				Quantity = quantity;
			}
		}

		private const string Header = "\n<color=#D8C48A>Contents:</color> ";

		internal static string Format(IReadOnlyList<HoverContentEntry> entries, int maximumKinds, int itemsPerLine, int maximumCharacters, int unscannedStacks = 0)
		{
			if (maximumKinds < 1)
			{
				throw new ArgumentOutOfRangeException("maximumKinds");
			}
			if (itemsPerLine < 1)
			{
				throw new ArgumentOutOfRangeException("itemsPerLine");
			}
			if (maximumCharacters < "\n<color=#D8C48A>Contents:</color> ".Length + 5)
			{
				throw new ArgumentOutOfRangeException("maximumCharacters");
			}
			if (unscannedStacks < 0)
			{
				throw new ArgumentOutOfRangeException("unscannedStacks");
			}
			List<AggregatedKind> list = Aggregate(entries);
			StringBuilder stringBuilder = new StringBuilder(Math.Min(maximumCharacters, 512));
			stringBuilder.Append("\n<color=#D8C48A>Contents:</color> ");
			if (list.Count == 0 && unscannedStacks == 0)
			{
				stringBuilder.Append("Empty");
				return stringBuilder.ToString();
			}
			int num = Math.Min(maximumKinds, list.Count);
			List<int> list2 = new List<int>(num);
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				AggregatedKind aggregatedKind = list[i];
				string text = Separator(num2, itemsPerLine);
				string text2 = aggregatedKind.Quantity.ToString(CultureInfo.InvariantCulture);
				int num3 = text.Length + aggregatedKind.DisplayName.Length + 2 + text2.Length;
				if (stringBuilder.Length + num3 > maximumCharacters)
				{
					break;
				}
				list2.Add(stringBuilder.Length);
				stringBuilder.Append(text);
				stringBuilder.Append(aggregatedKind.DisplayName);
				stringBuilder.Append(" ×");
				stringBuilder.Append(text2);
				num2++;
			}
			int num4 = list.Count - num2;
			if (num4 > 0 || unscannedStacks > 0)
			{
				string text3 = OmissionMarker(num4, unscannedStacks);
				while (num2 > 0)
				{
					string text4 = Separator(num2, itemsPerLine);
					if (stringBuilder.Length + text4.Length + text3.Length <= maximumCharacters)
					{
						break;
					}
					num2--;
					stringBuilder.Length = list2[num2];
					num4++;
					text3 = OmissionMarker(num4, unscannedStacks);
				}
				string text5 = Separator(num2, itemsPerLine);
				if (stringBuilder.Length + text5.Length + text3.Length > maximumCharacters)
				{
					text3 = CompactOmissionMarker(num4, unscannedStacks);
				}
				if (stringBuilder.Length + text5.Length + text3.Length <= maximumCharacters)
				{
					stringBuilder.Append(text5);
					stringBuilder.Append(text3);
				}
			}
			return stringBuilder.ToString();
		}

		private static List<AggregatedKind> Aggregate(IReadOnlyList<HoverContentEntry> entries)
		{
			Dictionary<string, AggregatedKind> dictionary = new Dictionary<string, AggregatedKind>(StringComparer.Ordinal);
			if (entries != null)
			{
				for (int i = 0; i < entries.Count; i++)
				{
					HoverContentEntry hoverContentEntry = entries[i];
					string text = NormalizeResourceId(hoverContentEntry.ResourceId);
					if (text.Length == 0 || hoverContentEntry.Quantity <= 0)
					{
						continue;
					}
					string text2 = HoverLabelPolicy.NormalizeDisplayLabel(hoverContentEntry.DisplayName, text);
					if (dictionary.TryGetValue(text, out var value))
					{
						value.Quantity = AddSaturated(value.Quantity, hoverContentEntry.Quantity);
						if (StringComparer.Ordinal.Compare(text2, value.DisplayName) < 0)
						{
							value.DisplayName = text2;
						}
					}
					else
					{
						dictionary.Add(text, new AggregatedKind(text, text2, hoverContentEntry.Quantity));
					}
				}
			}
			List<AggregatedKind> list = new List<AggregatedKind>(dictionary.Values);
			list.Sort(CompareAggregates);
			return list;
		}

		private static string OmissionMarker(int omittedKinds, int unscannedStacks)
		{
			if (unscannedStacks == 0)
			{
				return "+" + omittedKinds.ToString(CultureInfo.InvariantCulture) + " more";
			}
			if (omittedKinds == 0)
			{
				return "+" + unscannedStacks.ToString(CultureInfo.InvariantCulture) + " unscanned stacks";
			}
			return "+" + omittedKinds.ToString(CultureInfo.InvariantCulture) + " more kinds; " + unscannedStacks.ToString(CultureInfo.InvariantCulture) + " unscanned stacks";
		}

		private static string CompactOmissionMarker(int omittedKinds, int unscannedStacks)
		{
			if (unscannedStacks == 0)
			{
				return "+" + omittedKinds.ToString(CultureInfo.InvariantCulture) + " more";
			}
			if (omittedKinds == 0)
			{
				return "+" + unscannedStacks.ToString(CultureInfo.InvariantCulture) + " stacks";
			}
			return "+" + omittedKinds.ToString(CultureInfo.InvariantCulture) + "k/+" + unscannedStacks.ToString(CultureInfo.InvariantCulture) + "s";
		}

		private static string Separator(int shown, int itemsPerLine)
		{
			if (shown == 0)
			{
				return string.Empty;
			}
			if (shown % itemsPerLine != 0)
			{
				return ", ";
			}
			return "\n";
		}

		private static int CompareAggregates(AggregatedKind left, AggregatedKind right)
		{
			int num = StringComparer.OrdinalIgnoreCase.Compare(left.DisplayName, right.DisplayName);
			if (num != 0)
			{
				return num;
			}
			num = StringComparer.Ordinal.Compare(left.DisplayName, right.DisplayName);
			if (num == 0)
			{
				return StringComparer.Ordinal.Compare(left.ResourceId, right.ResourceId);
			}
			return num;
		}

		private static string NormalizeResourceId(string value)
		{
			if (!string.IsNullOrWhiteSpace(value) && value.Length <= 256)
			{
				return value.Trim();
			}
			return string.Empty;
		}

		private static int AddSaturated(int left, int right)
		{
			if (left <= int.MaxValue - right)
			{
				return left + right;
			}
			return int.MaxValue;
		}
	}
	internal static class ContainerQueryCoverage
	{
		private const float RadiusEpsilon = 0.001f;

		internal static bool IsTruncated(float requestedRadius, float effectiveRadius, bool candidateLimitReached)
		{
			if (float.IsNaN(requestedRadius) || float.IsInfinity(requestedRadius) || requestedRadius <= 0f)
			{
				throw new ArgumentOutOfRangeException("requestedRadius");
			}
			if (float.IsNaN(effectiveRadius) || float.IsInfinity(effectiveRadius) || effectiveRadius <= 0f)
			{
				throw new ArgumentOutOfRangeException("effectiveRadius");
			}
			if (!candidateLimitReached)
			{
				return effectiveRadius + 0.001f < requestedRadius;
			}
			return true;
		}
	}
	internal readonly struct SpatialCandidateKey : IComparable<SpatialCandidateKey>
	{
		internal float DistanceSquared { get; }

		internal string EndpointId { get; }

		internal int InstanceId { get; }

		internal SpatialCandidateKey(float distanceSquared, string endpointId, int instanceId)
		{
			if (float.IsNaN(distanceSquared) || float.IsInfinity(distanceSquared) || distanceSquared < 0f)
			{
				throw new ArgumentOutOfRangeException("distanceSquared");
			}
			DistanceSquared = distanceSquared;
			EndpointId = endpointId ?? string.Empty;
			InstanceId = instanceId;
		}

		public int CompareTo(SpatialCandidateKey other)
		{
			int num = DistanceSquared.CompareTo(other.DistanceSquared);
			if (num != 0)
			{
				return num;
			}
			int num2 = StringComparer.Ordinal.Compare(EndpointId, other.EndpointId);
			if (num2 == 0)
			{
				return InstanceId.CompareTo(other.InstanceId);
			}
			return num2;
		}
	}
	internal sealed class SpatialSelectionProfile
	{
		internal IReadOnlyList<SpatialCandidateKey> Selected { get; }

		internal int Visited { get; }

		internal bool Truncated { get; }

		internal SpatialSelectionProfile(IReadOnlyList<SpatialCandidateKey> selected, int visited, bool truncated)
		{
			Selected = selected;
			Visited = visited;
			Truncated = truncated;
		}
	}
	internal static class ContainerSpatialPolicy
	{
		internal const float CellSizeMeters = 10f;

		internal const float HardMaximumRadiusMeters = 50f;

		internal const int HardMaximumCandidates = 256;

		internal const int HardMaximumAbsoluteCell = 1000000;

		internal static bool CanRetain(bool membershipExists, bool cellUnchanged, bool endpointUnchanged, bool exactContainerPresent)
		{
			return membershipExists && cellUnchanged && endpointUnchanged && exactContainerPresent;
		}

		internal static bool CanIndexEndpoint(string endpointId)
		{
			return !string.IsNullOrEmpty(endpointId);
		}

		internal static bool IsUniqueEndpointMemberCount(int memberCount)
		{
			return memberCount == 1;
		}

		internal static int CellCoordinate(float value)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				throw new ArgumentOutOfRangeException("value");
			}
			double num = Math.Floor((double)value / 10.0);
			if (num <= -1000000.0)
			{
				return -1000000;
			}
			if (num >= 1000000.0)
			{
				return 1000000;
			}
			return (int)num;
		}

		internal static int MaximumCellsForRadius(float radiusMeters)
		{
			int num = (int)Math.Ceiling(Math.Max(0f, Math.Min(50f, radiusMeters)) * 2f / 10f) + 1;
			return checked(num * num);
		}

		internal static SpatialSelectionProfile ProfileNearest(IEnumerable<SpatialCandidateKey> source, int maximum)
		{
			maximum = Math.Max(1, Math.Min(256, maximum));
			SortedSet<SpatialCandidateKey> sortedSet = new SortedSet<SpatialCandidateKey>();
			int num = 0;
			foreach (SpatialCandidateKey item in source ?? Array.Empty<SpatialCandidateKey>())
			{
				if (num < int.MaxValue)
				{
					num++;
				}
				sortedSet.Add(item);
				if (sortedSet.Count > maximum)
				{
					sortedSet.Remove(sortedSet.Max);
				}
			}
			return new SpatialSelectionProfile(new List<SpatialCandidateKey>(sortedSet).AsReadOnly(), num, num > maximum);
		}
	}
	internal readonly struct ControllerBindingCacheKey : IEquatable<ControllerBindingCacheKey>
	{
		internal object ZInputInstance { get; }

		internal string Modifier { get; }

		internal string QuickStack { get; }

		internal string Restock { get; }

		internal string Sort { get; }

		internal string Consolidate { get; }

		internal string Search { get; }

		internal ControllerBindingCacheKey(object zInputInstance, string modifier, string quickStack, string restock, string sort, string consolidate, string search)
		{
			ZInputInstance = zInputInstance;
			Modifier = modifier ?? string.Empty;
			QuickStack = quickStack ?? string.Empty;
			Restock = restock ?? string.Empty;
			Sort = sort ?? string.Empty;
			Consolidate = consolidate ?? string.Empty;
			Search = search ?? string.Empty;
		}

		public bool Equals(ControllerBindingCacheKey other)
		{
			if (ZInputInstance == other.ZInputInstance && string.Equals(Modifier, other.Modifier, StringComparison.Ordinal) && string.Equals(QuickStack, other.QuickStack, StringComparison.Ordinal) && string.Equals(Restock, other.Restock, StringComparison.Ordinal) && string.Equals(Sort, other.Sort, StringComparison.Ordinal) && string.Equals(Consolidate, other.Consolidate, StringComparison.Ordinal))
			{
				return string.Equals(Search, other.Search, StringComparison.Ordinal);
			}
			return false;
		}

		public override bool Equals(object value)
		{
			if (value is ControllerBindingCacheKey other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (((((((((((((ZInputInstance != null) ? RuntimeHelpers.GetHashCode(ZInputInstance) : 0) * 397) ^ StringComparer.Ordinal.GetHashCode(Modifier)) * 397) ^ StringComparer.Ordinal.GetHashCode(QuickStack)) * 397) ^ StringComparer.Ordinal.GetHashCode(Restock)) * 397) ^ StringComparer.Ordinal.GetHashCode(Sort)) * 397) ^ StringComparer.Ordinal.GetHashCode(Consolidate)) * 397) ^ StringComparer.Ordinal.GetHashCode(Search);
		}
	}
	internal readonly struct ControllerSessionPaths
	{
		internal string Modifier { get; }

		internal string QuickStack { get; }

		internal string Restock { get; }

		internal string Sort { get; }

		internal string Consolidate { get; }

		internal string Search { get; }

		internal ControllerSessionPaths(string modifier, string quickStack, string restock, string sort, string consolidate, string search)
		{
			Modifier = modifier ?? string.Empty;
			QuickStack = quickStack ?? string.Empty;
			Restock = restock ?? string.Empty;
			Sort = sort ?? string.Empty;
			Consolidate = consolidate ?? string.Empty;
			Search = search ?? string.Empty;
		}

		internal bool Contains(string path)
		{
			if (!Same(path, Modifier) && !Same(path, QuickStack) && !Same(path, Restock) && !Same(path, Sort) && !Same(path, Consolidate))
			{
				return Same(path, Search);
			}
			return true;
		}

		private static bool Same(string left, string right)
		{
			if (!string.IsNullOrEmpty(left) && !string.IsNullOrEmpty(right))
			{
				return string.Equals(left, right, StringComparison.Ordinal);
			}
			return false;
		}
	}
	public sealed class QuickStackSource
	{
		public string StackId { get; }

		public string ResourceId { get; }

		public int Quantity { get; }

		public bool ProtectedSlot { get; }

		public QuickStackSource(string stackId, string resourceId, int quantity, bool protectedSlot = false)
		{
			StackId = Require(stackId, "stackId");
			ResourceId = Require(resourceId, "resourceId");
			if (quantity <= 0)
			{
				throw new ArgumentOutOfRangeException("quantity");
			}
			Quantity = quantity;
			ProtectedSlot = protectedSlot;
		}

		internal static string Require(string value, string parameterName)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				throw new ArgumentException("A stable identifier is required.", parameterName);
			}
			return value.Trim();
		}
	}
	public sealed class QuickStackDestination
	{
		private readonly ReadOnlyDictionary<string, int> _capacityByResource;

		public string EndpointId { get; }

		public float DistanceSquared { get; }

		public bool Authorized { get; }

		public bool Personal { get; }

		public bool InUse { get; }

		public IReadOnlyDictionary<string, int> CapacityByExistingResource => _capacityByResource;

		public QuickStackDestination(string endpointId, float distanceSquared, bool authorized, bool personal, bool inUse, IDictionary<string, int> capacityByExistingResource)
		{
			EndpointId = QuickStackSource.Require(endpointId, "endpointId");
			if (float.IsNaN(distanceSquared) || float.IsInfinity(distanceSquared) || distanceSquared < 0f)
			{
				throw new ArgumentOutOfRangeException("distanceSquared");
			}
			DistanceSquared = distanceSquared;
			Authorized = authorized;
			Personal = personal;
			InUse = inUse;
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			if (capacityByExistingResource != null)
			{
				foreach (KeyValuePair<string, int> item in capacityByExistingResource)
				{
					string key = QuickStackSource.Require(item.Key, "capacityByExistingResource");
					if (item.Value < 0)
					{
						throw new ArgumentOutOfRangeException("capacityByExistingResource");
					}
					dictionary.Add(key, item.Value);
				}
			}
			_capacityByResource = new ReadOnlyDictionary<string, int>(dictionary);
		}
	}
	public sealed class QuickStackMove
	{
		public string StackId { get; }

		public string DestinationEndpointId { get; }

		public string ResourceId { get; }

		public int Quantity { get; }

		internal QuickStackMove(string stackId, string destinationEndpointId, string resourceId, int quantity)
		{
			StackId = stackId;
			DestinationEndpointId = destinationEndpointId;
			ResourceId = resourceId;
			Quantity = quantity;
		}
	}
	public sealed class QuickStackPlan
	{
		public IReadOnlyList<QuickStackMove> Moves { get; }

		public int RequestedQuantity { get; }

		public int PlannedQuantity { get; }

		public int RemainingQuantity => RequestedQuantity - PlannedQuantity;

		internal QuickStackPlan(IReadOnlyList<QuickStackMove> moves, int requestedQuantity, int plannedQuantity)
		{
			Moves = moves;
			RequestedQuantity = requestedQuantity;
			PlannedQuantity = plannedQuantity;
		}
	}
	public static class QuickStackPlanner
	{
		private sealed class DestinationState
		{
			private readonly Dictionary<string, int> _capacity;

			internal string EndpointId { get; }

			internal float DistanceSquared { get; }

			internal DestinationState(QuickStackDestination destination)
			{
				EndpointId = destination.EndpointId;
				DistanceSquared = destination.DistanceSquared;
				_capacity = new Dictionary<string, int>(StringComparer.Ordinal);
				foreach (KeyValuePair<string, int> item in destination.CapacityByExistingResource)
				{
					_capacity.Add(item.Key, item.Value);
				}
			}

			internal int GetCapacity(string resourceId)
			{
				if (!_capacity.TryGetValue(resourceId, out var value))
				{
					return 0;
				}
				return value;
			}

			internal void Consume(string resourceId, int amount)
			{
				_capacity[resourceId] -= amount;
			}
		}

		public static QuickStackPlan Plan(IEnumerable<QuickStackSource> sources, IEnumerable<QuickStackDestination> destinations, bool includePersonalContainers = false)
		{
			if (sources == null)
			{
				throw new ArgumentNullException("sources");
			}
			if (destinations == null)
			{
				throw new ArgumentNullException("destinations");
			}
			List<QuickStackSource> list = new List<QuickStackSource>();
			int num = 0;
			foreach (QuickStackSource source in sources)
			{
				if (source == null)
				{
					throw new ArgumentException("Sources cannot contain null.", "sources");
				}
				list.Add(source);
				if (!source.ProtectedSlot)
				{
					num = AddSaturated(num, source.Quantity);
				}
			}
			list.Sort((QuickStackSource left, QuickStackSource right) => StringComparer.Ordinal.Compare(left.StackId, right.StackId));
			List<DestinationState> list2 = new List<DestinationState>();
			foreach (QuickStackDestination destination in destinations)
			{
				if (destination == null)
				{
					throw new ArgumentException("Destinations cannot contain null.", "destinations");
				}
				if (destination.Authorized && !destination.InUse && (!destination.Personal || includePersonalContainers))
				{
					list2.Add(new DestinationState(destination));
				}
			}
			list2.Sort(delegate(DestinationState left, DestinationState right)
			{
				int num5 = left.DistanceSquared.CompareTo(right.DistanceSquared);
				return (num5 == 0) ? StringComparer.Ordinal.Compare(left.EndpointId, right.EndpointId) : num5;
			});
			List<QuickStackMove> list3 = new List<QuickStackMove>();
			int num2 = 0;
			foreach (QuickStackSource item in list)
			{
				if (item.ProtectedSlot)
				{
					continue;
				}
				int num3 = item.Quantity;
				foreach (DestinationState item2 in list2)
				{
					int capacity = item2.GetCapacity(item.ResourceId);
					if (capacity > 0)
					{
						int num4 = Math.Min(num3, capacity);
						item2.Consume(item.ResourceId, num4);
						list3.Add(new QuickStackMove(item.StackId, item2.EndpointId, item.ResourceId, num4));
						num3 -= num4;
						num2 = AddSaturated(num2, num4);
						if (num3 == 0)
						{
							break;
						}
					}
				}
			}
			return new QuickStackPlan(list3.AsReadOnly(), num, num2);
		}

		private static int AddSaturated(int left, int right)
		{
			if (left <= int.MaxValue - right)
			{
				return left + right;
			}
			return int.MaxValue;
		}
	}
	internal enum StorageActionKind
	{
		None,
		QuickStack,
		Restock,
		SortOpenedContainer,
		Consolidate,
		Search,
		StoreAllOpenedContainer
	}
	internal enum StorageInputOrigin
	{
		None,
		Keyboard,
		Controller
	}
	[Flags]
	internal enum StorageActionEdges
	{
		None = 0,
		KeyboardQuickStack = 1,
		KeyboardRestock = 2,
		KeyboardSort = 4,
		KeyboardConsolidate = 8,
		KeyboardSearch = 0x10,
		ControllerQuickStack = 0x20,
		ControllerRestock = 0x40,
		ControllerSort = 0x80,
		ControllerConsolidate = 0x100,
		ControllerSearch = 0x200,
		KeyboardStoreAll = 0x400
	}
	internal enum StorageRouteOutcome
	{
		None,
		Execute,
		Blocked
	}
	internal enum StorageRouteReason
	{
		None,
		Disabled,
		GameplayInputBlocked,
		DraggedItem,
		StoreOpen,
		MapOpen,
		InventoryOpen,
		SortRequiresOpenedContainer,
		HostAuthorityRequired,
		LocalPlayerOwnershipRequired,
		StoreAllRequiresOpenedContainer
	}
	internal readonly struct StorageActionRequest
	{
		internal StorageActionKind Action { get; }

		internal StorageInputOrigin Origin { get; }

		internal bool IsPresent => Action != StorageActionKind.None;

		internal StorageActionRequest(StorageActionKind action, StorageInputOrigin origin)
		{
			Action = action;
			Origin = origin;
		}
	}
	internal readonly struct StorageRouteContext
	{
		internal bool Enabled { get; }

		internal bool GameplayInputBlocked { get; }

		internal bool DraggedItem { get; }

		internal bool InventoryOpen { get; }

		internal bool OpenedContainer { get; }

		internal bool StoreOpen { get; }

		internal bool MapOpen { get; }

		internal bool MutationAuthorityAvailable { get; }

		internal bool LocalPlayerOwnershipAvailable { get; }

		internal StorageRouteContext(bool enabled, bool gameplayInputBlocked, bool draggedItem, bool inventoryOpen, bool openedContainer, bool storeOpen, bool mapOpen, bool mutationAuthorityAvailable = true, bool localPlayerOwnershipAvailable = true)
		{
			Enabled = enabled;
			GameplayInputBlocked = gameplayInputBlocked;
			DraggedItem = draggedItem;
			InventoryOpen = inventoryOpen;
			OpenedContainer = openedContainer;
			StoreOpen = storeOpen;
			MapOpen = mapOpen;
			MutationAuthorityAvailable = mutationAuthorityAvailable;
			LocalPlayerOwnershipAvailable = localPlayerOwnershipAvailable;
		}
	}
	internal readonly struct StorageRouteDecision
	{
		internal StorageRouteOutcome Outcome { get; }

		internal StorageActionRequest Request { get; }

		internal StorageRouteReason Reason { get; }

		internal StorageRouteDecision(StorageRouteOutcome outcome, StorageActionRequest request, StorageRouteReason reason)
		{
			Outcome = outcome;
			Request = request;
			Reason = reason;
		}
	}
	internal static class StorageActionRouter
	{
		internal static StorageActionRequest Select(StorageActionEdges edges)
		{
			StorageActionRequest result = Select(edges, StorageActionEdges.KeyboardSort, StorageActionEdges.ControllerSort, StorageActionKind.SortOpenedContainer);
			if (result.IsPresent)
			{
				return result;
			}
			result = Select(edges, StorageActionEdges.KeyboardStoreAll, StorageActionEdges.None, StorageActionKind.StoreAllOpenedContainer);
			if (result.IsPresent)
			{
				return result;
			}
			result = Select(edges, StorageActionEdges.KeyboardQuickStack, StorageActionEdges.ControllerQuickStack, StorageActionKind.QuickStack);
			if (result.IsPresent)
			{
				return result;
			}
			result = Select(edges, StorageActionEdges.KeyboardRestock, StorageActionEdges.ControllerRestock, StorageActionKind.Restock);
			if (result.IsPresent)
			{
				return result;
			}
			result = Select(edges, StorageActionEdges.KeyboardConsolidate, StorageActionEdges.ControllerConsolidate, StorageActionKind.Consolidate);
			if (result.IsPresent)
			{
				return result;
			}
			return Select(edges, StorageActionEdges.KeyboardSearch, StorageActionEdges.ControllerSearch, StorageActionKind.Search);
		}

		internal static StorageRouteDecision Route(StorageActionRequest request, StorageRouteContext context)
		{
			if (!request.IsPresent)
			{
				return new StorageRouteDecision(StorageRouteOutcome.None, request, StorageRouteReason.None);
			}
			if (!context.Enabled)
			{
				return Blocked(request, StorageRouteReason.Disabled);
			}
			if (context.GameplayInputBlocked)
			{
				return Blocked(request, StorageRouteReason.GameplayInputBlocked);
			}
			if (context.DraggedItem)
			{
				return Blocked(request, StorageRouteReason.DraggedItem);
			}
			if (context.StoreOpen)
			{
				return Blocked(request, StorageRouteReason.StoreOpen);
			}
			if (context.MapOpen)
			{
				return Blocked(request, StorageRouteReason.MapOpen);
			}
			if (request.Action == StorageActionKind.Consolidate && !context.LocalPlayerOwnershipAvailable)
			{
				return Blocked(request, StorageRouteReason.LocalPlayerOwnershipRequired);
			}
			if (request.Action != StorageActionKind.Search && request.Action != StorageActionKind.Consolidate && request.Action != StorageActionKind.StoreAllOpenedContainer && !context.MutationAuthorityAvailable)
			{
				return Blocked(request, StorageRouteReason.HostAuthorityRequired);
			}
			if (request.Action == StorageActionKind.SortOpenedContainer)
			{
				if (!context.InventoryOpen || !context.OpenedContainer)
				{
					return Blocked(request, StorageRouteReason.SortRequiresOpenedContainer);
				}
				return Execute(request);
			}
			if (request.Action == StorageActionKind.StoreAllOpenedContainer)
			{
				if (!context.InventoryOpen || !context.OpenedContainer)
				{
					return Blocked(request, StorageRouteReason.StoreAllRequiresOpenedContainer);
				}
				return Execute(request);
			}
			if (request.Action == StorageActionKind.Restock || request.Action == StorageActionKind.Search)
			{
				return Execute(request);
			}
			if (request.Action == StorageActionKind.QuickStack && context.InventoryOpen && !context.OpenedContainer)
			{
				return Execute(request);
			}
			if (context.InventoryOpen)
			{
				return Blocked(request, StorageRouteReason.InventoryOpen);
			}
			return Execute(request);
		}

		private static StorageActionRequest Select(StorageActionEdges edges, StorageActionEdges keyboard, StorageActionEdges controller, StorageActionKind action)
		{
			if ((edges & keyboard) != StorageActionEdges.None)
			{
				return new StorageActionRequest(action, StorageInputOrigin.Keyboard);
			}
			if ((edges & controller) == 0)
			{
				return new StorageActionRequest(StorageActionKind.None, StorageInputOrigin.None);
			}
			return new StorageActionRequest(action, StorageInputOrigin.Controller);
		}

		private static StorageRouteDecision Execute(StorageActionRequest request)
		{
			return new StorageRouteDecision(StorageRouteOutcome.Execute, request, StorageRouteReason.None);
		}

		private static StorageRouteDecision Blocked(StorageActionRequest request, StorageRouteReason reason)
		{
			return new StorageRouteDecision(StorageRouteOutcome.Blocked, request, reason);
		}
	}
	internal static class StorageActionDiagnostics
	{
		internal static string ActionCode(StorageActionKind action)
		{
			return action switch
			{
				StorageActionKind.QuickStack => "quick-stack", 
				StorageActionKind.Restock => "restock", 
				StorageActionKind.SortOpenedContainer => "sort-opened-container", 
				StorageActionKind.Consolidate => "consolidate", 
				StorageActionKind.Search => "search", 
				StorageActionKind.StoreAllOpenedContainer => "store-all-opened-container", 
				_ => "none", 
			};
		}

		internal static string OriginCode(StorageInputOrigin origin)
		{
			return origin switch
			{
				StorageInputOrigin.Keyboard => "keyboard", 
				StorageInputOrigin.Controller => "controller", 
				_ => "none", 
			};
		}

		internal static string RouteReasonCode(StorageRouteReason reason)
		{
			return reason switch
			{
				StorageRouteReason.Disabled => "config.disabled", 
				StorageRouteReason.GameplayInputBlocked => "input.context-blocked", 
				StorageRouteReason.DraggedItem => "inventory.drag-active", 
				StorageRouteReason.StoreOpen => "ui.store-open", 
				StorageRouteReason.MapOpen => "ui.map-open", 
				StorageRouteReason.InventoryOpen => "ui.inventory-open", 
				StorageRouteReason.SortRequiresOpenedContainer => "ui.open-container-required", 
				StorageRouteReason.HostAuthorityRequired => "authority.local-player-owner-required", 
				StorageRouteReason.LocalPlayerOwnershipRequired => "authority.local-player-owner-required", 
				StorageRouteReason.StoreAllRequiresOpenedContainer => "ui.open-container-required", 
				_ => "ok", 
			};
		}

		internal static string RouteFeedback(StorageRouteReason reason)
		{
			return reason switch
			{
				StorageRouteReason.Disabled => "Runic Storage is disabled in configuration.", 
				StorageRouteReason.GameplayInputBlocked => "Runic Storage: close the current menu, text window, or dialog first.", 
				StorageRouteReason.DraggedItem => "Runic Storage: place or cancel the item currently attached to the cursor first.", 
				StorageRouteReason.StoreOpen => "Runic Storage: close the trader window first.", 
				StorageRouteReason.MapOpen => "Runic Storage: close the map first.", 
				StorageRouteReason.InventoryOpen => "Runic Storage: close the opened chest first, or use Sort/Store All for that chest.", 
				StorageRouteReason.SortRequiresOpenedContainer => "Runic Storage: open a non-personal container before sorting.", 
				StorageRouteReason.HostAuthorityRequired => "Runic Storage: this action requires the owning local player.", 
				StorageRouteReason.LocalPlayerOwnershipRequired => "Runic Storage: Consolidate requires the owning local player; no carried items were changed.", 
				StorageRouteReason.StoreAllRequiresOpenedContainer => "Runic Storage: open a non-personal container before using Store All.", 
				_ => string.Empty, 
			};
		}
	}
	internal enum ControllerChordDisposition
	{
		ReportWithoutConsume,
		ExecuteAndConsume,
		ReportAndConsume
	}
	internal static class ControllerChordSessionPolicy
	{
		internal static ControllerChordDisposition Decide(bool sessionActive, StorageRouteDecision decision)
		{
			return Decide(sessionActive, decision.Outcome);
		}

		internal static ControllerChordDisposition Decide(bool sessionActive, StorageRouteOutcome outcome)
		{
			if (outcome == StorageRouteOutcome.Execute)
			{
				return ControllerChordDisposition.ExecuteAndConsume;
			}
			if (!sessionActive || outcome != StorageRouteOutcome.Blocked)
			{
				return ControllerChordDisposition.ReportWithoutConsume;
			}
			return ControllerChordDisposition.ReportAndConsume;
		}
	}
	internal enum QuickStackNoOpReason
	{
		None,
		InventoryEmpty,
		AllStacksProtected,
		NoAuthorizedContainers,
		NoMatchingResources,
		DestinationsUnavailable
	}
	internal readonly struct QuickStackObservation
	{
		internal int CarriedStacks { get; }

		internal int EligibleStacks { get; }

		internal int ProtectedStacks { get; }

		internal int AuthorizedContainers { get; }

		internal int MatchedStacks { get; }

		internal int MovedQuantity { get; }

		internal QuickStackObservation(int carriedStacks, int eligibleStacks, int protectedStacks, int authorizedContainers, int matchedStacks, int movedQuantity)
		{
			CarriedStacks = Math.Max(0, carriedStacks);
			EligibleStacks = Math.Max(0, eligibleStacks);
			ProtectedStacks = Math.Max(0, protectedStacks);
			AuthorizedContainers = Math.Max(0, authorizedContainers);
			MatchedStacks = Math.Max(0, matchedStacks);
			MovedQuantity = Math.Max(0, movedQuantity);
		}
	}
	internal static class QuickStackDiagnostics
	{
		internal static QuickStackNoOpReason Classify(QuickStackObservation observation)
		{
			if (observation.MovedQuantity > 0)
			{
				return QuickStackNoOpReason.None;
			}
			if (observation.CarriedStacks == 0)
			{
				return QuickStackNoOpReason.InventoryEmpty;
			}
			if (observation.EligibleStacks == 0 && observation.ProtectedStacks > 0)
			{
				return QuickStackNoOpReason.AllStacksProtected;
			}
			if (observation.AuthorizedContainers == 0)
			{
				return QuickStackNoOpReason.NoAuthorizedContainers;
			}
			if (observation.MatchedStacks == 0)
			{
				return QuickStackNoOpReason.NoMatchingResources;
			}
			return QuickStackNoOpReason.DestinationsUnavailable;
		}

		internal static string ReasonCode(QuickStackNoOpReason reason)
		{
			return reason switch
			{
				QuickStackNoOpReason.InventoryEmpty => "inventory.empty", 
				QuickStackNoOpReason.AllStacksProtected => "inventory.all-protected", 
				QuickStackNoOpReason.NoAuthorizedContainers => "discovery.none-authorized", 
				QuickStackNoOpReason.NoMatchingResources => "resource.no-existing-match", 
				QuickStackNoOpReason.DestinationsUnavailable => "destination.full-or-unavailable", 
				_ => "ok", 
			};
		}
	}
	internal enum StorageProtectionState : byte
	{
		NotApplicable,
		Unlocked,
		Locked
	}
	internal readonly struct StorageProtectionSnapshot
	{
		private readonly StorageProtectionState[] _states;

		internal int Count
		{
			get
			{
				StorageProtectionState[] states = _states;
				if (states == null)
				{
					return 0;
				}
				return states.Length;
			}
		}

		internal StorageProtectionSnapshot(StorageProtectionState[] states)
		{
			_states = states;
		}

		internal StorageProtectionState StateAt(int index)
		{
			if (_states == null || index < 0 || index >= _states.Length)
			{
				return StorageProtectionState.NotApplicable;
			}
			return _states[index];
		}
	}
	internal static class StorageItemProtection
	{
		internal const int MaximumCarriedStacks = 128;

		internal static bool TryCapture<T>(IReadOnlyList<T> items, out StorageProtectionSnapshot snapshot, out string failureCode) where T : class
		{
			snapshot = default(StorageProtectionSnapshot);
			if (items == null || items.Count > 128)
			{
				failureCode = ((items == null) ? "protection.items-unavailable" : "protection.stack-bound-exceeded");
				return false;
			}
			Type type = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
				select assembly.GetType("RunicInventory.Api.InventoryIntegrationApi", throwOnError: false)).FirstOrDefault((Type type2) => type2 != null);
			if (type == null)
			{
				snapshot = new StorageProtectionSnapshot(new StorageProtectionState[items.Count]);
				failureCode = "ok:inventory-absent";
				return true;
			}
			MethodInfo method = type.GetMethod("TryGetProtection", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
			{
				typeof(object),
				typeof(int).MakeByRefType()
			}, null);
			if (method == null)
			{
				failureCode = "protection.optional-api-malformed";
				return false;
			}
			StorageProtectionState[] array = new StorageProtectionState[items.Count];
			try
			{
				bool flag = default(bool);
				for (int num = 0; num < items.Count; num++)
				{
					if (items[num] == null)
					{
						failureCode = "protection.item-null";
						return false;
					}
					object[] array2 = new object[2]
					{
						items[num],
						0
					};
					object obj = method.Invoke(null, array2);
					int num2;
					if (obj is bool)
					{
						flag = (bool)obj;
						num2 = 1;
					}
					else
					{
						num2 = 0;
					}
					if (((uint)num2 & (flag ? 1u : 0u)) == 0)
					{
						array[num] = StorageProtectionState.NotApplicable;
						continue;
					}
					switch ((array2[1] is int num3) ? num3 : 0)
					{
					case 1:
						array[num] = StorageProtectionState.Unlocked;
						break;
					case 2:
						array[num] = StorageProtectionState.Locked;
						break;
					default:
						failureCode = "protection.in-domain-unknown";
						return false;
					}
				}
			}
			catch
			{
				failureCode = "protection.provider-exception";
				return false;
			}
			snapshot = new StorageProtectionSnapshot(array);
			failureCode = "ok";
			return true;
		}
	}
	internal sealed class StorageSearchAttackSuppression
	{
		internal const string PrimaryAttackAction = "Attack";

		private bool _pointerCaptured;

		private int _releaseFrame = -1;

		internal void CapturePrimaryPointer()
		{
			_pointerCaptured = true;
			_releaseFrame = -1;
		}

		internal bool ShouldSuppress(string actionName, bool pickerOpen, bool primaryAttackHeld, int frame)
		{
			if (!IsPrimaryAttack(actionName))
			{
				return false;
			}
			if (pickerOpen)
			{
				if (primaryAttackHeld)
				{
					CapturePrimaryPointer();
				}
				return true;
			}
			if (!_pointerCaptured)
			{
				return false;
			}
			if (primaryAttackHeld)
			{
				_releaseFrame = -1;
				return true;
			}
			if (_releaseFrame < 0)
			{
				_releaseFrame = frame;
				return true;
			}
			if (frame <= _releaseFrame)
			{
				return true;
			}
			Reset();
			return false;
		}

		internal void Reset()
		{
			_pointerCaptured = false;
			_releaseFrame = -1;
		}

		internal static bool IsPrimaryAttack(string actionName)
		{
			return string.Equals(actionName, "Attack", StringComparison.Ordinal);
		}
	}
	internal enum StorageSearchMenuFontColor
	{
		LightGray,
		White,
		Gold,
		Yellow,
		Orange,
		Red,
		Pink,
		Purple,
		Blue,
		Cyan,
		Turquoise,
		Green,
		Lime
	}
	internal readonly struct StorageSearchMenuColor : IEquatable<StorageSearchMenuColor>
	{
		internal byte Red { get; }

		internal byte Green { get; }

		internal byte Blue { get; }

		internal byte Alpha { get; }

		internal StorageSearchMenuColor(byte red, byte green, byte blue, byte alpha)
		{
			Red = red;
			Green = green;
			Blue = blue;
			Alpha = alpha;
		}

		public bool Equals(StorageSearchMenuColor other)
		{
			if (Red == other.Red && Green == other.Green && Blue == other.Blue)
			{
				return Alpha == other.Alpha;
			}
			return false;
		}

		public override bool Equals(object value)
		{
			if (value is StorageSearchMenuColor other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (((Red * 397) ^ Green) * 397) ^ (Blue * 397) ^ Alpha;
		}
	}
	internal readonly struct StorageSearchMenuLayout
	{
		internal int FontSize { get; }

		internal int ControlHeight { get; }

		internal int ItemHeight { get; }

		internal int ActionButtonWidth { get; }

		internal int PreferredWindowWidth { get; }

		internal int PreferredWindowHeight { get; }

		internal int NonScrollHeight { get; }

		internal StorageSearchMenuLayout(int fontSize, int controlHeight, int itemHeight, int actionButtonWidth, int preferredWindowWidth, int preferredWindowHeight, int nonScrollHeight)
		{
			FontSize = fontSize;
			ControlHeight = controlHeight;
			ItemHeight = itemHeight;
			ActionButtonWidth = actionButtonWidth;
			PreferredWindowWidth = preferredWindowWidth;
			PreferredWindowHeight = preferredWindowHeight;
			NonScrollHeight = nonScrollHeight;
		}
	}
	internal static class StorageSearchMenuAppearance
	{
		internal const int MinimumFontSize = 10;

		internal const int MaximumFontSize = 32;

		internal const int DefaultFontSize = 14;

		internal const StorageSearchMenuFontColor DefaultFontColor = StorageSearchMenuFontColor.LightGray;

		internal static int ClampFontSize(int value)
		{
			return Math.Max(10, Math.Min(32, value));
		}

		internal static StorageSearchMenuColor ResolveFontColor(StorageSearchMenuFontColor value)
		{
			return value switch
			{
				StorageSearchMenuFontColor.White => Color(byte.MaxValue, byte.MaxValue, byte.MaxValue), 
				StorageSearchMenuFontColor.Gold => Color(byte.MaxValue, 215, 0), 
				StorageSearchMenuFontColor.Yellow => Color(byte.MaxValue, byte.MaxValue, 0), 
				StorageSearchMenuFontColor.Orange => Color(byte.MaxValue, 165, 0), 
				StorageSearchMenuFontColor.Red => Color(byte.MaxValue, 64, 64), 
				StorageSearchMenuFontColor.Pink => Color(byte.MaxValue, 192, 203), 
				StorageSearchMenuFontColor.Purple => Color(192, 128, byte.MaxValue), 
				StorageSearchMenuFontColor.Blue => Color(64, 160, byte.MaxValue), 
				StorageSearchMenuFontColor.Cyan => Color(0, byte.MaxValue, byte.MaxValue), 
				StorageSearchMenuFontColor.Turquoise => Color(64, 224, 208), 
				StorageSearchMenuFontColor.Green => Color(64, 208, 96), 
				StorageSearchMenuFontColor.Lime => Color(0, byte.MaxValue, 0), 
				_ => Color(230, 230, 230), 
			};
		}

		internal static StorageSearchMenuFontColor NormalizeFontColorConfigValue(string value)
		{
			string value2 = (value ?? string.Empty).Trim();
			if (Enum.TryParse<StorageSearchMenuFontColor>(value2, ignoreCase: true, out var result) && Enum.IsDefined(typeof(StorageSearchMenuFontColor), result))
			{
				return result;
			}
			if (!TryParseLegacyHexColor(value2, out var color))
			{
				return StorageSearchMenuFontColor.LightGray;
			}
			return FindNearestNamedColor(color);
		}

		private static bool TryParseLegacyHexColor(string value, out StorageSearchMenuColor color)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.StartsWith("#", StringComparison.Ordinal))
			{
				text = text.Substring(1);
			}
			if (text.Length != 6 && text.Length != 8)
			{
				color = default(StorageSearchMenuColor);
				return false;
			}
			byte result = byte.MaxValue;
			if (!TryByte(text, 0, out var result2) || !TryByte(text, 2, out var result3) || !TryByte(text, 4, out var result4) || (text.Length == 8 && !TryByte(text, 6, out result)))
			{
				color = default(StorageSearchMenuColor);
				return false;
			}
			color = new StorageSearchMenuColor(result2, result3, result4, result);
			return true;
		}

		private static StorageSearchMenuFontColor FindNearestNamedColor(StorageSearchMenuColor legacy)
		{
			StorageSearchMenuFontColor result = StorageSearchMenuFontColor.LightGray;
			long num = long.MaxValue;
			foreach (StorageSearchMenuFontColor value in Enum.GetValues(typeof(StorageSearchMenuFontColor)))
			{
				StorageSearchMenuColor storageSearchMenuColor = ResolveFontColor(value);
				long num2 = legacy.Red - storageSearchMenuColor.Red;
				long num3 = legacy.Green - storageSearchMenuColor.Green;
				long num4 = legacy.Blue - storageSearchMenuColor.Blue;
				long num5 = num2 * num2 + num3 * num3 + num4 * num4;
				if (num5 < num)
				{
					result = value;
					num = num5;
				}
			}
			return result;
		}

		internal static StorageSearchMenuLayout LayoutFor(int configuredFontSize)
		{
			int num = ClampFontSize(configuredFontSize);
			int num2 = Math.Max(0, num - 14);
			return new StorageSearchMenuLayout(num, Math.Max(24, num + 8), Math.Max(30, num + 12), Math.Max(62, num * 3 + 16), 560 + num2 * 10, 610 + num2 * 8, 82 + num * 2);
		}

		private static bool TryByte(string value, int start, out byte result)
		{
			return byte.TryParse(value.Substring(start, 2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out result);
		}

		private static StorageSearchMenuColor Color(byte red, byte green, byte blue)
		{
			return new StorageSearchMenuColor(red, green, blue, byte.MaxValue);
		}
	}
}