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("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f556d01ba578811190b24467d0afe74ca948dcb8")]
[assembly: AssemblyProduct("Storage Groups")]
[assembly: AssemblyTitle("StorageGroups.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]
	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.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 (IsEligibleDestination(source, groups, item.ItemType))
			{
				return null;
			}
			IReadOnlyCollection<ContainerRoutingCandidate> readOnlyCollection = (IReadOnlyCollection<ContainerRoutingCandidate>)(((object)(candidates as IReadOnlyCollection<ContainerRoutingCandidate>)) ?? ((object)candidates.ToArray()));
			ContainerRoutingCandidate containerRoutingCandidate = SelectDestination(item, readOnlyCollection, 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, readOnlyCollection.Where((ContainerRoutingCandidate candidate) => candidate.Settings.GroupName == null), range) ?? SelectNearest(item, readOnlyCollection.Where(delegate(ContainerRoutingCandidate candidate)
					{
						string groupName2 = candidate.Settings.GroupName;
						if (groupName2 != null)
						{
							GroupDefinition? groupDefinition2 = groups.GetGroup(groupName2);
							if (groupDefinition2 == null)
							{
								return true;
							}
							return !groupDefinition2.EvictMismatching;
						}
						return false;
					}), range);
				}
			}
			return null;
		}

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

		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 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 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 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");
			return new ContainerSettings(name, groupName, evictNonGroupItems);
		}

		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);
		}
	}
	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 ContainerRelayReceipts = "SCR_RelayReceipts";

		public const string GroupRegistryBlob = "SCR_Groups";

		public const string GroupRegistryCorruptBackup = "SCR_GroupsCorruptBackup";
	}
}
namespace SmartContainerRouting.Core.Model
{
	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 static ContainerSettings Default { get; } = new ContainerSettings();

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

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

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

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

		public bool Equals(ContainerSettings? other)
		{
			if (other != null && string.Equals(Name, other.Name, StringComparison.Ordinal) && string.Equals(GroupName, other.GroupName, StringComparison.Ordinal))
			{
				return EvictNonGroupItems == other.EvictNonGroupItems;
			}
			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();
		}

		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 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 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();
		}
	}
}