using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using Microsoft.CodeAnalysis;
using YAVSOS.Core.Catalog;
using YAVSOS.Core.Classification;
using YAVSOS.Core.Interface;
using YAVSOS.Core.Policy;
using YAVSOS.Core.Transfers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BastionNtB")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2026 BastionNtB")]
[assembly: AssemblyDescription("Game-independent domain and policy layer for YAVSOS.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d5aaa1b9ccbb9dd00e376b293e718c38397c8336")]
[assembly: AssemblyProduct("Yet Another Valheim Storage Organization System")]
[assembly: AssemblyTitle("YAVSOS.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.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 YAVSOS.Core
{
	public static class ProjectIdentity
	{
		public const string Guid = "com.bastionntb.yavsos";

		public const string Name = "Yet Another Valheim Storage Organization System";

		public const string Version = "1.0.0";

		public const string MinimumManagedVersion = "1.0.0";
	}
}
namespace YAVSOS.Core.Transfers
{
	public sealed class CleanupChest
	{
		public string Id { get; }

		public string RulePayload { get; }

		public TransferInventorySnapshot Inventory { get; }

		public bool LocallyOwned { get; }

		public bool OptOut { get; }

		public double Distance { get; }

		public CleanupChest(string id, string rulePayload, TransferInventorySnapshot inventory, bool locallyOwned, bool optOut = false, double distance = 0.0)
		{
			Id = TransferCanonical.Text(id, 256, empty: false);
			RulePayload = rulePayload ?? throw new ArgumentNullException("rulePayload");
			Inventory = inventory ?? throw new ArgumentNullException("inventory");
			if (double.IsNaN(distance) || distance < 0.0)
			{
				throw new ArgumentOutOfRangeException("distance");
			}
			LocallyOwned = locallyOwned;
			OptOut = optOut;
			Distance = distance;
		}
	}
	public sealed class CleanupInput
	{
		public ClassificationTaxonomy Taxonomy { get; }

		public ICategoryAnswers Answers { get; }

		public IReadOnlyList<CleanupChest> Chests { get; }

		public Func<string, int>? CategorySize { get; }

		public bool MucAvailable { get; }

		public Func<string, TransferItemIdentity, bool>? AzuAllows { get; }

		public IReadOnlyCollection<Guid> Held { get; }

		public Func<TransferStack, IReadOnlyList<FacetEvidence>>? InstanceFacets { get; }

		public CleanupInput(ClassificationTaxonomy taxonomy, ICategoryAnswers answers, IEnumerable<CleanupChest> chests, Func<string, int>? categorySize = null, bool mucAvailable = false, Func<string, TransferItemIdentity, bool>? azuAllows = null, IEnumerable<Guid>? held = null, Func<TransferStack, IReadOnlyList<FacetEvidence>>? instanceFacets = null)
		{
			InstanceFacets = instanceFacets;
			Taxonomy = taxonomy ?? throw new ArgumentNullException("taxonomy");
			Answers = answers ?? throw new ArgumentNullException("answers");
			Chests = Array.AsReadOnly((chests ?? throw new ArgumentNullException("chests")).ToArray());
			if (Chests.Any((CleanupChest x) => x == null))
			{
				throw new ArgumentException("Null cleanup chest.");
			}
			if (Chests.Select((CleanupChest x) => x.Id).Distinct<string>(StringComparer.Ordinal).Count() != Chests.Count)
			{
				throw new ArgumentException("Duplicate cleanup chest id.");
			}
			if (Chests.Select((CleanupChest x) => x.Inventory.Stamp.InventoryId).Distinct<string>(StringComparer.Ordinal).Count() != Chests.Count)
			{
				throw new ArgumentException("Two cleanup chests share one inventory.");
			}
			CategorySize = categorySize;
			MucAvailable = mucAvailable;
			AzuAllows = azuAllows;
			Held = new HashSet<Guid>(held ?? Array.Empty<Guid>());
		}
	}
	public enum CleanupRoute
	{
		Direct,
		MucAdd,
		MucRemove
	}
	public enum CleanupKind
	{
		Rejected,
		Unruled,
		Resort
	}
	public enum CleanupReason
	{
		NoDestination,
		NoCapacity,
		AzuExcluded,
		OtherOwnerNoMuc,
		BothRemote,
		OtherOwnerFormatUnknown,
		MucBusy,
		Unsupported,
		Held,
		Budget,
		ChestLimit,
		CategoriesPending
	}
	public sealed class CleanupMove
	{
		public string SourceId { get; }

		public string DestinationId { get; }

		public Guid Handle { get; }

		public TransferItemIdentity Identity { get; }

		public int Units { get; }

		public int DestinationX { get; }

		public int DestinationY { get; }

		public Guid? MergeHandle { get; }

		public CleanupRoute Route { get; }

		public CleanupKind Kind { get; }

		public bool MergesPlanned { get; }

		internal CleanupMove(string source, string destination, Guid handle, TransferItemIdentity identity, int units, int x, int y, Guid? merge, CleanupRoute route, CleanupKind kind, bool mergesPlanned = false)
		{
			MergesPlanned = mergesPlanned;
			SourceId = source;
			DestinationId = destination;
			Handle = handle;
			Identity = identity;
			Units = units;
			DestinationX = x;
			DestinationY = y;
			MergeHandle = merge;
			Route = route;
			Kind = kind;
		}

		public bool TryMergeTarget(TransferInventorySnapshot source, TransferInventorySnapshot destination, out Guid? merge)
		{
			return TransferGrid.TryMergeTarget(MergesPlanned, MergeHandle, source, Handle, destination, DestinationX, DestinationY, out merge);
		}
	}
	public sealed class CleanupRemainder
	{
		public string SourceId { get; }

		public Guid Handle { get; }

		public TransferItemIdentity Identity { get; }

		public int Units { get; }

		public CleanupReason Reason { get; }

		public string? DestinationId { get; }

		internal CleanupRemainder(string source, Guid handle, TransferItemIdentity identity, int units, CleanupReason reason, string? destination)
		{
			SourceId = source;
			Handle = handle;
			Identity = identity;
			Units = units;
			Reason = reason;
			DestinationId = destination;
		}
	}
	public sealed class CleanupPlan
	{
		public string PolicyStamp { get; }

		public bool CategoriesPending { get; }

		public IReadOnlyList<CleanupMove> Moves { get; }

		public IReadOnlyList<CleanupRemainder> Remainders { get; }

		public int SkippedChests { get; }

		internal CleanupPlan(string stamp, bool pending, IReadOnlyList<CleanupMove> moves, IReadOnlyList<CleanupRemainder> remainders, int skipped)
		{
			PolicyStamp = stamp;
			CategoriesPending = pending;
			Moves = moves;
			Remainders = remainders;
			SkippedChests = skipped;
		}
	}
	public static class CleanupPlanner
	{
		internal sealed class Destination
		{
			internal readonly CleanupChest Chest;

			internal readonly RankedDestination Ranked;

			internal readonly CleanupGate Gate;

			internal readonly CleanupRoute Via;

			internal readonly CleanupReason? Blocked;

			internal Destination(CleanupChest chest, RankedDestination ranked, CleanupGate gate, CleanupRoute via = CleanupRoute.Direct, CleanupReason? blocked = null)
			{
				Chest = chest;
				Ranked = ranked;
				Gate = gate;
				Via = via;
				Blocked = blocked;
			}
		}

		internal sealed class Assessment
		{
			internal ChestRuleDecision Decision;

			internal CleanupKind? Kind;

			internal ClassificationResult? Item;

			internal bool Stays;

			internal RankedDestination? Current;

			internal List<Destination> Destinations = new List<Destination>();
		}

		public const int MaximumChests = 256;

		public const int MaximumSources = 64;

		public const int MaximumMoves = 512;

		public static CleanupPlan Plan(CleanupInput input, ChestRuleEvaluator? evaluator = null)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (evaluator == null)
			{
				evaluator = new ChestRuleEvaluator();
			}
			ClassificationTaxonomy taxonomy = input.Taxonomy;
			ICategoryAnswers answers = input.Answers;
			string stamp = taxonomy.Fingerprint + ":" + answers.Generation;
			List<CleanupMove> list = new List<CleanupMove>();
			List<CleanupRemainder> list2 = new List<CleanupRemainder>();
			if (!answers.CategoriesReady)
			{
				return new CleanupPlan(stamp, pending: true, list.AsReadOnly(), list2.AsReadOnly(), 0);
			}
			List<CleanupChest> list3 = Considered(input.Chests);
			int num = input.Chests.Count - list3.Count;
			HashSet<string> hashSet = Sources(list3);
			Dictionary<string, TransferGrid> dictionary = list3.ToDictionary<CleanupChest, string, TransferGrid>((CleanupChest cleanupChest2) => cleanupChest2.Id, (CleanupChest cleanupChest2) => new TransferGrid(cleanupChest2.Inventory, mergePlanned: true), StringComparer.Ordinal);
			List<(CleanupChest, DestinationCandidate)> ruled = Receivers(list3, evaluator, taxonomy);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			foreach (CleanupChest item in list3)
			{
				if (item.OptOut || item.Inventory.Stacks.Count == 0)
				{
					continue;
				}
				if (!hashSet.Contains(item.Id))
				{
					num++;
					continue;
				}
				TransferGrid transferGrid = dictionary[item.Id];
				foreach (TransferStack stack in item.Inventory.Stacks)
				{
					Assessment assessment = Assess(input, evaluator, ruled, item, stack);
					if (!assessment.Kind.HasValue)
					{
						continue;
					}
					CleanupKind value = assessment.Kind.Value;
					if (assessment.Item == null && assessment.Destinations.Count == 0 && !assessment.Stays)
					{
						if (value == CleanupKind.Rejected)
						{
							list2.Add(new CleanupRemainder(item.Id, stack.Handle, stack.Identity, stack.Quantity, CleanupReason.NoDestination, null));
						}
					}
					else
					{
						if (assessment.Stays)
						{
							continue;
						}
						List<(CleanupChest, CleanupRoute)> list4 = (from destination in assessment.Destinations
							where destination.Gate == CleanupGate.Usable
							select (Chest: destination.Chest, Route: destination.Via)).ToList();
						CleanupReason? cleanupReason = assessment.Destinations.FirstOrDefault((Destination destination) => destination.Gate == CleanupGate.Blocked)?.Blocked;
						string text = assessment.Destinations.FirstOrDefault((Destination destination) => destination.Blocked == CleanupReason.AzuExcluded)?.Chest.Id;
						if (list4.Count == 0)
						{
							CleanupReason valueOrDefault = cleanupReason.GetValueOrDefault();
							if (value != CleanupKind.Resort && (cleanupReason.HasValue || value == CleanupKind.Rejected))
							{
								list2.Add(new CleanupRemainder(item.Id, stack.Handle, stack.Identity, stack.Quantity, valueOrDefault, (valueOrDefault == CleanupReason.AzuExcluded) ? text : null));
							}
							continue;
						}
						if (stack.Protected || !stack.TransferSupported || item.Inventory.ProtectedCells.Contains(stack.Y * item.Inventory.Width + stack.X))
						{
							list2.Add(new CleanupRemainder(item.Id, stack.Handle, stack.Identity, stack.Quantity, CleanupReason.Unsupported, null));
							continue;
						}
						if (input.Held.Contains(stack.Handle))
						{
							list2.Add(new CleanupRemainder(item.Id, stack.Handle, stack.Identity, stack.Quantity, CleanupReason.Held, null));
							continue;
						}
						int num2 = stack.Quantity;
						bool flag = false;
						foreach (var (cleanupChest, cleanupRoute) in list4)
						{
							if (num2 == 0)
							{
								break;
							}
							string text2 = cleanupRoute switch
							{
								CleanupRoute.MucRemove => item.Id, 
								CleanupRoute.MucAdd => cleanupChest.Id, 
								_ => null, 
							};
							if (text2 != null && hashSet2.Contains(text2))
							{
								flag = true;
								continue;
							}
							TransferGrid transferGrid2 = dictionary[cleanupChest.Id];
							int x;
							int y;
							Guid? merge;
							int room;
							bool planned;
							while (num2 > 0 && list.Count < 512 && transferGrid2.TryFind(stack.MergeKey, stack.MaximumStack, out x, out y, out merge, out room, out planned))
							{
								int num3 = Math.Min(num2, room);
								transferGrid2.Add(x, y, stack.MergeKey, stack.MaximumStack, num3);
								transferGrid.Remove(stack.X, stack.Y, num3);
								list.Add(new CleanupMove(item.Id, cleanupChest.Id, stack.Handle, stack.Identity, num3, x, y, merge, cleanupRoute, value, planned));
								num2 -= num3;
								if (text2 != null)
								{
									hashSet2.Add(text2);
									break;
								}
							}
							if (list.Count >= 512)
							{
								break;
							}
						}
						if (num2 > 0)
						{
							CleanupReason cleanupReason2 = ((list.Count >= 512) ? CleanupReason.Budget : ((!flag) ? CleanupReason.NoCapacity : CleanupReason.MucBusy));
							if (value != CleanupKind.Resort || cleanupReason2 == CleanupReason.Budget)
							{
								list2.Add(new CleanupRemainder(item.Id, stack.Handle, stack.Identity, num2, cleanupReason2, null));
							}
						}
					}
				}
			}
			return new CleanupPlan(stamp, pending: false, list.AsReadOnly(), list2.AsReadOnly(), num);
		}

		public static bool ResortStillBetter(ClassificationResult? item, string prefab, ChestRules source, ChestRules destination, IEnumerable<FacetEvidence>? facets, ClassificationTaxonomy taxonomy)
		{
			if (source == null || destination == null || source.State != ChestRuleState.Configured || destination.State != ChestRuleState.Configured)
			{
				return false;
			}
			DestinationEligibility eligibility = new DestinationEligibility(accessible: true, hasCapacity: true, protectionAllows: true);
			DestinationCandidate[] candidates = new DestinationCandidate[1]
			{
				new DestinationCandidate("source", source, eligibility)
			};
			DestinationCandidate[] candidates2 = new DestinationCandidate[1]
			{
				new DestinationCandidate("destination", destination, eligibility)
			};
			FacetEvidence[] currentInstanceFacets = facets?.ToArray();
			RankedDestination rankedDestination = ((item == null) ? DestinationRouting.ExactOnly(prefab, candidates).FirstOrDefault() : DestinationRouting.Rank(item, prefab, candidates, currentInstanceFacets, taxonomy).FirstOrDefault());
			RankedDestination rankedDestination2 = ((item == null) ? DestinationRouting.ExactOnly(prefab, candidates2).FirstOrDefault() : DestinationRouting.Rank(item, prefab, candidates2, currentInstanceFacets, taxonomy).FirstOrDefault());
			if (rankedDestination != null && rankedDestination2 != null)
			{
				return Better(rankedDestination2, rankedDestination);
			}
			return false;
		}

		public static bool Better(RankedDestination candidate, RankedDestination current)
		{
			int num = Compare<bool>(current.Candidate.Rules.Overflow, candidate.Candidate.Rules.Overflow);
			if (num != 0)
			{
				return num > 0;
			}
			num = Compare<int>(candidate.Candidate.Rules.Priority, current.Candidate.Rules.Priority);
			if (num != 0)
			{
				return num > 0;
			}
			num = Compare<int>((int)candidate.Match, (int)current.Match);
			if (num != 0)
			{
				return num > 0;
			}
			return Compare<int>(current.Generality, candidate.Generality) > 0;
			static int Compare<T>(T a, T b) where T : notnull, IComparable<T>
			{
				return a.CompareTo(b);
			}
		}

		internal static List<(CleanupChest Chest, DestinationCandidate Candidate)> Receivers(IEnumerable<CleanupChest> chests, ChestRuleEvaluator evaluator, ClassificationTaxonomy taxonomy)
		{
			List<(CleanupChest, DestinationCandidate)> list = new List<(CleanupChest, DestinationCandidate)>();
			foreach (CleanupChest chest in chests)
			{
				DestinationCandidate destinationCandidate = StoreOrder.Candidate(chest.Id, chest.RulePayload, evaluator, taxonomy);
				if (destinationCandidate != null)
				{
					list.Add((chest, destinationCandidate));
				}
			}
			return list;
		}

		internal static List<CleanupChest> Considered(IEnumerable<CleanupChest> chests)
		{
			return chests.OrderBy((CleanupChest x) => x.Distance).ThenBy<CleanupChest, string>((CleanupChest x) => x.Id, StringComparer.Ordinal).Take(256)
				.OrderBy<CleanupChest, string>((CleanupChest x) => x.Id, StringComparer.Ordinal)
				.ToList();
		}

		internal static HashSet<string> Sources(IEnumerable<CleanupChest> considered)
		{
			return new HashSet<string>(from x in (from x in considered
					where !x.OptOut && x.Inventory.Stacks.Count != 0
					orderby x.Distance
					select x).ThenBy<CleanupChest, string>((CleanupChest x) => x.Id, StringComparer.Ordinal).Take(64)
				select x.Id, StringComparer.Ordinal);
		}

		internal static Assessment Assess(CleanupInput input, ChestRuleEvaluator evaluator, List<(CleanupChest Chest, DestinationCandidate Candidate)> ruled, CleanupChest source, TransferStack stack)
		{
			ClassificationTaxonomy taxonomy = input.Taxonomy;
			ICategoryAnswers answers = input.Answers;
			string prefab = stack.Identity.Prefab;
			IReadOnlyList<FacetEvidence> facets = input.InstanceFacets?.Invoke(stack);
			Assessment result = new Assessment
			{
				Decision = evaluator.Evaluate(source.RulePayload, prefab, taxonomy, answers, facets)
			};
			Assessment assessment = result;
			assessment.Kind = result.Decision switch
			{
				ChestRuleDecision.Reject => CleanupKind.Rejected, 
				ChestRuleDecision.NoRule => CleanupKind.Unruled, 
				ChestRuleDecision.Accept => CleanupKind.Resort, 
				_ => null, 
			};
			if (!result.Kind.HasValue)
			{
				return result;
			}
			ClassificationResult classificationResult = (result.Item = answers.Resolve(prefab));
			if (classificationResult == null)
			{
				if (result.Kind == CleanupKind.Resort)
				{
					DestinationCandidate item = ruled.FirstOrDefault<(CleanupChest, DestinationCandidate)>(((CleanupChest Chest, DestinationCandidate Candidate) x) => x.Chest == source).Item2;
					result.Current = ((item == null) ? null : DestinationRouting.ExactOnly(prefab, new DestinationCandidate[1] { item }).FirstOrDefault());
					if (result.Current == null)
					{
						result.Stays = true;
						return result;
					}
				}
				foreach (RankedDestination item3 in DestinationRouting.ExactOnly(prefab, from x in ruled
					where x.Chest != source
					select x.Candidate))
				{
					AddDestination(item3);
				}
				return result;
			}
			if (result.Kind == CleanupKind.Resort)
			{
				DestinationCandidate item2 = ruled.FirstOrDefault<(CleanupChest, DestinationCandidate)>(((CleanupChest Chest, DestinationCandidate Candidate) x) => x.Chest == source).Item2;
				result.Current = ((item2 == null) ? null : DestinationRouting.Rank(classificationResult, prefab, new DestinationCandidate[1] { item2 }, facets, taxonomy).FirstOrDefault());
				if (result.Current == null)
				{
					result.Stays = true;
					return result;
				}
			}
			foreach (RankedDestination item4 in DestinationRouting.Rank(classificationResult, prefab, from x in ruled
				where x.Chest != source
				select x.Candidate, facets, taxonomy, input.CategorySize))
			{
				AddDestination(item4);
			}
			return result;
			void AddDestination(RankedDestination row)
			{
				CleanupChest chest;
				if (!row.ExistingItemFallback)
				{
					chest = ruled.First<(CleanupChest, DestinationCandidate)>(((CleanupChest Chest, DestinationCandidate Candidate) x) => x.Candidate == row.Candidate).Item1;
					if (result.Current != null && !Better(row, result.Current))
					{
						result.Destinations.Add(Gate(CleanupGate.NotBetter));
					}
					else if (evaluator.Evaluate(chest.RulePayload, prefab, taxonomy, answers, facets) != ChestRuleDecision.Accept)
					{
						result.Destinations.Add(Gate(CleanupGate.RuleMismatch));
					}
					else if (input.AzuAllows != null && !input.AzuAllows(chest.Id, stack.Identity))
					{
						result.Destinations.Add(Gate(CleanupGate.Blocked, CleanupReason.AzuExcluded));
					}
					else if (source.LocallyOwned && chest.LocallyOwned)
					{
						result.Destinations.Add(Gate(CleanupGate.Usable));
					}
					else if (!source.LocallyOwned && !chest.LocallyOwned)
					{
						result.Destinations.Add(Gate(CleanupGate.Blocked, CleanupReason.BothRemote));
					}
					else if (!input.MucAvailable)
					{
						result.Destinations.Add(Gate(CleanupGate.Blocked, CleanupReason.OtherOwnerNoMuc));
					}
					else
					{
						List<Destination> destinations = result.Destinations;
						CleanupRoute via = (source.LocallyOwned ? CleanupRoute.MucAdd : CleanupRoute.MucRemove);
						destinations.Add(Gate(CleanupGate.Usable, null, via));
					}
				}
				Destination Gate(CleanupGate gate, CleanupReason? reason = null, CleanupRoute via2 = CleanupRoute.Direct)
				{
					return new Destination(chest, row, gate, via2, reason);
				}
			}
		}
	}
	internal enum CleanupGate
	{
		Usable,
		NotBetter,
		RuleMismatch,
		Blocked
	}
	public sealed class CleanupReport
	{
		private sealed class Tally
		{
			internal string Item = "";

			internal int Stacks;

			internal int Units;
		}

		private readonly Dictionary<CleanupReason, int> remaining = new Dictionary<CleanupReason, int>();

		private readonly Dictionary<TransferRefusal, int> refused = new Dictionary<TransferRefusal, int>();

		private readonly string title;

		private readonly string verb;

		private readonly string left;

		public const int MaximumNamesPerLine = 16;

		private readonly Dictionary<(ResultKind Kind, int Reason), List<Tally>> names = new Dictionary<(ResultKind, int), List<Tally>>();

		private static readonly CleanupReason[] Left = new CleanupReason[9]
		{
			CleanupReason.NoCapacity,
			CleanupReason.NoDestination,
			CleanupReason.AzuExcluded,
			CleanupReason.Held,
			CleanupReason.Unsupported,
			CleanupReason.MucBusy,
			CleanupReason.Budget,
			CleanupReason.ChestLimit,
			CleanupReason.CategoriesPending
		};

		private static readonly CleanupReason[] Skipped = new CleanupReason[3]
		{
			CleanupReason.OtherOwnerNoMuc,
			CleanupReason.BothRemote,
			CleanupReason.OtherOwnerFormatUnknown
		};

		public int MovedStacks { get; private set; }

		public int MovedUnits { get; private set; }

		public int MucMovedStacks { get; private set; }

		public int Unconfirmed { get; private set; }

		public int MucUnconfirmed { get; private set; }

		public int Refused => refused.Values.Sum();

		public int Remaining => remaining.Values.Sum();

		public int ChestsInRange { get; private set; }

		public int ChestsHandled { get; private set; }

		public int Count(CleanupReason reason)
		{
			if (!remaining.TryGetValue(reason, out var value))
			{
				return 0;
			}
			return value;
		}

		public int Count(TransferRefusal reason)
		{
			if (!refused.TryGetValue(reason, out var value))
			{
				return 0;
			}
			return value;
		}

		public CleanupReport()
			: this("Cleanup", "moved", "left in place")
		{
		}

		private CleanupReport(string title, string verb, string left)
		{
			this.title = title;
			this.verb = verb;
			this.left = left;
		}

		public static CleanupReport ForStash()
		{
			return new CleanupReport("Stash", "stored", "left in your inventory");
		}

		public void Range(int inRange, int handled)
		{
			if (inRange < 0 || handled < 0 || handled > inRange)
			{
				throw new ArgumentOutOfRangeException("handled");
			}
			ChestsInRange = inRange;
			ChestsHandled = handled;
		}

		public void Remain(CleanupReason reason, string? item = null)
		{
			remaining[reason] = Count(reason) + 1;
			Name(ResultKind.Remaining, (int)reason, item, 1);
		}

		public void Refuse(TransferRefusal reason, string? item = null)
		{
			if (reason == TransferRefusal.None || reason == TransferRefusal.Unconfirmed)
			{
				throw new ArgumentException("Not a refusal.", "reason");
			}
			refused[reason] = Count(reason) + 1;
			Name(ResultKind.Refused, (int)reason, item, 1);
		}

		public void Moved(int units, bool viaMuc = false, string? item = null)
		{
			if (units < 1)
			{
				throw new ArgumentOutOfRangeException("units");
			}
			MovedStacks++;
			MovedUnits += units;
			if (viaMuc)
			{
				MucMovedStacks++;
			}
			Name(ResultKind.Moved, 0, item, units);
		}

		public void Unconfirm(bool viaMuc = false, string? item = null)
		{
			Unconfirmed++;
			if (viaMuc)
			{
				MucUnconfirmed++;
			}
			Name(ResultKind.Unconfirmed, 0, item, 1);
		}

		private void Name(ResultKind kind, int reason, string? item, int units)
		{
			if (item == null)
			{
				return;
			}
			if (!names.TryGetValue((kind, reason), out List<Tally> value))
			{
				names.Add((kind, reason), value = new List<Tally>());
			}
			Tally tally = value.Find((Tally x) => StringComparer.Ordinal.Equals(x.Item, item));
			if (tally == null)
			{
				if (value.Count == 16)
				{
					return;
				}
				value.Add(tally = new Tally
				{
					Item = item
				});
			}
			tally.Stacks++;
			tally.Units += units;
		}

		public ResultSummary Detail(Func<string, string>? itemName = null, int maximumLines = 8, int namesPerLine = 4)
		{
			if (maximumLines < 1)
			{
				throw new ArgumentOutOfRangeException("maximumLines");
			}
			if (namesPerLine < 0)
			{
				throw new ArgumentOutOfRangeException("namesPerLine");
			}
			List<ResultLine> lines = new List<ResultLine>();
			Add(ResultKind.Moved, 0, MovedStacks, $"{verb} {MovedStacks} stack{Plural(MovedStacks)} ({MovedUnits} item{Plural(MovedUnits)})" + ((MucMovedStacks == 0) ? "" : $", {MucMovedStacks} via MultiUserChest"));
			foreach (CleanupReason item in Left.Concat(Skipped))
			{
				Add(ResultKind.Remaining, (int)item, Count(item), Count(item) + " " + (Skipped.Contains(item) ? "skipped" : left) + " (" + Describe(item) + ")");
			}
			foreach (KeyValuePair<TransferRefusal, int> item2 in refused.OrderBy((KeyValuePair<TransferRefusal, int> x) => x.Key))
			{
				Add(ResultKind.Refused, (int)item2.Key, item2.Value, item2.Value + " refused (" + Describe(item2.Key) + ")");
			}
			Add(ResultKind.Unconfirmed, 0, Unconfirmed, Unconfirmed + " unconfirmed" + ((MucUnconfirmed == 0) ? "" : $" ({MucUnconfirmed} via MultiUserChest)") + ", not retried");
			List<ResultLine> list = lines.Take(maximumLines).ToList();
			int more = lines.Count - list.Count;
			return new ResultSummary(title, Summary(), list, more);
			void Add(ResultKind kind, int reason, int count, string label)
			{
				if (count != 0)
				{
					List<Tally> value;
					Tally[] source = (names.TryGetValue((kind, reason), out value) ? value.Take(namesPerLine).ToArray() : Array.Empty<Tally>());
					string[] items = source.Select(delegate(Tally x)
					{
						string text = ResultSummary.Bound(Display(itemName, x.Item), 40);
						int num = ((kind == ResultKind.Moved) ? x.Units : x.Stacks);
						return text + ((num > 1) ? (" ×" + num) : "");
					}).ToArray();
					lines.Add(new ResultLine(kind, (kind == ResultKind.Remaining) ? new CleanupReason?((CleanupReason)reason) : ((CleanupReason?)null), (kind == ResultKind.Refused) ? new TransferRefusal?((TransferRefusal)reason) : ((TransferRefusal?)null), count, label, items, Math.Max(0, count - source.Sum((Tally x) => x.Stacks))));
				}
			}
		}

		private static string Display(Func<string, string>? itemName, string item)
		{
			string text = itemName?.Invoke(item);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return item;
		}

		public string Summary()
		{
			List<string> list = new List<string>();
			list.Add($"{verb} {MovedStacks} stack{Plural(MovedStacks)} ({MovedUnits} item{Plural(MovedUnits)})" + ((MucMovedStacks == 0) ? "" : $", {MucMovedStacks} via MultiUserChest"));
			List<string> list2 = list;
			CleanupReason[] array = new CleanupReason[9]
			{
				CleanupReason.NoCapacity,
				CleanupReason.NoDestination,
				CleanupReason.AzuExcluded,
				CleanupReason.Held,
				CleanupReason.Unsupported,
				CleanupReason.MucBusy,
				CleanupReason.Budget,
				CleanupReason.ChestLimit,
				CleanupReason.CategoriesPending
			};
			List<string> list3 = (from x in array
				where Count(x) != 0
				select Count(x) + " " + Describe(x)).ToList();
			if (list3.Count != 0)
			{
				list2.Add(LeftTotal(array) + " " + left + " (" + string.Join(", ", list3) + ")");
			}
			foreach (CleanupReason item in new CleanupReason[3]
			{
				CleanupReason.OtherOwnerNoMuc,
				CleanupReason.BothRemote,
				CleanupReason.OtherOwnerFormatUnknown
			}.Where((CleanupReason x) => Count(x) != 0))
			{
				list2.Add(Count(item) + " skipped (" + Describe(item) + ")");
			}
			if (Refused != 0)
			{
				list2.Add(Refused + " refused (" + string.Join(", ", from x in refused
					orderby x.Key
					select x.Value + " " + Describe(x.Key)) + ")");
			}
			if (Unconfirmed != 0)
			{
				list2.Add(Unconfirmed + " unconfirmed" + ((MucUnconfirmed == 0) ? "" : $" ({MucUnconfirmed} via MultiUserChest)"));
			}
			if (ChestsInRange > ChestsHandled)
			{
				list2.Add($"{ChestsInRange} chests in range; only the nearest {ChestsHandled} could be handled");
			}
			return title + ": " + string.Join(" · ", list2);
		}

		private int LeftTotal(IEnumerable<CleanupReason> reasons)
		{
			return reasons.Sum((Func<CleanupReason, int>)Count);
		}

		private static string Plural(int count)
		{
			if (count != 1)
			{
				return "s";
			}
			return "";
		}

		public static string Describe(CleanupReason reason)
		{
			return reason switch
			{
				CleanupReason.NoCapacity => "no room", 
				CleanupReason.NoDestination => "no chest takes it", 
				CleanupReason.AzuExcluded => "AzuAutoStore's config excludes it", 
				CleanupReason.Held => "in use", 
				CleanupReason.Unsupported => "protected", 
				CleanupReason.MucBusy => "other player's chest busy, run again", 
				CleanupReason.Budget => "run limit reached, run again", 
				CleanupReason.ChestLimit => "in a chest farther than the nearest " + 64 + " with items; clean up again closer to it", 
				CleanupReason.OtherOwnerNoMuc => "another player's chest, no MultiUserChest", 
				CleanupReason.BothRemote => "both chests are other players'", 
				CleanupReason.OtherOwnerFormatUnknown => "another player's chest, their MultiUserChest format is unknown", 
				CleanupReason.CategoriesPending => "waiting for categories to load, run again shortly", 
				_ => reason.ToString(), 
			};
		}

		public static string Describe(TransferRefusal reason)
		{
			return reason switch
			{
				TransferRefusal.InventoryChanged => "chest changed", 
				TransferRefusal.OwnerChanged => "a chest changed owner, run again", 
				TransferRefusal.PolicyChanged => "rules or categories changed, run again", 
				TransferRefusal.RuleMismatch => "rules changed, run again", 
				TransferRefusal.AccessDenied => "no access", 
				TransferRefusal.NoCapacity => "no room", 
				TransferRefusal.Protected => "protected", 
				TransferRefusal.Disconnected => "left the world", 
				TransferRefusal.Expired => "too far or too late", 
				TransferRefusal.UnsupportedCapability => "unsupported item", 
				TransferRefusal.UnsupportedAuthority => "not the chest owner", 
				TransferRefusal.Busy => "MultiUserChest refused or refunded it", 
				TransferRefusal.TurnedOff => "turned off on this server", 
				_ => reason.ToString(), 
			};
		}
	}
	public enum ResultKind
	{
		Moved,
		Remaining,
		Refused,
		Unconfirmed
	}
	public sealed class ResultLine
	{
		public ResultKind Kind { get; }

		public CleanupReason? Reason { get; }

		public TransferRefusal? Refusal { get; }

		public int Count { get; }

		public string Label { get; }

		public IReadOnlyList<string> Items { get; }

		public int More { get; }

		public string Text { get; }

		internal ResultLine(ResultKind kind, CleanupReason? reason, TransferRefusal? refusal, int count, string label, IReadOnlyList<string> items, int more)
		{
			Kind = kind;
			Reason = reason;
			Refusal = refusal;
			Count = count;
			Label = label;
			Items = items;
			More = more;
			string text = string.Join(", ", items) + ((more == 0) ? "" : (((items.Count == 0) ? "" : " ") + "+" + more + " more"));
			Text = ResultSummary.Bound(label + ((text.Length == 0) ? "" : (": " + text)), 160);
		}
	}
	public sealed class ResultSummary
	{
		public const int MaximumText = 160;

		public string Title { get; }

		public string Headline { get; }

		public IReadOnlyList<ResultLine> Lines { get; }

		public int MoreLines { get; }

		public bool Empty => Lines.Count == 0;

		internal ResultSummary(string title, string headline, IReadOnlyList<ResultLine> lines, int more)
		{
			Title = title;
			Headline = headline;
			Lines = lines;
			MoreLines = more;
		}

		internal static string Bound(string text, int maximum)
		{
			if (text.Length > maximum)
			{
				return text.Substring(0, maximum - 1) + "…";
			}
			return text;
		}
	}
	public enum ContainerPolicyReadState
	{
		Absent,
		Supported,
		Unsupported
	}
	public sealed class ContainerPolicyRead
	{
		public ContainerPolicyReadState State { get; }

		public string OriginalPayload { get; }

		public ulong Revision { get; }

		public ChestRules? Rules { get; }

		public bool HasRule
		{
			get
			{
				if (State == ContainerPolicyReadState.Supported)
				{
					ChestRules? rules = Rules;
					if (rules == null)
					{
						return false;
					}
					return rules.State == ChestRuleState.Configured;
				}
				return false;
			}
		}

		internal ContainerPolicyRead(ContainerPolicyReadState state, string payload, ulong revision = 0uL, ChestRules? rules = null)
		{
			State = state;
			OriginalPayload = payload;
			Revision = revision;
			Rules = rules;
		}
	}
	public sealed class ChestRuleEdit
	{
		internal sealed class Alternative
		{
			internal string Key = "";

			internal bool HasCategories;

			internal IReadOnlyDictionary<string, IReadOnlyList<string>> Filters;

			internal IEnumerable<string> Known = Array.Empty<string>();

			internal IEnumerable<string> Unknown = Array.Empty<string>();

			internal ClassificationFilterRule? Full;

			internal ChestRuleAlternative? Preserved;
		}

		public const int MaximumPriority = 999;

		public IReadOnlyList<string> Categories { get; }

		public IReadOnlyList<string> Includes { get; }

		public IReadOnlyList<string> Excludes { get; }

		public IReadOnlyList<string> UnknownCategories { get; }

		public int HiddenParts { get; private set; }

		public int? Priority { get; }

		public IReadOnlyDictionary<string, IReadOnlyList<string>> Filters { get; }

		public IReadOnlyDictionary<string, IReadOnlyList<string>> EditedFilters { get; }

		public ChestRuleEdit(IEnumerable<string>? categories, IEnumerable<string>? includes, IEnumerable<string>? excludes, IEnumerable<string>? unknownCategories = null, int? priority = null, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? filters = null, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? editedFilters = null)
		{
			Categories = Own(categories, 256);
			Includes = Own(includes, 2048);
			Excludes = Own(excludes, 2048);
			UnknownCategories = Own(unknownCategories, 256);
			bool flag;
			if (priority.HasValue)
			{
				int valueOrDefault = priority.GetValueOrDefault();
				if (valueOrDefault < -999 || valueOrDefault > 999)
				{
					flag = true;
					goto IL_0072;
				}
			}
			flag = false;
			goto IL_0072;
			IL_0072:
			if (flag)
			{
				throw new ArgumentOutOfRangeException("priority");
			}
			Priority = priority;
			Filters = OwnFilters(filters);
			EditedFilters = OwnFilters(editedFilters);
		}

		public static ChestRuleEdit From(ChestRules rules, bool withFilters = false)
		{
			if (rules == null)
			{
				throw new ArgumentNullException("rules");
			}
			Alternative[] array = Alternatives(rules).ToArray();
			string key = "";
			int value = Math.Max(-999, Math.Min(999, rules.Priority));
			if (withFilters && !array.Any((Alternative x) => x.Key.Length == 0 && x.HasCategories))
			{
				Alternative[] array2 = array.Where((Alternative x) => x.Key.Length != 0).ToArray();
				string[] array3 = array2.Select((Alternative x) => x.Key).Distinct<string>(StringComparer.Ordinal).ToArray();
				if (array3.Length == 1 && (array2.All((Alternative x) => x.HasCategories) || array2.Length == 1))
				{
					key = array3[0];
				}
			}
			Alternative[] array4 = array.Where((Alternative x) => Edited(x, key)).ToArray();
			KeyValuePair<string, IEnumerable<string>>[] array5 = ((key.Length == 0) ? null : array4[0].Filters.Select<KeyValuePair<string, IReadOnlyList<string>>, KeyValuePair<string, IEnumerable<string>>>((KeyValuePair<string, IReadOnlyList<string>> x) => new KeyValuePair<string, IEnumerable<string>>(x.Key, x.Value)).ToArray());
			return new ChestRuleEdit(array4.SelectMany((Alternative x) => x.Known), rules.Includes, rules.Excludes, array4.SelectMany((Alternative x) => x.Unknown), value, array5, array5)
			{
				HiddenParts = array.Length - array4.Length + (rules.Overflow ? 1 : 0)
			};
		}

		internal static IEnumerable<Alternative> Alternatives(ChestRules rules)
		{
			return rules.FullRules.Select((ClassificationFilterRule x) => new Alternative
			{
				Key = Key(x.Filters),
				HasCategories = (x.Categories.Count != 0),
				Filters = x.Filters,
				Known = x.Categories,
				Full = x
			}).Concat(rules.Preserved.Select(delegate(ChestRuleAlternative x)
			{
				Alternative obj = new Alternative
				{
					Key = Key(x.Filters),
					HasCategories = true,
					Filters = x.Filters
				};
				IEnumerable<string> enumerable = x.Effective?.Categories;
				obj.Known = enumerable ?? Array.Empty<string>();
				obj.Unknown = x.UnknownCategories;
				obj.Preserved = x;
				return obj;
			}));
		}

		internal static bool Edited(Alternative row, string key)
		{
			if (row.Key == key)
			{
				if (!row.HasCategories)
				{
					return key.Length != 0;
				}
				return true;
			}
			return false;
		}

		internal static string Key(IReadOnlyDictionary<string, IReadOnlyList<string>> filters)
		{
			return string.Join(";", from x in filters.Where<KeyValuePair<string, IReadOnlyList<string>>>((KeyValuePair<string, IReadOnlyList<string>> x) => x.Value.Count != 0).OrderBy<KeyValuePair<string, IReadOnlyList<string>>, string>((KeyValuePair<string, IReadOnlyList<string>> x) => x.Key, StringComparer.Ordinal)
				select x.Key + "=" + string.Join(",", x.Value.OrderBy<string, string>((string v) => v, StringComparer.Ordinal)));
		}

		private static IReadOnlyDictionary<string, IReadOnlyList<string>> OwnFilters(IEnumerable<KeyValuePair<string, IEnumerable<string>>>? input)
		{
			SortedDictionary<string, IReadOnlyList<string>> sortedDictionary = new SortedDictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal);
			KeyValuePair<string, IEnumerable<string>>[] array = ClassificationValidation.Bounded(input ?? Array.Empty<KeyValuePair<string, IEnumerable<string>>>(), 32);
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<string, IEnumerable<string>> keyValuePair = array[i];
				string[] array2 = ClassificationValidation.Bounded(keyValuePair.Value ?? throw new ArgumentNullException("input"), 64).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string x) => x, StringComparer.Ordinal)
					.ToArray();
				ClassificationFilters.ValidateRuleFilter(keyValuePair.Key, array2);
				if (sortedDictionary.ContainsKey(keyValuePair.Key))
				{
					throw new ArgumentException("Duplicate filter dimension.");
				}
				if (array2.Length != 0)
				{
					sortedDictionary.Add(keyValuePair.Key, Array.AsReadOnly(array2));
				}
			}
			return new ReadOnlyDictionary<string, IReadOnlyList<string>>(sortedDictionary);
		}

		private static IReadOnlyList<string> Own(IEnumerable<string>? input, int limit)
		{
			string[] array = ClassificationValidation.Bounded(input ?? Array.Empty<string>(), limit);
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				ClassificationValidation.Text(array2[i], 2048);
			}
			return Array.AsReadOnly(array.Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string x) => x, StringComparer.Ordinal).ToArray());
		}
	}
	public static class ContainerPolicyEnvelope
	{
		public const string ZdoKey = "com.bastionntb.yavsos.container-policy";

		private const string RuleFormat = "yavsos-chest-rules-xml-1";

		public static string Serialize(ulong revision, ChestRules rules)
		{
			if (rules == null)
			{
				throw new ArgumentNullException("rules");
			}
			XElement xElement = new XElement("root", new XAttribute("type", "object"), Value("schemaVersion", "number", "1"), Value("revision", "string", revision.ToString(CultureInfo.InvariantCulture)), new XElement("policy", new XAttribute("type", "object"), Value("format", "string", "yavsos-chest-rules-xml-1"), Value("rulesXml", "string", ChestRuleCodec.Serialize(rules))));
			using BoundedTransferStream boundedTransferStream = new BoundedTransferStream(65536);
			using (XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter(boundedTransferStream, TransferCanonical.Utf8, ownsStream: false))
			{
				xElement.WriteTo(writer);
			}
			return TransferCanonical.Utf8.GetString(boundedTransferStream.ToArray());
		}

		public static ContainerPolicyRead Read(string payload, ClassificationTaxonomy taxonomy)
		{
			if (payload == null)
			{
				throw new ArgumentNullException("payload");
			}
			if (taxonomy == null)
			{
				throw new ArgumentNullException("taxonomy");
			}
			if (payload.Length == 0)
			{
				return new ContainerPolicyRead(ContainerPolicyReadState.Absent, payload, 0uL);
			}
			try
			{
				TransferCanonical.Text(payload, 65536, empty: false);
				ValidateJsonSyntax(payload);
				byte[] bytes = TransferCanonical.Utf8.GetBytes(payload);
				XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas
				{
					MaxDepth = 8,
					MaxStringContentLength = 65536,
					MaxArrayLength = 65536,
					MaxBytesPerRead = 65536,
					MaxNameTableCharCount = 1024
				};
				using XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(bytes, 0, bytes.Length, TransferCanonical.Utf8, quotas, null);
				XElement xElement = XElement.Load(reader, LoadOptions.None);
				Object(xElement, "schemaVersion", "revision", "policy");
				if (Leaf(xElement, "schemaVersion", "number") != "1")
				{
					throw new InvalidDataException("Unknown policy envelope schema.");
				}
				string text = Leaf(xElement, "revision", "string");
				if (!ulong.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result.ToString(CultureInfo.InvariantCulture) != text)
				{
					throw new InvalidDataException("Invalid policy revision.");
				}
				XElement xElement2 = xElement.Element("policy");
				Object(xElement2, "format", "rulesXml");
				if (Leaf(xElement2, "format", "string") != "yavsos-chest-rules-xml-1")
				{
					throw new InvalidDataException("Unsupported policy rules format.");
				}
				ChestRules rules = ChestRuleCodec.Parse(Leaf(xElement2, "rulesXml", "string"), taxonomy);
				return new ContainerPolicyRead(ContainerPolicyReadState.Supported, payload, result, rules);
			}
			catch (Exception ex) when (ex is ArgumentException || ex is XmlException || ex is InvalidDataException || ex is FormatException)
			{
				return new ContainerPolicyRead(ContainerPolicyReadState.Unsupported, payload, 0uL);
			}
		}

		public static TransferRefusal TryEdit(string currentPayload, string expectedPayload, ClassificationTaxonomy taxonomy, ChestRuleEdit? edit, out string? updatedPayload)
		{
			updatedPayload = null;
			if (!StringComparer.Ordinal.Equals(currentPayload, expectedPayload))
			{
				return TransferRefusal.PolicyChanged;
			}
			ContainerPolicyRead containerPolicyRead = Read(currentPayload, taxonomy);
			if (edit == null)
			{
				updatedPayload = "";
				return TransferRefusal.None;
			}
			if (containerPolicyRead.State == ContainerPolicyReadState.Unsupported || containerPolicyRead.Revision == ulong.MaxValue)
			{
				return TransferRefusal.UnsupportedCapability;
			}
			ChestRules rules = containerPolicyRead.Rules;
			try
			{
				string key = ChestRuleEdit.Key(edit.EditedFilters);
				ChestRuleEdit.Alternative[] array = ((rules == null) ? Array.Empty<ChestRuleEdit.Alternative>() : (from x in ChestRuleEdit.Alternatives(rules)
					where !ChestRuleEdit.Edited(x, key)
					select x).ToArray());
				IEnumerable<ClassificationFilterRule> enumerable = from x in array
					where x.Full != null
					select x.Full;
				IEnumerable<ChestRuleAlternative> enumerable2 = from x in array
					where x.Preserved != null
					select x.Preserved;
				foreach (string category in edit.Categories)
				{
					taxonomy.Require(category);
				}
				KeyValuePair<string, IEnumerable<string>>[] array2 = edit.Filters.Select<KeyValuePair<string, IReadOnlyList<string>>, KeyValuePair<string, IEnumerable<string>>>((KeyValuePair<string, IReadOnlyList<string>> x) => new KeyValuePair<string, IEnumerable<string>>(x.Key, x.Value)).ToArray();
				(ClassificationFilterRule, ChestRuleAlternative) tuple = ((edit.Categories.Count + edit.UnknownCategories.Count != 0) ? ChestRuleCodec.Alternative(taxonomy, edit.Categories.Concat(edit.UnknownCategories), array2) : (((ClassificationFilterRule? Rule, ChestRuleAlternative? Preserved))((array2.Length == 0) ? (null, null) : (new ClassificationFilterRule(taxonomy, Array.Empty<string>(), array2), null))));
				bool flag = rules != null && rules.State == ChestRuleState.Configured && rules.Overflow;
				if (tuple.Item1 == null && tuple.Item2 == null && array.Length == 0 && edit.Includes.Count + edit.Excludes.Count == 0 && !flag)
				{
					updatedPayload = "";
					return TransferRefusal.None;
				}
				ChestRules rules2 = new ChestRules(taxonomy, ChestRuleState.Configured, (tuple.Item1 == null) ? enumerable : enumerable.Concat(new ClassificationFilterRule[1] { tuple.Item1 }), edit.Includes, edit.Excludes, edit.Priority ?? rules?.Priority ?? 0, flag, existingItemFallback: false, (tuple.Item2 == null) ? enumerable2 : enumerable2.Concat(new ChestRuleAlternative[1] { tuple.Item2 }));
				updatedPayload = Serialize(containerPolicyRead.Revision + 1, rules2);
				return TransferRefusal.None;
			}
			catch (Exception ex) when (ex is ArgumentException || ex is InvalidDataException)
			{
				updatedPayload = null;
				return TransferRefusal.UnsupportedCapability;
			}
		}

		private static XElement Value(string name, string type, string value)
		{
			return new XElement(name, new XAttribute("type", type), value);
		}

		private static void ValidateJsonSyntax(string text)
		{
			int at = 0;
			ObjectSyntax(1);
			Space();
			if (at != text.Length)
			{
				throw new InvalidDataException("Trailing policy JSON content.");
			}
			bool Digit()
			{
				if (at < text.Length && text[at] >= '0')
				{
					return text[at] <= '9';
				}
				return false;
			}
			void Need(char value)
			{
				if (!Take(value))
				{
					throw new InvalidDataException("Incomplete policy JSON.");
				}
			}
			void Number()
			{
				if (at < text.Length && text[at] == '-')
				{
					at++;
				}
				if (!Digit())
				{
					throw new InvalidDataException("Invalid policy JSON number.");
				}
				if (text[at] == '0')
				{
					at++;
				}
				else
				{
					while (Digit())
					{
						at++;
					}
				}
				if (at < text.Length && text[at] == '.')
				{
					at++;
					if (!Digit())
					{
						throw new InvalidDataException("Invalid policy JSON fraction.");
					}
					while (Digit())
					{
						at++;
					}
				}
				if (at < text.Length && (text[at] == 'e' || text[at] == 'E'))
				{
					at++;
					if (at < text.Length && (text[at] == '+' || text[at] == '-'))
					{
						at++;
					}
					if (!Digit())
					{
						throw new InvalidDataException("Invalid policy JSON exponent.");
					}
					while (Digit())
					{
						at++;
					}
				}
			}
			void ObjectSyntax(int depth)
			{
				if (depth > 8)
				{
					throw new InvalidDataException("Policy JSON depth bound.");
				}
				Need('{');
				if (!Take('}'))
				{
					while (true)
					{
						String();
						Need(':');
						Space();
						if (at >= text.Length)
						{
							throw new InvalidDataException("Incomplete policy JSON value.");
						}
						if (text[at] == '{')
						{
							ObjectSyntax(depth + 1);
						}
						else if (text[at] == '"')
						{
							String();
						}
						else
						{
							Number();
						}
						if (Take('}'))
						{
							break;
						}
						Need(',');
					}
				}
			}
			void Space()
			{
				for (; at < text.Length && (text[at] == ' ' || text[at] == '\t' || text[at] == '\r' || text[at] == '\n'); at++)
				{
				}
			}
			void String()
			{
				Need('"');
				while (at < text.Length)
				{
					char c = text[at++];
					if (c == '"')
					{
						return;
					}
					if (c < ' ')
					{
						throw new InvalidDataException("Unescaped policy JSON control character.");
					}
					if (c == '\\')
					{
						if (at >= text.Length)
						{
							throw new InvalidDataException("Incomplete policy JSON escape.");
						}
						switch (text[at++])
						{
						case 'u':
						{
							for (int i = 0; i < 4; i++)
							{
								if (at >= text.Length || !Uri.IsHexDigit(text[at++]))
								{
									throw new InvalidDataException("Invalid policy JSON Unicode escape.");
								}
							}
							break;
						}
						default:
							throw new InvalidDataException("Invalid policy JSON escape.");
						case '"':
						case '/':
						case '\\':
						case 'b':
						case 'f':
						case 'n':
						case 'r':
						case 't':
							break;
						}
					}
				}
				throw new InvalidDataException("Incomplete policy JSON string.");
			}
			bool Take(char value)
			{
				Space();
				if (at >= text.Length || text[at] != value)
				{
					return false;
				}
				at++;
				return true;
			}
		}

		private static void Object(XElement element, params string[] fields)
		{
			if ((string?)element.Attribute("type") != "object" || element.Attributes().Count() != 1 || element.Elements().Count() != fields.Length || fields.Any((string f) => element.Elements(f).Count() != 1) || element.Nodes().Any((XNode n) => !(n is XElement)))
			{
				throw new InvalidDataException("Unsupported policy object shape.");
			}
		}

		private static string Leaf(XElement parent, string name, string type)
		{
			XElement xElement = parent.Element(name) ?? throw new InvalidDataException("Missing policy field.");
			if ((string?)xElement.Attribute("type") != type || xElement.Attributes().Count() != 1 || xElement.HasElements)
			{
				throw new InvalidDataException("Invalid policy field type.");
			}
			return xElement.Value;
		}
	}
	public enum DelegatedMoveState
	{
		Pending,
		Moved,
		Refused,
		Unconfirmed
	}
	public sealed class DelegatedMoveObserver
	{
		public const double DefaultWindowSeconds = 40.0;

		private readonly int destinationBefore;

		private readonly int otherDestinationBefore;

		private int sourceBefore;

		private bool sourceUnknown;

		private readonly double deadline;

		private bool taken;

		public CleanupRoute Route { get; }

		public int Units { get; }

		public DelegatedMoveState State { get; private set; }

		public int MovedUnits { get; private set; }

		public string Detail { get; private set; } = "";

		public DelegatedMoveObserver(CleanupRoute route, int units, int sourceBefore, int destinationBefore, int otherDestinationBefore, double now, double windowSeconds = 40.0)
		{
			if (route == CleanupRoute.Direct)
			{
				throw new ArgumentException("Direct moves are verified synchronously.", "route");
			}
			if (units < 1 || sourceBefore < units || destinationBefore < 0 || otherDestinationBefore < 0)
			{
				throw new ArgumentOutOfRangeException("units");
			}
			if (double.IsNaN(now) || double.IsInfinity(now) || windowSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("now");
			}
			Route = route;
			Units = units;
			this.sourceBefore = sourceBefore;
			this.destinationBefore = destinationBefore;
			this.otherDestinationBefore = otherDestinationBefore;
			deadline = now + windowSeconds;
		}

		public void SourceTaken(int units)
		{
			if (units < 0)
			{
				throw new ArgumentOutOfRangeException("units");
			}
			sourceBefore -= units;
		}

		public void SourceUnknown()
		{
			sourceUnknown = true;
		}

		public DelegatedMoveState Observe(double now, int source, int destination, int otherDestination, bool sessionCurrent)
		{
			if (State != DelegatedMoveState.Pending)
			{
				return State;
			}
			if (!sessionCurrent)
			{
				return Finish(DelegatedMoveState.Unconfirmed, 0, "the session ended while MultiUserChest was moving it");
			}
			int num = Math.Max(0, destination - destinationBefore);
			int num2 = sourceBefore - source;
			if (Route == CleanupRoute.MucAdd)
			{
				if (num2 > 0)
				{
					taken = true;
				}
				if (num >= Units)
				{
					return Finish(DelegatedMoveState.Moved, Units, "arrived");
				}
				if (sourceUnknown)
				{
					if (now >= deadline)
					{
						return Finish(DelegatedMoveState.Unconfirmed, 0, $"after {40.0:0} s: destination +{num}; another move changed the source");
					}
					return State;
				}
				if (taken && num2 <= 0 && num == 0)
				{
					return Finish(DelegatedMoveState.Refused, 0, "refunded by MultiUserChest");
				}
				if (taken && num > 0 && num2 == num)
				{
					return Finish(DelegatedMoveState.Moved, num, "partly arrived; the rest was refunded");
				}
			}
			else
			{
				if (otherDestination > otherDestinationBefore)
				{
					return Finish(DelegatedMoveState.Unconfirmed, 0, "a different item arrived");
				}
				if (num >= Units)
				{
					return Finish(DelegatedMoveState.Moved, Units, "arrived");
				}
			}
			if (now >= deadline)
			{
				return Finish(DelegatedMoveState.Unconfirmed, 0, $"after {40.0:0} s: source −{num2}, destination +{num}");
			}
			return State;
		}

		private DelegatedMoveState Finish(DelegatedMoveState state, int moved, string detail)
		{
			State = state;
			MovedUnits = moved;
			Detail = detail;
			return state;
		}
	}
	public enum TransferRefusal
	{
		None,
		AccessDenied,
		Busy,
		UnsupportedAuthority,
		UnsupportedCapability,
		Protected,
		PolicyChanged,
		InventoryChanged,
		OwnerChanged,
		NoCapacity,
		Expired,
		Disconnected,
		ProtocolMismatch,
		InvariantFailed,
		Unconfirmed,
		RuleMismatch,
		TurnedOff
	}
	public sealed class TransferInventoryStamp : IEquatable<TransferInventoryStamp>
	{
		public string InventoryId { get; }

		public Guid InstanceGeneration { get; }

		public ulong ChangeEpoch { get; }

		public ulong LayoutProtectionRevision { get; }

		public long OwnerPeer { get; }

		public ushort NativeOwnerRevision { get; }

		public string AuthoritativePayloadFingerprint { get; }

		public TransferInventoryStamp(string inventoryId, Guid instanceGeneration, ulong changeEpoch, ulong layoutProtectionRevision, long ownerPeer, ushort nativeOwnerRevision, string authoritativePayloadFingerprint)
		{
			InventoryId = TransferCanonical.Text(inventoryId, 2048, empty: false);
			if (instanceGeneration == Guid.Empty)
			{
				throw new ArgumentException("Missing adapter instance generation.");
			}
			InstanceGeneration = instanceGeneration;
			ChangeEpoch = changeEpoch;
			LayoutProtectionRevision = layoutProtectionRevision;
			OwnerPeer = ownerPeer;
			NativeOwnerRevision = nativeOwnerRevision;
			AuthoritativePayloadFingerprint = TransferCanonical.Text(authoritativePayloadFingerprint, 128, empty: false);
		}

		public bool Equals(TransferInventoryStamp? other)
		{
			if (other != null && StringComparer.Ordinal.Equals(InventoryId, other.InventoryId) && InstanceGeneration == other.InstanceGeneration && ChangeEpoch == other.ChangeEpoch && LayoutProtectionRevision == other.LayoutProtectionRevision && OwnerPeer == other.OwnerPeer && NativeOwnerRevision == other.NativeOwnerRevision)
			{
				return StringComparer.Ordinal.Equals(AuthoritativePayloadFingerprint, other.AuthoritativePayloadFingerprint);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return StringComparer.Ordinal.GetHashCode(InventoryId);
		}
	}
	public sealed class TransferStack
	{
		public Guid Handle { get; }

		public int X { get; }

		public int Y { get; }

		public int Quantity { get; }

		public int MaximumStack { get; }

		public TransferItemIdentity Identity { get; }

		public bool Protected { get; }

		public bool TransferSupported { get; }

		public string? MergeClass { get; }

		public string MergeKey
		{
			get
			{
				if (MaximumStack <= 1 || MergeClass == null)
				{
					return "item:" + Identity.Fingerprint;
				}
				return "class:" + MergeClass;
			}
		}

		public TransferStack(Guid handle, int x, int y, int quantity, int maximumStack, TransferItemIdentity identity, bool isProtected = false, bool transferSupported = true, string? mergeClass = null)
		{
			if (handle == Guid.Empty || x < 0 || y < 0 || maximumStack < 1 || quantity < 1 || quantity > maximumStack)
			{
				throw new ArgumentException("Invalid selected stack.");
			}
			Handle = handle;
			X = x;
			Y = y;
			Quantity = quantity;
			MaximumStack = maximumStack;
			Identity = identity ?? throw new ArgumentNullException("identity");
			Protected = isProtected;
			TransferSupported = transferSupported;
			if (mergeClass != null)
			{
				MergeClass = TransferCanonical.Text(mergeClass, 256, empty: false);
			}
		}
	}
	public sealed class TransferInventorySnapshot
	{
		public TransferInventoryStamp Stamp { get; }

		public int Width { get; }

		public int Height { get; }

		public IReadOnlyList<TransferStack> Stacks { get; }

		public IReadOnlyList<int> ProtectedCells { get; }

		public string ContentFingerprint { get; }

		public TransferInventorySnapshot(TransferInventoryStamp stamp, int width, int height, IEnumerable<TransferStack> stacks, IEnumerable<int> protectedCells)
		{
			Stamp = stamp ?? throw new ArgumentNullException("stamp");
			if (width < 1 || height < 1 || (long)width * (long)height > 65536)
			{
				throw new ArgumentException("Unsupported grid bounds.");
			}
			Width = width;
			Height = height;
			if (stacks == null || protectedCells == null)
			{
				throw new ArgumentNullException();
			}
			List<TransferStack> list = new List<TransferStack>();
			HashSet<int> hashSet = new HashSet<int>();
			HashSet<Guid> hashSet2 = new HashSet<Guid>();
			foreach (TransferStack stack in stacks)
			{
				if (stack == null || stack.X >= width || stack.Y >= height || !hashSet.Add(stack.Y * width + stack.X) || !hashSet2.Add(stack.Handle))
				{
					throw new ArgumentException("Invalid or duplicate stack/cell.");
				}
				list.Add(stack);
			}
			Stacks = Array.AsReadOnly((from s in list
				orderby s.Y, s.X
				select s).ToArray());
			HashSet<int> hashSet3 = new HashSet<int>();
			foreach (int protectedCell in protectedCells)
			{
				if (protectedCell < 0 || protectedCell >= width * height)
				{
					throw new ArgumentException("Protected cell outside grid.");
				}
				hashSet3.Add(protectedCell);
			}
			ProtectedCells = Array.AsReadOnly(hashSet3.OrderBy((int x) => x).ToArray());
			ContentFingerprint = TransferCanonical.Hash(WriteCanonical, 1048576);
		}

		private void WriteCanonical(BinaryWriter w)
		{
			w.Write("yavsos-transfer-inventory-1");
			w.Write(Width);
			w.Write(Height);
			w.Write(ProtectedCells.Count);
			foreach (int protectedCell in ProtectedCells)
			{
				w.Write(protectedCell);
			}
			w.Write(Stacks.Count);
			foreach (TransferStack stack in Stacks)
			{
				w.Write(stack.Handle.ToByteArray());
				w.Write(stack.X);
				w.Write(stack.Y);
				w.Write(stack.Quantity);
				w.Write(stack.MaximumStack);
				w.Write(stack.Protected);
				w.Write(stack.TransferSupported);
				w.Write(stack.MergeClass ?? "");
				stack.Identity.WriteCanonical(w);
			}
		}
	}
	public sealed class DepositPlan
	{
		public Guid OperationId { get; }

		public Guid SessionNonce { get; }

		public string PolicyStamp { get; }

		public string RuleStamp { get; }

		public TransferInventorySnapshot Source { get; }

		public TransferInventorySnapshot Destination { get; }

		public TransferStack Selection { get; }

		public int RequestedUnits { get; }

		public int PlannedUnits { get; }

		public int DestinationX { get; }

		public int DestinationY { get; }

		public Guid? MergeHandle { get; }

		public double AdmissionDeadline { get; }

		private DepositPlan(Guid operationId, Guid sessionNonce, string policyStamp, string ruleStamp, TransferInventorySnapshot source, TransferInventorySnapshot destination, TransferStack selection, int requestedUnits, int plannedUnits, int x, int y, Guid? mergeHandle, double deadline)
		{
			OperationId = operationId;
			SessionNonce = sessionNonce;
			PolicyStamp = policyStamp;
			RuleStamp = ruleStamp;
			Source = source;
			Destination = destination;
			Selection = selection;
			RequestedUnits = requestedUnits;
			PlannedUnits = plannedUnits;
			DestinationX = x;
			DestinationY = y;
			MergeHandle = mergeHandle;
			AdmissionDeadline = deadline;
		}

		public static TransferRefusal TryCreateAt(Guid operationId, Guid sessionNonce, string policyStamp, string ruleStamp, TransferInventorySnapshot source, TransferInventorySnapshot destination, Guid selection, int requestedUnits, int x, int y, Guid? mergeHandle, double now, double admissionDeadline, out DepositPlan? plan)
		{
			plan = null;
			if (operationId == Guid.Empty || sessionNonce == Guid.Empty || requestedUnits < 1 || source == null || destination == null || source.Stamp.InventoryId == destination.Stamp.InventoryId || double.IsNaN(now) || double.IsInfinity(now) || now < 0.0 || double.IsNaN(admissionDeadline) || double.IsInfinity(admissionDeadline) || admissionDeadline <= now)
			{
				return TransferRefusal.Expired;
			}
			TransferCanonical.Text(policyStamp, 2048, empty: false);
			TransferCanonical.Text(ruleStamp, 2048, empty: false);
			TransferStack transferStack = source.Stacks.SingleOrDefault((TransferStack s) => s.Handle == selection);
			if (transferStack == null)
			{
				return TransferRefusal.InventoryChanged;
			}
			if (transferStack.Protected || source.ProtectedCells.Contains(transferStack.Y * source.Width + transferStack.X))
			{
				return TransferRefusal.Protected;
			}
			if (!transferStack.TransferSupported)
			{
				return TransferRefusal.UnsupportedCapability;
			}
			if (x < 0 || y < 0 || x >= destination.Width || y >= destination.Height)
			{
				return TransferRefusal.NoCapacity;
			}
			int value = y * destination.Width + x;
			if (destination.ProtectedCells.Contains(value))
			{
				return TransferRefusal.NoCapacity;
			}
			TransferStack transferStack2 = destination.Stacks.SingleOrDefault((TransferStack s) => s.X == x && s.Y == y);
			int num;
			if (!mergeHandle.HasValue)
			{
				if (transferStack2 != null)
				{
					return TransferRefusal.NoCapacity;
				}
				num = transferStack.MaximumStack;
				goto IL_0218;
			}
			if (transferStack2 != null)
			{
				Guid handle = transferStack2.Handle;
				Guid? guid = mergeHandle;
				if (guid.HasValue && !(handle != guid.GetValueOrDefault()) && !transferStack2.Protected && transferStack2.TransferSupported && transferStack2.MaximumStack == transferStack.MaximumStack && StringComparer.Ordinal.Equals(transferStack.MergeKey, transferStack2.MergeKey))
				{
					num = transferStack2.MaximumStack - transferStack2.Quantity;
					if (num < 1)
					{
						return TransferRefusal.NoCapacity;
					}
					goto IL_0218;
				}
			}
			return TransferRefusal.InventoryChanged;
			IL_0218:
			int num2 = Math.Min(Math.Min(requestedUnits, transferStack.Quantity), num);
			plan = new DepositPlan(operationId, sessionNonce, policyStamp, ruleStamp, source, destination, transferStack, num2, num2, x, y, mergeHandle, admissionDeadline);
			return TransferRefusal.None;
		}
	}
	public readonly struct DirectMoveObservation
	{
		public int Decrease { get; }

		public int Increase { get; }

		public bool OthersUnchanged { get; }

		public bool CellHoldsKey { get; }

		public bool NothingChanged { get; }

		internal DirectMoveObservation(int decrease, int increase, bool others, bool cell, bool nothing)
		{
			Decrease = decrease;
			Increase = increase;
			OthersUnchanged = others;
			CellHoldsKey = cell;
			NothingChanged = nothing;
		}
	}
	public static class MoveVerification
	{
		public static string MergeKey(TransferInventorySnapshot snapshot, Guid handle, TransferItemIdentity identity)
		{
			if (snapshot == null || identity == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			return snapshot.Stacks.FirstOrDefault((TransferStack x) => x.Handle == handle)?.MergeKey ?? identity.Fingerprint;
		}

		public static Dictionary<string, int> Totals(TransferInventorySnapshot snapshot)
		{
			if (snapshot == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			foreach (TransferStack stack in snapshot.Stacks)
			{
				dictionary[stack.MergeKey] = Get(dictionary, stack.MergeKey) + stack.Quantity;
			}
			return dictionary;
		}

		public static int Get(IReadOnlyDictionary<string, int> totals, string key)
		{
			if (!totals.TryGetValue(key, out var value))
			{
				return 0;
			}
			return value;
		}

		public static bool SameExcept(IReadOnlyDictionary<string, int> before, IReadOnlyDictionary<string, int> after, string key)
		{
			foreach (KeyValuePair<string, int> item in before)
			{
				if (item.Key != key && Get(after, item.Key) != item.Value)
				{
					return false;
				}
			}
			foreach (KeyValuePair<string, int> item2 in after)
			{
				if (item2.Key != key && Get(before, item2.Key) != item2.Value)
				{
					return false;
				}
			}
			return true;
		}

		public static DirectMoveObservation Observe(TransferInventorySnapshot sourceBefore, TransferInventorySnapshot destinationBefore, TransferInventorySnapshot sourceAfter, TransferInventorySnapshot destinationAfter, string key, int x, int y)
		{
			if (sourceBefore == null || destinationBefore == null || sourceAfter == null || destinationAfter == null || key == null)
			{
				throw new ArgumentNullException("sourceBefore");
			}
			Dictionary<string, int> dictionary = Totals(sourceBefore);
			Dictionary<string, int> dictionary2 = Totals(sourceAfter);
			Dictionary<string, int> dictionary3 = Totals(destinationBefore);
			Dictionary<string, int> dictionary4 = Totals(destinationAfter);
			TransferStack transferStack = destinationAfter.Stacks.FirstOrDefault((TransferStack s) => s.X == x && s.Y == y);
			return new DirectMoveObservation(Get(dictionary, key) - Get(dictionary2, key), Get(dictionary4, key) - Get(dictionary3, key), SameExcept(dictionary, dictionary2, key) && SameExcept(dictionary3, dictionary4, key), transferStack != null && StringComparer.Ordinal.Equals(transferStack.MergeKey, key), StringComparer.Ordinal.Equals(sourceBefore.ContentFingerprint, sourceAfter.ContentFingerprint) && StringComparer.Ordinal.Equals(destinationBefore.ContentFingerprint, destinationAfter.ContentFingerprint));
		}

		public static (int Source, int Destination, int OtherDestination) Counts(TransferInventorySnapshot source, TransferInventorySnapshot destination, string key)
		{
			if (source == null || destination == null || key == null)
			{
				throw new ArgumentNullException("source");
			}
			Dictionary<string, int> dictionary = Totals(destination);
			return (Source: Get(Totals(source), key), Destination: Get(dictionary, key), OtherDestination: dictionary.Where((KeyValuePair<string, int> x) => x.Key != key).Sum((KeyValuePair<string, int> x) => x.Value));
		}
	}
	public enum MultiUserChestCopy
	{
		None,
		Standalone,
		AzuAutoStore,
		Yavsos
	}
	public static class MultiUserChestCopies
	{
		public const string StandaloneGuid = "com.maxsch.valheim.MultiUserChest";

		public const string AzuGuid = "Azumatt.AzuAutoStore";

		public static readonly string[] Conflicting = new string[3] { "org.bepinex.plugins.valheim.quick_stack", "aedenthorn.SimpleSort", "aedenthorn.QuickStore" };

		public static MultiUserChestCopy Choose(Func<string, bool> loaded)
		{
			if (loaded == null)
			{
				throw new ArgumentNullException("loaded");
			}
			if (loaded("com.maxsch.valheim.MultiUserChest"))
			{
				return MultiUserChestCopy.Standalone;
			}
			if (Conflicting.Any(loaded))
			{
				return MultiUserChestCopy.None;
			}
			if (!loaded("Azumatt.AzuAutoStore"))
			{
				return MultiUserChestCopy.Yavsos;
			}
			return MultiUserChestCopy.AzuAutoStore;
		}
	}
	public sealed class NativeTransferPrefabLimits
	{
		public int MaximumStack { get; }

		public int MaximumQuality { get; }

		public int Variants { get; }

		public NativeTransferPrefabLimits(int maximumStack, int maximumQuality, int variants)
		{
			MaximumStack = maximumStack;
			MaximumQuality = maximumQuality;
			Variants = variants;
		}
	}
	public sealed class NativeTransferRecord
	{
		private readonly byte[] identity;

		public int X { get; }

		public int Y { get; }

		public int Stack { get; }

		internal NativeTransferRecord(int x, int y, int stack, byte[] identity)
		{
			X = x;
			Y = y;
			Stack = stack;
			this.identity = identity;
		}

		public byte[] CopyIdentity()
		{
			return (byte[])identity.Clone();
		}

		public bool SameIdentity(NativeTransferRecord other)
		{
			if (other != null)
			{
				return identity.SequenceEqual(other.identity);
			}
			return false;
		}
	}
	public static class NativeTransferInventoryCodec
	{
		private sealed class Cursor
		{
			private readonly byte[] bytes;

			private int offset;

			private readonly int end;

			internal int Offset => offset;

			internal Cursor(byte[] bytes, int start, int end)
			{
				this.bytes = bytes;
				offset = start;
				this.end = end;
			}

			private void Require(int count)
			{
				if (count < 0 || count > end - offset)
				{
					throw new InvalidDataException("Truncated native inventory.");
				}
			}

			internal byte Byte()
			{
				Require(1);
				return bytes[offset++];
			}

			internal int UShort()
			{
				return Byte() | (Byte() << 8);
			}

			internal int Int()
			{
				return Byte() | (Byte() << 8) | (Byte() << 16) | (Byte() << 24);
			}

			internal long Long()
			{
				return (uint)Int() | ((long)Int() << 32);
			}

			internal int NumItems()
			{
				byte b = Byte();
				if (b < 128)
				{
					return b;
				}
				int num = ((b & 0x7F) << 8) | Byte();
				if (num < 128)
				{
					throw new InvalidDataException("Noncanonical native metadata count.");
				}
				return num;
			}

			internal string? Text(int maximum, bool retain)
			{
				uint num = 0u;
				int num2 = 0;
				while (true)
				{
					byte b = Byte();
					if (num2 == 28 && (b & 0xF8) != 0)
					{
						throw new InvalidDataException("Native text length overflow.");
					}
					num |= (uint)((b & 0x7F) << num2);
					if ((b & 0x80) == 0)
					{
						if (num2 == 0 || b != 0)
						{
							break;
						}
						throw new InvalidDataException("Noncanonical native text length.");
					}
					num2 += 7;
					if (num2 > 28)
					{
						throw new InvalidDataException("Native text length overflow.");
					}
				}
				if (num > maximum)
				{
					throw new InvalidDataException("Native text exceeds bound.");
				}
				Require((int)num);
				try
				{
					Utf8.GetCharCount(bytes, offset, (int)num);
					string result = (retain ? Utf8.GetString(bytes, offset, (int)num) : null);
					offset += (int)num;
					return result;
				}
				catch (DecoderFallbackException)
				{
					throw new InvalidDataException("Malformed native UTF-8.");
				}
			}
		}

		public const int MaximumBytes = 1048576;

		private static readonly UTF8Encoding Utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		public static void Validate(byte[] payload, int width, int height, Func<int, NativeTransferPrefabLimits?> currentPrefab)
		{
			if (payload == null)
			{
				throw new ArgumentNullException("payload");
			}
			if (payload.Length > 1048576)
			{
				throw new InvalidDataException("Unsupported bounded native inventory.");
			}
			ValidateCore(payload, 0, width, height, currentPrefab, requireEnd: true, null);
		}

		public static IReadOnlyList<NativeTransferRecord> Decode(byte[] payload, int width, int height, Func<int, NativeTransferPrefabLimits?> currentPrefab)
		{
			if (payload == null)
			{
				throw new ArgumentNullException("payload");
			}
			if (payload.Length > 1048576)
			{
				throw new InvalidDataException("Unsupported bounded native inventory.");
			}
			List<NativeTransferRecord> list = new List<NativeTransferRecord>();
			ValidateCore(payload, 0, width, height, currentPrefab, requireEnd: true, list);
			return list.AsReadOnly();
		}

		public static int ValidatePrefix(byte[] payload, int offset, int width, int height, Func<int, NativeTransferPrefabLimits?> currentPrefab)
		{
			return ValidateCore(payload, offset, width, height, currentPrefab, requireEnd: false, null);
		}

		private static int ValidateCore(byte[] payload, int start, int width, int height, Func<int, NativeTransferPrefabLimits?> currentPrefab, bool requireEnd, List<NativeTransferRecord>? decoded)
		{
			if (payload == null)
			{
				throw new ArgumentNullException("payload");
			}
			if (currentPrefab == null)
			{
				throw new ArgumentNullException("currentPrefab");
			}
			if (start < 0 || start > payload.Length || width < 1 || height < 1 || width > 256 || height > 256)
			{
				throw new InvalidDataException("Unsupported bounded native inventory.");
			}
			Cursor cursor = new Cursor(payload, start, (int)Math.Min(payload.Length, (long)start + 1048576L));
			if (cursor.Int() != 110)
			{
				throw new InvalidDataException("Unknown native inventory format.");
			}
			int num = cursor.UShort();
			if (num > width * height)
			{
				throw new InvalidDataException("Unsupported native item count.");
			}
			HashSet<int> hashSet = new HashSet<int>();
			List<(int, int, int, int)> list = new List<(int, int, int, int)>(num);
			List<(int, int, int, int, int, int)> list2 = new List<(int, int, int, int, int, int)>(num);
			for (int i = 0; i < num; i++)
			{
				int offset = cursor.Offset;
				int num2 = cursor.Int();
				float num3 = (float)num2 * 0.01f * 100f;
				if (num2 < 0 || (double)num3 > 2147483647.0 || (int)num3 != num2)
				{
					throw new InvalidDataException("Native durability would normalize.");
				}
				byte b = cursor.Byte();
				byte b2 = cursor.Byte();
				cursor.Byte();
				if (b >= width || b2 >= height || !hashSet.Add(b2 * width + b))
				{
					throw new InvalidDataException("Invalid or duplicate native item cell.");
				}
				byte b3 = cursor.Byte();
				int num4 = (((b3 & 4) == 0) ? 1 : cursor.UShort());
				int item = (((b3 & 8) == 0) ? (-1) : cursor.Offset);
				int num5 = (((b3 & 8) == 0) ? 1 : cursor.UShort());
				int num6 = (((b3 & 0x10) != 0) ? cursor.Int() : 0);
				if (num4 < 1 || num5 < 1 || num6 < 0)
				{
					throw new InvalidDataException("Invalid native item scalar.");
				}
				if (((b3 & 4) != 0 && num4 == 1) || ((b3 & 8) != 0 && num5 == 1) || ((b3 & 0x10) != 0 && num6 == 0))
				{
					throw new InvalidDataException("Noncanonical native scalar flags.");
				}
				if ((b3 & 0x20) != 0)
				{
					if (cursor.Long() == 0L)
					{
						throw new InvalidDataException("Noncanonical native crafter flag.");
					}
					cursor.Text(16384, retain: false);
				}
				if ((b3 & 0x40) == 0)
				{
					throw new InvalidDataException("Native item lacks prefab identity.");
				}
				int num7 = cursor.Int();
				if (num7 == 0)
				{
					throw new InvalidDataException("Native item has no registered identity.");
				}
				if ((b3 & 0x80) != 0)
				{
					int num8 = cursor.NumItems();
					if (num8 < 1 || num8 > 2048)
					{
						throw new InvalidDataException("Unsupported native metadata count.");
					}
					HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
					for (int j = 0; j < num8; j++)
					{
						if (!hashSet2.Add(cursor.Text(16384, retain: true)))
						{
							throw new InvalidDataException("Duplicate native metadata key.");
						}
						cursor.Text(65536, retain: false);
					}
				}
				if ((cursor.Byte() & -2) != 0)
				{
					throw new InvalidDataException("Unknown native cheat flags.");
				}
				list.Add((num7, num5, num4, num6));
				list2.Add((offset, cursor.Offset, b, b2, num5, item));
			}
			if (requireEnd && cursor.Offset != payload.Length)
			{
				throw new InvalidDataException("Trailing native inventory data.");
			}
			foreach (var item2 in list)
			{
				NativeTransferPrefabLimits nativeTransferPrefabLimits = currentPrefab(item2.Item1);
				if (nativeTransferPrefabLimits == null || nativeTransferPrefabLimits.MaximumStack < 1 || nativeTransferPrefabLimits.MaximumStack > 65535 || nativeTransferPrefabLimits.MaximumQuality < 1 || nativeTransferPrefabLimits.MaximumQuality > 65535 || nativeTransferPrefabLimits.Variants < 0 || item2.Item2 > nativeTransferPrefabLimits.MaximumStack || item2.Item3 > nativeTransferPrefabLimits.MaximumQuality || (item2.Item4 != 0 && item2.Item4 >= nativeTransferPrefabLimits.Variants))
				{
					throw new InvalidDataException("Native item is not supported by its current registered prefab.");
				}
			}
			if (decoded != null)
			{
				foreach (var item3 in list2)
				{
					List<byte> list3 = new List<byte>(item3.Item2 - item3.Item1);
					var (k, _, _, _, _, _) = item3;
					for (; k < item3.Item2; k++)
					{
						int num9 = k - item3.Item1;
						if (num9 != 4 && num9 != 5 && (item3.Item6 < 0 || (k != item3.Item6 && k != item3.Item6 + 1)))
						{
							list3.Add((num9 == 7) ? ((byte)(payload[k] & -9)) : payload[k]);
						}
					}
					decoded.Add(new NativeTransferRecord(item3.Item3, item3.Item4, item3.Item5, list3.ToArray()));
				}
			}
			return cursor.Offset - start;
		}
	}
	public enum PlacementOutcome
	{
		Goes,
		NoRoom,
		Blocked,
		NoChest,
		Stays,
		Kept,
		NotReady,
		OptedOut,
		Skipped
	}
	public enum ChestVerdict
	{
		Chosen,
		Backup,
		Full,
		Current,
		NotBetter,
		RuleRejects,
		Never,
		NoRule,
		RuleUnreadable,
		RuleCleared,
		OtherOwnerNoMuc,
		OtherOwnerFormatUnknown,
		BothRemote,
		AzuExcluded,
		CategoriesPending,
		OutOfRange,
		OverLimit,
		NotConsidered
	}
	public sealed class ChestExplanation
	{
		public string ChestId { get; }

		public ChestVerdict Verdict { get; }

		public string Text { get; }

		public RankedDestination? Rank { get; }

		internal ChestExplanation(string id, ChestVerdict verdict, string text, RankedDestination? rank)
		{
			ChestId = id;
			Verdict = verdict;
			Text = text;
			Rank = rank;
		}
	}
	public sealed class PlacementExplanation
	{
		public string Prefab { get; }

		public PlacementOutcome Outcome { get; }

		public string? ChosenId { get; }

		public CleanupReason? Blocked { get; }

		public string Summary { get; }

		public IReadOnlyList<ChestExplanation> Chests { get; }

		internal PlacementExplanation(string prefab, PlacementOutcome outcome, string? chosen, CleanupReason? blocked, string summary, List<ChestExplanation> chests)
		{
			Prefab = prefab;
			Outcome = outcome;
			ChosenId = chosen;
			Blocked = blocked;
			Summary = summary;
			Chests = chests.AsReadOnly();
		}

		public ChestExplanation? For(string chestId)
		{
			return Chests.FirstOrDefault((ChestExplanation x) => StringComparer.Ordinal.Equals(x.ChestId, chestId));
		}
	}
	public static class PlacementExplainer
	{
		private sealed class Names
		{
			private readonly ClassificationTaxonomy taxonomy;

			private readonly Func<string, string>? chest;

			private readonly Func<string, string>? item;

			private readonly Func<string, string, string>? open;

			internal Names(ClassificationTaxonomy taxonomy, Func<string, string>? chest, Func<string, string>? item, Func<string, string, string>? open)
			{
				this.taxonomy = taxonomy;
				this.chest = chest;
				this.item = item;
				this.open = open;
			}

			internal string Chest(string id)
			{
				return Bounded(chest?.Invoke(id), id);
			}

			internal string Item(string prefab)
			{
				return Bounded(item?.Invoke(prefab), prefab);
			}

			internal string Category(string id)
			{
				if (!taxonomy.Categories.TryGetValue(id, out ClassificationCategory value))
				{
					return id;
				}
				return value.Name;
			}

			internal static string Value(string dimension, string value, Func<string, string, string>? open)
			{
				if (!(value != "unknown") || ClassificationFilters.Values(dimension) != null || open == null)
				{
					return RuleText.ValueName(dimension, value);
				}
				return open(dimension, value);
			}

			internal static string Dimension(string id)
			{
				return id switch
				{
					"mod" => "origin mod", 
					"related-mod" => "related mod", 
					"construction-mod" => "building mod", 
					"food-stat" => "food stat", 
					"eaten-by" => "eaten by", 
					_ => id, 
				};
			}

			private static string Bounded(string? text, string fallback)
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					return fallback;
				}
				if (text.Length > 64)
				{
					return text.Substring(0, 63) + "…";
				}
				return text;
			}

			internal string Why(RankedDestination rank, ClassificationResult item, FacetEvidence[] facets)
			{
				ChestRules rules = rank.Candidate.Rules;
				string text;
				if (rank.ExistingItemFallback)
				{
					text = "already holds this item";
				}
				else if (rank.Match == AcceptanceMatch.ExactItem)
				{
					text = "lists it under Always";
				}
				else
				{
					ClassificationFilterRule classificationFilterRule = rank.Rule ?? rules.Acceptance.Rules.FirstOrDefault(delegate(ClassificationFilterRule x)
					{
						bool flag = x.Categories.Count == 0 && ClassificationFilters.MatchesValidated(item, x, facets);
						if (!flag)
						{
							AcceptanceMatch match = rank.Match;
							bool flag2 = (uint)(match - 3) <= 1u;
							flag = flag2 && x.Categories.Count != 0 && ClassificationFilters.MatchesValidated(item, x, facets);
						}
						return flag;
					});
					string text2 = rank.Category ?? classificationFilterRule?.Categories.FirstOrDefault((string c) => item.Memberships.Any((MembershipEvidence m) => m.Category == c));
					text = ((text2 != null) ? ("category " + Category(text2)) : ((rank.Match == AcceptanceMatch.Any) ? "takes anything" : "its filters"));
					string text3 = ((classificationFilterRule == null) ? "" : RuleText.Short(classificationFilterRule.Filters, open));
					if (text3.Length != 0)
					{
						text = text + ((text2 != null) ? " › " : " ") + text3;
					}
					if (rank.Generality > 0)
					{
						text = text + ", " + rank.Generality + " level" + ((rank.Generality == 1) ? "" : "s") + " above the item's own category";
					}
				}
				if (rules.Priority != 0)
				{
					text = text + ", " + ChestPriority.Short(rules.Priority);
				}
				if (rules.Overflow)
				{
					text += ", overflow";
				}
				return text;
			}
		}

		public static PlacementExplanation Stash(StashInput input, Guid handle, ChestRuleEvaluator? evaluator = null, Func<string, string>? chestName = null, Func<string, string>? itemName = null, IEnumerable<string>? outOfRange = null, Func<string, string, string>? openName = null, bool detail = true)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			TransferStack transferStack = input.Player.Stacks.FirstOrDefault((TransferStack x) => x.Handle == handle) ?? throw new ArgumentException("Unknown player stack.", "handle");
			if (evaluator == null)
			{
				evaluator = new ChestRuleEvaluator();
			}
			Names names = new Names(input.Taxonomy, chestName, itemName, openName);
			string prefab = transferStack.Identity.Prefab;
			string text = names.Item(prefab);
			List<ChestExplanation> rows = new List<ChestExplanation>();
			List<StashChest> list = input.Chests.Take(256).ToList();
			(List<(StashChest Chest, DestinationCandidate Candidate)> Ruled, List<StashChest> Unruled) tuple = StashPlanner.Receivers(list, evaluator, input.Taxonomy);
			List<(StashChest, DestinationCandidate)> item = tuple.Ruled;
			List<StashChest> item2 = tuple.Unruled;
			bool flag = input.Only != null && !input.Only.Contains(transferStack.Handle);
			bool flag2 = flag || StashPlanner.Kept(input, transferStack);
			List<StashPlanner.Route> list2 = (flag2 ? new List<StashPlanner.Route>() : StashPlanner.Routes(input, evaluator, item, item2, transferStack));
			if (!input.Answers.CategoriesReady && list2.Count == 0 && !flag2)
			{
				rows.AddRange(input.Chests.Select((StashChest x) => new ChestExplanation(x.Id, ChestVerdict.CategoriesPending, "categories not ready yet", null)));
				return Done(PlacementOutcome.NotReady, text + " stays: categories are not ready yet, try again shortly");
			}
			ClassificationResult resolved = input.Answers.Resolve(prefab);
			IReadOnlyList<FacetEvidence> readOnlyList = input.InstanceFacets?.Invoke(transferStack);
			FacetEvidence[] facets = ((resolved == null) ? null : ClassificationFilters.InstanceFacets(resolved, readOnlyList));
			StashPlanner.Route route = null;
			HashSet<StashPlanner.Route> hashSet = new HashSet<StashPlanner.Route>();
			CleanupReason? cleanupReason = null;
			PlacementOutcome placementOutcome;
			string summary;
			if (flag2)
			{
				placementOutcome = PlacementOutcome.Kept;
				summary = text + " stays: " + (flag ? "not selected" : "protected (equipped, quest item, hotbar or quick slot)");
			}
			else if (list2.Count == 0)
			{
				placementOutcome = PlacementOutcome.NoChest;
				summary = text + " stays: no chest in range takes it";
			}
			else if (!transferStack.TransferSupported)
			{
				placementOutcome = PlacementOutcome.Kept;
				summary = text + " stays: " + CleanupReport.Describe(CleanupReason.Unsupported);
			}
			else if (input.Held.Contains(transferStack.Handle))
			{
				placementOutcome = PlacementOutcome.Kept;
				summary = text + " stays: " + CleanupReport.Describe(CleanupReason.Held);
			}
			else
			{
				foreach (StashPlanner.Route item3 in list2)
				{
					if (item3.Blocked.HasValue)
					{
						CleanupReason? cleanupReason2 = cleanupReason;
						if (!cleanupReason2.HasValue)
						{
							cleanupReason = item3.Blocked;
						}
						continue;
					}
					if (Room(item3.Chest.Inventory, transferStack))
					{
						route = item3;
						break;
					}
					hashSet.Add(item3);
				}
				if (route != null)
				{
					placementOutcome = PlacementOutcome.Goes;
					summary = text + " → " + names.Chest(route.Chest.Id) + ": " + Why(route);
					cleanupReason = null;
				}
				else if (cleanupReason.HasValue)
				{
					placementOutcome = PlacementOutcome.Blocked;
					summary = text + " stays: " + CleanupReport.Describe(cleanupReason.Value);
				}
				else
				{
					placementOutcome = PlacementOutcome.NoRoom;
					summary = text + " stays: the chests that take it are full";
				}
			}
			IEnumerable<StashChest> enumerable;
			if (!detail)
			{
				enumerable = Enumerable.Empty<StashChest>();
			}
			else
			{
				IEnumerable<StashChest> chests = input.Chests;
				enumerable = chests;
			}
			foreach (StashChest chest in enumerable)
			{
				if (!list.Contains(chest))
				{
					rows.Add(new ChestExplanation(chest.Id, ChestVerdict.OverLimit, "beyond this run's chest limit", null));
					continue;
				}
				StashPlanner.Route route2 = list2.FirstOrDefault((StashPlanner.Route x) => x.Chest == chest);
				if (route2 != null)
				{
					rows.Add((placementOutcome == PlacementOutcome.Kept) ? new ChestExplanation(chest.Id, ChestVerdict.NotConsidered, Why(route2) + "; but the item stays", route2.Ranked) : Routed(chest.Id, route2.Blocked, route2 == route, route != null && !hashSet.Contains(route2), Why(route2), route2.Ranked));
				}
				else if (flag2)
				{
					rows.Add(new ChestExplanation(chest.Id, ChestVerdict.NotConsidered, "not considered", null));
				}
				else if (evaluator.Unruled(chest.RulePayload, input.Taxonomy))
				{
					rows.Add(new ChestExplanation(chest.Id, ChestVerdict.NoRule, "no rule, and it holds no " + text, null));
				}
				else
				{
					rows.Add(Refusal(chest.Id, chest.RulePayload, prefab, resolved, input.Taxonomy, input.Answers, evaluator, readOnlyList, openName));
				}
			}
			return Done(placementOutcome, summary, route?.Chest.Id, cleanupReason);
			PlacementExplanation Done(PlacementOutcome outcome, string summary2, string? chosen = null, CleanupReason? blocked = null)
			{
				if (!detail)
				{
					rows.Clear();
				}
				else
				{
					foreach (string item4 in outOfRange ?? Array.Empty<string>())
					{
						rows.Add(new ChestExplanation(item4, ChestVerdict.OutOfRange, "out of range", null));
					}
				}
				return new PlacementExplanation(prefab, outcome, chosen, blocked, summary2, rows);
			}
			string Why(StashPlanner.Route route3)
			{
				if (route3.Tier != StashTier.Holder)
				{
					return names.Why(route3.Ranked, resolved, facets);
				}
				return "no rule, already holds this item";
			}
		}

		public static PlacementExplanation Cleanup(CleanupInput input, string sourceId, Guid handle, ChestRuleEvaluator? evaluator = null, Func<string, string>? chestName = null, Func<string, string>? itemName = null, IEnumerable<string>? outOfRange = null, Func<string, string, string>? openName = null, bool detail = true)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			CleanupChest source = input.Chests.FirstOrDefault((CleanupChest x) => StringComparer.Ordinal.Equals(x.Id, sourceId)) ?? throw new ArgumentException("Unknown source chest.", "sourceId");
			TransferStack transferStack = source.Inventory.Stacks.FirstOrDefault((TransferStack x) => x.Handle == handle) ?? throw new ArgumentException("Unknown source stack.", "handle");
			if (evaluator == null)
			{
				evaluator = new ChestRuleEvaluator();
			}
			Names names = new Names(input.Taxonomy, chestName, itemName, openName);
			string prefab = transferStack.Identity.Prefab;
			string text = names.Item(prefab);
			List<ChestExplanation> rows = new List<ChestExplanation>();
			if (!input.Answers.CategoriesReady)
			{
				Rest(ChestVerdict.CategoriesPending, "categories not ready yet");
				return Done(PlacementOutcome.NotReady, text + " stays: categories are not ready yet, try again shortly");
			}
			if (source.OptOut)
			{
				Rest(ChestVerdict.NotConsidered, "not considered");
				return Done(PlacementOutcome.OptedOut, text + " stays: its chest is set to \"Don't clean up\"");
			}
			List<CleanupChest> list = CleanupPlanner.Considered(input.Chests);
			if (!list.Contains(source) || !CleanupPlanner.Sources(list).Contains(source.Id))
			{
				Rest(ChestVerdict.NotConsidered, "not considered");
				return Done(PlacementOutcome.Skipped, text + " stays: " + CleanupReport.Describe(CleanupReason.ChestLimit));
			}
			List<(CleanupChest, DestinationCandidate)> ruled = CleanupPlanner.Receivers(list, evaluator, input.Taxonomy);
			CleanupPlanner.Assessment assessment = CleanupPlanner.Assess(input, evaluator, ruled, source, transferStack);
			ClassificationResult item = assessment.Item;
			FacetEvidence[] facets = ((item == null) ? null : ClassificationFilters.InstanceFacets(item, input.InstanceFacets?.Invoke(transferStack)));
			List<CleanupPlanner.Destination> list2 = assessment.Destinations.Where((CleanupPlanner.Destination x) => x.Gate == CleanupGate.Usable).ToList();
			CleanupPlanner.Destination destination = assessment.Destinations.FirstOrDefault((CleanupPlanner.Destination x) => x.Gate == CleanupGate.Blocked);
			CleanupPlanner.Destination destination2 = null;
			HashSet<CleanupPlanner.Destination> hashSet = new HashSet<CleanupPlanner.Destination>();
			CleanupReason? blocked = null;
			bool flag = true;
			string text2 = names.Chest(source.Id);
			PlacementOutcome placementOutcome;
			string summary;
			if (!assessment.Kind.HasValue)
			{
				placementOutcome = PlacementOutcome.Stays;
				summary = text + " stays: the rule of " + text2 + " can't be read by this version";
				flag = false;
			}
			else if (item == null && assessment.Destinations.Count == 0 && !assessment.Stays)
			{
				placementOutcome = ((assessment.Kind == CleanupKind.Rejected) ? PlacementOutcome.NoChest : PlacementOutcome.Stays);
				summary = text + " stays: it has no categories, so no rule but an exact one takes it";
				flag = false;
			}
			else if (assessment.Stays)
			{
				placementOutcome = PlacementOutcome.Stays;
				flag = false;
				summary = text + " stays in " + text2 + ": its rule takes it";
			}
			else if (list2.Count == 0)
			{
				if (assessment.Kind == CleanupKind.Resort)
				{
					placementOutcome = PlacementOutcome.Stays;
					summary = text + " stays in " + text2 + ": no better chest takes it";
				}
				else if (destination != null)
				{
					placementOutcome = PlacementOutcome.Blocked;
					blocked = destination.Blocked;
					summary = text + " stays: " + CleanupReport.Describe(blocked.Value);
				}
				else
				{
					placementOutcome = PlacementOutcome.NoChest;
					summary = text + " stays: no chest in range takes it";
				}
			}
			else if (transferStack.Protected || !transferStack.TransferSupported || source.Inventory.ProtectedCells.Contains(transferStack.Y * source.Inventory.Width + transferStack.X))
			{
				placementOutcome = PlacementOutcome.Kept;
				summary = text + " stays: " + CleanupReport.Describe(CleanupReason.Unsupported);
			}
			else if (input.Held.Contains(transferStack.Handle))
			{
				placementOutcome = PlacementOutcome.Kept;
				summary = text + " stays: " + CleanupReport.Describe(CleanupReason.Held);
			}
			else
			{
				foreach (CleanupPlanner.Destination item2 in list2)
				{
					if (Room(item2.Chest.Inventory, transferStack))
					{
						destination2 = item2;
						break;
					}
					hashSet.Add(item2);
				}
				if (destination2 != null)
				{
					placementOutcome = PlacementOutcome.Goes;
					summary = text + " → " + names.Chest(destination2.Chest.Id) + ": " + names.Why(destination2.Ranked, item, facets);
				}
				else if (assessment.Kind == CleanupKind.Resort)
				{
					placementOutcome = PlacementOutcome.Stays;
					summary = text + " stays in " + text2 + ": the better chests are full";
				}
				else
				{
					placementOutcome = PlacementOutcome.NoRoom;
					summary = text + " stays: the chests that take it are full";
				}
			}
			IEnumerable<CleanupChest> enumerable;
			if (!detail)
			{
				enumerable = Enumerable.Empty<CleanupChest>();
			}
			else
			{
				IEnumerable<CleanupChest> chests = input.Chests;
				enumerable = chests;
			}
			foreach (CleanupChest chest in enumerable)
			{
				if (chest == source)
				{
					string text3;
					switch (assessment.Kind)
					{
					case CleanupKind.Rejected:
						text3 = "where it is; its rule doesn't take it";
						break;
					case CleanupKind.Unruled:
						text3 = "where it is; no rule";
						break;
					case CleanupKind.Resort:
						if (assessment.Current != null)
						{
							text3 = "where it is; " + names.Why(assessment.Current, item, facets);
							break;
						}
						goto default;
					default:
						text3 = "where it is";
						break;
					}
					string text4 = text3;
					rows.Add(new ChestExplanation(chest.Id, ChestVerdict.Current, text4, assessment.Current));
				}
				else if (!list.Contains(chest))
				{
					rows.Add(new ChestExplanation(chest.Id, ChestVerdict.OverLimit, "beyond this run's chest limit", null));
				}
				else
				{
					CleanupPlanner.Destination destination3 = assessment.Destinations.FirstOrDefault((CleanupPlanner.Destination x) => x.Chest == chest);
					if (destination3 != null)
					{
						string text5 = names.Why(destination3.Ranked, item, facets);
						List<ChestExplanation> list3 = rows;
						list3.Add(destination3.Gate switch
						{
							CleanupGate.NotBetter => new ChestExplanation(chest.Id, ChestVerdict.NotBetter, text5 + "; no better than " + text2, destination3.Ranked), 
							CleanupGate.RuleMismatch => new ChestExplanation(chest.Id, ChestVerdict.RuleRejects, "its rule doesn't take it", destination3.Ranked), 
							CleanupGate.Blocked => Routed(chest.Id, destination3.Blocked, chosen: false, backup: false, text5, destination3.Ranked), 
							_ => (placementOutcome == PlacementOutcome.Kept) ? new ChestExplanation(chest.Id, ChestVerdict.NotConsidered, text5 + "; but the item stays", destination3.Ranked) : Routed(chest.Id, null, destination3 == destination2, destination2 != null && !hashSet.Contains(destination3), text5, destination3.Ranked), 
						});
					}
					else if (!flag)
					{
						rows.Add(new ChestExplanation(chest.Id, ChestVerdict.NotConsidered, "not considered", null));
					}
					else if (evaluator.Unruled(chest.RulePayload, input.Taxonomy))
					{
						rows.Add(new ChestExplanation(chest.Id, ChestVerdict.NoRule, "no rule; cleanup only fills ruled chests", null));
					}
					else
					{
						rows.Add(Refusal(chest.Id, chest.RulePayload, prefab, item, input.Taxonomy, input.Answers, evaluator, input.InstanceFacets?.Invoke(transferStack), openName));
					}
				}
			}
			return Done(placementOutcome, summary, destination2?.Chest.Id, blocked);
			PlacementExplanation Done(PlacementOutcome outcome, string summary2, string? chosen = null, CleanupReason? blocked2 = null)
			{
				if (!detail)
				{
					rows.Clear();
				}
				else
				{
					foreach (string item3 in outOfRange ?? Array.Empty<string>())
					{
						rows.Add(new ChestExplanation(item3, ChestVerdict.OutOfRange, "out of range", null));
					}
				}
				return new PlacementExplanation(prefab, outcome, chosen, blocked2, summary2, rows);
			}
			void Rest(ChestVerdict verdict, string text6)
			{
				foreach (CleanupChest chest2 in input.Chests)
				{
					rows.Add(new ChestExplanation(chest2.Id, (chest2 == source) ? ChestVerdict.Current : verdict, (chest2 == source) ? "where it is" : text6, null));
				}
			}
		}

		private static ChestExplanation Routed(string id, CleanupReason? blocked, bool chosen, bool backup, string why, RankedDestination? rank)
		{
			if (blocked.HasValue)
			{
				return new ChestExplanation(id, blocked switch
				{
					CleanupReason.OtherOwnerNoMuc => ChestVerdict.OtherOwnerNoMuc, 
					CleanupReason.OtherOwnerFormatUnknown => ChestVerdict.OtherOwnerFormatUnknown, 
					CleanupReason.BothRemote => ChestVerdict.BothRemote, 
					CleanupReason.AzuExcluded => ChestVerdict.AzuExcluded, 
					_ => ChestVerdict.RuleRejects, 
				}, why + "; but " + CleanupReport.Describe(blocked.Value), rank);
			}
			if (chosen)
			{
				return new ChestExplanation(id, ChestVerdict.Chosen, why, rank);
			}
			if (!backup)
			{
				return new ChestExplanation(id, ChestVerdict.Full, why + "; no room", rank);
			}
			return new ChestExplanation(id, ChestVerdict.Backup, why + "; ranked lower", rank);
		}

		private static ChestExplanation Refusal(string id, string payload, string prefab, ClassificationResult? item, ClassificationTaxonomy taxonomy, ICategoryAnswers answers, ChestRuleEvaluator evaluator, IReadOnlyList<FacetEvidence>? facets, Func<string, string, string>? openName)
		{
			ContainerPolicyRead containerPolicyRead = evaluator.Read(payload, taxonomy);
			if (containerPolicyRead.State == ContainerPolicyReadState.Unsupported)
			{
				return new ChestExplanation(id, ChestVerdict.RuleUnreadable, "its rule can't be read by this version", null);
			}
			if (containerPolicyRead.Rules == null || containerPolicyRead.Rules.State == ChestRuleState.Unconfigured)
			{
				return new ChestExplanation(id, ChestVerdict.RuleCleared, "its rule was cleared", null);
			}
			if (containerPolicyRead.Rules.Excludes.Contains<string>(prefab, StringComparer.Ordinal))
			{
				return new ChestExplanation(id, ChestVerdict.Never, "lists it under Never", null);
			}
			if (!answers.CategoriesReady && containerPolicyRead.Rules.Acceptance.Rules.Count != 0)
			{
				return new ChestExplanation(id, ChestVerdict.CategoriesPending, "categories not ready yet", null);
			}
			if (item == null)
			{
				return new ChestExplanation(id, ChestVerdict.RuleRejects, "this item has no categories", null);
			}
			if (evaluator.Evaluate(payload, prefab, taxonomy, answers, facets) != ChestRuleDecision.Accept)
			{
				return new ChestExplanation(id, ChestVerdict.RuleRejects, Missed(containerPolicyRead.Rules, item, ClassificationFilters.InstanceFacets(item, facets), taxonomy, openName), null);
			}
			return new ChestExplanation(id, ChestVerdict.RuleRejects, "its rule takes it, but routing ranked it out", null);
		}

		private static string Missed(ChestRules rules, ClassificationResult item, FacetEvidence[] facets, ClassificationTaxonomy taxonomy, Func<string, string, string>? openName)
		{
			foreach (ClassificationFilterRule rule in rules.Acceptance.Rules)
			{
				if (rule.Categories.Count != 0 && !item.Memberships.Any((MembershipEvidence x) => rule.Categories.Contains<string>(x.Category, StringComparer.Ordinal)))
				{
					continue;
				}
				foreach (KeyValuePair<string, IReadOnlyList<string>> filter in rule.Filters.Where<KeyValuePair<string, IReadOn