using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using AutoChestSort.Chests;
using AutoChestSort.Commands;
using AutoChestSort.Config;
using AutoChestSort.Core;
using AutoChestSort.Core.Config;
using AutoChestSort.Core.Groups;
using AutoChestSort.Core.Inventory;
using AutoChestSort.Core.Localization;
using AutoChestSort.Core.Logging;
using AutoChestSort.Core.Network;
using AutoChestSort.Core.Sorting;
using AutoChestSort.Core.Sorting.Distribution;
using AutoChestSort.Core.Ui;
using AutoChestSort.Groups;
using AutoChestSort.Localization;
using AutoChestSort.Network;
using AutoChestSort.Sorting;
using AutoChestSort.Ui;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Nexxy")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 Nexxy")]
[assembly: AssemblyDescription("Valheim chest auto-sorting mod (BepInEx).")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1f8132cb0513483b73b1f973e223d866478e81b9")]
[assembly: AssemblyProduct("AutoChestSort")]
[assembly: AssemblyTitle("AutoChestSort")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AutoChestSort
{
	internal static class AcsLog
	{
		private static readonly LogChangeGate Changes = new LogChangeGate();

		private static ManualLogSource _log;

		private static bool _configKnown;

		internal static bool DebugEnabled { get; private set; }

		internal static string DebugSource
		{
			get
			{
				if (!_configKnown)
				{
					return "default";
				}
				return "config";
			}
		}

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

		internal static bool ApplyConfigDebug(bool enabled)
		{
			_configKnown = true;
			if (DebugEnabled != enabled)
			{
				if (!enabled)
				{
					Info("debug logging disabled (config)");
				}
				DebugEnabled = enabled;
				if (enabled)
				{
					Info("debug logging enabled (config)");
				}
			}
			return DebugEnabled;
		}

		internal static void Info(string message)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogInfo((object)message);
			}
		}

		internal static bool InfoIfChanged(string key, string state, string message)
		{
			if (!Changes.HasChanged(key, state))
			{
				Debug(message);
				return false;
			}
			Info(message);
			return true;
		}

		internal static bool WarningIfChanged(string key, string state, string message)
		{
			if (!Changes.HasChanged(key, state))
			{
				Debug(message);
				return false;
			}
			Warning(message);
			return true;
		}

		internal static void ForgetChangeStates()
		{
			Changes.Clear();
		}

		internal static void Warning(string message)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogWarning((object)message);
			}
		}

		internal static void Error(string message)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogError((object)message);
			}
		}

		internal static void Error(string message, Exception error)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogError((object)(message + ": " + error));
			}
		}

		internal static void Debug(string message)
		{
			if (DebugEnabled)
			{
				ManualLogSource log = _log;
				if (log != null)
				{
					log.LogInfo((object)message);
				}
			}
		}
	}
	[BepInPlugin("nexxy.valheim.autochestsort", "AutoChestSort", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class AutoChestSortPlugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		private void Awake()
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			AcsLog.Install(((BaseUnityPlugin)this).Logger);
			AcsConfigService.Install(((BaseUnityPlugin)this).Config);
			AcsChestCatalog.Install();
			AcsLog.Info("Hello from ACS v1.0.0 on Valheim " + ReadGameVersion());
			AcsLog.Debug("Core reserved chest names: " + string.Join(", ", ReservedNames.All));
			AcsLocalization.Register(((BaseUnityPlugin)this).Info.Metadata, ((BaseUnityPlugin)this).Logger);
			string text = "ACS localization: registered=" + AcsLocalization.IsRegistered + ", tokens=" + AcsTokens.Count + ", languages=" + string.Join("/", ToArray(AcsTokens.Languages)) + ", batchMode=" + Application.isBatchMode;
			if (AcsLocalization.IsRegistered)
			{
				AcsLog.Debug(text);
			}
			else
			{
				AcsLog.Warning(text + " - texts fall back to their raw tokens");
			}
			bool allowVanillaClients = AcsConfigService.Current.AllowVanillaClients;
			AcsLog.Info("ACS network gate: " + ((object)(CompatibilityLevel)5/*cast due to .constrained prefix*/).ToString() + " / " + ((object)(VersionStrictness)3/*cast due to .constrained prefix*/).ToString() + ", plugin version 1.0.0, allowVanillaClients=" + (allowVanillaClients ? "true" : "false") + " (a client with ACS must match this version; a client without ACS " + (allowVanillaClients ? "may join" : "is turned away at the handshake") + ")");
			AcsCommands.Install();
			_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "nexxy.valheim.autochestsort");
			ContainerOpenSignal.Install(_harmony);
			VanillaClientGate.Install(_harmony);
			AcsLocalization.CatchUpIfAlreadyInitialized();
		}

		private static string[] ToArray(IReadOnlyList<string> values)
		{
			string[] array = new string[values.Count];
			for (int i = 0; i < values.Count; i++)
			{
				array[i] = values[i];
			}
			return array;
		}

		private void OnDestroy()
		{
			AcsConfigService.Shutdown();
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
				_harmony = null;
			}
		}

		private static string ReadGameVersion()
		{
			try
			{
				return GetVersionStringDirect();
			}
			catch (Exception ex)
			{
				try
				{
					return GetVersionStringReflected();
				}
				catch (Exception ex2)
				{
					return "unknown (" + ex.GetType().Name + " / " + ex2.GetType().Name + ")";
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static string GetVersionStringDirect()
		{
			return Version.GetVersionString(false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static string GetVersionStringReflected()
		{
			Type type = AccessTools.TypeByName("Version");
			if (type == null)
			{
				return "unknown (type Version not found)";
			}
			MethodInfo method = type.GetMethod("GetVersionString", BindingFlags.Static | BindingFlags.Public);
			if (method != null)
			{
				ParameterInfo[] parameters = method.GetParameters();
				object[] array = new object[parameters.Length];
				for (int i = 0; i < parameters.Length; i++)
				{
					array[i] = parameters[i].DefaultValue;
				}
				return Convert.ToString(method.Invoke(null, array));
			}
			PropertyInfo property = type.GetProperty("CurrentVersion", BindingFlags.Static | BindingFlags.Public);
			if (property != null)
			{
				return Convert.ToString(property.GetValue(null, null));
			}
			return "unknown (no version API on type Version)";
		}
	}
	public static class PluginInfo
	{
		public const string Guid = "nexxy.valheim.autochestsort";

		public const string Name = "AutoChestSort";

		public const string Version = "1.0.0";
	}
	internal static class AcsVersion
	{
		public const string Value = "1.0.0";
	}
}
namespace AutoChestSort.Ui
{
	internal sealed class AcsDialog
	{
		private const float Width = 520f;

		private const float Height = 300f;

		private GameObject _root;

		private Text _title;

		private Text _body;

		private Text _warning;

		private Button _yes;

		private Button _no;

		private Button _cancel;

		private Text _yesLabel;

		private Text _noLabel;

		private Text _cancelLabel;

		private Action _onYes;

		private Action _onNo;

		private Action _onCancel;

		internal bool IsOpen
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		internal bool Show(string title, string body, string warning, string yes, string no, string cancel, Action onYes, Action onNo, Action onCancel)
		{
			if (!EnsureBuilt())
			{
				return false;
			}
			_onYes = onYes;
			_onNo = onNo;
			_onCancel = onCancel;
			_title.text = title ?? string.Empty;
			_body.text = body ?? string.Empty;
			bool flag = !string.IsNullOrEmpty(warning);
			((Component)_warning).gameObject.SetActive(flag);
			_warning.text = (flag ? warning : string.Empty);
			SetButton(_yes, _yesLabel, yes);
			SetButton(_no, _noLabel, no);
			SetButton(_cancel, _cancelLabel, cancel);
			_root.SetActive(true);
			_root.transform.SetAsLastSibling();
			return true;
		}

		internal void Hide()
		{
			_onYes = null;
			_onNo = null;
			_onCancel = null;
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
		}

		internal void Destroy()
		{
			Hide();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
		}

		private static void SetButton(Button button, Text label, string caption)
		{
			bool flag = !string.IsNullOrEmpty(caption);
			((Component)button).gameObject.SetActive(flag);
			if (flag)
			{
				label.text = caption;
			}
		}

		private bool EnsureBuilt()
		{
			if ((Object)(object)_root != (Object)null && (Object)(object)GUIManager.CustomGUIFront != (Object)null && (Object)(object)_root.transform.parent == (Object)(object)GUIManager.CustomGUIFront.transform)
			{
				return true;
			}
			try
			{
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
					_root = null;
				}
				GUIManager instance = GUIManager.Instance;
				GameObject customGUIFront = GUIManager.CustomGUIFront;
				if (instance == null || (Object)(object)customGUIFront == (Object)null || (Object)(object)instance.AveriaSerifBold == (Object)null)
				{
					return false;
				}
				Build(instance, customGUIFront);
				return true;
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: building the ACS dialog failed", error);
				_root = null;
				return false;
			}
		}

		private void Build(GUIManager manager, GameObject parent)
		{
			//IL_0012: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0131: 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_014d: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			_root = manager.CreateWoodpanel(parent.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 520f, 300f, false);
			((Object)_root).name = "ACS_Dialog";
			_title = MakeText(manager, "ACS_DialogTitle", 18, manager.ValheimOrange, new Vector2(0f, 122f), 480f, 26f, (TextAnchor)4);
			_body = MakeText(manager, "ACS_DialogBody", 16, manager.ValheimBeige, new Vector2(0f, 52f), 480f, 84f, (TextAnchor)4);
			_warning = MakeText(manager, "ACS_DialogWarning", 14, manager.ValheimYellow, new Vector2(0f, -48f), 480f, 68f, (TextAnchor)4);
			_yes = MakeButton(manager, "ACS_DialogYes", new Vector2(-150f, -120f), out _yesLabel, (UnityAction)delegate
			{
				Fire(_onYes);
			});
			_no = MakeButton(manager, "ACS_DialogNo", new Vector2(0f, -120f), out _noLabel, (UnityAction)delegate
			{
				Fire(_onNo);
			});
			_cancel = MakeButton(manager, "ACS_DialogCancel", new Vector2(150f, -120f), out _cancelLabel, (UnityAction)delegate
			{
				Fire(_onCancel);
			});
			_root.SetActive(false);
		}

		private Text MakeText(GUIManager manager, string name, int size, Color color, Vector2 position, float width, float height, TextAnchor anchor)
		{
			//IL_001b: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = manager.CreateText(string.Empty, _root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, manager.AveriaSerifBold, size, color, true, Color.black, width, height, false);
			((Object)obj).name = name;
			Text component = obj.GetComponent<Text>();
			component.alignment = anchor;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)1;
			return component;
		}

		private Button MakeButton(GUIManager manager, string name, Vector2 position, out Text label, UnityAction action)
		{
			//IL_001b: 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)
			GameObject val = manager.CreateButton(string.Empty, _root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, 130f, 34f);
			((Object)val).name = name;
			label = val.GetComponentInChildren<Text>();
			Button component = val.GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener(action);
			return component;
		}

		private void Fire(Action action)
		{
			try
			{
				action?.Invoke();
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: a dialog button failed", error);
				Hide();
				AcsUiText.MessageToken("$acs_err_server");
			}
		}
	}
	internal static class AcsUiText
	{
		internal static string Status(GroupResponse response)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (response == null)
			{
				return string.Empty;
			}
			string token = AcsStatusTokens.TokenForOrFallback(response.Status);
			return AcsStatusTokens.PlaceholderCount(response.Status) switch
			{
				2 => AcsLocalization.Format(token, Display(response), response.AffectedChests), 
				1 => AcsLocalization.Format(token, Display(response)), 
				_ => AcsLocalization.Get(token), 
			};
		}

		internal static string Learned(GroupResponse response)
		{
			string token = ChestPanelTokens.LearnedToken(response.SkippedItems);
			if (response.SkippedItems <= 0)
			{
				return AcsLocalization.Format(token, Display(response), response.Items.Count);
			}
			return AcsLocalization.Format(token, Display(response), response.Items.Count, response.SkippedItems);
		}

		internal static string Display(GroupResponse response)
		{
			if (response == null)
			{
				return string.Empty;
			}
			if (response.DisplayName.Length <= 0)
			{
				return response.GroupName;
			}
			return response.DisplayName;
		}

		internal static string JoinItems(IReadOnlyList<string> values)
		{
			if (values == null || values.Count == 0)
			{
				return AcsLocalization.Get("$acs_ui_info_empty");
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < values.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(values[i]);
			}
			return stringBuilder.ToString();
		}

		internal static void Message(string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				MessageHud instance = MessageHud.instance;
				if ((Object)(object)instance == (Object)null)
				{
					AcsLog.Debug("ui: no MessageHud for \"" + text + "\"");
				}
				else
				{
					instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false, true);
				}
			}
		}

		internal static void MessageToken(string token)
		{
			if (!string.IsNullOrEmpty(token))
			{
				Message(AcsLocalization.Get(token));
			}
		}
	}
	internal sealed class ChestPanelWidgets
	{
		internal const float PanelWidth = 430f;

		internal const float CollapsedHeight = 92f;

		private const float NameWidth = 250f;

		private const float RowHeight = 30f;

		private const float ButtonSize = 36f;

		private const float ButtonPitch = 42f;

		private const float Margin = 8f;

		private const float LineHeight = 18f;

		private const float InfoTop = 42f;

		private const float StatusTop = 60f;

		private const float ItemsTop = 80f;

		private const float ItemsMinHeight = 20f;

		private const float ItemsMaxHeight = 200f;

		private static Vector2 _offset = new Vector2(0f, -6f);

		private float _itemsHeight = 20f;

		internal GameObject Root { get; private set; }

		internal InputField NameField { get; private set; }

		internal Button ResetButton { get; private set; }

		internal Button InfoButton { get; private set; }

		internal Button LearnButton { get; private set; }

		internal Button DeleteButton { get; private set; }

		internal Text InfoLine { get; private set; }

		internal Text StatusLine { get; private set; }

		internal GameObject ItemsPanel { get; private set; }

		internal Text ItemsText { get; private set; }

		internal UITooltip LearnTooltip { get; private set; }

		internal UITooltip DeleteTooltip { get; private set; }

		internal UITooltip ResetTooltip { get; private set; }

		internal UITooltip InfoTooltip { get; private set; }

		internal static Vector2 Offset => _offset;

		internal bool AreItemsVisible
		{
			get
			{
				if ((Object)(object)ItemsPanel != (Object)null)
				{
					return ItemsPanel.activeSelf;
				}
				return false;
			}
		}

		private ChestPanelWidgets()
		{
		}

		internal static ChestPanelWidgets TryBuild(RectTransform parent)
		{
			if ((Object)(object)parent == (Object)null)
			{
				return null;
			}
			try
			{
				GUIManager instance = GUIManager.Instance;
				if (instance == null || (Object)(object)instance.AveriaSerifBold == (Object)null)
				{
					return null;
				}
				ChestPanelWidgets chestPanelWidgets = new ChestPanelWidgets();
				chestPanelWidgets.Build(instance, parent);
				return chestPanelWidgets;
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: building the chest panel failed", error);
				return null;
			}
		}

		internal void MoveTo(Vector2 offset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			_offset = offset;
			if ((Object)(object)Root != (Object)null)
			{
				Root.GetComponent<RectTransform>().anchoredPosition = offset;
			}
		}

		internal void SetItemsVisible(bool visible)
		{
			if (!((Object)(object)ItemsPanel == (Object)null) && !((Object)(object)Root == (Object)null))
			{
				ItemsPanel.SetActive(visible);
				Resize(visible);
			}
		}

		internal void SetItemsText(string text)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ItemsText == (Object)null)
			{
				return;
			}
			ItemsText.text = text ?? string.Empty;
			float num = 0f;
			try
			{
				num = ItemsText.preferredHeight;
			}
			catch (Exception ex)
			{
				AcsLog.Debug("ui: measuring the item list failed (" + ex.GetType().Name + ")");
			}
			float num2 = Mathf.Clamp(Mathf.Max(num, Estimate(ItemsText.text)), 20f, 200f);
			if (!(Mathf.Abs(num2 - _itemsHeight) < 1f))
			{
				_itemsHeight = num2;
				if ((Object)(object)ItemsPanel != (Object)null)
				{
					ItemsPanel.GetComponent<RectTransform>().sizeDelta = new Vector2(414f, _itemsHeight);
				}
				Resize(AreItemsVisible);
			}
		}

		private static float Estimate(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return 20f;
			}
			return (float)(1 + text.Length / 58) * 16f + 4f;
		}

		private void Resize(bool itemsVisible)
		{
			if (!((Object)(object)Root == (Object)null))
			{
				float num = (itemsVisible ? (80f + _itemsHeight + 8f) : 92f);
				Root.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, num);
			}
		}

		internal void Destroy()
		{
			if ((Object)(object)Root != (Object)null)
			{
				Object.Destroy((Object)(object)Root);
				Root = null;
			}
		}

		private void Build(GUIManager manager, RectTransform parent)
		{
			//IL_000d: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: 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_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			Root = manager.CreateWoodpanel((Transform)(object)parent, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), _offset, 430f, 92f, false);
			((Object)Root).name = "ACS_ChestPanel";
			RectTransform component = Root.GetComponent<RectTransform>();
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = _offset;
			float num = -215f;
			float num2 = -23f;
			GameObject val = manager.CreateInputField(Root.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(num + 8f + 125f, num2), (ContentType)0, AcsLocalization.Get("$acs_ui_name_placeholder"), 16, 250f, 30f);
			((Object)val).name = "ACS_Name";
			NameField = val.GetComponent<InputField>();
			NameField.characterLimit = 32;
			NameField.lineType = (LineType)0;
			AddTooltip(val, "$acs_ui_tooltip_name");
			float num3 = num + 8f + 250f + 42f - 18f;
			ResetButton = MakeButton(manager, "Ø", "ACS_Reset", num3, num2, "$acs_ui_tooltip_reset", out var tooltip);
			ResetTooltip = tooltip;
			num3 += 42f;
			InfoButton = MakeButton(manager, "i", "ACS_Info", num3, num2, "$acs_ui_tooltip_info", out var tooltip2);
			InfoTooltip = tooltip2;
			num3 += 42f;
			LearnButton = MakeButton(manager, "+", "ACS_Learn", num3, num2, "$acs_ui_tooltip_learn", out var tooltip3);
			LearnTooltip = tooltip3;
			num3 += 42f;
			DeleteButton = MakeButton(manager, "−", "ACS_Delete", num3, num2, "$acs_ui_tooltip_delete", out var tooltip4);
			DeleteTooltip = tooltip4;
			InfoLine = MakeLine(manager, "ACS_InfoLine", 42f, 14, manager.ValheimBeige);
			StatusLine = MakeLine(manager, "ACS_StatusLine", 60f, 13, manager.ValheimYellow);
			ItemsPanel = new GameObject("ACS_Items", new Type[1] { typeof(RectTransform) });
			ItemsPanel.transform.SetParent(Root.transform, false);
			RectTransform component2 = ItemsPanel.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.5f, 1f);
			component2.anchorMax = new Vector2(0.5f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = new Vector2(0f, -80f);
			component2.sizeDelta = new Vector2(414f, _itemsHeight);
			GameObject val2 = manager.CreateText(string.Empty, ItemsPanel.transform, new Vector2(0f, 0f), new Vector2(1f, 1f), Vector2.zero, manager.AveriaSerifBold, 13, manager.ValheimOrange, true, Color.black, 0f, 0f, false);
			((Object)val2).name = "ACS_ItemsText";
			ItemsText = val2.GetComponent<Text>();
			ItemsText.alignment = (TextAnchor)0;
			ItemsText.horizontalOverflow = (HorizontalWrapMode)0;
			ItemsText.verticalOverflow = (VerticalWrapMode)1;
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			ItemsPanel.SetActive(false);
		}

		private Text MakeLine(GUIManager manager, string name, float top, int size, Color color)
		{
			//IL_001b: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = manager.CreateText(string.Empty, Root.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, 0f - (top + 9f)), manager.AveriaSerifBold, size, color, true, Color.black, 414f, 18f, false);
			((Object)obj).name = name;
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(414f, 18f);
			component.anchoredPosition = new Vector2(0f, 0f - (top + 9f));
			Text component2 = obj.GetComponent<Text>();
			component2.alignment = (TextAnchor)3;
			component2.horizontalOverflow = (HorizontalWrapMode)1;
			component2.verticalOverflow = (VerticalWrapMode)1;
			return component2;
		}

		private Button MakeButton(GUIManager manager, string label, string name, float x, float y, string tooltipToken, out UITooltip tooltip)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = manager.CreateButton(label, Root.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(x, y), 36f, 30f);
			((Object)val).name = name;
			tooltip = AddTooltip(val, tooltipToken);
			return val.GetComponent<Button>();
		}

		internal static void SetTooltipText(UITooltip tooltip, string text)
		{
			//IL_0031: 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)
			if ((Object)(object)tooltip == (Object)null)
			{
				return;
			}
			string text2 = text ?? string.Empty;
			if (string.Equals(tooltip.m_text, text2, StringComparison.Ordinal))
			{
				return;
			}
			try
			{
				tooltip.Set(tooltip.m_topic, text2, (RectTransform)null, default(Vector2));
			}
			catch (Exception ex)
			{
				tooltip.m_text = text2;
				AcsLog.Debug("ui: refreshing a tooltip failed (" + ex.GetType().Name + ")");
			}
		}

		private static UITooltip AddTooltip(GameObject target, string token)
		{
			try
			{
				GameObject val = TooltipPrefab();
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				UITooltip val2 = target.GetComponent<UITooltip>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = target.AddComponent<UITooltip>();
				}
				val2.m_tooltipPrefab = val;
				val2.m_text = AcsLocalization.Get(token);
				return val2;
			}
			catch (Exception ex)
			{
				AcsLog.Debug("ui: no tooltip for " + ((Object)target).name + " (" + ex.GetType().Name + ")");
				return null;
			}
		}

		private static GameObject TooltipPrefab()
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			UITooltip[] componentsInChildren = ((Component)instance).GetComponentsInChildren<UITooltip>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null && (Object)(object)componentsInChildren[i].m_tooltipPrefab != (Object)null)
				{
					return componentsInChildren[i].m_tooltipPrefab;
				}
			}
			return null;
		}
	}
	internal sealed class ChestUiController : MonoBehaviour
	{
		private struct Sent
		{
			internal GroupOpcode Opcode { get; }

			internal ZDOID Chest { get; }

			internal Sent(GroupOpcode opcode, ZDOID chest)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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)
				Opcode = opcode;
				Chest = chest;
			}
		}

		internal const float PollSeconds = 2f;

		internal const float WriteTimeoutSeconds = 6f;

		internal const float StatusSeconds = 6f;

		private readonly AcsDialog _dialog = new AcsDialog();

		private readonly Dictionary<int, Sent> _mine = new Dictionary<int, Sent>();

		private ChestPanelWidgets _widgets;

		private bool _handlersWired;

		private Container _chest;

		private ZDOID _chestId;

		private ChestPanelFacts _facts;

		private ChestPanelState _state;

		private float _pollTimer;

		private int _pendingWrite;

		private float _pendingSince;

		private int _storeVersion;

		private int _lockRevision = -1;

		private GroupStatus _lastQueryStatus;

		private GroupResponse _preview;

		private ConflictQueue _queue;

		private LearnMode _commitMode;

		private bool _modeChosen;

		private string _status = string.Empty;

		private float _statusUntil;

		private bool _itemsDirty = true;

		private bool _nameFocused;

		private bool _known;

		private int _buildAttempts;

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

		internal static ChestUiController Instance { get; private set; }

		internal ZDOID OpenChestId
		{
			get
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_chest != (Object)null))
				{
					return ZDOID.None;
				}
				return _chestId;
			}
		}

		internal static void Install()
		{
			//IL_0025: 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_0030: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				if (GUIManager.IsHeadless())
				{
					AcsLog.Debug("ui: headless process, no chest panel");
					return;
				}
				GameObject val = new GameObject("ACS_ChestUi");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<ChestUiController>();
				AcsLog.Info("ui: chest panel installed (poll " + 2f + " s)");
			}
		}

		internal string Describe()
		{
			return "chest=" + (((Object)(object)_chest != (Object)null) ? ((object)Unsafe.As<ZDOID, ZDOID>(ref _chestId)/*cast due to .constrained prefix*/).ToString() : "none") + " name=\"" + _facts.DisplayName + "\" role=" + ((object)Unsafe.As<GroupRole, GroupRole>(ref _facts.Role)/*cast due to .constrained prefix*/).ToString() + " stacks=" + _facts.ChestStacks + " groupItems=" + _facts.GroupItems + " chests=" + _facts.ChestCount + " open(others)=" + _facts.OpenChests + " known=" + _facts.Known + " busy=" + (_pendingWrite != 0) + " dialog=" + _dialog.IsOpen + " commitMode=" + ((object)Unsafe.As<LearnMode, LearnMode>(ref _commitMode)/*cast due to .constrained prefix*/).ToString() + " modeChosen=" + _modeChosen + " storeVersion=" + _storeVersion + " lockRevision=" + _lockRevision + " widgets=" + (_widgets != null) + " " + InputBlockGuard.Describe();
		}

		internal void MoveTo(Vector2 offset)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			_widgets?.MoveTo(offset);
		}

		internal unsafe void OnPanelGone(string reason)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_chest == (Object)null)
			{
				InputBlockGuard.Release(reason);
				return;
			}
			ZDOID chestId = _chestId;
			AcsLog.Debug("ui: chest panel closed (" + reason + "), chest " + ((object)(*(ZDOID*)(&chestId))/*cast due to .constrained prefix*/).ToString());
			Teardown(reason);
		}

		private void OnDestroy()
		{
			try
			{
				Teardown("controller destroyed");
				_dialog.Destroy();
				_widgets?.Destroy();
				_widgets = null;
				ItemNames.Clear();
				GroupRpc.ResponseReceived -= OnResponse;
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: tearing the chest panel down failed", error);
			}
			finally
			{
				if ((Object)(object)Instance == (Object)(object)this)
				{
					Instance = null;
				}
			}
		}

		private void Awake()
		{
			GroupRpc.ResponseReceived += OnResponse;
		}

		private void Update()
		{
			try
			{
				Container val = CurrentContainer();
				if ((Object)(object)val != (Object)(object)_chest)
				{
					if ((Object)(object)_chest != (Object)null)
					{
						Teardown("another chest");
					}
					if ((Object)(object)val != (Object)null)
					{
						Setup(val);
					}
				}
				if ((Object)(object)_chest == (Object)null)
				{
					InputBlockGuard.Release("no chest open");
					return;
				}
				UpdateNameFocus();
				ExpirePendingWrite();
				Poll();
				RefreshState();
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: the chest panel update failed, closing it", error);
				try
				{
					Teardown("update failed");
				}
				catch (Exception error2)
				{
					AcsLog.Error("ui: emergency teardown failed", error2);
					InputBlockGuard.Release("emergency");
				}
			}
		}

		private static Container CurrentContainer()
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null || ((Character)Player.m_localPlayer).IsDead())
			{
				return null;
			}
			Container currentContainer = instance.m_currentContainer;
			if ((Object)(object)currentContainer == (Object)null || !currentContainer.IsOwner())
			{
				return null;
			}
			ZDO zdo = ChestRegistry.GetZdo(currentContainer);
			if (zdo == null || !AcsChestCatalog.Current.IsSupported(zdo.GetPrefab()))
			{
				return null;
			}
			return currentContainer;
		}

		private void Setup(Container container)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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)
			ZDO zdo = ChestRegistry.GetZdo(container);
			if (zdo != null && EnsureWidgets())
			{
				_chest = container;
				_chestId = zdo.m_uid;
				_facts = default(ChestPanelFacts);
				_facts.DisplayName = ChestName.GetDisplay(zdo);
				_facts.Role = GroupRoles.Of(_facts.DisplayName);
				_facts.ChestStacks = CountStacks(container);
				_known = false;
				_pendingWrite = 0;
				_storeVersion = 0;
				_lockRevision = -1;
				_lastQueryStatus = (GroupStatus)0;
				_preview = null;
				_queue = null;
				_modeChosen = false;
				_commitMode = (LearnMode)0;
				_items.Clear();
				_itemsDirty = true;
				_status = string.Empty;
				_statusUntil = 0f;
				_mine.Clear();
				SetNameFieldText(_facts.DisplayName);
				_widgets.Root.SetActive(true);
				_widgets.SetItemsVisible(AcsConfigService.Current.EnableDebug);
				_pollTimer = 0f;
				SendQuery();
				RefreshState();
				AcsLog.Debug("ui: chest panel opened for " + ChestName.Describe(zdo) + ", name \"" + _facts.DisplayName + "\", stacks " + _facts.ChestStacks);
			}
		}

		private void Teardown(string reason)
		{
			//IL_0056: 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)
			InputBlockGuard.Release(reason);
			_dialog.Hide();
			_preview = null;
			_queue = null;
			_modeChosen = false;
			_status = string.Empty;
			_statusUntil = 0f;
			_mine.Clear();
			_pendingWrite = 0;
			_chest = null;
			_chestId = ZDOID.None;
			_known = false;
			if (_widgets != null)
			{
				if ((Object)(object)_widgets.NameField != (Object)null)
				{
					_widgets.NameField.DeactivateInputField();
				}
				_widgets.SetItemsVisible(visible: false);
				if ((Object)(object)_widgets.Root != (Object)null)
				{
					_widgets.Root.SetActive(false);
				}
			}
			_nameFocused = false;
		}

		private bool EnsureWidgets()
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_container == (Object)null)
			{
				return false;
			}
			if (_widgets != null && (Object)(object)_widgets.Root != (Object)null && (Object)(object)_widgets.Root.transform.parent == (Object)(object)((Component)instance.m_container).transform)
			{
				return true;
			}
			_handlersWired = false;
			_widgets?.Destroy();
			_widgets = ChestPanelWidgets.TryBuild(instance.m_container);
			if (_widgets == null)
			{
				_buildAttempts++;
				if (_buildAttempts == 1 || _buildAttempts % 300 == 0)
				{
					AcsLog.Warning("ui: the chest panel could not be built yet (attempt " + _buildAttempts + "), retrying");
				}
				return false;
			}
			WireHandlers();
			AcsLog.Debug("ui: chest panel built under InventoryGui.m_container");
			return true;
		}

		private void WireHandlers()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			if (!_handlersWired && _widgets != null)
			{
				_handlersWired = true;
				((UnityEvent<string>)(object)_widgets.NameField.onEndEdit).AddListener((UnityAction<string>)OnNameSubmitted);
				((UnityEvent)_widgets.ResetButton.onClick).AddListener(new UnityAction(OnResetClicked));
				((UnityEvent)_widgets.InfoButton.onClick).AddListener(new UnityAction(OnInfoClicked));
				((UnityEvent)_widgets.LearnButton.onClick).AddListener(new UnityAction(OnLearnClicked));
				((UnityEvent)_widgets.DeleteButton.onClick).AddListener(new UnityAction(OnDeleteClicked));
			}
		}

		private void UpdateNameFocus()
		{
			bool flag = _widgets != null && (Object)(object)_widgets.NameField != (Object)null && _widgets.NameField.isFocused;
			if (flag != _nameFocused)
			{
				_nameFocused = flag;
				if (flag)
				{
					InputBlockGuard.Block();
				}
				else
				{
					InputBlockGuard.Release("name field lost focus");
				}
			}
		}

		private void ExpirePendingWrite()
		{
			if (_pendingWrite != 0 && !(Time.unscaledTime - _pendingSince < 6f))
			{
				AcsLog.Warning("ui: no answer to request #" + _pendingWrite + " within " + 6f + " s, the panel is usable again");
				_mine.Remove(_pendingWrite);
				_pendingWrite = 0;
				if (_dialog.IsOpen)
				{
					_dialog.Hide();
					_preview = null;
					_queue = null;
				}
				AnnounceToken("$acs_err_server");
			}
		}

		private void Poll()
		{
			_pollTimer -= Time.unscaledDeltaTime;
			if (!(_pollTimer > 0f))
			{
				_pollTimer = 2f;
				SendQuery();
			}
		}

		private void RefreshState()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if (_widgets == null || (Object)(object)_chest == (Object)null)
			{
				return;
			}
			ZDO zdo = ChestRegistry.GetZdo(_chest);
			if (zdo == null)
			{
				Teardown("chest zdo gone");
				return;
			}
			string display = ChestName.GetDisplay(zdo);
			if (!_nameFocused && !string.Equals(display, _facts.DisplayName, StringComparison.Ordinal))
			{
				_facts.DisplayName = display;
				_facts.Role = GroupRoles.Of(display);
				SetNameFieldText(display);
			}
			_facts.ChestStacks = CountStacks(_chest);
			_facts.CtrlHeld = ZInput.GetKey((KeyCode)306, false) || ZInput.GetKey((KeyCode)305, false);
			_facts.Known = _known;
			_facts.Busy = _pendingWrite != 0;
			_facts.DialogOpen = _dialog.IsOpen;
			_state = ChestPanelState.Evaluate(_facts);
			((Selectable)_widgets.NameField).interactable = _state.NameFieldEnabled;
			_widgets.NameField.readOnly = !_state.NameFieldEnabled;
			if (!_state.NameFieldEnabled && _widgets.NameField.isFocused)
			{
				_widgets.NameField.DeactivateInputField();
			}
			((Selectable)_widgets.ResetButton).interactable = _state.ResetEnabled;
			((Selectable)_widgets.InfoButton).interactable = _state.InfoEnabled;
			((Selectable)_widgets.LearnButton).interactable = _state.LearnEnabled;
			((Selectable)_widgets.DeleteButton).interactable = _state.DeleteEnabled;
			if (!_state.InfoEnabled && _widgets.AreItemsVisible)
			{
				_widgets.SetItemsVisible(visible: false);
			}
			ChestPanelWidgets.SetTooltipText(_widgets.LearnTooltip, AcsLocalization.Get((_state.LearnBlockedToken.Length > 0) ? _state.LearnBlockedToken : "$acs_ui_tooltip_learn"));
			ChestPanelWidgets.SetTooltipText(_widgets.DeleteTooltip, AcsLocalization.Get((_state.DeleteEnabled || _state.DeleteBlockedToken.Length == 0) ? "$acs_ui_tooltip_delete" : _state.DeleteBlockedToken));
			ChestPanelWidgets.SetTooltipText(_widgets.ResetTooltip, AcsLocalization.Get((!_state.ResetEnabled && _state.Locked) ? "$acs_msg_group_locked" : "$acs_ui_tooltip_reset"));
			ChestPanelWidgets.SetTooltipText(_widgets.InfoTooltip, AcsLocalization.Get((_state.InfoBlockedToken.Length > 0) ? _state.InfoBlockedToken : "$acs_ui_tooltip_info"));
			_widgets.InfoLine.text = BuildInfoLine();
			_widgets.StatusLine.text = CurrentStatus();
			if (_widgets.AreItemsVisible && _itemsDirty)
			{
				_widgets.SetItemsText(BuildItemsText());
				_itemsDirty = false;
			}
		}

		private string CurrentStatus()
		{
			if (_status.Length == 0)
			{
				return string.Empty;
			}
			if (Time.unscaledTime >= _statusUntil)
			{
				_status = string.Empty;
				return string.Empty;
			}
			return _status;
		}

		private void Announce(string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				AcsUiText.Message(text);
				_status = text;
				_statusUntil = Time.unscaledTime + 6f;
				if ((Object)(object)_widgets?.StatusLine != (Object)null)
				{
					_widgets.StatusLine.text = text;
				}
			}
		}

		private void AnnounceToken(string token)
		{
			if (!string.IsNullOrEmpty(token))
			{
				Announce(AcsLocalization.Get(token));
			}
		}

		private string BuildInfoLine()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(AcsLocalization.Get(ChestPanelTokens.RoleToken(_facts.Role)));
			if (((ChestPanelFacts)(ref _facts)).IsGroup)
			{
				stringBuilder.Append(": ").Append(_facts.DisplayName);
				stringBuilder.Append("  ").Append(AcsLocalization.Format("$acs_ui_info_chests", _facts.ChestCount));
			}
			if (!_known)
			{
				stringBuilder.Append("  ").Append(GroupStatusExtensions.IsOk(_lastQueryStatus) ? AcsLocalization.Get("$acs_ui_waiting") : AcsLocalization.Get(AcsStatusTokens.TokenForOrFallback(_lastQueryStatus)));
			}
			else if (_state != null && _state.Locked)
			{
				stringBuilder.Append("  ").Append(AcsLocalization.Get("$acs_msg_group_locked"));
			}
			if (AcsConfigService.Current.EnableDebug)
			{
				stringBuilder.Append("  [").Append(_chestId).Append(" v")
					.Append(_storeVersion)
					.Append(" lr")
					.Append(_lockRevision)
					.Append(" open")
					.Append(_facts.OpenChests)
					.Append("]");
			}
			return stringBuilder.ToString();
		}

		private string BuildItemsText()
		{
			return AcsLocalization.Get("$acs_ui_info_header") + ": " + AcsUiText.JoinItems(ItemNames.Display(_items));
		}

		private void SetItems(List<string> items)
		{
			if (items != null && !SameItems(items))
			{
				_items.Clear();
				_items.AddRange(items);
				_itemsDirty = true;
			}
		}

		private bool SameItems(List<string> items)
		{
			if (items.Count != _items.Count)
			{
				return false;
			}
			for (int i = 0; i < items.Count; i++)
			{
				if (!string.Equals(items[i], _items[i], StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		private static int CountStacks(Container container)
		{
			try
			{
				Inventory val = ((container != null) ? container.GetInventory() : null);
				return (val != null) ? val.NrOfItems() : 0;
			}
			catch (Exception ex)
			{
				AcsLog.Debug("ui: reading the chest inventory failed (" + ex.GetType().Name + ")");
				return 0;
			}
		}

		private void SetNameFieldText(string text)
		{
			if (!((Object)(object)_widgets?.NameField == (Object)null))
			{
				_widgets.NameField.text = text ?? string.Empty;
			}
		}

		private void OnNameSubmitted(string typed)
		{
			try
			{
				if ((Object)(object)_chest == (Object)null || _state == null)
				{
					return;
				}
				string text = ChestNameNormalizer.ToRaw(typed);
				if (string.Equals(text, ChestNameNormalizer.ToRaw(_facts.DisplayName), StringComparison.Ordinal))
				{
					SetNameFieldText(_facts.DisplayName);
				}
				else if (!_state.NameFieldEnabled)
				{
					SetNameFieldText(_facts.DisplayName);
					if (_state.Locked)
					{
						AnnounceToken("$acs_msg_group_locked");
					}
				}
				else
				{
					Send((GroupOpcode)4, (LearnMode)0, text);
				}
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: submitting the chest name failed", error);
			}
		}

		private void OnResetClicked()
		{
			try
			{
				if ((Object)(object)_chest == (Object)null || _state == null || !_state.ResetEnabled)
				{
					Explain((_state != null && _state.Locked) ? "$acs_msg_group_locked" : string.Empty);
				}
				else
				{
					Send((GroupOpcode)5, (LearnMode)0, string.Empty);
				}
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: the reset button failed", error);
			}
		}

		private void OnInfoClicked()
		{
			try
			{
				if (_widgets != null && _state != null && _state.InfoEnabled)
				{
					_widgets.SetItemsVisible(!_widgets.AreItemsVisible);
					if (_widgets.AreItemsVisible)
					{
						_widgets.SetItemsText(BuildItemsText());
						_itemsDirty = false;
					}
				}
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: the info button failed", error);
			}
		}

		private void OnLearnClicked()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)_chest == (Object)null) && _state != null)
				{
					if (!_state.LearnEnabled)
					{
						Explain(_state.LearnBlockedToken);
						return;
					}
					if (_state.LearnIsMiscFastpath)
					{
						Send((GroupOpcode)6, (LearnMode)0, string.Empty);
						return;
					}
					_preview = null;
					_queue = null;
					_modeChosen = false;
					_commitMode = (LearnMode)0;
					Send((GroupOpcode)1, (LearnMode)0, string.Empty);
				}
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: the learn button failed", error);
			}
		}

		private void OnDeleteClicked()
		{
			try
			{
				if ((Object)(object)_chest == (Object)null || _state == null)
				{
					return;
				}
				if (!_state.DeleteEnabled)
				{
					Explain(_state.DeleteBlockedToken);
					return;
				}
				if (!_state.DeleteArmed)
				{
					AnnounceToken("$acs_msg_delete_needs_ctrl");
					return;
				}
				string displayName = _facts.DisplayName;
				if (!_dialog.Show(AcsLocalization.Format("$acs_dlg_delete_title", displayName), AcsLocalization.Format("$acs_dlg_delete_text", _facts.ChestCount), string.Empty, AcsLocalization.Get("$acs_dlg_button_yes"), string.Empty, AcsLocalization.Get("$acs_dlg_button_cancel"), delegate
				{
					_dialog.Hide();
					Send((GroupOpcode)3, (LearnMode)0, string.Empty);
				}, null, Cancelled))
				{
					AcsLog.Warning("ui: the delete confirmation could not be shown, nothing was deleted");
					AnnounceToken("$acs_err_server");
				}
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: the delete button failed", error);
			}
		}

		private void Cancelled()
		{
			_dialog.Hide();
			_preview = null;
			_queue = null;
			_modeChosen = false;
			AnnounceToken("$acs_msg_cancelled");
		}

		private void Explain(string token)
		{
			AnnounceToken(token);
		}

		private void ShowModeStep()
		{
			if (_preview != null && _queue != null)
			{
				LearnDialogPlan plan = LearnDialogPlan.ForPreview(_preview.Removed.Count);
				string text = AcsUiText.Display(_preview);
				string body = AcsLocalization.Format("$acs_dlg_confirm_learn", text) + "\n" + AcsLocalization.Format("$acs_dlg_learn_new", AcsUiText.JoinItems(ItemNames.Display(_preview.Accepted)));
				string warning = (plan.ShowsRemovedWarning ? (RemovedWarning((LearnMode)0) + "\n" + AcsLocalization.Get("$acs_dlg_learn_merge_hint")) : string.Empty);
				if (!_dialog.Show(AcsLocalization.Format("$acs_dlg_learn_title", text), body, warning, AcsLocalization.Get(plan.PrimaryToken), plan.HasSecondary ? AcsLocalization.Get(plan.SecondaryToken) : string.Empty, AcsLocalization.Get(plan.CancelToken), delegate
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					ChooseMode(plan.PrimaryMode);
				}, plan.HasSecondary ? ((Action)delegate
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					ChooseMode(plan.SecondaryMode);
				}) : null, Cancelled))
				{
					AcsLog.Warning("ui: the learn dialog could not be shown, the learn run is dropped - nothing was changed");
					Cancelled();
				}
			}
		}

		private unsafe void ChooseMode(LearnMode mode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_commitMode = mode;
			_modeChosen = true;
			_dialog.Hide();
			string[] obj = new string[7]
			{
				"ui: learn mode ",
				((object)(*(LearnMode*)(&mode))/*cast due to .constrained prefix*/).ToString(),
				" chosen for \"",
				AcsUiText.Display(_preview),
				"\", ",
				null,
				null
			};
			ConflictQueue queue = _queue;
			obj[5] = ((queue != null) ? queue.Total : 0).ToString();
			obj[6] = " conflict(s) to answer";
			AcsLog.Debug(string.Concat(obj));
			ShowNextLearnStep();
		}

		private void ShowNextLearnStep()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (_preview == null || _queue == null)
			{
				return;
			}
			if (_queue.IsCancelled)
			{
				Cancelled();
				return;
			}
			if (!_modeChosen)
			{
				ShowModeStep();
				return;
			}
			string text = AcsUiText.Display(_preview);
			string warning = RemovedWarning(_commitMode);
			LearnConflict current = _queue.Current;
			if (current != null)
			{
				string text2 = ((_queue.Total > 1) ? (AcsLocalization.Format("$acs_dlg_conflict_progress", _queue.Position, _queue.Total) + "\n") : string.Empty);
				if (!_dialog.Show(AcsLocalization.Format("$acs_dlg_learn_title", text), text2 + AcsLocalization.Format("$acs_dlg_conflict_text", ItemNames.Display(current.Item.Name), current.CurrentGroup), warning, AcsLocalization.Get("$acs_dlg_button_yes"), AcsLocalization.Get("$acs_dlg_button_no"), AcsLocalization.Get("$acs_dlg_button_cancel"), delegate
				{
					AnswerConflict(takeover: true);
				}, delegate
				{
					AnswerConflict(takeover: false);
				}, Cancelled))
				{
					AcsLog.Warning("ui: the conflict dialog could not be shown, the learn run is dropped - nothing was changed");
					Cancelled();
				}
			}
			else
			{
				SendCommit();
			}
		}

		private string RemovedWarning(LearnMode mode)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (_preview == null || _preview.Removed.Count == 0 || (int)mode != 0)
			{
				return string.Empty;
			}
			return AcsLocalization.Format("$acs_dlg_removed_header", AcsUiText.JoinItems(ItemNames.Display(_preview.Removed))) + "\n" + AcsLocalization.Get("$acs_dlg_removed_hint");
		}

		private void AnswerConflict(bool takeover)
		{
			if (_queue != null)
			{
				_queue.Answer(takeover);
				_dialog.Hide();
				ShowNextLearnStep();
			}
		}

		private void SendQuery()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (!((Object)(object)_chest == (Object)null))
			{
				int num = GroupRpc.NextRequestId();
				_mine[num] = new Sent((GroupOpcode)7, _chestId);
				TrimPending();
				if (!GroupRpc.Send(new GroupRequest((GroupOpcode)7, num, ((ZDOID)(ref _chestId)).UserID, ((ZDOID)(ref _chestId)).ID, (LearnMode)0, (string)null, 0, (IEnumerable<string>)null, (IEnumerable<string>)null)))
				{
					_mine.Remove(num);
				}
			}
		}

		private void Send(GroupOpcode opcode, LearnMode mode, string text)
		{
			//IL_001c: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if (!((Object)(object)_chest == (Object)null))
			{
				int num = GroupRpc.NextRequestId();
				_mine[num] = new Sent(opcode, _chestId);
				TrimPending();
				_pendingWrite = num;
				_pendingSince = Time.unscaledTime;
				if (!GroupRpc.Send(new GroupRequest(opcode, num, ((ZDOID)(ref _chestId)).UserID, ((ZDOID)(ref _chestId)).ID, mode, text, 0, (IEnumerable<string>)null, (IEnumerable<string>)null)))
				{
					_mine.Remove(num);
					_pendingWrite = 0;
					AnnounceToken("$acs_err_server");
				}
				else
				{
					RefreshState();
				}
			}
		}

		private void SendCommit()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			if (!((Object)(object)_chest == (Object)null) && _preview != null && _queue != null && _modeChosen)
			{
				int num = GroupRpc.NextRequestId();
				_mine[num] = new Sent((GroupOpcode)2, _chestId);
				TrimPending();
				_pendingWrite = num;
				_pendingSince = Time.unscaledTime;
				if (!GroupRpc.Send(new GroupRequest((GroupOpcode)2, num, ((ZDOID)(ref _chestId)).UserID, ((ZDOID)(ref _chestId)).ID, _commitMode, (string)null, _preview.StoreVersion, (IEnumerable<string>)_queue.Takeover, (IEnumerable<string>)_queue.Skip)))
				{
					_mine.Remove(num);
					_pendingWrite = 0;
					AnnounceToken("$acs_err_server");
				}
				else
				{
					RefreshState();
				}
			}
		}

		private void TrimPending()
		{
			if (_mine.Count > 32)
			{
				_mine.Clear();
				_pendingWrite = 0;
			}
		}

		private void OnResponse(GroupResponse response)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Invalid comparison between Unknown and I4
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Invalid comparison between Unknown and I4
			try
			{
				if (response == null || !_mine.TryGetValue(response.RequestId, out var value))
				{
					return;
				}
				_mine.Remove(response.RequestId);
				if (_pendingWrite == response.RequestId)
				{
					_pendingWrite = 0;
				}
				if ((Object)(object)_chest == (Object)null || value.Chest != _chestId)
				{
					AcsLog.Debug("ui: dropped a late " + ((object)response.Opcode/*cast due to .constrained prefix*/).ToString() + " answer for " + ((object)value.Chest/*cast due to .constrained prefix*/).ToString());
					return;
				}
				GroupOpcode opcode = response.Opcode;
				if ((int)opcode != 1)
				{
					if ((int)opcode != 2)
					{
						if ((int)opcode == 7)
						{
							OnQueryAnswer(response);
						}
						else
						{
							OnWriteAnswer(response);
						}
					}
					else
					{
						OnCommitAnswer(response);
					}
				}
				else
				{
					OnPreviewAnswer(response);
				}
				RefreshState();
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: handling a group answer failed", error);
			}
		}

		private void OnQueryAnswer(GroupResponse response)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			_lastQueryStatus = response.Status;
			if (!response.IsOk)
			{
				_known = false;
				return;
			}
			_known = true;
			_facts.Role = response.Role;
			_facts.GroupItems = response.Items.Count;
			_facts.ChestCount = response.ChestCount;
			_facts.OpenChests = response.OpenChests;
			_storeVersion = response.StoreVersion;
			_lockRevision = response.LockRevision;
			SetItems(response.Items);
			if (response.DisplayName.Length > 0 && !_nameFocused && !string.Equals(response.DisplayName, _facts.DisplayName, StringComparison.Ordinal))
			{
				_facts.DisplayName = response.DisplayName;
				SetNameFieldText(response.DisplayName);
			}
		}

		private void OnPreviewAnswer(GroupResponse response)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (!response.IsOk)
			{
				_preview = null;
				_queue = null;
				_modeChosen = false;
				Announce(AcsUiText.Status(response));
				return;
			}
			_preview = response;
			_queue = new ConflictQueue((IEnumerable<LearnConflict>)response.Conflicts);
			_storeVersion = response.StoreVersion;
			_modeChosen = false;
			if (response.SkippedItems > 0)
			{
				AcsLog.Debug("ui: the preview skipped " + response.SkippedItems + " stack(s) the server cannot resolve");
			}
			ShowModeStep();
		}

		private void OnCommitAnswer(GroupResponse response)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if (!response.IsOk)
			{
				if ((int)response.Status == 25 || (int)response.Status == 35)
				{
					_preview = null;
					_queue = null;
					_modeChosen = false;
					_dialog.Hide();
				}
				Announce(AcsUiText.Status(response));
			}
			else
			{
				_preview = null;
				_queue = null;
				_modeChosen = false;
				_dialog.Hide();
				_storeVersion = response.StoreVersion;
				SetItems(response.Items);
				_facts.GroupItems = response.Items.Count;
				Announce(AcsUiText.Learned(response));
				_pollTimer = 0f;
			}
		}

		private void OnWriteAnswer(GroupResponse response)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			Announce(AcsUiText.Status(response));
			if (response.IsOk)
			{
				_facts.DisplayName = response.DisplayName;
				_facts.Role = response.Role;
				SetNameFieldText(response.DisplayName);
				_storeVersion = response.StoreVersion;
			}
			else
			{
				ZDO zdo = ChestRegistry.GetZdo(_chest);
				if (zdo != null)
				{
					_facts.DisplayName = ChestName.GetDisplay(zdo);
					_facts.Role = GroupRoles.Of(_facts.DisplayName);
					SetNameFieldText(_facts.DisplayName);
				}
			}
			_known = false;
			_pollTimer = 2f;
			SendQuery();
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	internal static class ContainerHoverPatch
	{
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Postfix(Container __instance, ref string __result)
		{
			try
			{
				if (!AcsConfigService.Current.ShowChestNameOnHover || (Object)(object)__instance == (Object)null)
				{
					return;
				}
				ZDO zdo = ChestRegistry.GetZdo(__instance);
				if (zdo != null && AcsChestCatalog.Current.IsSupported(zdo.GetPrefab()))
				{
					string display = ChestName.GetDisplay(zdo);
					if (display.Length != 0)
					{
						string line = AcsLocalization.Format("$acs_ui_hover_name", display);
						__result = Insert(__result, line);
					}
				}
			}
			catch (Exception ex)
			{
				AcsLog.Debug("ui: the hover text of a chest could not be extended (" + ex.GetType().Name + ": " + ex.Message + ")");
			}
		}

		private static string Insert(string hover, string line)
		{
			if (string.IsNullOrEmpty(hover))
			{
				return line;
			}
			int num = hover.IndexOf('\n');
			if (num < 0)
			{
				return hover + "\n" + line;
			}
			return hover.Substring(0, num) + "\n" + line + hover.Substring(num);
		}
	}
	internal static class InputBlockGuard
	{
		internal static bool IsBlocking { get; private set; }

		internal static int Taken { get; private set; }

		internal static int Released { get; private set; }

		internal static void Block()
		{
			if (IsBlocking)
			{
				return;
			}
			try
			{
				GUIManager.BlockInput(true);
				IsBlocking = true;
				Taken++;
				AcsLog.Debug("ui: input blocked (name field focused), taken=" + Taken);
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: blocking the input failed", error);
			}
		}

		internal static void Release(string reason)
		{
			if (!IsBlocking)
			{
				return;
			}
			try
			{
				GUIManager.BlockInput(false);
			}
			catch (Exception error)
			{
				AcsLog.Error("ui: releasing the input failed (" + reason + ")", error);
			}
			finally
			{
				IsBlocking = false;
				Released++;
				AcsLog.Debug("ui: input released (" + reason + "), released=" + Released);
			}
		}

		internal static string Describe()
		{
			return "blocking=" + IsBlocking + " taken=" + Taken + " released=" + Released;
		}
	}
	[HarmonyPatch(typeof(InventoryGui))]
	internal static class InventoryGuiPatches
	{
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		[HarmonyPatch("Hide")]
		private static void HidePostfix()
		{
			ChestUiController.Instance?.OnPanelGone("InventoryGui.Hide");
		}

		[HarmonyPostfix]
		[HarmonyWrapSafe]
		[HarmonyPatch("CloseContainer")]
		private static void CloseContainerPostfix()
		{
			ChestUiController.Instance?.OnPanelGone("InventoryGui.CloseContainer");
		}

		[HarmonyPostfix]
		[HarmonyWrapSafe]
		[HarmonyPatch("UpdateContainer")]
		private static void UpdateContainerPostfix(InventoryGui __instance)
		{
			if ((Object)(object)__instance.m_currentContainer == (Object)null || !__instance.m_currentContainer.IsOwner())
			{
				ChestUiController.Instance?.OnPanelGone("InventoryGui.UpdateContainer (no owned container)");
			}
		}
	}
	internal static class ItemNames
	{
		private static readonly Dictionary<string, string> Cache = new Dictionary<string, string>(StringComparer.Ordinal);

		internal static void Clear()
		{
			Cache.Clear();
		}

		internal static string Display(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return string.Empty;
			}
			if (Cache.TryGetValue(prefabName, out var value))
			{
				return value;
			}
			string text = Resolve(prefabName);
			if (!string.Equals(text, prefabName, StringComparison.Ordinal))
			{
				Cache[prefabName] = text;
			}
			return text;
		}

		internal static List<string> Display(IReadOnlyList<string> prefabNames)
		{
			List<string> list = new List<string>(prefabNames?.Count ?? 0);
			if (prefabNames == null)
			{
				return list;
			}
			for (int i = 0; i < prefabNames.Count; i++)
			{
				list.Add(Display(prefabNames[i]));
			}
			return list;
		}

		private static string Resolve(string prefabName)
		{
			try
			{
				string text = SharedName(prefabName);
				if (string.IsNullOrEmpty(text))
				{
					return prefabName;
				}
				Localization instance = Localization.instance;
				if (instance == null)
				{
					return prefabName;
				}
				string text2 = instance.Localize(text);
				return string.IsNullOrWhiteSpace(text2) ? prefabName : text2.Trim();
			}
			catch (Exception ex)
			{
				AcsLog.Debug("ui: resolving the item name of \"" + prefabName + "\" failed (" + ex.GetType().Name + ")");
				return prefabName;
			}
		}

		private static string SharedName(string prefabName)
		{
			ObjectDB instance = ObjectDB.instance;
			GameObject val = default(GameObject);
			if ((Object)(object)instance != (Object)null && instance.TryGetItemPrefab(prefabName, ref val) && (Object)(object)val != (Object)null)
			{
				string text = TokenOf(val);
				if (text.Length > 0)
				{
					return text;
				}
			}
			ZNetScene instance2 = ZNetScene.instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				GameObject prefab = instance2.GetPrefab(prefabName);
				if ((Object)(object)prefab != (Object)null)
				{
					return TokenOf(prefab);
				}
			}
			return string.Empty;
		}

		private static string TokenOf(GameObject prefab)
		{
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
			{
				return string.Empty;
			}
			return component.m_itemData.m_shared.m_name ?? string.Empty;
		}
	}
}
namespace AutoChestSort.Sorting
{
	internal static class ContainerOpenSignal
	{
		internal const string RequestOpenRpc = "RPC_RequestOpen";

