using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.CodeAnalysis;
using SmartContainerRouting.Core.Model;
using SmartContainerRouting.Core.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("jonasd")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.3.0")]
[assembly: AssemblyInformationalVersion("0.2.3+7859651d1575cac84e5a82ef3b2ffa36c1170ea5")]
[assembly: AssemblyProduct("Storage Groups")]
[assembly: AssemblyTitle("StorageGroups.Core")]
[assembly: AssemblyVersion("0.2.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 SmartContainerRouting.Core
{
	public static class CoreInfo
	{
		public static string Version => "0.2.3";
	}
}
namespace SmartContainerRouting.Core.Versioning
{
	public sealed class PeerVersionTracker
	{
		private sealed class Peer
		{
			public string Name { get; set; }

			public float FirstSeen { get; }

			public float LastSeen { get; set; }

			public bool Connected { get; set; }

			public string? Version { get; set; }

			public bool SentUnannouncedTraffic { get; set; }

			public float? SpawnedAt { get; set; }

			public Peer(string name, float firstSeen)
			{
				Name = name;
				FirstSeen = firstSeen;
				LastSeen = firstSeen;
			}

			public bool IsConfirmedOutdated(string serverVersion)
			{
				if (Version != null)
				{
					if (IsCompatible(Version, serverVersion))
					{
						return IsOlderThan(Version, "0.2.3");
					}
					return true;
				}
				return SentUnannouncedTraffic;
			}
		}

		public const float ForgetSeconds = 20f;

		public const float MissingModGraceSeconds = 30f;

		public const string MinimumSafeVersion = "0.2.3";

		private readonly string _serverVersion;

		private readonly Dictionary<long, Peer> _peers = new Dictionary<long, Peer>();

		public IReadOnlyCollection<long> PeerIds => (IReadOnlyCollection<long>)(object)_peers.Keys.ToArray();

		public PeerVersionTracker(string serverVersion)
		{
			_serverVersion = serverVersion;
		}

		public static bool IsOlderThan(string? version, string minimum)
		{
			int[] array = Parse(version);
			int[] array2 = Parse(minimum);
			if (array == null || array2 == null)
			{
				return true;
			}
			for (int i = 0; i < 3; i++)
			{
				if (array[i] != array2[i])
				{
					return array[i] < array2[i];
				}
			}
			return false;
			static int[]? Parse(string? text)
			{
				string[] array3 = ((text != null) ? text.Split('-', '+')[0].Split(new char[1] { '.' }) : null);
				if (array3 == null || array3.Length < 2)
				{
					return null;
				}
				int[] array4 = new int[3];
				for (int j = 0; j < 3; j++)
				{
					if (j < array3.Length && !int.TryParse(array3[j], out array4[j]))
					{
						return null;
					}
				}
				return array4;
			}
		}

		public static bool IsCompatible(string? a, string? b)
		{
			(int, int)? tuple = MajorMinor(a);
			if (tuple.HasValue)
			{
				(int, int) valueOrDefault = tuple.GetValueOrDefault();
				tuple = MajorMinor(b);
				if (tuple.HasValue)
				{
					(int, int) valueOrDefault2 = tuple.GetValueOrDefault();
					(int, int) tuple2 = valueOrDefault;
					(int, int) tuple3 = valueOrDefault2;
					if (tuple2.Item1 == tuple3.Item1)
					{
						return tuple2.Item2 == tuple3.Item2;
					}
					return false;
				}
			}
			return false;
		}

		public void SyncConnected(IEnumerable<(long PeerId, string Name)> connected, float now)
		{
			(long, string)[] array = connected.ToArray();
			HashSet<long> hashSet = new HashSet<long>(array.Select(((long PeerId, string Name) peer) => peer.PeerId));
			KeyValuePair<long, Peer>[] array2 = _peers.ToArray();
			for (int num = 0; num < array2.Length; num++)
			{
				KeyValuePair<long, Peer> keyValuePair = array2[num];
				keyValuePair.Value.Connected = hashSet.Contains(keyValuePair.Key);
				if (!keyValuePair.Value.Connected && now - keyValuePair.Value.LastSeen >= 20f)
				{
					_peers.Remove(keyValuePair.Key);
				}
			}
			(long, string)[] array3 = array;
			for (int num = 0; num < array3.Length; num++)
			{
				var (key, name) = array3[num];
				if (!_peers.TryGetValue(key, out Peer value))
				{
					value = new Peer(name, now);
					_peers[key] = value;
				}
				value.Name = name;
				value.Connected = true;
				value.LastSeen = now;
			}
		}

		public void Announced(long peerId, string version, float now)
		{
			if (!_peers.TryGetValue(peerId, out Peer value))
			{
				value = new Peer(string.Empty, now);
				_peers[peerId] = value;
			}
			value.Version = version;
			value.LastSeen = now;
		}

		public void SawUnannouncedModTraffic(long peerId, float now)
		{
			if (!_peers.TryGetValue(peerId, out Peer value))
			{
				value = new Peer(string.Empty, now);
				_peers[peerId] = value;
			}
			value.SentUnannouncedTraffic = true;
			value.LastSeen = now;
		}

		public void SawSpawned(long peerId, float now)
		{
			if (!_peers.TryGetValue(peerId, out Peer value))
			{
				value = new Peer(string.Empty, now);
				_peers[peerId] = value;
			}
			Peer peer = value;
			float? spawnedAt = peer.SpawnedAt;
			float valueOrDefault = spawnedAt.GetValueOrDefault();
			if (!spawnedAt.HasValue)
			{
				valueOrDefault = now;
				float? spawnedAt2 = valueOrDefault;
				peer.SpawnedAt = spawnedAt2;
			}
		}

		public IReadOnlyList<long> MissingModPastGrace(float now)
		{
			return (from pair in _peers.Where<KeyValuePair<long, Peer>>(delegate(KeyValuePair<long, Peer> pair)
				{
					if (pair.Value.Connected && pair.Value.Version == null && !pair.Value.SentUnannouncedTraffic)
					{
						float? spawnedAt = pair.Value.SpawnedAt;
						if (spawnedAt.HasValue)
						{
							float valueOrDefault = spawnedAt.GetValueOrDefault();
							return now - valueOrDefault >= 30f;
						}
					}
					return false;
				})
				select pair.Key into id
				orderby id
				select id).ToArray();
		}

		public IReadOnlyList<long> RunningTheMod()
		{
			return (from pair in _peers.Where<KeyValuePair<long, Peer>>(delegate(KeyValuePair<long, Peer> pair)
				{
					if (pair.Value.Connected)
					{
						string version = pair.Value.Version;
						if (version != null)
						{
							return !IsOlderThan(version, "0.2.3");
						}
					}
					return false;
				})
				select pair.Key into id
				orderby id
				select id).ToArray();
		}

		public string NameOf(long peerId)
		{
			if (!_peers.TryGetValue(peerId, out Peer value) || value.Name.Length <= 0)
			{
				return "A player";
			}
			return value.Name;
		}

		public IReadOnlyList<string> Outdated()
		{
			return (from pair in ConfirmedOutdated()
				select (pair.Value.Name.Length <= 0) ? "A player" : pair.Value.Name).OrderBy<string, string>((string name) => name, StringComparer.Ordinal).ToArray();
		}

		public IReadOnlyList<long> ConfirmedOutdatedPeerIds()
		{
			return (from pair in ConfirmedOutdated()
				select pair.Key).ToArray();
		}

		private IEnumerable<KeyValuePair<long, Peer>> ConfirmedOutdated()
		{
			return _peers.Where<KeyValuePair<long, Peer>>((KeyValuePair<long, Peer> pair) => pair.Value.Connected && pair.Value.IsConfirmedOutdated(_serverVersion));
		}

		private static (int, int)? MajorMinor(string? version)
		{
			string[] array = version?.Split(new char[1] { '.' });
			if (array == null || array.Length < 2 || !int.TryParse(array[0], out var result) || !int.TryParse(array[1], out var result2))
			{
				return null;
			}
			return (result, result2);
		}
	}
}
namespace SmartContainerRouting.Core.Text
{
	public static class ContainerHoverText
	{
		public static string? BuildExtraLine(ContainerSettings settings, Func<string, string?> groupDisplayName, Func<string, bool>? groupEvictsMismatching = null, bool isWarded = false)
		{
			List<string> list = new List<string>();
			string groupName = settings.GroupName;
			if (groupName != null)
			{
				list.Add("[" + (groupDisplayName(groupName) ?? groupName) + "]");
			}
			string groupName2 = settings.GroupName;
			if (groupName2 != null && (groupEvictsMismatching?.Invoke(groupName2) ?? settings.IsEvicting))
			{
				list.Add("Strict: only group items");
			}
			if (isWarded)
			{
				list.Add("Routes within this ward only");
			}
			if (list.Count != 0)
			{
				return string.Join(" | ", list);
			}
			return null;
		}
	}
	public static class DisplayNameSanitizer
	{
		public const int MaxLength = 32;

		public static string? Sanitize(string? value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return null;
			}
			string text = StripMarkupCharacters(value.Trim());
			if (text.Length == 0)
			{
				return null;
			}
			if (text.Length <= 32)
			{
				return text;
			}
			return text.Substring(0, 32);
		}

		private static string StripMarkupCharacters(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				if (c != '<' && c != '>')
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	public static class GroupButtonHover
	{
		public const int MaxItems = 8;

		public static string Describe(string? groupName, IEnumerable<string> itemNames)
		{
			List<string> list = new List<string> { "Open group settings" };
			if (groupName == null)
			{
				list.Add("No group assigned");
				return string.Join("\n", list);
			}
			list.Add("Items in current group [" + groupName + "]:");
			List<string> list2 = itemNames.Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string name) => name, StringComparer.Ordinal).ToList();
			if (list2.Count == 0)
			{
				list.Add("(none yet, use Add Contents)");
			}
			else
			{
				list.AddRange(list2.Take(8));
				if (list2.Count > 8)
				{
					list.Add($"+{list2.Count - 8} more");
				}
			}
			return string.Join("\n", list);
		}
	}
	public static class GroupNameNormalizer
	{
		public static string? Normalize(string? value)
		{
			return DisplayNameSanitizer.Sanitize(value)?.ToLowerInvariant();
		}
	}
	public static class GroupNameSuggestion
	{
		public static string? Suggest(IEnumerable<KeyValuePair<string, int>> stacks, GroupRegistry registry)
		{
			string text = (from entry in (from @group in (from stack in stacks
						select new KeyValuePair<string, int>(DisplayNameSanitizer.Sanitize(stack.Key), stack.Value) into stack
						where stack.Key != null
						select stack).GroupBy<KeyValuePair<string, int>, string>((KeyValuePair<string, int> stack) => stack.Key, StringComparer.Ordinal)
					select (Name: @group.Key, Total: @group.Sum((KeyValuePair<string, int> stack) => stack.Value)) into entry
					orderby entry.Total descending
					select entry).ThenBy<(string, int), string>(((string Name, int Total) entry) => entry.Name, StringComparer.Ordinal)
				select entry.Name).FirstOrDefault();
			if (text == null || !registry.HasGroup(text))
			{
				return text;
			}
			int num = 2;
			string text3;
			while (true)
			{
				string text2 = " " + num.ToString(CultureInfo.InvariantCulture);
				text3 = text[..Math.Min(text.Length, 32 - text2.Length)].TrimEnd(Array.Empty<char>()) + text2;
				if (!registry.HasGroup(text3))
				{
					break;
				}
				num++;
			}
			return text3;
		}
	}
	public static class RouteSummary
	{
		public sealed class Neighbour
		{
			public ContainerSettings Settings { get; }

			public double Distance { get; }

			public bool HasRoom { get; }

			public bool SameWard { get; }

			public Neighbour(ContainerSettings settings, double distance, bool hasRoom, bool sameWard)
			{
				Settings = settings;
				Distance = distance;
				HasRoom = hasRoom;
				SameWard = sameWard;
			}
		}

		public const int MaxGroupLines = 6;

		public static string Describe(ContainerSettings source, GroupRegistry groups, IEnumerable<Neighbour> neighbours, double range, bool held)
		{
			List<string> list = new List<string>();
			if (held)
			{
				list.Add("Sorting paused");
			}
			list.Add("Routes (" + Meters(range) + ")");
			List<Neighbour> source2 = neighbours.Where((Neighbour n) => n.Distance <= range && n.Settings.GroupName != null && groups.GetGroup(n.Settings.GroupName) != null).ToList();
			List<string> list2 = (from entry in (from @group in source2.GroupBy<Neighbour, string>((Neighbour n) => groups.GetGroup(n.Settings.GroupName).Name, StringComparer.OrdinalIgnoreCase)
					select DescribeGroup(@group.Key, @group.ToList()) into entry
					orderby entry.Distance
					select entry).ThenBy<(double, string), string>(((double Distance, string Text) entry) => entry.Text, StringComparer.Ordinal)
				select entry.Text).ToList();
			if (list2.Count == 0)
			{
				list.Add("No group chests in range");
			}
			else
			{
				list.AddRange(list2.Take(6));
				if (list2.Count > 6)
				{
					list.Add($"+{list2.Count - 6} more");
				}
			}
			IEnumerable<GroupDefinition?> first = source2.Select((Neighbour n) => groups.GetGroup(n.Settings.GroupName));
			string groupName = source.GroupName;
			object second;
			if (groupName != null)
			{
				GroupDefinition groupDefinition = groups.GetGroup(groupName);
				if (groupDefinition != null)
				{
					second = new GroupDefinition[1] { groupDefinition };
					goto IL_019d;
				}
			}
			second = new GroupDefinition[0];
			goto IL_019d;
			IL_019d:
			List<string> list3 = (from @group in first.Concat<GroupDefinition>((IEnumerable<GroupDefinition>)second)
				where @group.EvictMismatching
				select @group.Name).Distinct<string>(StringComparer.OrdinalIgnoreCase).OrderBy<string, string>((string name) => name, StringComparer.Ordinal).ToList();
			if (list3.Count > 0)
			{
				list.Add("Strict: " + string.Join(", ", list3.Select((string name) => "[" + name + "]")));
			}
			return string.Join("\n", list);
		}

		private static (double Distance, string Text) DescribeGroup(string name, IReadOnlyList<Neighbour> chests)
		{
			List<Neighbour> list = chests.Where((Neighbour c) => c.SameWard).ToList();
			if (list.Count == 0)
			{
				double num = chests.Min((Neighbour c) => c.Distance);
				return (Distance: num, Text: "[" + name + "] " + Meters(num) + ", ward edge");
			}
			List<Neighbour> list2 = list.Where((Neighbour c) => c.HasRoom).ToList();
			if (list2.Count <= 0)
			{
				return (Distance: list.Min((Neighbour c) => c.Distance), Text: "[" + name + "] " + Meters(list.Min((Neighbour c) => c.Distance)) + ", full");
			}
			return (Distance: list2.Min((Neighbour c) => c.Distance), Text: "[" + name + "] " + Meters(list2.Min((Neighbour c) => c.Distance)));
		}

		private static string Meters(double meters)
		{
			return Math.Round(meters).ToString(CultureInfo.InvariantCulture) + " m";
		}
	}
	public static class RoutingMessage
	{
		public static string Describe(string itemName, int amount, bool isEviction, string? destinationGroup, double distanceMeters, bool insideWard, bool relayed)
		{
			List<string> list = new List<string> { Math.Round(distanceMeters).ToString(CultureInfo.InvariantCulture) + " m" };
			if (insideWard)
			{
				list.Add("inside ward");
			}
			if (relayed)
			{
				list.Add("via another player");
			}
			string text = ((destinationGroup == null) ? "an ungrouped chest" : ("[" + destinationGroup + "]"));
			return string.Format("{0} {1} {2} to {3} ({4})", isEviction ? "Evicted" : "Routed", amount, itemName, text, string.Join(", ", list));
		}

		public static string Combine(IReadOnlyList<string> lines, int maxLines = 4)
		{
			List<string> list = new List<string>(lines.Take(maxLines));
			if (lines.Count > maxLines)
			{
				list.Add($"and {lines.Count - maxLines} more");
			}
			return string.Join("\n", list);
		}
	}
}
namespace SmartContainerRouting.Core.Routing
{
	public static class ContainerRouter
	{
		public static ContainerRoutingCandidate? SelectRoute(ContainerSettings source, PlacedItem item, IEnumerable<ContainerRoutingCandidate> candidates, GroupRegistry groups, double range)
		{
			if (BuiltInGroups.IsLocked(groups, source.GroupName))
			{
				return null;
			}
			ContainerRoutingCandidate[] array = candidates.Where((ContainerRoutingCandidate candidate) => !BuiltInGroups.IsLocked(groups, candidate.Settings.GroupName)).ToArray();
			if (IsEligibleDestination(source, groups, item.ItemType))
			{
				if (!source.Priority)
				{
					return SelectNearest(item, array.Where((ContainerRoutingCandidate candidate) => candidate.Settings.Priority && IsEligible(candidate.Settings, source.GroupName)), range);
				}
				return null;
			}
			ContainerRoutingCandidate containerRoutingCandidate = SelectDestination(item, array, groups, range);
			if (containerRoutingCandidate != null)
			{
				return containerRoutingCandidate;
			}
			string groupName = source.GroupName;
			if (groupName != null)
			{
				GroupDefinition? groupDefinition = groups.GetGroup(groupName);
				if (groupDefinition != null && groupDefinition.EvictMismatching)
				{
					return SelectNearest(item, array.Where((ContainerRoutingCandidate candidate) => candidate.Settings.GroupName == null), range) ?? SelectNearest(item, array.Where((ContainerRoutingCandidate candidate) => IsKnownNonStrictGroup(candidate.Settings, groups)), range);
				}
			}
			return null;
		}

		public static bool CanAccept(ContainerSettings settings, GroupRegistry groups, string itemType, bool isReturn)
		{
			if (BuiltInGroups.IsLocked(groups, settings.GroupName))
			{
				return false;
			}
			if (!isReturn && settings.GroupName != null && !IsEligibleDestination(settings, groups, itemType))
			{
				return IsKnownNonStrictGroup(settings, groups);
			}
			return true;
		}

		public static ContainerRoutingCandidate? SelectLeftoverHome(PlacedItem item, IEnumerable<ContainerRoutingCandidate> candidates, GroupRegistry groups, double range)
		{
			ContainerRoutingCandidate[] array = candidates.Where((ContainerRoutingCandidate candidate) => !BuiltInGroups.IsLocked(groups, candidate.Settings.GroupName)).ToArray();
			return SelectDestination(item, array, groups, range) ?? SelectNearest(item, array.Where((ContainerRoutingCandidate candidate) => candidate.Settings.GroupName == null), range) ?? SelectNearest(item, array.Where((ContainerRoutingCandidate candidate) => IsKnownNonStrictGroup(candidate.Settings, groups)), range);
		}

		public static bool WouldEvict(ContainerSettings settings, GroupRegistry groups, string itemType)
		{
			string groupName = settings.GroupName;
			if (groupName != null)
			{
				GroupDefinition? groupDefinition = groups.GetGroup(groupName);
				if (groupDefinition != null && groupDefinition.EvictMismatching)
				{
					return !IsEligibleDestination(settings, groups, itemType);
				}
			}
			return false;
		}

		private static bool IsKnownNonStrictGroup(ContainerSettings settings, GroupRegistry groups)
		{
			string groupName = settings.GroupName;
			if (groupName != null)
			{
				GroupDefinition groupDefinition = groups.GetGroup(groupName);
				if (groupDefinition != null && !groupDefinition.EvictMismatching)
				{
					return !BuiltInGroups.IsLocked(groupDefinition);
				}
			}
			return false;
		}

		public static ContainerRoutingCandidate? SelectDestination(PlacedItem item, IEnumerable<ContainerRoutingCandidate> candidates, GroupRegistry groups, double range)
		{
			string groupName = groups.GetGroupForItem(item.ItemType);
			if (groupName == null || BuiltInGroups.IsLocked(groups, groupName))
			{
				return null;
			}
			ContainerRoutingCandidate[] array = candidates.Where((ContainerRoutingCandidate c) => IsEligible(c.Settings, groupName)).ToArray();
			return SelectNearest(item, array.Where((ContainerRoutingCandidate c) => c.Settings.Priority), range) ?? SelectNearest(item, array, range);
		}

		public static bool IsSettled(ContainerSettings settings, GroupRegistry groups, string itemType)
		{
			if (!BuiltInGroups.IsLocked(groups, settings.GroupName))
			{
				if (settings.Priority)
				{
					return IsEligibleDestination(settings, groups, itemType);
				}
				return false;
			}
			return true;
		}

		private static ContainerRoutingCandidate? SelectNearest(PlacedItem item, IEnumerable<ContainerRoutingCandidate> candidates, double range)
		{
			ContainerRoutingCandidate containerRoutingCandidate = null;
			double num = double.PositiveInfinity;
			foreach (ContainerRoutingCandidate candidate in candidates)
			{
				if (candidate.HasCapacityFor(item.ItemType))
				{
					double num2 = item.Position.DistanceTo(candidate.Position);
					if (!(num2 > range) && (num2 < num || (num2 == num && (containerRoutingCandidate == null || string.CompareOrdinal(candidate.Id, containerRoutingCandidate.Id) < 0))))
					{
						num = num2;
						containerRoutingCandidate = candidate;
					}
				}
			}
			return containerRoutingCandidate;
		}

		public static bool IsEligibleDestination(ContainerSettings settings, GroupRegistry groups, string itemType)
		{
			return IsEligible(settings, groups.GetGroupForItem(itemType));
		}

		private static bool IsEligible(ContainerSettings settings, string? groupName)
		{
			if (groupName != null)
			{
				return string.Equals(settings.GroupName, groupName, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}
	}
	public sealed class ContainerRoutingCandidate
	{
		public string Id { get; }

		public Position Position { get; }

		public int FreeCapacity { get; }

		public IReadOnlyDictionary<string, int> PartialStackCapacity { get; }

		public ContainerSettings Settings { get; }

		public ContainerRoutingCandidate(string id, Position position, int freeCapacity, ContainerSettings settings, IReadOnlyDictionary<string, int>? partialStackCapacity = null)
		{
			Id = id;
			Position = position;
			FreeCapacity = freeCapacity;
			Settings = settings;
			PartialStackCapacity = partialStackCapacity ?? new Dictionary<string, int>();
		}

		public bool HasCapacityFor(string itemType)
		{
			if (FreeCapacity <= 0)
			{
				if (PartialStackCapacity.TryGetValue(itemType, out var value))
				{
					return value > 0;
				}
				return false;
			}
			return true;
		}

		public bool HasMoreCapacityThan(ContainerRoutingCandidate previous)
		{
			if (FreeCapacity > previous.FreeCapacity)
			{
				return true;
			}
			foreach (KeyValuePair<string, int> item in PartialStackCapacity)
			{
				if (item.Value > 0 && (!previous.PartialStackCapacity.TryGetValue(item.Key, out var value) || item.Value > value))
				{
					return true;
				}
			}
			return false;
		}
	}
	public sealed class ItemTypeQuantity
	{
		public string ItemType { get; }

		public int Stack { get; }

		public ItemTypeQuantity(string itemType, int stack)
		{
			ItemType = itemType;
			Stack = stack;
		}
	}
	public sealed class LoopWatch
	{
		private const double ForgetEverySeconds = 1.0;

		private const int MaxKeys = 1024;

		private readonly int _threshold;

		private readonly double _window;

		private readonly Dictionary<string, Queue<double>> _events = new Dictionary<string, Queue<double>>();

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

		private double _nextForget = double.MinValue;

		public int TrackedKeys => _events.Count;

		public LoopWatch(int threshold, double windowSeconds)
		{
			_threshold = threshold;
			_window = windowSeconds;
		}

		public bool Record(string key, double now)
		{
			Forget(now);
			if (!_events.TryGetValue(key, out Queue<double> value))
			{
				value = new Queue<double>();
				_events[key] = value;
			}
			value.Enqueue(now);
			while (value.Count > _threshold)
			{
				value.Dequeue();
			}
			if (value.Count < _threshold || now - value.Peek() >= _window || (_reportedAt.TryGetValue(key, out var value2) && now - value2 < _window))
			{
				return false;
			}
			_reportedAt[key] = now;
			return true;
		}

		public bool HasRecent(string key, double now)
		{
			if (_events.TryGetValue(key, out Queue<double> value))
			{
				return value.Any((double time) => now - time < _window);
			}
			return false;
		}

		private void Forget(double now)
		{
			if (now < _nextForget && _events.Count < 1024)
			{
				return;
			}
			_nextForget = now + 1.0;
			if (_events.Count >= 1024)
			{
				_events.Clear();
				_reportedAt.Clear();
				return;
			}
			foreach (Queue<double> value in _events.Values)
			{
				while (value.Count > 0 && now - value.Peek() >= _window)
				{
					value.Dequeue();
				}
			}
			string[] array = (from pair in _events
				where pair.Value.Count == 0
				select pair.Key).ToArray();
			foreach (string key in array)
			{
				_events.Remove(key);
			}
			array = (from pair in _reportedAt
				where now - pair.Value >= _window
				select pair.Key).ToArray();
			foreach (string key2 in array)
			{
				_reportedAt.Remove(key2);
			}
		}
	}
	public static class NewArrivalFilter
	{
		public static Dictionary<string, int> ComputeBudget(IReadOnlyList<ItemTypeQuantity> knownStacks, IReadOnlyList<ItemTypeQuantity> currentStacks)
		{
			Dictionary<string, int> dictionary = SumByType(currentStacks);
			foreach (KeyValuePair<string, int> item in SumByType(knownStacks))
			{
				int value;
				int num = (dictionary.TryGetValue(item.Key, out value) ? value : 0);
				dictionary[item.Key] = num - item.Value;
			}
			return dictionary;
		}

		public static IReadOnlyList<T> SelectWithinBudget<T>(Dictionary<string, int> budgetByType, IReadOnlyList<T> candidates, Func<T, ItemTypeQuantity> toStack)
		{
			List<T> list = new List<T>();
			foreach (T candidate in candidates)
			{
				ItemTypeQuantity itemTypeQuantity = toStack(candidate);
				int value;
				int num = (budgetByType.TryGetValue(itemTypeQuantity.ItemType, out value) ? value : 0);
				if (num >= itemTypeQuantity.Stack)
				{
					list.Add(candidate);
					budgetByType[itemTypeQuantity.ItemType] = num - itemTypeQuantity.Stack;
				}
			}
			return list;
		}

		public static IReadOnlyList<T> SelectGenuinelyNew<T>(IReadOnlyList<ItemTypeQuantity> knownStacks, IReadOnlyList<ItemTypeQuantity> currentStacks, IReadOnlyList<T> candidates, Func<T, ItemTypeQuantity> toStack)
		{
			return SelectWithinBudget(ComputeBudget(knownStacks, currentStacks), candidates, toStack);
		}

		private static Dictionary<string, int> SumByType(IReadOnlyList<ItemTypeQuantity> stacks)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ItemTypeQuantity stack in stacks)
			{
				dictionary[stack.ItemType] = (dictionary.TryGetValue(stack.ItemType, out var value) ? value : 0) + stack.Stack;
			}
			return dictionary;
		}
	}
	public sealed class PlacedItem
	{
		public string ItemType { get; }

		public Position Position { get; }

		public PlacedItem(string itemType, Position position)
		{
			ItemType = itemType;
			Position = position;
		}
	}
	public readonly struct Position : IEquatable<Position>
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public Position(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public double DistanceTo(Position other)
		{
			float num = X - other.X;
			float num2 = Y - other.Y;
			float num3 = Z - other.Z;
			return Math.Sqrt(num * num + num2 * num2 + num3 * num3);
		}

		public bool Equals(Position other)
		{
			if (X.Equals(other.X) && Y.Equals(other.Y))
			{
				return Z.Equals(other.Z);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((17 * 31 + X.GetHashCode()) * 31 + Y.GetHashCode()) * 31 + Z.GetHashCode();
		}
	}
	public sealed class RelayLedger<TPayload>
	{
		public sealed class PendingRequest
		{
			public long RequestId { get; }

			public string DestinationId { get; }

			public TPayload Payload { get; }

			public double SentAt { get; internal set; }

			public int Attempts { get; internal set; }

			internal PendingRequest(long requestId, string destinationId, TPayload payload, double sentAt)
			{
				RequestId = requestId;
				DestinationId = destinationId;
				Payload = payload;
				SentAt = sentAt;
				Attempts = 1;
			}
		}

		public sealed class DueRequests
		{
			public IReadOnlyList<PendingRequest> Resend { get; }

			public IReadOnlyList<PendingRequest> GiveUp { get; }

			internal DueRequests(IReadOnlyList<PendingRequest> resend, IReadOnlyList<PendingRequest> giveUp)
			{
				Resend = resend;
				GiveUp = giveUp;
			}
		}

		private readonly double _resendAfter;

		private readonly int _maxAttempts;

		private readonly double _cooldown;

		private readonly Dictionary<long, PendingRequest> _pending = new Dictionary<long, PendingRequest>();

		private readonly Dictionary<string, double> _cooldownUntil = new Dictionary<string, double>(StringComparer.Ordinal);

		private readonly Random _random = new Random();

		public int PendingCount => _pending.Count;

		public IEnumerable<PendingRequest> Pending => _pending.Values;

		public RelayLedger(double resendAfterSeconds, int maxAttempts, double cooldownSeconds)
		{
			_resendAfter = resendAfterSeconds;
			_maxAttempts = maxAttempts;
			_cooldown = cooldownSeconds;
		}

		public long Start(string destinationId, TPayload payload, double now)
		{
			long num;
			do
			{
				byte[] array = new byte[8];
				_random.NextBytes(array);
				num = BitConverter.ToInt64(array, 0);
			}
			while (num == 0L || _pending.ContainsKey(num));
			_pending[num] = new PendingRequest(num, destinationId, payload, now);
			return num;
		}

		public bool TryComplete(long requestId, out PendingRequest request)
		{
			if (_pending.TryGetValue(requestId, out request))
			{
				_pending.Remove(requestId);
				return true;
			}
			return false;
		}

		public DueRequests Tick(double now)
		{
			List<PendingRequest> list = new List<PendingRequest>();
			List<PendingRequest> list2 = new List<PendingRequest>();
			foreach (PendingRequest value in _pending.Values)
			{
				if (!(now - value.SentAt < _resendAfter))
				{
					if (value.Attempts >= _maxAttempts)
					{
						list2.Add(value);
						continue;
					}
					value.Attempts++;
					value.SentAt = now;
					list.Add(value);
				}
			}
			foreach (PendingRequest item in list2)
			{
				_pending.Remove(item.RequestId);
				MarkRejected(item.DestinationId, now);
			}
			return new DueRequests(list, list2);
		}

		public void MarkRejected(string destinationId, double now)
		{
			_cooldownUntil[destinationId] = now + _cooldown;
		}

		public bool IsCoolingDown(string destinationId, double now)
		{
			if (_cooldownUntil.TryGetValue(destinationId, out var value))
			{
				return now < value;
			}
			return false;
		}
	}
	public sealed class RelayReachability
	{
		private readonly Dictionary<string, long> _unanswered = new Dictionary<string, long>();

		private readonly Dictionary<string, (long Holder, uint State)> _refused = new Dictionary<string, (long, uint)>();

		public int MarkedCount => _unanswered.Keys.Union(_refused.Keys).Count();

		public void MarkUnanswered(string chestId, long holder)
		{
			_unanswered[chestId] = holder;
		}

		public void MarkRefused(string chestId, long holder, uint state)
		{
			_refused[chestId] = (holder, state);
		}

		public bool HasMark(string chestId)
		{
			if (!_unanswered.ContainsKey(chestId))
			{
				return _refused.ContainsKey(chestId);
			}
			return true;
		}

		public bool IsBlocked(string chestId, long currentHolder, uint currentState)
		{
			if (!_unanswered.TryGetValue(chestId, out var value) || value != currentHolder)
			{
				if (_refused.TryGetValue(chestId, out (long, uint) value2) && value2.Item1 == currentHolder)
				{
					return value2.Item2 == currentState;
				}
				return false;
			}
			return true;
		}

		public void PlayersChanged()
		{
			Clear();
		}

		public void GroupsChanged()
		{
			_refused.Clear();
		}

		public void Clear()
		{
			_unanswered.Clear();
			_refused.Clear();
		}
	}
	public static class RelayReceipts
	{
		public const int DefaultCapacity = 64;

		public static bool TryFind(string? stored, long sender, long requestId, out int added)
		{
			foreach (var item in Parse(stored))
			{
				if (item.Sender == sender && item.RequestId == requestId)
				{
					added = item.Added;
					return true;
				}
			}
			added = 0;
			return false;
		}

		public static string Add(string? stored, long sender, long requestId, int added, int capacity = 64)
		{
			List<(long, long, int)> list = Parse(stored).ToList();
			list.Add((sender, requestId, added));
			return string.Join(";", from entry in list.Skip(Math.Max(0, list.Count - capacity))
				select string.Join(":", entry.Sender.ToString(CultureInfo.InvariantCulture), entry.RequestId.ToString(CultureInfo.InvariantCulture), entry.Added.ToString(CultureInfo.InvariantCulture)));
		}

		private static IEnumerable<(long Sender, long RequestId, int Added)> Parse(string? stored)
		{
			if (string.IsNullOrEmpty(stored))
			{
				yield break;
			}
			string[] array = stored.Split(new char[1] { ';' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ':' });
				if (array2.Length == 3 && long.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && long.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
				{
					yield return (Sender: result, RequestId: result2, Added: result3);
				}
			}
		}
	}
	public static class WardWall
	{
		public static bool CanRoute(IEnumerable<string> sourceWardIds, IEnumerable<string> destinationWardIds)
		{
			return new HashSet<string>(sourceWardIds, StringComparer.Ordinal).SetEquals(destinationWardIds);
		}
	}
}
namespace SmartContainerRouting.Core.Persistence
{
	public static class AnchorPlacement
	{
		public const float ParkX = -16300f;

		public const float ParkZ = -16300f;

		private const double ZoneSize = 64.0;

		public static bool NeedsParking(float x, float z)
		{
			if (Zone(x) == Zone(-16300f))
			{
				return Zone(z) != Zone(-16300f);
			}
			return true;
		}

		private static int Zone(float position)
		{
			return (int)Math.Floor(((double)position + 32.0) / 64.0);
		}
	}
	public static class ContainerSettingsCodec
	{
		public static ContainerSettings Decode(Func<string, string> getString, Func<string, bool> getBool, GroupRegistry? groups = null)
		{
			string name = getString("SCR_Name");
			string groupName = GroupReference.Resolve(getString("SCR_GroupId"), getString("SCR_Group"), groups);
			bool evictNonGroupItems = getBool("SCR_EvictNonGroup");
			bool priority = getBool("SCR_Priority");
			return new ContainerSettings(name, groupName, evictNonGroupItems, priority);
		}

		public static void Encode(ContainerSettings settings, Action<string, string> setString, Action<string, bool> setBool, GroupRegistry? groups = null, string? knownGroupId = null, Func<string, string>? getExisting = null)
		{
			string text = GroupReference.IdFor(settings.GroupName, groups);
			if (text.Length == 0 && settings.GroupName != null && !string.IsNullOrEmpty(knownGroupId))
			{
				text = knownGroupId;
			}
			if (text.Length == 0 && groups == null && settings.GroupName != null && getExisting != null && GroupNameNormalizer.Normalize(getExisting("SCR_Group")) == settings.GroupName)
			{
				text = getExisting("SCR_GroupId") ?? string.Empty;
			}
			setString("SCR_Name", settings.Name ?? string.Empty);
			setString("SCR_Group", settings.GroupName ?? string.Empty);
			setString("SCR_GroupId", text);
			setBool("SCR_EvictNonGroup", settings.EvictNonGroupItems);
			setBool("SCR_Priority", settings.Priority);
		}
	}
	public sealed class GroupRegistryCache
	{
		private readonly Func<string?, GroupRegistry> _decode;

		private bool _hasValue;

		private string? _source;

		private GroupRegistry _registry = GroupRegistry.Empty;

		public GroupRegistryCache(Func<string?, GroupRegistry> decode)
		{
			_decode = decode ?? throw new ArgumentNullException("decode");
		}

		public GroupRegistry Get(string? source)
		{
			if (!_hasValue || !string.Equals(_source, source, StringComparison.Ordinal))
			{
				_source = source;
				_registry = _decode(source);
				_hasValue = true;
			}
			return _registry;
		}

		public void Set(string? source, GroupRegistry registry)
		{
			_source = source;
			_registry = registry;
			_hasValue = true;
		}

		public bool TryGet(string? source, out GroupRegistry registry)
		{
			if (source == null)
			{
				registry = GroupRegistry.Empty;
				return false;
			}
			registry = Get(source);
			return true;
		}
	}
	public static class GroupRegistryCodec
	{
		private sealed class GroupDto
		{
			public string? Id { get; set; }

			public string? Name { get; set; } = string.Empty;

			public long CreatorId { get; set; }

			public bool EvictMismatching { get; set; }

			public List<string?>? ItemTypes { get; set; } = new List<string>();
		}

		public static string Serialize(GroupRegistry registry)
		{
			StringBuilder stringBuilder = new StringBuilder("[");
			bool flag = true;
			foreach (GroupDefinition item in registry.Groups.OrderBy<GroupDefinition, string>((GroupDefinition group) => group.Name, StringComparer.Ordinal))
			{
				stringBuilder.Append(flag ? "{" : ",{");
				Json.WriteMember(stringBuilder, "id", item.Id, first: true);
				Json.WriteMember(stringBuilder, "name", item.Name);
				Json.WriteMember(stringBuilder, "creatorId", item.CreatorId);
				Json.WriteMember(stringBuilder, "evictMismatching", item.EvictMismatching);
				Json.WriteMember(stringBuilder, "itemTypes", item.ItemTypes.OrderBy<string, string>((string item) => item, StringComparer.Ordinal));
				stringBuilder.Append('}');
				flag = false;
			}
			return stringBuilder.Append(']').ToString();
		}

		public static GroupRegistry Deserialize(string? json)
		{
			TryDeserialize(json, out GroupRegistry registry);
			return registry;
		}

		public static bool TryDeserialize(string? json, out GroupRegistry registry)
		{
			if (string.IsNullOrWhiteSpace(json))
			{
				registry = GroupRegistry.Empty;
				return true;
			}
			List<GroupDto> list;
			try
			{
				list = ReadGroups(Json.Parse(json));
			}
			catch (FormatException)
			{
				registry = GroupRegistry.Empty;
				return false;
			}
			GroupRegistry groupRegistry = GroupRegistry.Empty;
			foreach (GroupDto item in list)
			{
				if (item == null)
				{
					continue;
				}
				string text = DisplayNameSanitizer.Sanitize(item.Name);
				if (text == null)
				{
					continue;
				}
				groupRegistry = groupRegistry.WithGroup(text, item.CreatorId, item.Id);
				if (!groupRegistry.HasGroup(text))
				{
					continue;
				}
				if (item.EvictMismatching)
				{
					groupRegistry = groupRegistry.WithEvictMismatching(text, value: true);
				}
				foreach (string item2 in item.ItemTypes ?? new List<string>())
				{
					if (!string.IsNullOrWhiteSpace(item2))
					{
						groupRegistry = groupRegistry.WithItemAssignedToGroup(item2, text);
					}
				}
			}
			registry = groupRegistry;
			return true;
		}

		private static List<GroupDto?> ReadGroups(Json.JsonValue root)
		{
			if (root.Kind == Json.JsonKind.Null)
			{
				return new List<GroupDto>();
			}
			if (root.Kind != Json.JsonKind.Array)
			{
				throw new FormatException("Expected an array of groups.");
			}
			List<GroupDto> list = new List<GroupDto>(root.Items.Count);
			foreach (Json.JsonValue item in root.Items)
			{
				if (item.Kind == Json.JsonKind.Null)
				{
					list.Add(null);
					continue;
				}
				if (item.Kind != Json.JsonKind.Object)
				{
					throw new FormatException("Expected a group object.");
				}
				GroupDto groupDto = new GroupDto();
				foreach (KeyValuePair<string, Json.JsonValue> member in item.Members)
				{
					switch (member.Key)
					{
					case "id":
						groupDto.Id = member.Value.AsNullableString();
						break;
					case "name":
						groupDto.Name = member.Value.AsNullableString();
						break;
					case "creatorId":
						groupDto.CreatorId = member.Value.AsLong();
						break;
					case "evictMismatching":
						groupDto.EvictMismatching = member.Value.AsBool();
						break;
					case "itemTypes":
						groupDto.ItemTypes = member.Value.AsNullableStringList();
						break;
					}
				}
				list.Add(groupDto);
			}
			return list;
		}
	}
	public static class GroupRegistryMutationCodec
	{
		private sealed class MutationDto
		{
			public string? Kind { get; set; }

			public string? GroupName { get; set; }

			public string? NewGroupName { get; set; }

			public string? ItemType { get; set; }

			public List<string>? ItemTypes { get; set; }

			public long PlayerId { get; set; }

			public bool EvictMismatching { get; set; }

			public string? GroupId { get; set; }
		}

		public static string Serialize(GroupRegistryMutation mutation)
		{
			StringBuilder stringBuilder = new StringBuilder("{");
			Json.WriteMember(stringBuilder, "kind", mutation.Kind.ToString(), first: true);
			Json.WriteMember(stringBuilder, "groupName", mutation.GroupName);
			Json.WriteMember(stringBuilder, "newGroupName", mutation.NewGroupName);
			Json.WriteMember(stringBuilder, "itemType", mutation.ItemType);
			Json.WriteMember(stringBuilder, "itemTypes", mutation.ItemTypes);
			Json.WriteMember(stringBuilder, "playerId", mutation.PlayerId);
			Json.WriteMember(stringBuilder, "evictMismatching", mutation.EvictMismatching);
			Json.WriteMember(stringBuilder, "groupId", mutation.GroupId);
			return stringBuilder.Append('}').ToString();
		}

		public static GroupRegistryMutation? Deserialize(string? json)
		{
			if (string.IsNullOrWhiteSpace(json))
			{
				return null;
			}
			MutationDto mutationDto;
			try
			{
				mutationDto = ReadMutation(Json.Parse(json));
			}
			catch (FormatException)
			{
				return null;
			}
			if (mutationDto?.Kind == null || !Enum.TryParse<GroupRegistryMutationKind>(mutationDto.Kind, out var result))
			{
				return null;
			}
			switch (result)
			{
			case GroupRegistryMutationKind.CreateGroup:
			{
				string groupName5 = mutationDto.GroupName;
				if (groupName5 != null)
				{
					return GroupRegistryMutation.CreateGroup(groupName5, mutationDto.PlayerId, mutationDto.GroupId);
				}
				break;
			}
			case GroupRegistryMutationKind.DeleteGroup:
			{
				string groupName4 = mutationDto.GroupName;
				if (groupName4 != null)
				{
					return GroupRegistryMutation.DeleteGroup(groupName4, mutationDto.PlayerId);
				}
				break;
			}
			case GroupRegistryMutationKind.RenameGroup:
			{
				string groupName6 = mutationDto.GroupName;
				if (groupName6 != null)
				{
					string newGroupName = mutationDto.NewGroupName;
					if (newGroupName != null)
					{
						return GroupRegistryMutation.RenameGroup(groupName6, newGroupName, mutationDto.PlayerId);
					}
				}
				break;
			}
			case GroupRegistryMutationKind.AssignItem:
			{
				string itemType = mutationDto.ItemType;
				if (itemType != null)
				{
					string groupName2 = mutationDto.GroupName;
					if (groupName2 != null)
					{
						return GroupRegistryMutation.AssignItem(itemType, groupName2);
					}
				}
				break;
			}
			case GroupRegistryMutationKind.UnassignItem:
			{
				string itemType2 = mutationDto.ItemType;
				if (itemType2 != null)
				{
					return GroupRegistryMutation.UnassignItem(itemType2);
				}
				break;
			}
			case GroupRegistryMutationKind.ReplaceGroupItems:
			{
				string groupName3 = mutationDto.GroupName;
				if (groupName3 != null)
				{
					List<string> itemTypes = mutationDto.ItemTypes;
					if (itemTypes != null)
					{
						return GroupRegistryMutation.ReplaceGroupItems(groupName3, itemTypes, mutationDto.PlayerId);
					}
				}
				break;
			}
			case GroupRegistryMutationKind.SetGroupEviction:
			{
				string groupName = mutationDto.GroupName;
				if (groupName != null)
				{
					return GroupRegistryMutation.SetGroupEviction(groupName, mutationDto.EvictMismatching, mutationDto.PlayerId);
				}
				break;
			}
			}
			return null;
		}

		private static MutationDto? ReadMutation(Json.JsonValue root)
		{
			if (root.Kind == Json.JsonKind.Null)
			{
				return null;
			}
			if (root.Kind != Json.JsonKind.Object)
			{
				throw new FormatException("Expected a mutation object.");
			}
			MutationDto mutationDto = new MutationDto();
			foreach (KeyValuePair<string, Json.JsonValue> member in root.Members)
			{
				switch (member.Key)
				{
				case "kind":
					mutationDto.Kind = member.Value.AsNullableString();
					break;
				case "groupName":
					mutationDto.GroupName = member.Value.AsNullableString();
					break;
				case "newGroupName":
					mutationDto.NewGroupName = member.Value.AsNullableString();
					break;
				case "itemType":
					mutationDto.ItemType = member.Value.AsNullableString();
					break;
				case "itemTypes":
					mutationDto.ItemTypes = member.Value.AsNullableStringList();
					break;
				case "playerId":
					mutationDto.PlayerId = member.Value.AsLong();
					break;
				case "evictMismatching":
					mutationDto.EvictMismatching = member.Value.AsBool();
					break;
				case "groupId":
					mutationDto.GroupId = member.Value.AsNullableString();
					break;
				}
			}
			return mutationDto;
		}
	}
	internal static class Json
	{
		public enum JsonKind
		{
			Null,
			True,
			False,
			Number,
			String,
			Array,
			Object
		}

		internal sealed class JsonValue
		{
			private readonly string? _text;

			private readonly bool _hasLoneSurrogate;

			public static readonly JsonValue Null = new JsonValue(JsonKind.Null);

			public static readonly JsonValue True = new JsonValue(JsonKind.True);

			public static readonly JsonValue False = new JsonValue(JsonKind.False);

			public JsonKind Kind { get; }

			public List<JsonValue> Items { get; } = new List<JsonValue>();

			public List<KeyValuePair<string, JsonValue>> Members { get; } = new List<KeyValuePair<string, JsonValue>>();

			private JsonValue(JsonKind kind, string? text = null, bool hasLoneSurrogate = false)
			{
				Kind = kind;
				_text = text;
				_hasLoneSurrogate = hasLoneSurrogate;
			}

			public static JsonValue Number(string text)
			{
				return new JsonValue(JsonKind.Number, text);
			}

			public static JsonValue String(string text, bool hasLoneSurrogate)
			{
				return new JsonValue(JsonKind.String, text, hasLoneSurrogate);
			}

			public static JsonValue Array()
			{
				return new JsonValue(JsonKind.Array);
			}

			public static JsonValue Object()
			{
				return new JsonValue(JsonKind.Object);
			}

			public string? AsNullableString()
			{
				if (Kind == JsonKind.Null)
				{
					return null;
				}
				if (Kind != JsonKind.String || _hasLoneSurrogate)
				{
					throw new FormatException("Expected a string.");
				}
				return _text;
			}

			public long AsLong()
			{
				if (Kind != JsonKind.Number || _text.IndexOfAny(new char[3] { '.', 'e', 'E' }) >= 0 || !long.TryParse(_text, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result))
				{
					throw new FormatException("Expected an integer.");
				}
				return result;
			}

			public bool AsBool()
			{
				return Kind switch
				{
					JsonKind.True => true, 
					JsonKind.False => false, 
					_ => throw new FormatException("Expected true or false."), 
				};
			}

			public List<string?>? AsNullableStringList()
			{
				if (Kind == JsonKind.Null)
				{
					return null;
				}
				if (Kind != JsonKind.Array)
				{
					throw new FormatException("Expected an array.");
				}
				List<string> list = new List<string>(Items.Count);
				foreach (JsonValue item in Items)
				{
					list.Add(item.AsNullableString());
				}
				return list;
			}
		}

		private sealed class Parser
		{
			private readonly string _text;

			private int _position;

			private int _depth;

			public Parser(string text)
			{
				_text = text;
			}

			public JsonValue ParseDocument()
			{
				SkipWhitespace();
				JsonValue result = ParseValue();
				SkipWhitespace();
				if (_position != _text.Length)
				{
					throw Error("Unexpected content after the JSON value.");
				}
				return result;
			}

			private JsonValue ParseValue()
			{
				if (_position >= _text.Length)
				{
					throw Error("Unexpected end of input.");
				}
				switch (_text[_position])
				{
				case '{':
					return ParseObject();
				case '[':
					return ParseArray();
				case '"':
					return ParseString();
				case 't':
					Expect("true");
					return JsonValue.True;
				case 'f':
					Expect("false");
					return JsonValue.False;
				case 'n':
					Expect("null");
					return JsonValue.Null;
				default:
					return ParseNumber();
				}
			}

			private JsonValue ParseObject()
			{
				Enter();
				_position++;
				JsonValue jsonValue = JsonValue.Object();
				SkipWhitespace();
				if (TryConsume('}'))
				{
					_depth--;
					return jsonValue;
				}
				do
				{
					SkipWhitespace();
					if (_position >= _text.Length || _text[_position] != '"')
					{
						throw Error("Expected a property name.");
					}
					string key = ParseString().AsNullableString();
					SkipWhitespace();
					if (!TryConsume(':'))
					{
						throw Error("Expected ':'.");
					}
					SkipWhitespace();
					jsonValue.Members.Add(new KeyValuePair<string, JsonValue>(key, ParseValue()));
					SkipWhitespace();
					if (TryConsume('}'))
					{
						_depth--;
						return jsonValue;
					}
				}
				while (TryConsume(','));
				throw Error("Expected ',' or '}'.");
			}

			private JsonValue ParseArray()
			{
				Enter();
				_position++;
				JsonValue jsonValue = JsonValue.Array();
				SkipWhitespace();
				if (TryConsume(']'))
				{
					_depth--;
					return jsonValue;
				}
				do
				{
					SkipWhitespace();
					jsonValue.Items.Add(ParseValue());
					SkipWhitespace();
					if (TryConsume(']'))
					{
						_depth--;
						return jsonValue;
					}
				}
				while (TryConsume(','));
				throw Error("Expected ',' or ']'.");
			}

			private JsonValue ParseString()
			{
				_position++;
				StringBuilder stringBuilder = new StringBuilder();
				while (true)
				{
					if (_position >= _text.Length)
					{
						throw Error("Unterminated string.");
					}
					char c = _text[_position++];
					if (c == '"')
					{
						break;
					}
					if (c < ' ')
					{
						throw Error("Control character in string.");
					}
					if (c != '\\')
					{
						stringBuilder.Append(c);
						continue;
					}
					if (_position >= _text.Length)
					{
						throw Error("Unterminated escape.");
					}
					switch (_text[_position++])
					{
					case '"':
						stringBuilder.Append('"');
						break;
					case '\\':
						stringBuilder.Append('\\');
						break;
					case '/':
						stringBuilder.Append('/');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'u':
					{
						if (_position + 4 > _text.Length || !ushort.TryParse(_text.Substring(_position, 4), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var result))
						{
							throw Error("Invalid \\u escape.");
						}
						stringBuilder.Append((char)result);
						_position += 4;
						break;
					}
					default:
						throw Error("Invalid escape.");
					}
				}
				string text = stringBuilder.ToString();
				return JsonValue.String(text, HasLoneSurrogate(text));
			}

			private JsonValue ParseNumber()
			{
				int position = _position;
				TryConsume('-');
				if (!TryConsume('0') && !ConsumeDigits())
				{
					throw Error("Invalid value.");
				}
				if (TryConsume('.') && !ConsumeDigits())
				{
					throw Error("Invalid number.");
				}
				if (_position < _text.Length && (_text[_position] == 'e' || _text[_position] == 'E'))
				{
					_position++;
					if (!TryConsume('+'))
					{
						TryConsume('-');
					}
					if (!ConsumeDigits())
					{
						throw Error("Invalid number.");
					}
				}
				return JsonValue.Number(_text.Substring(position, _position - position));
			}

			private bool ConsumeDigits()
			{
				int position = _position;
				while (_position < _text.Length && _text[_position] >= '0' && _text[_position] <= '9')
				{
					_position++;
				}
				return _position > position;
			}

			private void Expect(string literal)
			{
				if (string.CompareOrdinal(_text, _position, literal, 0, literal.Length) != 0)
				{
					throw Error("Invalid literal.");
				}
				_position += literal.Length;
			}

			private void Enter()
			{
				if (++_depth > 64)
				{
					throw Error("Nested too deeply.");
				}
			}

			private bool TryConsume(char expected)
			{
				if (_position < _text.Length && _text[_position] == expected)
				{
					_position++;
					return true;
				}
				return false;
			}

			private void SkipWhitespace()
			{
				while (true)
				{
					bool flag = _position < _text.Length;
					if (flag)
					{
						bool flag2;
						switch (_text[_position])
						{
						case '\t':
						case '\n':
						case '\r':
						case ' ':
							flag2 = true;
							break;
						default:
							flag2 = false;
							break;
						}
						flag = flag2;
					}
					if (flag)
					{
						_position++;
						continue;
					}
					break;
				}
			}

			private FormatException Error(string message)
			{
				return new FormatException($"{message} (at {_position})");
			}

			private static bool HasLoneSurrogate(string value)
			{
				for (int i = 0; i < value.Length; i++)
				{
					if (char.IsHighSurrogate(value[i]) && i + 1 < value.Length && char.IsLowSurrogate(value[i + 1]))
					{
						i++;
					}
					else if (char.IsSurrogate(value[i]))
					{
						return true;
					}
				}
				return false;
			}
		}

		private const int MaxDepth = 64;

		public static void WriteString(StringBuilder output, string? value)
		{
			if (value == null)
			{
				output.Append("null");
				return;
			}
			output.Append('"');
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				switch (c)
				{
				case '\\':
					output.Append("\\\\");
					continue;
				case '\b':
					output.Append("\\b");
					continue;
				case '\f':
					output.Append("\\f");
					continue;
				case '\n':
					output.Append("\\n");
					continue;
				case '\r':
					output.Append("\\r");
					continue;
				case '\t':
					output.Append("\\t");
					continue;
				}
				if (char.IsHighSurrogate(c) && i + 1 < value.Length && char.IsLowSurrogate(value[i + 1]))
				{
					AppendEscaped(output, c);
					AppendEscaped(output, value[++i]);
				}
				else if (char.IsSurrogate(c))
				{
					AppendEscaped(output, '\ufffd');
				}
				else if (c < ' ' || c > '~' || c == '"' || c == '&' || c == '\'' || c == '+' || c == '<' || c == '>' || c == '`')
				{
					AppendEscaped(output, c);
				}
				else
				{
					output.Append(c);
				}
			}
			output.Append('"');
		}

		public static void WriteMember(StringBuilder output, string name, string? value, bool first = false)
		{
			AppendName(output, name, first);
			WriteString(output, value);
		}

		public static void WriteMember(StringBuilder output, string name, long value)
		{
			AppendName(output, name, first: false);
			output.Append(value.ToString(CultureInfo.InvariantCulture));
		}

		public static void WriteMember(StringBuilder output, string name, bool value)
		{
			AppendName(output, name, first: false);
			output.Append(value ? "true" : "false");
		}

		public static void WriteMember(StringBuilder output, string name, IEnumerable<string?>? values)
		{
			AppendName(output, name, first: false);
			if (values == null)
			{
				output.Append("null");
				return;
			}
			output.Append('[');
			bool flag = true;
			foreach (string value in values)
			{
				if (!flag)
				{
					output.Append(',');
				}
				WriteString(output, value);
				flag = false;
			}
			output.Append(']');
		}

		private static void AppendName(StringBuilder output, string name, bool first)
		{
			if (!first)
			{
				output.Append(',');
			}
			output.Append('"').Append(name).Append("\":");
		}

		private static void AppendEscaped(StringBuilder output, char c)
		{
			StringBuilder stringBuilder = output.Append("\\u");
			int num = c;
			stringBuilder.Append(num.ToString("X4", CultureInfo.InvariantCulture));
		}

		public static JsonValue Parse(string text)
		{
			return new Parser(text).ParseDocument();
		}
	}
	public static class PersistenceKeys
	{
		public const string ContainerName = "SCR_Name";

		public const string ContainerGroup = "SCR_Group";

		public const string ContainerGroupId = "SCR_GroupId";

		public const string ContainerEvictNonGroupItems = "SCR_EvictNonGroup";

		public const string ContainerPriority = "SCR_Priority";

		public const string ContainerRelayReceipts = "SCR_RelayReceipts";

		public const string GroupRegistryBlob = "SCR_Groups";

		public const string GroupRegistryCorruptBackup = "SCR_GroupsCorruptBackup";
	}
}
namespace SmartContainerRouting.Core.Model
{
	public static class BuiltInGroups
	{
		public const string LockedId = "builtin:locked";

		public const string LockedName = "Locked";

		public const string DisplacedLockedName = "Locked (old)";

		public static bool IsLocked(GroupDefinition? group)
		{
			if (group != null)
			{
				return string.Equals(group.Id, "builtin:locked", StringComparison.Ordinal);
			}
			return false;
		}

		public static bool IsLocked(GroupRegistry groups, string? groupName)
		{
			if (groupName == null)
			{
				return false;
			}
			GroupDefinition groupDefinition = groups.GetGroup(groupName);
			if (groupDefinition == null)
			{
				return string.Equals(GroupNameNormalizer.Normalize(groupName), GroupNameNormalizer.Normalize("Locked"), StringComparison.Ordinal);
			}
			return IsLocked(groupDefinition);
		}

		public static GroupRegistry EnsureLocked(GroupRegistry registry)
		{
			GroupRegistry groupRegistry = registry;
			GroupDefinition groupById = groupRegistry.GetGroupById("builtin:locked");
			GroupDefinition groupDefinition = groupRegistry.GetGroup("Locked");
			if (groupDefinition != null && !IsLocked(groupDefinition))
			{
				groupRegistry = groupRegistry.WithRenamedGroup(groupDefinition.Name, FreeName(groupRegistry));
			}
			if (groupById == null)
			{
				return groupRegistry.WithGroup("Locked", 0L, "builtin:locked");
			}
			if (!string.Equals(groupById.Name, "Locked", StringComparison.Ordinal))
			{
				groupRegistry = groupRegistry.WithRenamedGroup(groupById.Name, "Locked");
			}
			if (groupById.ItemTypes.Count > 0)
			{
				groupRegistry = groupRegistry.WithGroupItemsReplaced("Locked", Array.Empty<string>());
			}
			if (groupById.EvictMismatching)
			{
				groupRegistry = groupRegistry.WithEvictMismatching("Locked", value: false);
			}
			return groupRegistry;
		}

		private static string FreeName(GroupRegistry registry)
		{
			if (!registry.HasGroup("Locked (old)"))
			{
				return "Locked (old)";
			}
			return (from n in Enumerable.Range(2, 2147483645)
				select $"Locked (old {n})").First((string name) => !registry.HasGroup(name));
		}
	}
	public sealed class ContainerSettings
	{
		public string? Name { get; }

		public string? GroupName { get; }

		public bool EvictNonGroupItems { get; }

		public bool IsEvicting
		{
			get
			{
				if (EvictNonGroupItems)
				{
					return GroupName != null;
				}
				return false;
			}
		}

		public bool Priority { get; }

		public static ContainerSettings Default { get; } = new ContainerSettings();

		public ContainerSettings(string? name = null, string? groupName = null, bool evictNonGroupItems = false, bool priority = false)
		{
			Name = NormalizeOrNull(name);
			GroupName = GroupNameNormalizer.Normalize(groupName);
			EvictNonGroupItems = evictNonGroupItems;
			Priority = priority;
		}

		public ContainerSettings WithName(string? name)
		{
			return new ContainerSettings(name, GroupName, EvictNonGroupItems, Priority);
		}

		public ContainerSettings WithGroupName(string? groupName)
		{
			return new ContainerSettings(Name, groupName, EvictNonGroupItems, Priority);
		}

		public ContainerSettings WithEvictNonGroupItems(bool value)
		{
			return new ContainerSettings(Name, GroupName, value, Priority);
		}

		public ContainerSettings WithPriority(bool value)
		{
			return new ContainerSettings(Name, GroupName, EvictNonGroupItems, value);
		}

		public bool Equals(ContainerSettings? other)
		{
			if (other != null && string.Equals(Name, other.Name, StringComparison.Ordinal) && string.Equals(GroupName, other.GroupName, StringComparison.Ordinal) && EvictNonGroupItems == other.EvictNonGroupItems)
			{
				return Priority == other.Priority;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((17 * 31 + (Name?.GetHashCode() ?? 0)) * 31 + (GroupName?.GetHashCode() ?? 0)) * 31 + EvictNonGroupItems.GetHashCode()) * 31 + Priority.GetHashCode();
		}

		private static string? NormalizeOrNull(string? value)
		{
			return DisplayNameSanitizer.Sanitize(value);
		}
	}
	public sealed class GroupDefinition
	{
		public string Name { get; }

		public string Id { get; }

		public ItemTypeSet ItemTypes { get; }

		public bool EvictMismatching { get; }

		public long CreatorId { get; }

		private GroupDefinition(string id, string name, ItemTypeSet itemTypes, long creatorId, bool evictMismatching = false)
		{
			Id = id;
			Name = name;
			ItemTypes = itemTypes;
			CreatorId = creatorId;
			EvictMismatching = evictMismatching;
		}

		public static string LegacyIdFor(string name)
		{
			return "name:" + GroupNameNormalizer.Normalize(name);
		}

		public static GroupDefinition Empty(string name, long creatorId = 0L, bool evictMismatching = false, string? id = null)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				throw new ArgumentException("Group name must not be empty.", "name");
			}
			return new GroupDefinition(string.IsNullOrWhiteSpace(id) ? LegacyIdFor(name) : id, name, ItemTypeSet.Empty, creatorId, evictMismatching);
		}

		internal GroupDefinition WithItem(string itemType)
		{
			return new GroupDefinition(Id, Name, ItemTypes.Add(itemType), CreatorId, EvictMismatching);
		}

		internal GroupDefinition WithoutItem(string itemType)
		{
			return new GroupDefinition(Id, Name, ItemTypes.Remove(itemType), CreatorId, EvictMismatching);
		}

		internal GroupDefinition WithItems(ItemTypeSet itemTypes)
		{
			return new GroupDefinition(Id, Name, itemTypes, CreatorId, EvictMismatching);
		}

		internal GroupDefinition WithEvictMismatching(bool value)
		{
			return new GroupDefinition(Id, Name, ItemTypes, CreatorId, value);
		}
	}
	public static class GroupItemAdditions
	{
		public static IReadOnlyList<string> Missing(GroupRegistry registry, string groupName, IEnumerable<string> chestItemTypes)
		{
			GroupDefinition group = registry.GetGroup(groupName);
			if (group == null)
			{
				return Array.Empty<string>();
			}
			return chestItemTypes.Where((string itemType) => !string.IsNullOrEmpty(itemType) && !group.ItemTypes.Contains(itemType)).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string itemType) => itemType, StringComparer.Ordinal)
				.ToList();
		}
	}
	public static class GroupItemTransfers
	{
		public static string? Describe(GroupRegistry registry, string targetGroupName, IEnumerable<string> itemTypes, Func<string, string> itemDisplayName)
		{
			string targetName = registry.GetGroup(targetGroupName)?.Name ?? targetGroupName;
			string[] array = (from @group in (from itemType in itemTypes.Distinct<string>(StringComparer.Ordinal)
					select (itemType: itemType, owner: registry.GetGroupForItem(itemType)) into pair
					where pair.owner != null && !string.Equals(pair.owner, targetName, StringComparison.OrdinalIgnoreCase)
					select pair).GroupBy<(string, string), string>(((string itemType, string owner) pair) => pair.owner, StringComparer.Ordinal).OrderBy<IGrouping<string, (string, string)>, string>((IGrouping<string, (string itemType, string owner)> @group) => @group.Key, StringComparer.Ordinal)
				select string.Join(", ", @group.Select(((string itemType, string owner) pair) => itemDisplayName(pair.itemType)).OrderBy<string, string>((string name) => name, StringComparer.Ordinal)) + " moved from " + @group.Key + " to " + targetName).ToArray();
			if (array.Length != 0)
			{
				return string.Join("\n", array);
			}
			return null;
		}
	}
	public static class GroupReference
	{
		public static string? Resolve(string? storedId, string? storedName, GroupRegistry? registry)
		{
			string text = GroupNameNormalizer.Normalize(storedName);
			if (registry == null)
			{
				return text;
			}
			GroupDefinition groupDefinition = ((!string.IsNullOrEmpty(storedId)) ? registry.GetGroupById(storedId) : ((text == null) ? null : (registry.GetGroupById(GroupDefinition.LegacyIdFor(text)) ?? registry.GetGroup(text))));
			if (groupDefinition != null)
			{
				return GroupNameNormalizer.Normalize(groupDefinition.Name);
			}
			return text;
		}

		public static bool WasDeleted(GroupRegistry? previousTrusted, GroupRegistry current, string groupName)
		{
			if (previousTrusted != null && previousTrusted.HasGroup(groupName))
			{
				return !current.HasGroup(groupName);
			}
			return false;
		}

		public static string IdFor(string? groupName, GroupRegistry? registry)
		{
			object obj;
			if (groupName != null)
			{
				obj = registry?.GetGroup(groupName)?.Id;
				if (obj == null)
				{
					return string.Empty;
				}
			}
			else
			{
				obj = string.Empty;
			}
			return (string)obj;
		}
	}
	public sealed class GroupRegistry
	{
		private readonly Dictionary<string, GroupDefinition> _groups;

		public static GroupRegistry Empty { get; } = new GroupRegistry(new Dictionary<string, GroupDefinition>());

		public IReadOnlyCollection<GroupDefinition> Groups => (IReadOnlyCollection<GroupDefinition>)(object)_groups.Values.ToArray();

		private GroupRegistry(Dictionary<string, GroupDefinition> groups)
		{
			_groups = groups;
		}

		public bool HasGroup(string groupName)
		{
			string text = GroupNameNormalizer.Normalize(groupName);
			if (text != null)
			{
				return _groups.ContainsKey(text);
			}
			return false;
		}

		public GroupDefinition? GetGroup(string groupName)
		{
			string text = GroupNameNormalizer.Normalize(groupName);
			if (text == null || !_groups.TryGetValue(text, out GroupDefinition value))
			{
				return null;
			}
			return value;
		}

		public GroupDefinition? GetGroupById(string? groupId)
		{
			if (!string.IsNullOrEmpty(groupId))
			{
				return _groups.Values.FirstOrDefault((GroupDefinition group) => string.Equals(group.Id, groupId, StringComparison.Ordinal));
			}
			return null;
		}

		public GroupRegistry WithGroup(string groupName, long creatorId = 0L, string? groupId = null)
		{
			string? obj = DisplayNameSanitizer.Sanitize(groupName) ?? throw new ArgumentException("Group name must not be empty.", "groupName");
			string key = GroupNameNormalizer.Normalize(obj);
			GroupDefinition groupDefinition = GroupDefinition.Empty(obj, creatorId, evictMismatching: false, groupId);
			if (!_groups.ContainsKey(key) && GetGroupById(groupDefinition.Id) == null)
			{
				return new GroupRegistry(With(_groups, key, groupDefinition));
			}
			return this;
		}

		public GroupRegistry WithoutGroup(string groupName)
		{
			string text = GroupNameNormalizer.Normalize(groupName);
			if (text == null)
			{
				return this;
			}
			if (!_groups.ContainsKey(text))
			{
				return this;
			}
			return new GroupRegistry(Without(_groups, text));
		}

		public GroupRegistry WithRenamedGroup(string oldName, string newName)
		{
			string text = DisplayNameSanitizer.Sanitize(newName);
			if (text == null)
			{
				throw new ArgumentException("Group name must not be empty.", "newName");
			}
			string text2 = GroupNameNormalizer.Normalize(oldName);
			if (!_groups.TryGetValue(text2, out GroupDefinition value))
			{
				throw new ArgumentException("Group '" + oldName + "' does not exist.", "oldName");
			}
			if (string.Equals(value.Name, text, StringComparison.Ordinal))
			{
				return this;
			}
			string text3 = GroupNameNormalizer.Normalize(text);
			if (text2 != text3 && _groups.ContainsKey(text3))
			{
				throw new ArgumentException("Group '" + text + "' already exists.", "newName");
			}
			GroupDefinition groupDefinition = GroupDefinition.Empty(text, value.CreatorId, value.EvictMismatching, value.Id).WithItems(value.ItemTypes);
			if (!(text2 == text3))
			{
				return new GroupRegistry(With(Without(_groups, text2), text3, groupDefinition));
			}
			return new GroupRegistry(With(_groups, text2, groupDefinition));
		}

		public GroupRegistry WithItemAssignedToGroup(string itemType, string groupName)
		{
			if (string.IsNullOrWhiteSpace(itemType))
			{
				throw new ArgumentException("Item type must not be empty.", "itemType");
			}
			string text = GroupNameNormalizer.Normalize(groupName);
			if (text == null || !_groups.TryGetValue(text, out GroupDefinition _))
			{
				throw new ArgumentException("Group '" + groupName + "' does not exist.", "groupName");
			}
			Dictionary<string, GroupDefinition> dictionary = new Dictionary<string, GroupDefinition>(_groups);
			foreach (KeyValuePair<string, GroupDefinition> group in _groups)
			{
				if (group.Key != text && group.Value.ItemTypes.Contains(itemType))
				{
					dictionary[group.Key] = group.Value.WithoutItem(itemType);
				}
			}
			dictionary[text] = dictionary[text].WithItem(itemType);
			return new GroupRegistry(dictionary);
		}

		public GroupRegistry WithItemUnassigned(string itemType)
		{
			Dictionary<string, GroupDefinition> dictionary = new Dictionary<string, GroupDefinition>(_groups);
			foreach (KeyValuePair<string, GroupDefinition> group in _groups)
			{
				if (group.Value.ItemTypes.Contains(itemType))
				{
					dictionary[group.Key] = group.Value.WithoutItem(itemType);
				}
			}
			return new GroupRegistry(dictionary);
		}

		public GroupRegistry WithGroupItemsReplaced(string groupName, IEnumerable<string> itemTypes)
		{
			string text = GroupNameNormalizer.Normalize(groupName);
			if (text == null || !_groups.TryGetValue(text, out GroupDefinition value))
			{
				throw new ArgumentException("Group '" + groupName + "' does not exist.", "groupName");
			}
			HashSet<string> hashSet = new HashSet<string>(itemTypes, StringComparer.Ordinal);
			if (hashSet.Any(string.IsNullOrWhiteSpace))
			{
				throw new ArgumentException("Item types must not be empty.", "itemTypes");
			}
			Dictionary<string, GroupDefinition> dictionary = new Dictionary<string, GroupDefinition>(_groups);
			foreach (KeyValuePair<string, GroupDefinition> group in _groups)
			{
				if (!(group.Key != text))
				{
					continue;
				}
				string[] array = group.Value.ItemTypes.Intersect(hashSet).ToArray();
				if (array.Length != 0)
				{
					GroupDefinition groupDefinition = group.Value;
					string[] array2 = array;
					foreach (string itemType in array2)
					{
						groupDefinition = groupDefinition.WithoutItem(itemType);
					}
					dictionary[group.Key] = groupDefinition;
				}
			}
			dictionary[text] = GroupDefinition.Empty(value.Name, value.CreatorId, value.EvictMismatching, value.Id).WithItems(ItemTypeSet.From(hashSet));
			return new GroupRegistry(dictionary);
		}

		public GroupRegistry WithEvictMismatching(string groupName, bool value)
		{
			string text = GroupNameNormalizer.Normalize(groupName);
			if (text == null || !_groups.TryGetValue(text, out GroupDefinition value2))
			{
				throw new ArgumentException("Group '" + groupName + "' does not exist.", "groupName");
			}
			if (value2.EvictMismatching != value)
			{
				return new GroupRegistry(With(_groups, text, value2.WithEvictMismatching(value)));
			}
			return this;
		}

		public string? GetGroupForItem(string itemType)
		{
			return _groups.Values.FirstOrDefault((GroupDefinition group) => group.ItemTypes.Contains(itemType))?.Name;
		}

		private static Dictionary<string, GroupDefinition> With(Dictionary<string, GroupDefinition> groups, string key, GroupDefinition group)
		{
			return new Dictionary<string, GroupDefinition>(groups) { [key] = group };
		}

		private static Dictionary<string, GroupDefinition> Without(Dictionary<string, GroupDefinition> groups, string key)
		{
			Dictionary<string, GroupDefinition> dictionary = new Dictionary<string, GroupDefinition>(groups);
			dictionary.Remove(key);
			return dictionary;
		}
	}
	public enum GroupRegistryMutationKind
	{
		CreateGroup,
		DeleteGroup,
		RenameGroup,
		AssignItem,
		UnassignItem,
		ReplaceGroupItems,
		SetGroupEviction
	}
	public sealed class GroupRegistryMutation
	{
		public GroupRegistryMutationKind Kind { get; }

		public string? GroupName { get; }

		public string? NewGroupName { get; }

		public string? ItemType { get; }

		public IReadOnlyList<string>? ItemTypes { get; }

		public bool EvictMismatching { get; }

		public string? GroupId { get; }

		public long PlayerId { get; }

		private GroupRegistryMutation(GroupRegistryMutationKind kind, string? groupName, string? newGroupName, string? itemType, long playerId, IReadOnlyList<string>? itemTypes = null, bool evictMismatching = false, string? groupId = null)
		{
			GroupId = groupId;
			Kind = kind;
			GroupName = groupName;
			NewGroupName = newGroupName;
			ItemType = itemType;
			ItemTypes = itemTypes;
			EvictMismatching = evictMismatching;
			PlayerId = playerId;
		}

		public static GroupRegistryMutation CreateGroup(string groupName, long creatorId, string? groupId = null)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.CreateGroup, groupName, null, null, creatorId, null, evictMismatching: false, groupId);
		}

		public static GroupRegistryMutation DeleteGroup(string groupName, long requesterId)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.DeleteGroup, groupName, null, null, requesterId);
		}

		public static GroupRegistryMutation RenameGroup(string oldGroupName, string newGroupName, long requesterId)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.RenameGroup, oldGroupName, newGroupName, null, requesterId);
		}

		public static GroupRegistryMutation AssignItem(string itemType, string groupName)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.AssignItem, groupName, null, itemType, 0L);
		}

		public static GroupRegistryMutation UnassignItem(string itemType)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.UnassignItem, null, null, itemType, 0L);
		}

		public static GroupRegistryMutation ReplaceGroupItems(string groupName, IEnumerable<string> itemTypes, long requesterId)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.ReplaceGroupItems, groupName, null, null, requesterId, itemTypes.ToArray());
		}

		public static GroupRegistryMutation SetGroupEviction(string groupName, bool value, long requesterId)
		{
			return new GroupRegistryMutation(GroupRegistryMutationKind.SetGroupEviction, groupName, null, null, requesterId, null, value);
		}

		public GroupRegistryMutation WithVerifiedPlayerId(long verifiedPlayerId)
		{
			return new GroupRegistryMutation(Kind, GroupName, NewGroupName, ItemType, verifiedPlayerId, ItemTypes, EvictMismatching, GroupId);
		}

		public bool IsRefusedFor(GroupRegistry registry)
		{
			switch (Kind)
			{
			case GroupRegistryMutationKind.CreateGroup:
				if (!string.Equals(GroupId, "builtin:locked", StringComparison.Ordinal))
				{
					return BuiltInGroups.IsLocked(registry, GroupName);
				}
				return false;
			case GroupRegistryMutationKind.RenameGroup:
				if (!BuiltInGroups.IsLocked(registry, GroupName))
				{
					return BuiltInGroups.IsLocked(registry, NewGroupName);
				}
				return true;
			case GroupRegistryMutationKind.DeleteGroup:
			case GroupRegistryMutationKind.AssignItem:
			case GroupRegistryMutationKind.SetGroupEviction:
				return BuiltInGroups.IsLocked(registry, GroupName);
			case GroupRegistryMutationKind.ReplaceGroupItems:
				if (BuiltInGroups.IsLocked(registry, GroupName))
				{
					IReadOnlyList<string> itemTypes = ItemTypes;
					if (itemTypes != null)
					{
						return itemTypes.Count > 0;
					}
					return false;
				}
				return false;
			default:
				return false;
			}
		}

		public GroupRegistry Apply(GroupRegistry registry)
		{
			return Kind switch
			{
				GroupRegistryMutationKind.CreateGroup => registry.WithGroup(GroupName, PlayerId, GroupId), 
				GroupRegistryMutationKind.DeleteGroup => registry.WithoutGroup(GroupName), 
				GroupRegistryMutationKind.RenameGroup => registry.WithRenamedGroup(GroupName, NewGroupName), 
				GroupRegistryMutationKind.AssignItem => registry.WithItemAssignedToGroup(ItemType, GroupName), 
				GroupRegistryMutationKind.UnassignItem => registry.WithItemUnassigned(ItemType), 
				GroupRegistryMutationKind.ReplaceGroupItems => registry.WithGroupItemsReplaced(GroupName, ItemTypes), 
				GroupRegistryMutationKind.SetGroupEviction => registry.WithEvictMismatching(GroupName, EvictMismatching), 
				_ => throw new InvalidOperationException($"Unknown mutation kind '{Kind}'."), 
			};
		}
	}
	public sealed class ItemPinCandidates
	{
		public IReadOnlyList<string> InChest { get; }

		public IReadOnlyList<string> CarriedOnly { get; }

		private ItemPinCandidates(IReadOnlyList<string> inChest, IReadOnlyList<string> carriedOnly)
		{
			InChest = inChest;
			CarriedOnly = carriedOnly;
		}

		public static ItemPinCandidates Build(IEnumerable<string> chestItemTypes, IEnumerable<string> carriedItemTypes)
		{
			List<string> list = DistinctSorted(chestItemTypes);
			HashSet<string> inChestSet = new HashSet<string>(list, StringComparer.Ordinal);
			List<string> carriedOnly = (from itemType in DistinctSorted(carriedItemTypes)
				where !inChestSet.Contains(itemType)
				select itemType).ToList();
			return new ItemPinCandidates(list, carriedOnly);
		}

		private static List<string> DistinctSorted(IEnumerable<string> itemTypes)
		{
			return itemTypes.Where((string itemType) => !string.IsNullOrEmpty(itemType)).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string itemType) => itemType, StringComparer.Ordinal)
				.ToList();
		}
	}
	public sealed class ItemTypeSet : IReadOnlyCollection<string>, IEnumerable<string>, IEnumerable
	{
		private readonly HashSet<string> _items;

		public static ItemTypeSet Empty { get; } = new ItemTypeSet(new HashSet<string>(StringComparer.Ordinal));

		public int Count => _items.Count;

		private ItemTypeSet(HashSet<string> items)
		{
			_items = items;
		}

		public bool Contains(string itemType)
		{
			return _items.Contains(itemType);
		}

		internal ItemTypeSet Add(string itemType)
		{
			if (_items.Contains(itemType))
			{
				return this;
			}
			return new ItemTypeSet(new HashSet<string>(_items, StringComparer.Ordinal) { itemType });
		}

		internal ItemTypeSet Remove(string itemType)
		{
			if (!_items.Contains(itemType))
			{
				return this;
			}
			HashSet<string> hashSet = new HashSet<string>(_items, StringComparer.Ordinal);
			hashSet.Remove(itemType);
			return new ItemTypeSet(hashSet);
		}

		internal static ItemTypeSet From(IEnumerable<string> itemTypes)
		{
			return new ItemTypeSet(new HashSet<string>(itemTypes, StringComparer.Ordinal));
		}

		public IEnumerator<string> GetEnumerator()
		{
			return _items.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
}