		internal const string OpenResponseRpc = "RPC_OpenResponse";

		private static readonly int RequestOpenHash = StableHash.Compute("RPC_RequestOpen");

		private static readonly int OpenResponseHash = StableHash.Compute("RPC_OpenResponse");

		private static bool _installed;

		internal static int Seen { get; private set; }

		internal static bool IsInstalled => _installed;

		internal static void Install(Harmony harmony)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			if (_installed || harmony == null)
			{
				return;
			}
			try
			{
				Type? typeFromHandle = typeof(ZRoutedRpc);
				MethodInfo methodInfo = AccessTools.Method(typeFromHandle, "HandleRoutedRPC", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeFromHandle, "RouteRPC", (Type[])null, (Type[])null);
				MethodInfo methodInfo3 = AccessTools.Method(typeof(ContainerOpenSignal), "OnRoutedRpc", (Type[])null, (Type[])null);
				if (methodInfo == null || methodInfo2 == null)
				{
					AcsLog.Warning("sorter: the open signal snoop is off - ZRoutedRpc." + ((methodInfo == null) ? "HandleRoutedRPC" : "RouteRPC") + " was not found; InUse, the owner revision jump and the revision stability window still protect every move");
					return;
				}
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo3), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(methodInfo3), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_installed = true;
				AcsLog.Debug("sorter: open signal snoop installed on ZRoutedRpc.HandleRoutedRPC and ZRoutedRpc.RouteRPC (decision X2)");
			}
			catch (Exception error)
			{
				AcsLog.Error("sorter: installing the open signal snoop failed, falling back to InUse plus the owner revision jump", error);
			}
		}

		private static void OnRoutedRpc(RoutedRPCData __0)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (__0 != null && (__0.m_methodHash == RequestOpenHash || __0.m_methodHash == OpenResponseHash) && !((ZDOID)(ref __0.m_targetZDO)).IsNone())
				{
					Sorter.NoteChestOpened(__0.m_targetZDO, __0.m_senderPeerID);
					Seen++;
				}
			}
			catch (Exception error)
			{
				AcsLog.Error("sorter: reading an open signal failed", error);
			}
		}
	}
	internal static class ItemProgressionRuntimeCheck
	{
		private static bool _loggedThisSession;

		internal static bool IsObjectDbReady
		{
			get
			{
				ObjectDB instance = ObjectDB.instance;
				if ((Object)(object)instance != (Object)null && instance.m_items != null)
				{
					return instance.m_items.Count > 0;
				}
				return false;
			}
		}

		internal static void Reset()
		{
			_loggedThisSession = false;
		}

		internal static bool LogOnce()
		{
			if (_loggedThisSession || !IsObjectDbReady)
			{
				return false;
			}
			_loggedThisSession = true;
			foreach (string item in Report())
			{
				AcsLog.Debug(item);
			}
			return true;
		}

		internal static IReadOnlyList<string> Report()
		{
			try
			{
				if (!IsObjectDbReady)
				{
					return new List<string> { "sorter progression: the item database is not up yet, ask again in a moment" };
				}
				List<string> list = new List<string>();
				List<string> list2 = new List<string>();
				Collect(list, list2);
				return ItemProgressionAudit.Check((IEnumerable<string>)list, (IEnumerable<string>)list2).Describe(12);
			}
			catch (Exception error)
			{
				AcsLog.Error("sorter progression: checking the progression table failed", error);
				return new List<string> { "sorter progression: the check failed, see the server log" };
			}
		}

		private static void Collect(List<string> names, List<string> stackables)
		{
			List<GameObject> items = ObjectDB.instance.m_items;
			for (int i = 0; i < items.Count; i++)
			{
				GameObject val = items[i];
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name))
				{
					names.Add(((Object)val).name);
					ItemDrop component = val.GetComponent<ItemDrop>();
					if ((Object)(object)component != (Object)null && component.m_itemData != null && component.m_itemData.m_shared != null && component.m_itemData.m_shared.m_maxStackSize > 1)
					{
						stackables.Add(((Object)val).name);
					}
				}
			}
		}
	}
	internal enum RelocationKind
	{
		UnassignedOut = 1,
		ForeignGroupOut,
		MiscIn
	}
	internal static class RelocationKindText
	{
		internal static string RoleOf(RelocationKind kind)
		{
			if (kind != RelocationKind.MiscIn)
			{
				return "group chest";
			}
			return "misc chest";
		}

		internal static string StageOf(RelocationKind kind)
		{
			return kind switch
			{
				RelocationKind.UnassignedOut => "unassigned", 
				RelocationKind.ForeignGroupOut => "foreign group", 
				_ => "misc", 
			};
		}

		internal static bool FromGroupChest(RelocationKind kind)
		{
			return kind != RelocationKind.MiscIn;
		}

		internal static MisplacedKind WantedOf(RelocationKind kind)
		{
			return (MisplacedKind)(kind switch
			{
				RelocationKind.UnassignedOut => 2, 
				RelocationKind.ForeignGroupOut => 1, 
				_ => 0, 
			});
		}
	}
	internal sealed class Sorter : MonoBehaviour
	{
		private struct CandidateMeter
		{
			internal static readonly CandidateMeter Empty;

			private long _scans;

			private long _total;

			private int _max;

			private int _last;

			internal void Note(int candidates)
			{
				_scans++;
				_total += candidates;
				_last = candidates;
				if (candidates > _max)
				{
					_max = candidates;
				}
			}

			internal string Describe()
			{
				if (_scans == 0L)
				{
					return "no scan yet";
				}
				double num = (double)_total / (double)_scans;
				return "last " + _last + ", avg " + num.ToString("F1", CultureInfo.InvariantCulture) + ", max " + _max + " over " + _scans + " scan(s)";
			}
		}

		private readonly struct WaitKey : IEquatable<WaitKey>
		{
			internal ChestId Chest { get; }

			internal int PrefabHash { get; }

			internal WaitKey(ChestId chest, int prefabHash)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Chest = chest;
				PrefabHash = prefabHash;
			}

			public bool Equals(WaitKey other)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				if (Chest == other.Chest)
				{
					return PrefabHash == other.PrefabHash;
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return (((object)Chest/*cast due to .constrained prefix*/).GetHashCode() * 397) ^ PrefabHash;
			}
		}

		private struct PendingVerification
		{
			internal ChestId SourceId;

			internal ChestId TargetId;

			internal int PrefabHash;

			internal int Amount;

			internal int ExpectedSourceAfter;

			internal int ExpectedTargetAfter;

			internal bool InPlaceMerge;

			internal bool Beautify;

			internal int ExpectedRecordsAfter;

			internal int ExpectedFingerprint;

			internal IReadOnlyList<ItemRecord> ExpectedLayout;

			internal byte[] BytesBefore;

			internal byte[] BytesAfter;

			internal uint TargetRevision;

			internal uint SourceRevision;

			internal string Item;

			internal int DelaySeconds;

			internal double DueAt;
		}

		private readonly struct ItemInfo
		{
			internal string PrefabName { get; }

			internal int MaxStack { get; }

			internal ItemInfo(string prefabName, int maxStack)
			{
				PrefabName = prefabName ?? string.Empty;
				MaxStack = maxStack;
			}
		}

		private const double SummarySeconds = 60.0;

		private const double RelocationQuietFactor = 2.0;

		private const double BeautifyQuietFactor = 60.0;

		private const double BeautifyBackoffSeconds = 600.0;

		private const int BeautifyLossEvidencePerSession = 3;

		private static GameObject _host;

		private readonly SortRotation _rotation = new SortRotation();

		private readonly SortRotation _distributionSources = new SortRotation();

		private readonly SortRotation _unassignedSources = new SortRotation();

		private readonly SortRotation _foreignSources = new SortRotation();

		private readonly SortRotation _miscSources = new SortRotation();

		private readonly SortRotation _beautifySources = new SortRotation();

		private readonly ChestTidyMemo _tidyAt = new ChestTidyMemo();

		private readonly BeautifyBackoff _beautifyBackoff = new BeautifyBackoff(600.0);

		private readonly SortCursorTable _cursors = new SortCursorTable();

		private readonly SortCursorTable _unassignedCursors = new SortCursorTable();

		private readonly SortCursorTable _foreignCursors = new SortCursorTable();

		private readonly SortCursorTable _miscCursors = new SortCursorTable();

		private readonly UnsortableTracker _unsortable = new UnsortableTracker();

		private readonly ChestStabilityTracker _stability = new ChestStabilityTracker();

		private readonly ConflictCounters _counters = new ConflictCounters();

		private readonly BlockedPauseTracker _pause = new BlockedPauseTracker();

		private readonly MovedLedger _ledger = new MovedLedger();

		private readonly InventoryCache _inventories = new InventoryCache();

		private readonly SortBudget _budget = new SortBudget();

		private readonly TickStatistics _tickStats = new TickStatistics();

		private readonly SorterSummaryWindow _summary = new SorterSummaryWindow();

		private readonly RelocationRateMeter _relocations = new RelocationRateMeter();

		private readonly LogChangeGate _gridGuard = new LogChangeGate();

		private readonly Dictionary<int, ItemInfo> _itemCache = new Dictionary<int, ItemInfo>();

		private readonly HashSet<long> _reportedUnknownItems = new HashSet<long>();

		private readonly List<ChestId> _activeInputs = new List<ChestId>();

		private readonly List<ChestId> _activeRelocationSources = new List<ChestId>();

		private readonly List<ChestId> _activeDistributionSources = new List<ChestId>();

		private readonly List<ChestId> _activeBeautifySources = new List<ChestId>();

		private readonly List<ChestSnapshot> _candidates = new List<ChestSnapshot>();

		private readonly HashSet<ChestId> _activeClusters = new HashSet<ChestId>();

		private double _activeClustersAt = -1.0;

		private CandidateMeter _inputCandidates = CandidateMeter.Empty;

		private CandidateMeter _relocationCandidates = CandidateMeter.Empty;

		private CandidateMeter _distributionCandidates = CandidateMeter.Empty;

		private readonly List<ChestId> _blockedThisRound = new List<ChestId>();

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

		private readonly List<PendingVerification> _pendingVerifications = new List<PendingVerification>();

		private readonly PendingWriteSet _pendingWrites = new PendingWriteSet();

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

		private const string StageBeautify = "beautify";

		private const string StageInput = "input";

		private readonly StageBlockLog _stageBlocks = new StageBlockLog();

		private bool _isServer;

		private bool _checkedRole;

		private double _nextTickAt;

		private double _nextSummaryAt;

		private bool _pausedByOperator;

		private int _miscCursor;

		private int _parsesThisTick;

		private int _cacheHitsThisTick;

		private SortOutcome _lastOutcome = (SortOutcome)1;

		private string _lastLine = "nothing yet";

		private bool _beautifyWasEnabled;

		private bool _distributionWasEnabled;

		private int _beautifyLossEvidenceLeft = 3;

		private ChestId _lastBeautified = ChestId.None;

		private long _beautifyNotReady;

		private long _beautifyUnsafe;

		private long _beautifyRewrites;

		private const string StageDistribution = "distribution";

		private readonly DistributionPlanCache _plans = new DistributionPlanCache();

		private readonly DistributionCycleGuard _cycles = new DistributionCycleGuard(4, 300.0);

		private readonly DistributionNoticeLog _distributionNotices = new DistributionNoticeLog();

		private readonly RelocationRateMeter _planRebuilds = new RelocationRateMeter();

		private long _distributionDeferrals;

		private long _distributionStuck;

		private long _distributionCycleStops;

		private string _lastDistributionUnit = string.Empty;

		internal static Sorter Instance { get; private set; }

		private static double Now => Time.realtimeSinceStartup;

		internal bool IsPausedByOperator => _pausedByOperator;

		private static int VerifyDelayOf(AcsConfig cfg)
		{
			int num = ((cfg == null) ? AcsConfigKeys.SortIntervalSeconds.FallbackInt : cfg.SortIntervalSeconds);
			if (num < AcsConfigKeys.SortIntervalSeconds.MinimumInt)
			{
				num = AcsConfigKeys.SortIntervalSeconds.MinimumInt;
			}
			else if (num > AcsConfigKeys.SortIntervalSeconds.MaximumInt)
			{
				num = AcsConfigKeys.SortIntervalSeconds.MaximumInt;
			}
			return ReadBackDelay.Seconds(num);
		}

		internal static void Install()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if ((Object)(object)_host == (Object)null)
			{
				_host = new GameObject("ACS_Sorter");
				Object.DontDestroyOnLoad((Object)(object)_host);
				Instance = _host.AddComponent<Sorter>();
			}
			Instance.BeginSession();
		}

		private void BeginSession()
		{
			if (_checkedRole && _isServer)
			{
				ClearWorldState("a new session started before the last one was seen to end");
			}
			_checkedRole = false;
			_isServer = false;
			((Behaviour)this).enabled = true;
		}

		private void ClearWorldState(string reason)
		{
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			_rotation.Clear();
			_unassignedSources.Clear();
			_foreignSources.Clear();
			_miscSources.Clear();
			_beautifySources.Clear();
			_tidyAt.Clear();
			_beautifyBackoff.Clear();
			_cursors.Clear();
			_unassignedCursors.Clear();
			_foreignCursors.Clear();
			_miscCursors.Clear();
			_unsortable.Clear();
			ClearDistributionState();
			_stability.Clear();
			_counters.Clear();
			_pause.Reset();
			_ledger.Clear();
			_inventories.Clear();
			_budget.Reset();
			_tickStats.Clear();
			_summary.Clear();
			_relocations.Clear();
			_gridGuard.Clear();
			_itemCache.Clear();
			_reportedUnknownItems.Clear();
			_activeInputs.Clear();
			_activeRelocationSources.Clear();
			_activeBeautifySources.Clear();
			_candidates.Clear();
			_blockedThisRound.Clear();
			_recentMoves.Clear();
			_pendingVerifications.Clear();
			_pendingWrites.Clear();
			_lastWaitReason.Clear();
			_stageBlocks.Clear();
			_nextTickAt = 0.0;
			_nextSummaryAt = 0.0;
			_miscCursor = 0;
			_parsesThisTick = 0;
			_cacheHitsThisTick = 0;
			_lastOutcome = (SortOutcome)1;
			_lastLine = "nothing yet";
			_beautifyWasEnabled = false;
			_beautifyLossEvidenceLeft = 3;
			_lastBeautified = ChestId.None;
			_beautifyNotReady = 0L;
			_beautifyUnsafe = 0L;
			_beautifyRewrites = 0L;
			ItemProgressionRuntimeCheck.Reset();
			AcsLog.Info("sorter: session ended, state cleared (" + reason + ")");
		}

		internal static void NoteChestOpened(ZDOID target, long sender)
		{
			//IL_002d: 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)
			Sorter instance = Instance;
			if (!((Object)(object)instance == (Object)null) && instance._isServer && !((ZDOID)(ref target)).IsNone())
			{
				ZDO val = ((ZDOMan.instance == null) ? null : ZDOMan.instance.GetZDO(target));
				if (val != null && AcsChestCatalog.Current.IsSupported(val.GetPrefab()))
				{
					ChestId val2 = default(ChestId);
					((ChestId)(ref val2))..ctor(((ZDOID)(ref target)).UserID, ((ZDOID)(ref target)).ID);
					double num = AcsConfigService.Current.CloseCooldownSeconds;
					instance._stability.MarkOpened(val2, Now, num);
					AcsLog.Debug("sorter: open signal for " + ChestLookup.Describe(val) + " from peer " + sender + ", locked for " + num.ToString("F1", CultureInfo.InvariantCulture) + " s");
				}
			}
		}

		internal void ForgetChestsNotIn(ChestCatalog catalog, string change)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (!_isServer)
			{
				AcsLog.Debug("sorter: the chest prefab list changed (" + change + "), nothing to forget in a client session");
				return;
			}
			ChestCatalog val = catalog ?? ChestCatalog.Empty;
			HashSet<ChestId> hashSet = new HashSet<ChestId>();
			IReadOnlyList<ChestEntry> readOnlyList;
			if (!((Object)(object)ChestIndex.Instance == (Object)null))
			{
				readOnlyList = ChestIndex.Instance.Model.Entries();
			}
			else
			{
				IReadOnlyList<ChestEntry> readOnlyList2 = (IReadOnlyList<ChestEntry>)(object)new ChestEntry[0];
				readOnlyList = readOnlyList2;
			}
			IReadOnlyList<ChestEntry> readOnlyList3 = readOnlyList;
			for (int i = 0; i < readOnlyList3.Count; i++)
			{
				if (val.IsSupported(readOnlyList3[i].PrefabHash))
				{
					hashSet.Add(readOnlyList3[i].Id);
				}
			}
			int num = _stability.PruneExcept((ICollection<ChestId>)hashSet);
			int num2 = _inventories.PruneExcept((ICollection<ChestId>)hashSet);
			int num3 = _unsortable.PruneExcept((ICollection<ChestId>)hashSet);
			int num4 = _cursors.PruneExcept((ICollection<ChestId>)hashSet) + _unassignedCursors.PruneExcept((ICollection<ChestId>)hashSet) + _foreignCursors.PruneExcept((ICollection<ChestId>)hashSet) + _miscCursors.PruneExcept((ICollection<ChestId>)hashSet);
			int num5 = PruneDistributionState(hashSet);
			int num6 = PruneWaitReasonsExcept(hashSet) + _stageBlocks.PruneExcept((ICollection<ChestId>)hashSet);
			int num7 = DropVerificationsExcept(hashSet);
			int num8 = _pendingWrites.PruneExcept((ICollection<ChestId>)hashSet);
			if (num8 > 0)
			{
				AcsLog.Warning("sorter: " + num8 + " read back lock(s) outlived their queue entry and were dropped with the catalog change. This is an ACS bug, please report it.");
			}
			int num9 = _tidyAt.PruneExcept((ICollection<ChestId>)hashSet) + _beautifyBackoff.PruneExcept((ICollection<ChestId>)hashSet);
			_rotation.Reset();
			_distributionSources.Reset();
			_unassignedSources.Reset();
			_foreignSources.Reset();
			_miscSources.Reset();
			_beautifySources.Reset();
			_blockedThisRound.Clear();
			_gridGuard.Clear();
			AcsLog.Info("sorter: the chest prefab list changed (" + change + "), forgot " + num + " stability, " + num2 + " inventory, " + num3 + " suppression, " + num4 + " cursor, " + num6 + " wait reason, " + num9 + " beautify, " + num5 + " distribution and " + num7 + " pending read back entry(ies); " + hashSet.Count + " indexed chest(s) are still supported");
		}

		internal void Pause()
		{
			_pausedByOperator = true;
			AcsLog.Info("sorter: paused by operator");
		}

		internal void Resume()
		{
			_pausedByOperator = false;
			_pause.Reset();
			_blockedThisRound.Clear();
			_rotation.Reset();
			_distributionSources.Reset();
			_unassignedSources.Reset();
			_foreignSources.Reset();
			_miscSources.Reset();
			AcsLog.Info("sorter: resumed by operator");
		}

		internal unsafe List<string> Status()
		{
			//IL_081a: Unknown result type (might be due to invalid IL or missing references)
			//IL_081f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0830: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0901: Unknown result type (might be due to invalid IL or missing references)
			//IL_0912: Unknown result type (might be due to invalid IL or missing references)
			//IL_0917: Unknown result type (might be due to invalid IL or missing references)
			//IL_097f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0984: Unknown result type (might be due to invalid IL or missing references)
			//IL_0995: Unknown result type (might be due to invalid IL or missing references)
			//IL_099a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a05: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cbf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db9: Unknown result type (might be due to invalid IL or missing references)
			double now = Now;
			List<string> list = new List<string>();
			AcsConfig current = AcsConfigService.Current;
			list.Add("sorter: " + (_isServer ? "server session" : "not a server, idle") + ", " + (_pausedByOperator ? "PAUSED by operator" : "running") + (_pause.IsPaused ? (", blocked pause for another " + _pause.SecondsLeft(now).ToString("F1", CultureInfo.InvariantCulture) + " s") : string.Empty) + ", last outcome " + ((object)Unsafe.As<SortOutcome, SortOutcome>(ref _lastOutcome)/*cast due to .constrained prefix*/).ToString());
			list.Add("sorter config: interval " + AcsConfigKeys.SortIntervalSeconds.Format((double)current.SortIntervalSeconds) + " s, graphEdgeRadius " + AcsConfigKeys.GraphEdgeRadius.Format(current.GraphEdgeRadius) + " m, activationRadius " + AcsConfigKeys.ActivationRadius.Format(current.ActivationRadius) + " m, closeCooldown " + current.CloseCooldownSeconds + " s, blockedPause " + current.BlockedPauseSeconds + " s, ignoreInUseWhenOwnerDisconnected " + current.IgnoreInUseWhenOwnerDisconnected + ", conflictWarnThreshold " + current.ConflictWarnThreshold + ", relocateMisplacedItems " + current.RelocateMisplacedItems + ", relocateUnassignedToMisc " + current.RelocateUnassignedToMisc + ", relocateItemStacks " + current.RelocateItemStacks + ", beautifyChestItemOrder " + current.BeautifyChestItemOrder + ", sortBudgetMsPerSecond " + AcsConfigKeys.SortBudgetMsPerSecond.Format(current.SortBudgetMsPerSecond));
			ChestCatalog current2 = AcsChestCatalog.Current;
			list.Add("sorter catalog: " + current2.Count + " chest prefab(s) (" + current2.CountOf((ChestPrefabOrigin)0) + " vanilla, " + current2.CountOf((ChestPrefabOrigin)1) + " from config)" + (current2.IsEmpty ? " - EMPTY, nothing is sorted" : string.Empty) + ", " + AcsChestCatalog.Rejections.Count + " prefab(s) rejected, builds " + AcsChestCatalog.BuildCount + ", last trigger " + AcsChestCatalog.LastReason);
			list.Add("sorter counters: " + ((_counters.Describe().Length == 0) ? "nothing yet" : _counters.Describe()));
			ChestClusters val = (((Object)(object)ChestIndex.Instance == (Object)null) ? ChestClusters.Empty : ChestIndex.Instance.Clusters);
			ChestCluster largest = val.Largest;
			list.Add("sorter clusters: " + val.Describe() + ", " + _activeClusters.Count + " with a player inside activationRadius" + ((largest != null && (largest.Count > 40 || largest.BoundingBoxDiameter > 80f)) ? (" - the largest one is above the diagnostics threshold (" + 40 + " chests / " + 80 + " m), acs_dump lists its members") : string.Empty));
			list.Add("sorter cluster sizes: " + DescribeClusterSizes(val));
			list.Add("sorter candidates per attempt: input " + _inputCandidates.Describe() + " | relocation " + _relocationCandidates.Describe() + " | distribution unit " + _distributionCandidates.Describe());
			list.Add("sorter suppression: input/relocation " + _unsortable.DescribeHitRate());
			list.Add("sorter budget: " + ((object)_budget)?.ToString() + (_budget.IsEnabled ? (", " + _budget.SecondsUntilAffordable(now).ToString("F1", CultureInfo.InvariantCulture) + " s until the next attempt") : " (no time limit)") + ", budgetSkips " + _counters.BudgetSkips);
			list.Add("sorter cost: " + _tickStats.Describe(now) + ", " + _summary.Summaries + " release summary(ies) written, next in " + _summary.SecondsUntilDue(now).ToString("F0", CultureInfo.InvariantCulture) + " s - sortIntervalSeconds (" + AcsConfigKeys.SortIntervalSeconds.Format((double)current.SortIntervalSeconds) + " s) is only the upper bound of the pace; the time quota sets the real one");
			list.Add("sorter relocation: " + (current.RelocateMisplacedItems ? "on" : "OFF") + ", tidy-up rate " + _relocations.Describe(now) + " (warns above " + 30 + "/min), relocated " + _counters.Relocated + " of " + _counters.Moves + " move(s)");
			DescribeDistribution(list, current, now);
			list.Add("sorter beautify: " + ((current.RelocateMisplacedItems && current.BeautifyChestItemOrder) ? "on" : (current.BeautifyChestItemOrder ? "OFF (relocateMisplacedItems is off, which switches every tidy-up stage off)" : "OFF (beautifyChestItemOrder)")) + ", beautified " + _counters.Beautified + " of " + _counters.Moves + " move(s), quiet window " + ((double)current.CloseCooldownSeconds * 60.0).ToString("F0", CultureInfo.InvariantCulture) + " s, " + _tidyAt.Count + " chest(s) remembered tidy, " + _beautifyBackoff.BackedOff(now) + " chest(s) braked after " + 3 + " undone rewrite(s) (" + _beautifyBackoff.Armed + " brake(s) armed this session), skipped " + _beautifyNotReady + " x no item database, " + _beautifyUnsafe + " x unsafe chest");
			string[] obj = new string[11]
			{
				"sorter beautify queue: ",
				_beautifySources.Count.ToString(),
				" group chest(s), round ",
				_beautifySources.Rounds.ToString(),
				", last ",
				null,
				null,
				null,
				null,
				null,
				null
			};
			ChestId last = _beautifySources.Last;
			object obj2;
			if (!((ChestId)(ref last)).IsNone)
			{
				last = _beautifySources.Last;
				obj2 = ((object)(*(ChestId*)(&last))/*cast due to .constrained prefix*/).ToString();
			}
			else
			{
				obj2 = "none";
			}
			obj[5] = (string)obj2;
			obj[6] = ", last rewrite ";
			obj[7] = (((ChestId)(ref _lastBeautified)).IsNone ? "none" : ((object)Unsafe.As<ChestId, ChestId>(ref _lastBeautified)/*cast due to .constrained prefix*/).ToString());
			obj[8] = " (";
			obj[9] = _beautifyRewrites.ToString();
			obj[10] = " this session)";
			list.Add(string.Concat(obj));
			string[] obj3 = new string[21]
			{
				"sorter relocation queue: unassigned ",
				_unassignedSources.Count.ToString(),
				" group chest(s), round ",
				_unassignedSources.Rounds.ToString(),
				", last ",
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			last = _unassignedSources.Last;
			object obj4;
			if (!((ChestId)(ref last)).IsNone)
			{
				last = _unassignedSources.Last;
				obj4 = ((object)(*(ChestId*)(&last))/*cast due to .constrained prefix*/).ToString();
			}
			else
			{
				obj4 = "none";
			}
			obj3[5] = (string)obj4;
			obj3[6] = " | foreign group ";
			obj3[7] = _foreignSources.Count.ToString();
			obj3[8] = " group chest(s), round ";
			obj3[9] = _foreignSources.Rounds.ToString();
			obj3[10] = ", last ";
			last = _foreignSources.Last;
			object obj5;
			if (!((ChestId)(ref last)).IsNone)
			{
				last = _foreignSources.Last;
				obj5 = ((object)(*(ChestId*)(&last))/*cast due to .constrained prefix*/).ToString();
			}
			else
			{
				obj5 = "none";
			}
			obj3[11] = (string)obj5;
			obj3[12] = " | misc ";
			obj3[13] = _miscSources.Count.ToString();
			obj3[14] = " misc chest(s), round ";
			obj3[15] = _miscSources.Rounds.ToString();
			obj3[16] = ", last ";
			last = _miscSources.Last;
			object obj6;
			if (!((ChestId)(ref last)).IsNone)
			{
				last = _miscSources.Last;
				obj6 = ((object)(*(ChestId*)(&last))/*cast due to .constrained prefix*/).ToString();
			}
			else
			{
				obj6 = "none";
			}
			obj3[17] = (string)obj6;
			obj3[18] = ", ";
			obj3[19] = _inventories.Count.ToString();
			obj3[20] = " cached inventory(ies)";
			list.Add(string.Concat(obj3));
			string text = _ledger.Describe((Func<int, string>)NameOf, 12);
			list.Add("sorter moved: " + ((text.Length == 0) ? "nothing yet" : text) + " (total " + _ledger.Total + " unit(s) in " + _ledger.TypeCount + " type(s), " + _pendingVerifications.Count + " move(s) waiting for their read back, " + _pendingWrites.Describe() + ")");
			list.Add("sorter queue: " + _rotation.Count + " active input chest(s), round " + _rotation.Rounds + ", misc cursor " + _miscCursor + ", blocked rounds " + _pause.BlockedRounds + "/" + 3 + ", " + _unsortable.Count + " suppressed stack(s) in " + _unsortable.ChestCount + " chest(s), " + _stability.Count + " chest(s) tracked, open signals seen " + ContainerOpenSignal.Seen + " (snoop " + (ContainerOpenSignal.IsInstalled ? "on" : "off") + ")");
			list.Add("acs client gate: " + VanillaClientGate.Describe());
			if (_rotation.Count == 0)
			{
				list.Add("sorter queue: no input chest is in a cluster wi