using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using ExtraPotions.Thing.Admin;
using ExtraPotions.Thing.Communication;
using ExtraPotions.Thing.Config;
using ExtraPotions.Thing.ConfigEditing.Attributes;
using ExtraPotions.Thing.ConfigEditing.Editors;
using ExtraPotions.Thing.Moderation;
using ExtraPotions.Thing.RemoteConfig;
using ExtraPotions.Thing.UI;
using ExtraPotions.Thing.WorldAdmin;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtraPotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2026 expDARE (ExtraPotions Meadworks)")]
[assembly: AssemblyFileVersion("0.1.14.0")]
[assembly: AssemblyInformationalVersion("0.1.14+source.C5CB98230C177B26BBB9D41F4869FF0DA5DE81F8C31B5A5A34E1D7BBF025C5D7")]
[assembly: AssemblyProduct("Thing.Core")]
[assembly: AssemblyTitle("Thing.Core")]
[assembly: AssemblyVersion("0.1.14.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ExtraPotions.Thing
{
	public static class ThingCore
	{
		public const string PluginGuid = "com.meadworks.thing";

		public const string ProductName = "Thing";

		public const string ProductVersion = "0.1.14";

		public const string Family = "Runestone";

		public const string TokenNamespace = "thing";

		public const string TokenPrefix = "meadworks_thing_";

		public const string DataFolder = "Meadworks/thing";

		public const string SupportedGameVersion = "1.0.17";
	}
}
namespace ExtraPotions.Thing.WorldAdmin
{
	public enum DropReceiptOutcome
	{
		Continue,
		Refused,
		Recovery
	}
	public static class DropReceipt
	{
		public static DropReceiptOutcome Decide(string status, int removed, int approved, int previousRemoved)
		{
			if (removed < 0 || approved < 0 || previousRemoved < 0 || removed > approved || (status != "ok" && status != "refused"))
			{
				return DropReceiptOutcome.Recovery;
			}
			if (status == "ok")
			{
				return DropReceiptOutcome.Continue;
			}
			if (previousRemoved <= 0 && removed <= 0)
			{
				return DropReceiptOutcome.Refused;
			}
			return DropReceiptOutcome.Recovery;
		}
	}
	public static class PickupRadius
	{
		public const float Min = 1f;

		public const float Max = 10f;

		public static bool TryParse(string? text, out float? radius)
		{
			radius = null;
			string text2 = (text ?? "").Trim();
			if (text2.Equals("reset", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (!float.TryParse(text2, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result) || !(result >= 1f) || !(result <= 10f))
			{
				return false;
			}
			radius = result;
			return true;
		}

		public static bool Reapply(float? wanted, float live)
		{
			if (wanted.HasValue)
			{
				return Math.Abs(wanted.Value - live) > 0.001f;
			}
			return false;
		}
	}
	public static class PoiData
	{
		public const string CapabilityId = "meadworks.thing.poi";

		public const string OperationId = "meadworks.thing.poi_locations";

		public static readonly Version Version = new Version(1, 0);

		public const int MaximumLocations = 512;

		public const int MaximumBytes = 16384;

		private static readonly HashSet<string> names = new HashSet<string>(StringComparer.Ordinal)
		{
			"Eikthyrnir", "GDKing", "Bonemass", "Dragonqueen", "GoblinKing", "Mistlands_DvergrBossEntrance1", "FaderLocation", "DN_Bossroom", "Vendor_BlackForest", "Hildir_camp",
			"BogWitch_Camp"
		};

		public static bool Known(string name)
		{
			if (name != null)
			{
				return names.Contains(name);
			}
			return false;
		}

		public static bool Trader(string name)
		{
			if (!(name == "Vendor_BlackForest") && !(name == "Hildir_camp"))
			{
				return name == "BogWitch_Camp";
			}
			return true;
		}

		private static bool Coordinate(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Abs(value) <= 20000f;
			}
			return false;
		}

		private static bool Valid(Tuple<string, float, float, float, bool> row)
		{
			if (row != null && Known(row.Item1) && Coordinate(row.Item2) && Coordinate(row.Item3))
			{
				return Coordinate(row.Item4);
			}
			return false;
		}

		public static IReadOnlyList<Tuple<string, float, float, float, bool>> Select(IEnumerable<Tuple<string, float, float, float, bool>> source)
		{
			Tuple<string, float, float, float, bool>[] source2 = source.Where(Valid).ToArray();
			HashSet<string> confirmed = new HashSet<string>(from r in source2
				where Trader(r.Item1) && r.Item5
				select r.Item1, StringComparer.Ordinal);
			Tuple<string, float, float, float, bool>[] array = source2.Where((Tuple<string, float, float, float, bool> r) => !Trader(r.Item1) || r.Item5 || !confirmed.Contains(r.Item1)).Distinct().OrderBy<Tuple<string, float, float, float, bool>, string>((Tuple<string, float, float, float, bool> r) => r.Item1, StringComparer.Ordinal)
				.ThenBy((Tuple<string, float, float, float, bool> r) => r.Item2)
				.ThenBy((Tuple<string, float, float, float, bool> r) => r.Item4)
				.ToArray();
			if (array.Length > 512 || 5 + array.Sum((Tuple<string, float, float, float, bool> r) => 14 + Encoding.UTF8.GetByteCount(r.Item1)) > 16384)
			{
				throw new InvalidOperationException("PoiLimit");
			}
			return Array.AsReadOnly(array);
		}

		public static byte[] Encode(IReadOnlyList<Tuple<string, float, float, float, bool>> rows)
		{
			if (rows == null || rows.Count > 512 || rows.Any((Tuple<string, float, float, float, bool> r) => !Valid(r)))
			{
				throw new ArgumentException("Invalid POI rows.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
			binaryWriter.Write((byte)1);
			binaryWriter.Write(rows.Count);
			foreach (Tuple<string, float, float, float, bool> row in rows)
			{
				binaryWriter.Write(row.Item1);
				binaryWriter.Write(row.Item2);
				binaryWriter.Write(row.Item3);
				binaryWriter.Write(row.Item4);
				binaryWriter.Write(row.Item5);
			}
			if (memoryStream.Length > 16384)
			{
				throw new ArgumentException("POI reply too large.");
			}
			return memoryStream.ToArray();
		}

		public static IReadOnlyList<Tuple<string, float, float, float, bool>> Decode(byte[] bytes)
		{
			if (bytes == null || bytes.Length < 5 || bytes.Length > 16384)
			{
				throw new FormatException("Invalid POI payload length.");
			}
			using MemoryStream memoryStream = new MemoryStream(bytes, writable: false);
			using BinaryReader binaryReader = new BinaryReader(memoryStream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
			if (binaryReader.ReadByte() != 1)
			{
				throw new FormatException("Unsupported POI payload.");
			}
			int num = binaryReader.ReadInt32();
			if (num < 0 || num > 512)
			{
				throw new FormatException("Invalid POI count.");
			}
			List<Tuple<string, float, float, float, bool>> list = new List<Tuple<string, float, float, float, bool>>(num);
			for (int i = 0; i < num; i++)
			{
				string item = binaryReader.ReadString();
				float item2 = binaryReader.ReadSingle();
				float item3 = binaryReader.ReadSingle();
				float item4 = binaryReader.ReadSingle();
				byte b = binaryReader.ReadByte();
				Tuple<string, float, float, float, bool> tuple = Tuple.Create(item, item2, item3, item4, b == 1);
				if (b > 1 || !Valid(tuple))
				{
					throw new FormatException("Invalid POI row.");
				}
				list.Add(tuple);
			}
			if (memoryStream.Position != memoryStream.Length)
			{
				throw new FormatException("Trailing POI payload.");
			}
			return list.AsReadOnly();
		}
	}
	public static class TerrainCells
	{
		public static IEnumerable<int> InRadius(int pitch, float centerX, float centerY, float radius, float spacing)
		{
			if (pitch <= 0 || pitch > 1024 || !Finite(centerX) || !Finite(centerY) || !Finite(radius) || radius < 0f || !Finite(spacing) || spacing <= 0f)
			{
				throw new ArgumentOutOfRangeException("pitch", "Invalid terrain grid.");
			}
			float squaredRadius = radius * radius;
			for (int h = 0; h < pitch; h++)
			{
				for (int w = 0; w < pitch; w++)
				{
					float num = ((float)w - centerX) * spacing;
					float num2 = ((float)h - centerY) * spacing;
					if (num * num + num2 * num2 <= squaredRadius)
					{
						yield return h * pitch + w;
					}
				}
			}
		}

		public static bool Shape(int pitch, params int[] lengths)
		{
			if (pitch <= 0 || pitch > 1024)
			{
				return false;
			}
			for (int i = 0; i < lengths.Length; i++)
			{
				if (lengths[i] != pitch * pitch)
				{
					return false;
				}
			}
			return lengths.Length != 0;
		}

		private static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public sealed class WardConfirmation
	{
		public const double MaxAgeSeconds = 75.0;

		private long generation = -1L;

		private string character = "";

		private double started;

		private double expires;

		public void Confirm(long session, string nativeCharacter, double requestStarted)
		{
			if (session < 0 || string.IsNullOrEmpty(nativeCharacter) || double.IsNaN(requestStarted) || double.IsInfinity(requestStarted) || requestStarted < 0.0)
			{
				Clear();
				return;
			}
			generation = session;
			character = nativeCharacter;
			started = requestStarted;
			expires = requestStarted + 75.0;
		}

		public bool Allows(long session, string nativeCharacter, double now)
		{
			if (character.Length > 0 && generation == session && character == nativeCharacter && !double.IsNaN(now) && !double.IsInfinity(now) && now >= started)
			{
				return now < expires;
			}
			return false;
		}

		public void Clear()
		{
			generation = -1L;
			character = "";
			expires = 0.0;
		}
	}
	public sealed class WardStatusSchedule
	{
		public const double RefreshSeconds = 60.0;

		private double next = double.PositiveInfinity;

		private bool requested;

		public void Confirmed(double requestStarted)
		{
			next = ((double.IsNaN(requestStarted) || double.IsInfinity(requestStarted)) ? double.PositiveInfinity : (requestStarted + 60.0));
		}

		public void Request()
		{
			requested = true;
		}

		public bool Due(bool wanted, double now)
		{
			if (wanted)
			{
				if (!requested)
				{
					return now >= next;
				}
				return true;
			}
			return false;
		}

		public void Sent()
		{
			requested = false;
			next = double.PositiveInfinity;
		}

		public void Clear()
		{
			requested = false;
			next = double.PositiveInfinity;
		}
	}
	public readonly struct PieceFootprint
	{
		public float X { get; }

		public float Z { get; }

		public float Extent { get; }

		public long Creator { get; }

		public PieceFootprint(float x, float z, float extent, long creator)
		{
			X = x;
			Z = z;
			Extent = Math.Max(0f, extent);
			Creator = creator;
		}

		public bool Overlaps(float centerX, float centerZ, float radius)
		{
			float num = X - centerX;
			float num2 = Z - centerZ;
			float num3 = radius + Extent;
			return num * num + num2 * num2 <= num3 * num3;
		}
	}
	public sealed class TerrainArea
	{
		public bool Complete { get; }

		public IReadOnlyList<PieceFootprint> Pieces { get; }

		public TerrainArea(bool complete, IReadOnlyList<PieceFootprint> pieces)
		{
			Complete = complete;
			Pieces = pieces ?? Array.Empty<PieceFootprint>();
		}
	}
	public enum TerrainOutcome
	{
		Proceed,
		RefusedNotAdmin,
		RefusedIncomplete,
		RefusedOtherPieces
	}
	public static class TerrainReset
	{
		public static int Radius(float requested, int serverMaximum)
		{
			int num = Math.Max(1, serverMaximum);
			if (float.IsNaN(requested) || float.IsInfinity(requested))
			{
				return 1;
			}
			return (int)Math.Min(num, Math.Max(1.0, Math.Round(requested, MidpointRounding.AwayFromZero)));
		}

		public static TerrainOutcome Decide(Verdict verdict, long requester, float centerX, float centerZ, int radius, TerrainArea area)
		{
			if (!AdminCheck.Permits(verdict))
			{
				return TerrainOutcome.RefusedNotAdmin;
			}
			if (area == null || !area.Complete)
			{
				return TerrainOutcome.RefusedIncomplete;
			}
			if (verdict == Verdict.Allowed)
			{
				return TerrainOutcome.Proceed;
			}
			if (!area.Pieces.Any((PieceFootprint p) => p.Overlaps(centerX, centerZ, radius) && (p.Creator == 0L || p.Creator != requester)))
			{
				return TerrainOutcome.Proceed;
			}
			return TerrainOutcome.RefusedOtherPieces;
		}
	}
	public enum DropKind
	{
		LooseItem,
		PlacedItem,
		BuildingPiece,
		Container,
		Tombstone,
		SwimmingFish
	}
	public static class DropRules
	{
		public static bool Removes(DropKind kind, float distance, float radius)
		{
			if (kind == DropKind.LooseItem && !float.IsNaN(distance) && distance >= 0f)
			{
				return distance <= radius;
			}
			return false;
		}
	}
	public static class TimeOfDay
	{
		public static double? AtCurrentDay(double seconds, double dayLength, double fraction)
		{
			if (double.IsNaN(seconds) || double.IsInfinity(seconds) || seconds < 0.0 || double.IsNaN(dayLength) || double.IsInfinity(dayLength) || dayLength <= 0.0 || double.IsNaN(fraction) || double.IsInfinity(fraction) || fraction < 0.0 || fraction >= 1.0)
			{
				return null;
			}
			double num = Math.Floor(seconds / dayLength) * dayLength + fraction * dayLength;
			if (!double.IsInfinity(num) && !(num > 315537897599.0))
			{
				return num;
			}
			return null;
		}

		public static double? Parse(string? text)
		{
			string text2 = (text ?? "").Trim();
			switch (text2.ToLowerInvariant())
			{
			case "midnight":
				return 0.0;
			case "sunrise":
				return 0.25;
			case "noon":
				return 0.5;
			case "sunset":
				return 0.75;
			default:
			{
				string[] array = text2.Split(':');
				if (array.Length != 2 || array[0].Length == 0 || array[0].Length > 2 || array[1].Length != 2)
				{
					return null;
				}
				if (!int.TryParse(array[0], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !int.TryParse(array[1], NumberStyles.None, CultureInfo.InvariantCulture, out var result2))
				{
					return null;
				}
				if (result > 23 || result2 > 59)
				{
					return null;
				}
				return (double)(result * 60 + result2) / 1440.0;
			}
			}
		}

		public static string Format(double fraction)
		{
			int num = (int)Math.Round((double.IsNaN(fraction) ? 0.0 : (fraction - Math.Floor(fraction))) * 1440.0) % 1440;
			return (num / 60).ToString("00", CultureInfo.InvariantCulture) + ":" + (num % 60).ToString("00", CultureInfo.InvariantCulture);
		}
	}
	public sealed class GlobalTimeState
	{
		public string SetBy { get; private set; } = "";

		public double Fraction { get; private set; }

		public bool Frozen { get; private set; }

		public void Apply(string adminId, double fraction, bool freeze)
		{
			SetBy = (adminId ?? "").Trim();
			Fraction = fraction;
			Frozen = freeze;
		}

		public bool ShouldRelease(Func<string, bool> online, Func<string, bool> isAdmin, bool releaseOnLeave)
		{
			if (!Frozen || !releaseOnLeave || SetBy.Length == 0)
			{
				return false;
			}
			if (online(SetBy))
			{
				return !isAdmin(SetBy);
			}
			return true;
		}

		public bool Release()
		{
			if (!Frozen)
			{
				return false;
			}
			Frozen = false;
			return true;
		}
	}
	public sealed class WardOverrideGrants
	{
		private readonly HashSet<string> granted = new HashSet<string>(StringComparer.Ordinal);

		public bool Grant(string id)
		{
			return granted.Add((id ?? "").Trim());
		}

		public bool Revoke(string id)
		{
			return granted.Remove((id ?? "").Trim());
		}

		public bool Has(string id)
		{
			return granted.Contains((id ?? "").Trim());
		}

		public IReadOnlyList<string> Prune(Func<string, bool> stillOnlineAdmin)
		{
			List<string> list = granted.Where((string id) => !stillOnlineAdmin(id)).OrderBy<string, string>((string id) => id, StringComparer.Ordinal).ToList();
			foreach (string item in list)
			{
				granted.Remove(item);
			}
			return list;
		}

		public void Clear()
		{
			granted.Clear();
		}
	}
}
namespace ExtraPotions.Thing.UI
{
	public static class GrantReply
	{
		public static bool IsCurrent(string requestedId, string selectedId)
		{
			if (!string.IsNullOrEmpty(requestedId))
			{
				return string.Equals(requestedId, selectedId, StringComparison.Ordinal);
			}
			return false;
		}

		public static bool TryRead(string requestedId, string selectedId, IReadOnlyList<string> lines, out AdminRight set)
		{
			set = AdminRight.None;
			if (!IsCurrent(requestedId, selectedId) || lines == null)
			{
				return false;
			}
			foreach (string line in lines)
			{
				bool fullAdmin;
				if (line != null && line.StartsWith("GRANTS\t", StringComparison.Ordinal))
				{
					return AdminPermissions.TryWire(line, out fullAdmin, out set);
				}
			}
			return false;
		}
	}
	public sealed class ThingUiRow
	{
		public string Kind { get; }

		public string Id { get; }

		public string Caption { get; }

		public string Detail { get; }

		public ThingUiRow(string kind, string id, string caption, string detail)
		{
			Kind = kind;
			Id = id;
			Caption = caption;
			Detail = detail;
		}
	}
	public sealed class ThingUiPage
	{
		public const int PageSize = 12;

		public const int MaxTotal = 10000;

		private const string Marker = "THING_UI_PAGE";

		public string Page { get; }

		public int Offset { get; }

		public int Total { get; }

		public string Version { get; }

		public IReadOnlyList<ThingUiRow> Rows { get; }

		private ThingUiPage(string page, int offset, int total, IReadOnlyList<ThingUiRow> rows, string version = "")
		{
			Page = page;
			Offset = offset;
			Total = total;
			Rows = rows;
			Version = version;
		}

		public static bool Known(string page)
		{
			switch (page)
			{
			default:
				return page == "config_entries";
			case "players":
			case "moderation":
			case "audit":
			case "permitted":
			case "admins":
			case "grants":
			case "announcements":
			case "delve":
			case "delve_actions":
			case "delve_due":
			case "delve_nearest":
			case "delve_nature":
			case "config_files":
				return true;
			}
		}

		public static bool AdminReadPage(string page)
		{
			if (Known(page) && page != "announcements" && page != "delve" && page != "delve_actions" && page != "delve_due" && page != "delve_nearest" && page != "delve_nature" && page != "config_files")
			{
				return page != "config_entries";
			}
			return false;
		}

		public static bool PlatformId(string id)
		{
			if (!string.IsNullOrWhiteSpace(id) && Encoding.UTF8.GetByteCount(id) <= 256)
			{
				return id.All((char c) => char.IsLetterOrDigit(c) || c == '_' || c == '-' || c == ':' || c == '.');
			}
			return false;
		}

		public static IReadOnlyList<string> Encode(string page, int offset, IEnumerable<ThingUiRow> source, string version = "")
		{
			if (version.Length > 0 && !MessageEditing.Version(version))
			{
				throw new ArgumentException("Invalid page version.");
			}
			if (!Known(page) || offset < 0 || offset >= 10000)
			{
				throw new ArgumentException("Invalid Thing page.");
			}
			List<ThingUiRow> list = source.Take(10000).ToList();
			List<string> list2 = new List<string>();
			list2.Add("THING_UI_PAGE\t" + page + "\t" + offset.ToString(CultureInfo.InvariantCulture) + "\t" + list.Count.ToString(CultureInfo.InvariantCulture) + ((version.Length == 0) ? "" : ("\t" + version)));
			List<string> list3 = list2;
			foreach (ThingUiRow item in list.Skip(offset).Take(12))
			{
				if (!PlatformId(item.Id))
				{
					throw new ArgumentException("Invalid row identity.");
				}
				list3.Add(string.Join("\t", AuditEntry.Escape(Clip(item.Kind, 16)), AuditEntry.Escape(item.Id), AuditEntry.Escape(Clip(item.Caption, 128)), AuditEntry.Escape(Clip(item.Detail, 224))));
			}
			return list3;
		}

		private static string Clip(string text, int bytes)
		{
			if (text == null)
			{
				text = "";
			}
			int num = 0;
			int num2 = 0;
			string text2 = text;
			for (int i = 0; i < text2.Length; i++)
			{
				char c = text2[i];
				int num3 = (char.IsSurrogate(c) ? 3 : Encoding.UTF8.GetByteCount(c.ToString()));
				if (num + num3 > bytes)
				{
					break;
				}
				num += num3;
				num2++;
			}
			if (num2 > 0 && char.IsHighSurrogate(text[num2 - 1]))
			{
				num2--;
			}
			return text.Substring(0, num2);
		}

		public static bool TryDecode(IReadOnlyList<string> lines, out ThingUiPage page)
		{
			page = null;
			if (lines == null || lines.Count < 1 || lines.Count > 13)
			{
				return false;
			}
			string[] array = lines[0].Split('\t');
			if ((array.Length != 4 && array.Length != 5) || (array.Length == 5 && !MessageEditing.Version(array[4])) || array[0] != "THING_UI_PAGE" || !Known(array[1]) || !int.TryParse(array[2], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result < 0 || result >= 10000 || !int.TryParse(array[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result2) || result2 < 0 || result2 > 10000 || lines.Count - 1 != Math.Min(12, Math.Max(0, result2 - result)))
			{
				return false;
			}
			List<ThingUiRow> list = new List<ThingUiRow>();
			foreach (string item in lines.Skip(1))
			{
				string[] array2 = item.Split('\t');
				string[] array3 = new string[4];
				if (array2.Length != 4)
				{
					return false;
				}
				for (int i = 0; i < array3.Length; i++)
				{
					if (!AuditEntry.TryUnescape(array2[i], out array3[i]))
					{
						return false;
					}
				}
				if (!PlatformId(array3[1]))
				{
					return false;
				}
				list.Add(new ThingUiRow(array3[0], array3[1], array3[2], array3[3]));
			}
			page = new ThingUiPage(array[1], result, result2, list, (array.Length == 5) ? array[4] : "");
			return true;
		}
	}
}
namespace ExtraPotions.Thing.RemoteConfig
{
	public sealed class ConfigListDocument
	{
		public ConfigEntryDocument Element = new ConfigEntryDocument();

		public IReadOnlyList<string> Values = Array.Empty<string>();

		public const int MaxItems = 128;

		public const int MaxValueBytes = 1024;

		public const int MaxValuesBytes = 4096;

		public static IReadOnlyList<string> PackValues(IReadOnlyList<string> values)
		{
			return ConfigWire.Pack(ValueBytes(values));
		}

		private static byte[] ValueBytes(IReadOnlyList<string> values)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter writer = new BinaryWriter(memoryStream, ConfigWire.Utf8, leaveOpen: true))
			{
				WriteValues(writer, values);
			}
			if (memoryStream.Length > 4096)
			{
				throw new FormatException();
			}
			return memoryStream.ToArray();
		}

		private static void WriteValues(BinaryWriter writer, IReadOnlyList<string> values)
		{
			if (values.Count > 128)
			{
				throw new FormatException();
			}
			writer.Write(values.Count);
			foreach (string value in values)
			{
				if (value == null || ConfigWire.Utf8.GetByteCount(value) > 1024)
				{
					throw new FormatException();
				}
				writer.Write(value);
			}
		}

		private static IReadOnlyList<string> ReadValues(BinaryReader reader)
		{
			int num = reader.ReadInt32();
			if (num < 0 || num > 128)
			{
				throw new FormatException();
			}
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = reader.ReadString();
				if (ConfigWire.Utf8.GetByteCount(array[i]) > 1024)
				{
					throw new FormatException();
				}
			}
			if (ValueBytes(array).Length > 4096)
			{
				throw new FormatException();
			}
			return array;
		}

		public static IReadOnlyList<string> UnpackValues(IReadOnlyList<string> chunks)
		{
			using MemoryStream memoryStream = new MemoryStream(ConfigWire.UnpackBytes(chunks, 4096));
			using BinaryReader reader = new BinaryReader(memoryStream, ConfigWire.Utf8);
			IReadOnlyList<string> result = ReadValues(reader);
			if (memoryStream.Position != memoryStream.Length)
			{
				throw new FormatException();
			}
			return result;
		}

		public IReadOnlyList<string> Encode()
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, ConfigWire.Utf8, leaveOpen: true))
			{
				binaryWriter.Write((byte)1);
				IReadOnlyList<string> readOnlyList = Element.Encode();
				binaryWriter.Write(readOnlyList.Count);
				foreach (string item in readOnlyList)
				{
					binaryWriter.Write(item);
				}
				WriteValues(binaryWriter, Values);
			}
			if (memoryStream.Length > 7168)
			{
				throw new FormatException();
			}
			return new string[1] { "THING_CONFIG_LIST" }.Concat(ConfigWire.Pack(memoryStream.ToArray())).ToArray();
		}

		public static bool TryDecode(IReadOnlyList<string> lines, out ConfigListDocument document)
		{
			document = null;
			if (lines.Count < 2 || lines.Count > 16 || lines[0] != "THING_CONFIG_LIST")
			{
				return false;
			}
			try
			{
				using MemoryStream memoryStream = new MemoryStream(ConfigWire.UnpackBytes(lines.Skip(1).ToArray(), 7168));
				using BinaryReader binaryReader = new BinaryReader(memoryStream, ConfigWire.Utf8);
				if (binaryReader.ReadByte() != 1)
				{
					return false;
				}
				int num = binaryReader.ReadInt32();
				if (num < 2 || num > 16)
				{
					return false;
				}
				string[] array = new string[num];
				for (int i = 0; i < num; i++)
				{
					array[i] = binaryReader.ReadString();
				}
				if (!ConfigEntryDocument.TryDecode(array, out ConfigEntryDocument document2))
				{
					return false;
				}
				IReadOnlyList<string> values = ReadValues(binaryReader);
				if (memoryStream.Position != memoryStream.Length)
				{
					return false;
				}
				document = new ConfigListDocument
				{
					Element = document2,
					Values = values
				};
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	public sealed class ConfigEditRequest
	{
		public string Verb { get; private set; } = "";

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

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

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

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

		public int Offset { get; private set; }

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

		public int Total { get; private set; }

		public byte[] Bytes { get; private set; } = Array.Empty<byte>();

		public IReadOnlyList<string> ListValues { get; private set; } = Array.Empty<string>();

		public bool Writes
		{
			get
			{
				if (!(Verb == "list-set") && !(Verb == "set") && !(Verb == "yaml-begin") && !(Verb == "yaml-put"))
				{
					return Verb == "yaml-commit";
				}
				return true;
			}
		}

		public ConfigEditRequest WithValue(string value)
		{
			return new ConfigEditRequest
			{
				Verb = "set",
				File = File,
				Entry = Entry,
				Version = Version,
				Value = value
			};
		}

		public static bool TryParse(IReadOnlyList<string> args, out ConfigEditRequest request)
		{
			request = null;
			if (args == null || args.Count == 0)
			{
				return false;
			}
			string text = args[0].ToLowerInvariant();
			ConfigEditRequest configEditRequest = new ConfigEditRequest();
			if (text == "set")
			{
				if (args.Count < 5 || !MessageEditing.Version(args[1]) || !MessageEditing.Version(args[2]) || !MessageEditing.Version(args[3]))
				{
					return false;
				}
				try
				{
					configEditRequest.Value = ConfigWire.Unpack(args.Skip(4).ToArray(), 4096);
				}
				catch
				{
					return false;
				}
				configEditRequest.Verb = "set";
				configEditRequest.File = args[1];
				configEditRequest.Entry = args[2];
				configEditRequest.Version = args[3];
				request = configEditRequest;
				return true;
			}
			if (text != "config" || args.Count < 2)
			{
				return false;
			}
			configEditRequest.Verb = args[1].ToLowerInvariant();
			if (configEditRequest.Verb == "list-get" || configEditRequest.Verb == "list-set")
			{
				if (args.Count < 4 || !MessageEditing.Version(args[2]) || !MessageEditing.Version(args[3]))
				{
					return false;
				}
				configEditRequest.File = args[2];
				configEditRequest.Entry = args[3];
				if (configEditRequest.Verb == "list-get")
				{
					if (args.Count != 4)
					{
						return false;
					}
				}
				else
				{
					if (args.Count < 6 || !MessageEditing.Version(args[4]))
					{
						return false;
					}
					configEditRequest.Version = args[4];
					try
					{
						configEditRequest.ListValues = ConfigListDocument.UnpackValues(args.Skip(5).ToArray());
					}
					catch
					{
						return false;
					}
				}
				request = configEditRequest;
				return true;
			}
			if (configEditRequest.Verb.StartsWith("yaml-", StringComparison.Ordinal))
			{
				if (args.Count < 3 || !MessageEditing.Version(args[2]))
				{
					return false;
				}
				configEditRequest.Token = args[2];
				switch (configEditRequest.Verb)
				{
				case "yaml-open":
					if (args.Count != 3)
					{
						return false;
					}
					configEditRequest.File = args[2];
					break;
				case "yaml-cancel":
				case "yaml-commit":
					if (args.Count != 3)
					{
						return false;
					}
					break;
				case "yaml-read":
				{
					if (args.Count != 4 || !int.TryParse(args[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result2) || result2 < 0 || result2 > 1048576)
					{
						return false;
					}
					configEditRequest.Offset = result2;
					break;
				}
				case "yaml-begin":
				{
					if (args.Count != 5 || !int.TryParse(args[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result3) || result3 < 0 || result3 > 1048576 || !MessageEditing.Version(args[4]))
					{
						return false;
					}
					configEditRequest.Total = result3;
					configEditRequest.Version = args[4];
					break;
				}
				case "yaml-put":
				{
					if (args.Count < 5 || !int.TryParse(args[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result < 0 || result > 1048576)
					{
						return false;
					}
					try
					{
						configEditRequest.Bytes = YamlTransfer.Unpack(args.Skip(4).ToArray());
					}
					catch
					{
						return false;
					}
					if (configEditRequest.Bytes.Length == 0)
					{
						return false;
					}
					configEditRequest.Offset = result;
					break;
				}
				default:
					return false;
				}
				request = configEditRequest;
				return true;
			}
			if (configEditRequest.Verb == "list")
			{
				if (args.Count != 2 && args.Count != 3)
				{
					return false;
				}
			}
			else
			{
				if (!(configEditRequest.Verb == "entries"))
				{
					if (configEditRequest.Verb == "get")
					{
						if (args.Count != 4 || !MessageEditing.Version(args[2]) || !MessageEditing.Version(args[3]))
						{
							return false;
						}
						configEditRequest.File = args[2];
						configEditRequest.Entry = args[3];
						request = configEditRequest;
						return true;
					}
					return false;
				}
				if ((args.Count != 3 && args.Count != 4) || !MessageEditing.Version(args[2]))
				{
					return false;
				}
				configEditRequest.File = args[2];
			}
			int num = ((configEditRequest.Verb == "list") ? 2 : 3);
			if (args.Count > num && (!int.TryParse(args[num], NumberStyles.None, CultureInfo.InvariantCulture, out var result4) || result4 < 0 || result4 >= 10000))
			{
				return false;
			}
			configEditRequest.Offset = ((args.Count > num) ? int.Parse(args[num], CultureInfo.InvariantCulture) : 0);
			request = configEditRequest;
			return true;
		}
	}
	public sealed class ConfigEntryDocument
	{
		public string File = "";

		public string Entry = "";

		public string Version = "";

		public string Section = "";

		public string Key = "";

		public string Description = "";

		public string Current = "";

		public string Default = "";

		public string Reason = "";

		public string Effective = "";

		public bool Editable;

		public SettingShape Shape = SettingShape.String();

		public EntryAttributes Attributes = AttributeReader.Read(Array.Empty<TagObject>());

		public IReadOnlyList<string> Encode()
		{
			if (!MessageEditing.Version(File) || !MessageEditing.Version(Entry) || !MessageEditing.Version(Version))
			{
				throw new FormatException("Invalid config document identity.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, ConfigWire.Utf8, leaveOpen: true))
			{
				binaryWriter.Write((byte)1);
				string[] array = new string[10] { File, Entry, Version, Section, Key, Description, Current, Default, Reason, Effective };
				foreach (string value in array)
				{
					binaryWriter.Write(value);
				}
				binaryWriter.Write(Editable);
				binaryWriter.Write((int)Shape.Kind);
				binaryWriter.Write(Shape.TypeName);
				binaryWriter.Write(Shape.HasConverter);
				binaryWriter.Write(Shape.IsFlags);
				binaryWriter.Write(Shape.HasRange);
				binaryWriter.Write(Shape.RangeMin);
				binaryWriter.Write(Shape.RangeMax);
				WriteList(binaryWriter, Shape.EnumNames);
				WriteList(binaryWriter, Shape.AcceptableList);
				WriteList(binaryWriter, Shape.KeyNames);
				binaryWriter.Write(Attributes.RequiresRestart);
				binaryWriter.Write(Attributes.Multiline);
				binaryWriter.Write(Attributes.ListSeparator ?? "");
				binaryWriter.Write(Attributes.Unit ?? "");
				binaryWriter.Write(Attributes.Step.HasValue);
				binaryWriter.Write(Attributes.Step.GetValueOrDefault());
				binaryWriter.Write(Attributes.ShowRangeAsPercent == true);
			}
			if (memoryStream.Length > 7168)
			{
				throw new FormatException("Config metadata exceeds one bounded frame.");
			}
			return new string[1] { "THING_CONFIG_ENTRY" }.Concat(ConfigWire.Pack(memoryStream.ToArray())).ToArray();
		}

		private static void WriteList(BinaryWriter writer, IReadOnlyList<string>? list)
		{
			if (list != null && list.Count > 512)
			{
				throw new FormatException("Too many metadata choices.");
			}
			writer.Write(list?.Count ?? (-1));
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				writer.Write(item);
			}
		}

		private static string[]? ReadList(BinaryReader reader)
		{
			int num = reader.ReadInt32();
			if (num == -1)
			{
				return null;
			}
			if (num < 0 || num > 512)
			{
				throw new FormatException();
			}
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = reader.ReadString();
			}
			return array;
		}

		public static bool TryDecode(IReadOnlyList<string> lines, out ConfigEntryDocument document)
		{
			document = null;
			if (lines == null || lines.Count < 2 || lines.Count > 16 || lines[0] != "THING_CONFIG_ENTRY")
			{
				return false;
			}
			try
			{
				using MemoryStream memoryStream = new MemoryStream(ConfigWire.UnpackBytes(lines.Skip(1).ToArray(), 7168));
				using BinaryReader binaryReader = new BinaryReader(memoryStream, ConfigWire.Utf8);
				if (binaryReader.ReadByte() != 1)
				{
					return false;
				}
				ConfigEntryDocument configEntryDocument = new ConfigEntryDocument
				{
					File = binaryReader.ReadString(),
					Entry = binaryReader.ReadString(),
					Version = binaryReader.ReadString(),
					Section = binaryReader.ReadString(),
					Key = binaryReader.ReadString(),
					Description = binaryReader.ReadString(),
					Current = binaryReader.ReadString(),
					Default = binaryReader.ReadString(),
					Reason = binaryReader.ReadString(),
					Effective = binaryReader.ReadString(),
					Editable = binaryReader.ReadBoolean()
				};
				if (!MessageEditing.Version(configEntryDocument.File) || !MessageEditing.Version(configEntryDocument.Entry) || !MessageEditing.Version(configEntryDocument.Version) || configEntryDocument.Current.Length > 4096 || configEntryDocument.Default.Length > 4096)
				{
					return false;
				}
				SettingKind settingKind = (SettingKind)binaryReader.ReadInt32();
				if (!Enum.IsDefined(typeof(SettingKind), settingKind))
				{
					return false;
				}
				string typeName = binaryReader.ReadString();
				bool hasConverter = binaryReader.ReadBoolean();
				bool flags = binaryReader.ReadBoolean();
				bool num = binaryReader.ReadBoolean();
				double num2 = binaryReader.ReadDouble();
				double num3 = binaryReader.ReadDouble();
				string[] array = ReadList(binaryReader);
				string[] array2 = ReadList(binaryReader);
				string[] array3 = ReadList(binaryReader);
				configEntryDocument.Shape = ((settingKind == SettingKind.Enum) ? SettingShape.Enum(typeName, array ?? Array.Empty<string>(), flags) : SettingShape.Of(settingKind, typeName, hasConverter));
				if (num)
				{
					if (double.IsNaN(num2) || double.IsInfinity(num2) || double.IsNaN(num3) || double.IsInfinity(num3))
					{
						return false;
					}
					configEntryDocument.Shape = configEntryDocument.Shape.WithRange(num2, num3);
				}
				if (array2 != null)
				{
					configEntryDocument.Shape = configEntryDocument.Shape.WithList(array2);
				}
				if (array3 != null)
				{
					configEntryDocument.Shape = configEntryDocument.Shape.WithKeyNames(array3);
				}
				configEntryDocument.Attributes.RequiresRestart = binaryReader.ReadBoolean();
				configEntryDocument.Attributes.Multiline = binaryReader.ReadBoolean();
				string text = binaryReader.ReadString();
				configEntryDocument.Attributes.ListSeparator = ((text.Length == 0) ? null : text);
				string text2 = binaryReader.ReadString();
				configEntryDocument.Attributes.Unit = ((text2.Length == 0) ? null : text2);
				bool num4 = binaryReader.ReadBoolean();
				double num5 = binaryReader.ReadDouble();
				if (num4)
				{
					if (double.IsNaN(num5) || double.IsInfinity(num5) || num5 <= 0.0)
					{
						return false;
					}
					configEntryDocument.Attributes.Step = num5;
				}
				configEntryDocument.Attributes.ShowRangeAsPercent = binaryReader.ReadBoolean();
				if (memoryStream.Position != memoryStream.Length)
				{
					return false;
				}
				document = configEntryDocument;
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	public static class ConfigWire
	{
		public const string Marker = "THING_CONFIG_ENTRY";

		public const int MaxDocumentBytes = 7168;

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

		public static IReadOnlyList<string> PackValue(string value)
		{
			return Pack(Utf8.GetBytes(value ?? ""));
		}

		public static IReadOnlyList<string> WriteEcho(string version, string value)
		{
			if (!MessageEditing.Version(version) || Utf8.GetByteCount(value) > 4096)
			{
				throw new FormatException();
			}
			return new string[1] { "THING_CONFIG_WRITE\t" + version }.Concat(PackValue(value)).ToArray();
		}

		public static bool TryWriteEcho(IReadOnlyList<string> lines, out string version, out string value)
		{
			version = (value = "");
			if (lines == null || lines.Count < 2 || lines.Count > 16)
			{
				return false;
			}
			string[] array = lines[0].Split('\t');
			if (array.Length != 2 || array[0] != "THING_CONFIG_WRITE" || !MessageEditing.Version(array[1]))
			{
				return false;
			}
			try
			{
				value = Unpack(lines.Skip(1).ToArray(), 4096);
				version = array[1];
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static IReadOnlyList<string> Pack(byte[] bytes)
		{
			string text = Convert.ToBase64String(bytes);
			List<string> list = new List<string>();
			for (int i = 0; i < text.Length; i += 700)
			{
				list.Add(text.Substring(i, Math.Min(700, text.Length - i)));
			}
			if (list.Count == 0)
			{
				list.Add("");
			}
			return list;
		}

		internal static string Unpack(IReadOnlyList<string> parts, int max)
		{
			return Utf8.GetString(UnpackBytes(parts, max));
		}

		internal static byte[] UnpackBytes(IReadOnlyList<string> parts, int max)
		{
			if (parts.Count < 1 || parts.Count > 15 || parts.Any((string p) => p == null || p.Length > 700))
			{
				throw new FormatException();
			}
			byte[] array = Convert.FromBase64String(string.Concat(parts));
			if (array.Length > max)
			{
				throw new FormatException();
			}
			return array;
		}
	}
	public enum FileVerdict
	{
		Allowed,
		RefusedPath,
		RefusedLink,
		RefusedAdminList,
		RefusedExtension,
		RefusedScope,
		RefusedTooLarge
	}
	public readonly struct FileRequest
	{
		public string Path { get; }

		public long SizeBytes { get; }

		public bool IsLink { get; }

		public FileRequest(string path, long sizeBytes, bool isLink)
		{
			Path = path ?? "";
			SizeBytes = sizeBytes;
			IsLink = isLink;
		}
	}
	public sealed class FilePolicy
	{
		public RemoteConfigScope Scope { get; }

		public bool CaseSensitive { get; }

		public ISet<string> AllowList { get; }

		public ISet<string> RegisteredYaml { get; }

		public FilePolicy(RemoteConfigScope scope, string allowList, IEnumerable<string> registeredYaml, bool caseSensitive)
		{
			Scope = scope;
			CaseSensitive = caseSensitive;
			StringComparer comparer = (caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);
			AllowList = new HashSet<string>(from n in ThingSettings.NormalizeList(allowList ?? "").Split(',')
				where n.Length > 0
				select n, comparer);
			RegisteredYaml = new HashSet<string>(registeredYaml ?? Enumerable.Empty<string>(), comparer);
		}
	}
	public static class RemoteFiles
	{
		public const long MaxBytes = 1048576L;

		public const string MeadworksPrefix = "com.meadworks.";

		public const string ThingConfig = "com.meadworks.thing.cfg";

		public const string ThingFolder = "Meadworks/thing/";

		public static FileVerdict Check(FileRequest request, FilePolicy policy)
		{
			if (policy == null)
			{
				throw new ArgumentNullException("policy");
			}
			string path = request.Path;
			if (!SafePath(path))
			{
				return FileVerdict.RefusedPath;
			}
			if (request.IsLink)
			{
				return FileVerdict.RefusedLink;
			}
			if (string.Equals(path, "adminlist.txt", StringComparison.OrdinalIgnoreCase))
			{
				return FileVerdict.RefusedAdminList;
			}
			bool flag = path.IndexOf('/') < 0;
			bool flag2 = path.EndsWith(".cfg", StringComparison.OrdinalIgnoreCase);
			bool flag3 = path.EndsWith(".yml", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".yaml", StringComparison.OrdinalIgnoreCase);
			if (flag3 ? (!policy.RegisteredYaml.Contains(path)) : (!flag2))
			{
				return FileVerdict.RefusedExtension;
			}
			StringComparison comparisonType = (policy.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
			bool flag4 = flag3 || (flag && path.StartsWith("com.meadworks.", comparisonType));
			if (policy.Scope switch
			{
				RemoteConfigScope.AllowList => (flag4 || (flag && policy.AllowList.Contains(path))) ? 1 : 0, 
				RemoteConfigScope.AllConfigFiles => (flag4 || flag) ? 1 : 0, 
				_ => flag4 ? 1 : 0, 
			} == 0)
			{
				return FileVerdict.RefusedScope;
			}
			if (request.SizeBytes < 0 || request.SizeBytes > 1048576)
			{
				return FileVerdict.RefusedTooLarge;
			}
			return FileVerdict.Allowed;
		}

		public static bool SafePath(string? path)
		{
			if (string.IsNullOrEmpty(path) || path[0] == '/')
			{
				return false;
			}
			if (path.Any((char c) => c == '\\' || c == ':' || char.IsControl(c)))
			{
				return false;
			}
			string[] array = path.Split('/');
			foreach (string text in array)
			{
				if (text.Length == 0 || text == "." || text == "..")
				{
					return false;
				}
				if (text.Trim() != text || text.EndsWith(".", StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		public static bool RawTextEditable(string path, IEnumerable<string> registeredYaml, bool caseSensitive)
		{
			return new FilePolicy(RemoteConfigScope.MeadworksOnly, "", registeredYaml, caseSensitive).RegisteredYaml.Contains(path ?? "");
		}

		public static bool Protected(string path)
		{
			if (!string.Equals(path, "com.meadworks.thing.cfg", StringComparison.OrdinalIgnoreCase))
			{
				return (path ?? "").StartsWith("Meadworks/thing/", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
	public static class FileVersion
	{
		public static string Hash(byte[] bytes)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(bytes ?? Array.Empty<byte>());
			StringBuilder stringBuilder = new StringBuilder(64);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2", CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		public static bool Matches(string expectedHash, byte[] current)
		{
			return string.Equals(expectedHash, Hash(current), StringComparison.OrdinalIgnoreCase);
		}
	}
	public static class Backups
	{
		private const string StampFormat = "yyyyMMdd-HHmmss";

		private const string Suffix = ".bak";

		public static string Name(string path, DateTime utc)
		{
			return path + "." + utc.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture) + ".bak";
		}

		public static IReadOnlyList<string> ToDelete(string path, IEnumerable<string> existing, int keep)
		{
			string text = path + ".";
			List<(DateTime, string)> list = new List<(DateTime, string)>();
			foreach (string item in existing ?? Enumerable.Empty<string>())
			{
				if (item.StartsWith(text, StringComparison.Ordinal) && item.EndsWith(".bak", StringComparison.Ordinal) && DateTime.TryParseExact(item.Substring(text.Length, item.Length - text.Length - ".bak".Length), "yyyyMMdd-HHmmss", CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
				{
					list.Add((result, item));
				}
			}
			List<string> list2 = (from m in list.OrderBy<(DateTime, string), DateTime>(((DateTime Stamp, string Name) m) => m.Stamp).ThenBy<(DateTime, string), string>(((DateTime Stamp, string Name) m) => m.Name, StringComparer.Ordinal)
				select m.Name).ToList();
			return list2.Take(Math.Max(0, list2.Count - Math.Max(0, keep))).ToList();
		}

		public static bool FirstWriteThisSession(string path, ISet<string> writtenThisSession)
		{
			return !writtenThisSession.Contains(path);
		}
	}
	public static class YamlTransfer
	{
		public const int MaxBytes = 1048576;

		public const int ChunkBytes = 6144;

		public static IReadOnlyList<string> Pack(byte[] bytes)
		{
			return ConfigWire.Pack(bytes);
		}

		public static byte[] Unpack(IReadOnlyList<string> parts)
		{
			return ConfigWire.UnpackBytes(parts, 6144);
		}

		public static string Text(byte[] bytes)
		{
			return ConfigWire.Utf8.GetString(bytes);
		}

		public static byte[] Bytes(string text)
		{
			return ConfigWire.Utf8.GetBytes(text);
		}

		public static IReadOnlyList<string> Header(string token, string version, int total)
		{
			return new string[1] { "THING_YAML\t" + token + "\t" + version + "\t" + total.ToString(CultureInfo.InvariantCulture) };
		}

		public static bool TryHeader(IReadOnlyList<string> lines, out string token, out string version, out int total)
		{
			token = (version = "");
			total = 0;
			if (lines.Count != 1)
			{
				return false;
			}
			string[] array = lines[0].Split('\t');
			if (array.Length != 4 || array[0] != "THING_YAML" || !MessageEditing.Version(array[1]) || !MessageEditing.Version(array[2]) || !int.TryParse(array[3], NumberStyles.None, CultureInfo.InvariantCulture, out total) || total < 0 || total > 1048576)
			{
				return false;
			}
			token = array[1];
			version = array[2];
			return true;
		}

		public static IReadOnlyList<string> Chunk(string token, int offset, byte[] bytes)
		{
			return new string[1] { "THING_YAML_CHUNK\t" + token + "\t" + offset.ToString(CultureInfo.InvariantCulture) }.Concat(Pack(bytes)).ToArray();
		}

		public static bool TryChunk(IReadOnlyList<string> lines, string token, int offset, out byte[] bytes)
		{
			bytes = Array.Empty<byte>();
			if (lines.Count < 2 || lines.Count > 16 || lines[0] != "THING_YAML_CHUNK\t" + token + "\t" + offset.ToString(CultureInfo.InvariantCulture))
			{
				return false;
			}
			try
			{
				bytes = Unpack(lines.Skip(1).ToArray());
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	public sealed class YamlUpload
	{
		private byte[]? bytes;

		private readonly string hash;

		public int Received { get; private set; }

		public int Length { get; }

		public YamlUpload(int length, string hash)
		{
			if (length < 0 || length > 1048576 || !MessageEditing.Version(hash))
			{
				throw new ArgumentException();
			}
			bytes = new byte[length];
			Length = length;
			this.hash = hash;
		}

		public bool Append(int offset, byte[] chunk)
		{
			if (bytes == null || chunk == null || chunk.Length == 0 || chunk.Length > 6144 || offset != Received || chunk.Length > Length - Received)
			{
				return false;
			}
			Buffer.BlockCopy(chunk, 0, bytes, Received, chunk.Length);
			Received += chunk.Length;
			return true;
		}

		public bool Take(out string text)
		{
			text = "";
			byte[] array = bytes;
			bytes = null;
			if (array == null || Received != Length || !FileVersion.Matches(hash, array))
			{
				return false;
			}
			try
			{
				text = YamlTransfer.Text(array);
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
}
namespace ExtraPotions.Thing.Moderation
{
	public static class GameListIdentity
	{
		public static bool Valid(string text)
		{
			if (string.IsNullOrEmpty(text) || text.Length > 160)
			{
				return false;
			}
			if (text.All((char c) => c >= '0' && c <= '9'))
			{
				return true;
			}
			int num = text.IndexOf('_');
			if (num > 0 && num < text.Length - 1 && text.Substring(0, num).All((char c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
			{
				return text.Substring(num + 1).All((char c) => char.IsLetterOrDigit(c) || c == '-' || c == '_' || c == ':' || c == '.');
			}
			return false;
		}
	}
	public readonly struct Actor
	{
		public string Id { get; }

		public string Name { get; }

		public Actor(string id, string name)
		{
			Id = (id ?? "").Trim();
			Name = name ?? "";
		}
	}
	public enum LedgerChange
	{
		Unchanged,
		Added,
		Updated,
		Removed
	}
	public enum RecordKind
	{
		Ban,
		Mute,
		Warn
	}
	public sealed class LedgerRecord
	{
		public RecordKind Kind { get; }

		public Actor Target { get; }

		public Actor Admin { get; }

		public string Reason { get; }

		public DateTime AtUtc { get; }

		public DateTime? ExpiresUtc { get; }

		public LedgerRecord(RecordKind kind, Actor target, Actor admin, string reason, DateTime atUtc, DateTime? expiresUtc)
		{
			Kind = kind;
			Target = target;
			Admin = admin;
			Reason = reason ?? "";
			AtUtc = atUtc;
			ExpiresUtc = expiresUtc;
		}

		public bool ActiveAt(DateTime nowUtc)
		{
			if (ExpiresUtc.HasValue)
			{
				return nowUtc < ExpiresUtc.Value;
			}
			return true;
		}
	}
	public sealed class ModerationLedger
	{
		private const string Header = "# Thing moderation ledger (managed by Thing on the server; one entry per line, tab-separated)";

		private const string TimeFormat = "yyyy-MM-dd'T'HH:mm:ss'Z'";

		private readonly Dictionary<string, LedgerRecord> bans = new Dictionary<string, LedgerRecord>(StringComparer.Ordinal);

		private readonly Dictionary<string, LedgerRecord> mutes = new Dictionary<string, LedgerRecord>(StringComparer.Ordinal);

		private readonly List<LedgerRecord> warnings = new List<LedgerRecord>();

		public IReadOnlyDictionary<string, LedgerRecord> Bans => bans;

		public IReadOnlyDictionary<string, LedgerRecord> Mutes => mutes;

		public IReadOnlyList<LedgerRecord> Warnings => warnings;

		public LedgerChange Ban(Actor target, Actor admin, string reason, DateTime nowUtc, TimeSpan? duration)
		{
			return Put(bans, RecordKind.Ban, target, admin, reason, nowUtc, duration);
		}

		public LedgerChange Unban(string id)
		{
			if (!bans.Remove((id ?? "").Trim()))
			{
				return LedgerChange.Unchanged;
			}
			return LedgerChange.Removed;
		}

		public bool IsBanned(string id, DateTime nowUtc)
		{
			if (bans.TryGetValue((id ?? "").Trim(), out LedgerRecord value))
			{
				return value.ActiveAt(nowUtc);
			}
			return false;
		}

		public IReadOnlyList<LedgerRecord> TakeExpired(DateTime nowUtc)
		{
			return Take(bans, nowUtc);
		}

		public LedgerChange Mute(Actor target, Actor admin, string reason, DateTime nowUtc, TimeSpan? duration)
		{
			return Put(mutes, RecordKind.Mute, target, admin, reason, nowUtc, duration);
		}

		public LedgerChange Unmute(string id)
		{
			if (!mutes.Remove((id ?? "").Trim()))
			{
				return LedgerChange.Unchanged;
			}
			return LedgerChange.Removed;
		}

		public bool IsMuted(string id, DateTime nowUtc)
		{
			if (mutes.TryGetValue((id ?? "").Trim(), out LedgerRecord value))
			{
				return value.ActiveAt(nowUtc);
			}
			return false;
		}

		public IReadOnlyList<LedgerRecord> TakeExpiredMutes(DateTime nowUtc)
		{
			return Take(mutes, nowUtc);
		}

		public void Warn(Actor target, Actor admin, string reason, DateTime nowUtc)
		{
			Require(target);
			warnings.Add(new LedgerRecord(RecordKind.Warn, target, admin, Reasons.Normalize(reason), Second(nowUtc), null));
		}

		public IReadOnlyList<LedgerRecord> WarningsFor(string id)
		{
			return warnings.Where((LedgerRecord w) => w.Target.Id == (id ?? "").Trim()).ToList();
		}

		public string Save()
		{
			StringBuilder stringBuilder = new StringBuilder("# Thing moderation ledger (managed by Thing on the server; one entry per line, tab-separated)").Append('\n');
			foreach (LedgerRecord item in bans.Values.OrderBy<LedgerRecord, string>((LedgerRecord r) => r.Target.Id, StringComparer.Ordinal))
			{
				stringBuilder.Append(Line(item)).Append('\n');
			}
			foreach (LedgerRecord item2 in mutes.Values.OrderBy<LedgerRecord, string>((LedgerRecord r) => r.Target.Id, StringComparer.Ordinal))
			{
				stringBuilder.Append(Line(item2)).Append('\n');
			}
			foreach (LedgerRecord warning in warnings)
			{
				stringBuilder.Append(Line(warning)).Append('\n');
			}
			return stringBuilder.ToString();
		}

		public static ModerationLedger Load(string? text, out int skipped)
		{
			ModerationLedger moderationLedger = new ModerationLedger();
			skipped = 0;
			string[] array = (text ?? "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].TrimEnd('\r');
				if (text2.Trim().Length == 0 || text2.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (!TryParse(text2, out LedgerRecord record) || record.Target.Id.Length == 0)
				{
					skipped++;
					continue;
				}
				switch (record.Kind)
				{
				case RecordKind.Ban:
					moderationLedger.bans[record.Target.Id] = record;
					break;
				case RecordKind.Mute:
					moderationLedger.mutes[record.Target.Id] = record;
					break;
				default:
					moderationLedger.warnings.Add(record);
					break;
				}
			}
			return moderationLedger;
		}

		private static LedgerChange Put(Dictionary<string, LedgerRecord> map, RecordKind kind, Actor target, Actor admin, string reason, DateTime nowUtc, TimeSpan? duration)
		{
			Require(target);
			if (duration.HasValue && duration.Value <= TimeSpan.Zero)
			{
				throw new ArgumentException("Expected a positive duration.", "duration");
			}
			DateTime dateTime = Second(nowUtc);
			DateTime? expiresUtc = (duration.HasValue ? new DateTime?(dateTime + duration.Value) : ((DateTime?)null));
			string text = Reasons.Normalize(reason);
			if (map.TryGetValue(target.Id, out LedgerRecord value))
			{
				if (value.Reason == text && !value.ExpiresUtc.HasValue && !expiresUtc.HasValue)
				{
					return LedgerChange.Unchanged;
				}
				map[target.Id] = new LedgerRecord(kind, target, admin, text, dateTime, expiresUtc);
				return LedgerChange.Updated;
			}
			map[target.Id] = new LedgerRecord(kind, target, admin, text, dateTime, expiresUtc);
			return LedgerChange.Added;
		}

		private static IReadOnlyList<LedgerRecord> Take(Dictionary<string, LedgerRecord> map, DateTime nowUtc)
		{
			List<LedgerRecord> list = map.Values.Where((LedgerRecord r) => !r.ActiveAt(nowUtc)).OrderBy<LedgerRecord, string>((LedgerRecord r) => r.Target.Id, StringComparer.Ordinal).ToList();
			foreach (LedgerRecord item in list)
			{
				map.Remove(item.Target.Id);
			}
			return list;
		}

		private static void Require(Actor target)
		{
			if (target.Id.Length == 0)
			{
				throw new ArgumentException("A moderation target needs a platform ID.", "target");
			}
		}

		private static DateTime Second(DateTime utc)
		{
			return DateTime.SpecifyKind(new DateTime(utc.Ticks - utc.Ticks % 10000000), DateTimeKind.Utc);
		}

		private static string Time(DateTime utc)
		{
			return utc.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);
		}

		private static string Line(LedgerRecord r)
		{
			return string.Join("\t", r.Kind.ToString().ToLowerInvariant(), AuditEntry.Escape(r.Target.Id), AuditEntry.Escape(r.Target.Name), AuditEntry.Escape(r.Admin.Id), AuditEntry.Escape(r.Admin.Name), Time(r.AtUtc), r.ExpiresUtc.HasValue ? Time(r.ExpiresUtc.Value) : "-", AuditEntry.Escape(r.Reason));
		}

		private static bool TryParse(string line, out LedgerRecord record)
		{
			record = null;
			string[] array = line.Split('\t');
			if (array.Length != 8)
			{
				return false;
			}
			RecordKind recordKind;
			switch (array[0])
			{
			case "ban":
				recordKind = RecordKind.Ban;
				break;
			case "mute":
				recordKind = RecordKind.Mute;
				break;
			case "warn":
				recordKind = RecordKind.Warn;
				break;
			default:
				return false;
			}
			if (!TryTime(array[5], out var utc))
			{
				return false;
			}
			DateTime? expiresUtc = null;
			if (array[6] != "-")
			{
				if (recordKind == RecordKind.Warn || !TryTime(array[6], out var utc2))
				{
					return false;
				}
				expiresUtc = utc2;
			}
			if (!AuditEntry.TryUnescape(array[1], out string value) || !AuditEntry.TryUnescape(array[2], out string value2) || !AuditEntry.TryUnescape(array[3], out string value3) || !AuditEntry.TryUnescape(array[4], out string value4) || !AuditEntry.TryUnescape(array[7], out string value5))
			{
				return false;
			}
			record = new LedgerRecord(recordKind, new Actor(value, value2), new Actor(value3, value4), value5, utc, expiresUtc);
			return true;
		}

		private static bool TryTime(string text, out DateTime utc)
		{
			bool result = DateTime.TryParseExact(text, "yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out utc);
			utc = DateTime.SpecifyKind(utc, DateTimeKind.Utc);
			return result;
		}
	}
	public enum DurationUnit
	{
		Minutes,
		Hours
	}
	public static class Durations
	{
		public static TimeSpan? Parse(string? text, DurationUnit defaultUnit, int maximum)
		{
			string text2 = (text ?? "").Trim().ToLowerInvariant();
			if (text2.Length == 0)
			{
				return null;
			}
			char c = text2[text2.Length - 1];
			string text3 = (char.IsDigit(c) ? text2 : text2.Substring(0, text2.Length - 1));
			if (text3.Length == 0 || !text3.All(char.IsDigit) || !long.TryParse(text3, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result <= 0)
			{
				return null;
			}
			double val;
			switch ((char)((!char.IsDigit(c)) ? c : ((defaultUnit == DurationUnit.Hours) ? 104 : 109)))
			{
			case 'm':
				val = result;
				break;
			case 'h':
				val = (double)result * 60.0;
				break;
			case 'd':
				val = (double)result * 1440.0;
				break;
			default:
				return null;
			}
			double val2 = ((defaultUnit == DurationUnit.Hours) ? ((double)maximum * 60.0) : ((double)maximum));
			return TimeSpan.FromMinutes(Math.Min(val, val2));
		}

		public static string Describe(TimeSpan span)
		{
			long num = (long)Math.Max(0.0, Math.Round(span.TotalMinutes));
			List<string> list = new List<string>();
			if (num / 1440 > 0)
			{
				list.Add((num / 1440).ToString(CultureInfo.InvariantCulture) + "d");
			}
			if (num / 60 % 24 > 0)
			{
				list.Add((num / 60 % 24).ToString(CultureInfo.InvariantCulture) + "h");
			}
			if (num % 60 > 0 || list.Count == 0)
			{
				list.Add((num % 60).ToString(CultureInfo.InvariantCulture) + "m");
			}
			return string.Join(" ", list);
		}
	}
	public static class Reasons
	{
		public const int MaxLength = 200;

		public static string Normalize(string? text)
		{
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			string text2 = (text ?? "").Trim();
			foreach (char c in text2)
			{
				if (char.IsWhiteSpace(c) || char.IsControl(c))
				{
					flag = true;
					continue;
				}
				if (flag && stringBuilder.Length > 0)
				{
					stringBuilder.Append(' ');
				}
				flag = false;
				stringBuilder.Append(c);
			}
			if (stringBuilder.Length <= 200)
			{
				return stringBuilder.ToString();
			}
			return stringBuilder.ToString(0, 200);
		}

		public static bool Acceptable(string? text, bool required)
		{
			if (required)
			{
				return Normalize(text).Length > 0;
			}
			return true;
		}
	}
	public static class GameListFile
	{
		public static IReadOnlyList<string> Parse(string? text)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			List<string> list = new List<string>();
			string[] array = (text ?? "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0 && !text2.StartsWith("//", StringComparison.Ordinal) && hashSet.Add(text2))
				{
					list.Add(text2);
				}
			}
			return list;
		}

		public static bool Contains(IEnumerable<string> list, string? id)
		{
			string wanted = (id ?? "").Trim();
			if (wanted.Length == 0)
			{
				return false;
			}
			return list.Any((string entry) => Same(entry, wanted));
		}

		private static bool Same(string a, string b)
		{
			if (string.Equals(a, b, StringComparison.Ordinal))
			{
				return true;
			}
			int num = a.IndexOf('_');
			int num2 = b.IndexOf('_');
			if (num >= 0 && num2 >= 0)
			{
				return false;
			}
			string text = ((num >= 0) ? a.Substring(num + 1) : a);
			string b2 = ((num2 >= 0) ? b.Substring(num2 + 1) : b);
			if (text.Length > 0 && text.All(char.IsDigit))
			{
				return string.Equals(text, b2, StringComparison.Ordinal);
			}
			return false;
		}
	}
	public readonly struct PlayerFreezeUpdate
	{
		public string PlayerId { get; }

		public long Peer { get; }

		public long Revision { get; }

		public bool Frozen { get; }

		public PlayerFreezeUpdate(string playerId, long peer, long revision, bool frozen)
		{
			PlayerId = playerId;
			Peer = peer;
			Revision = revision;
			Frozen = frozen;
		}
	}
	public sealed class PlayerFreezeSet
	{
		private sealed class State
		{
			internal PlayerFreezeUpdate Update;

			internal bool Acknowledged;

			internal double LastSent = double.NegativeInfinity;
		}

		private readonly Dictionary<string, State> players = new Dictionary<string, State>(StringComparer.Ordinal);

		private long revision;

		public void Retain(IEnumerable<KeyValuePair<string, long>> online)
		{
			Dictionary<string, long> dictionary = new Dictionary<string, long>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, long> item in online)
			{
				if (!string.IsNullOrEmpty(item.Key) && item.Value != 0L)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			string[] array = players.Keys.ToArray();
			foreach (string key in array)
			{
				if (!dictionary.TryGetValue(key, out var value) || value != players[key].Update.Peer)
				{
					players.Remove(key);
				}
			}
			foreach (KeyValuePair<string, long> item2 in dictionary)
			{
				if (!players.ContainsKey(item2.Key))
				{
					players.Add(item2.Key, new State
					{
						Update = new PlayerFreezeUpdate(item2.Key, item2.Value, ++revision, frozen: false)
					});
				}
			}
		}

		public bool TrySet(string playerId, long peer, bool frozen, out PlayerFreezeUpdate update)
		{
			update = default(PlayerFreezeUpdate);
			if (!players.TryGetValue(playerId, out State value) || peer == 0L || value.Update.Peer != peer)
			{
				return false;
			}
			update = new PlayerFreezeUpdate(playerId, peer, ++revision, frozen);
			value.Update = update;
			value.Acknowledged = false;
			value.LastSent = double.NegativeInfinity;
			return true;
		}

		public bool IsCurrent(PlayerFreezeUpdate update)
		{
			if (players.TryGetValue(update.PlayerId, out State value) && value.Update.Peer == update.Peer)
			{
				return value.Update.Revision == update.Revision;
			}
			return false;
		}

		public bool Acknowledge(long peer, long receivedRevision, bool frozen)
		{
			foreach (State value in players.Values)
			{
				PlayerFreezeUpdate update = value.Update;
				if (update.Peer == peer && update.Revision == receivedRevision && update.Frozen == frozen && !value.Acknowledged)
				{
					value.Acknowledged = true;
					return true;
				}
			}
			return false;
		}

		public IReadOnlyList<PlayerFreezeUpdate> Due(double now)
		{
			List<PlayerFreezeUpdate> list = new List<PlayerFreezeUpdate>();
			foreach (State value in players.Values)
			{
				if (!(now - value.LastSent < 1.0))
				{
					value.LastSent = now;
					list.Add(value.Update);
				}
			}
			return list;
		}

		public void ClearAll()
		{
			players.Clear();
		}

		public void Disconnect(string playerId)
		{
			players.Remove(playerId);
		}
	}
	public sealed class PlayerFreezeLease
	{
		public const double LeaseSeconds = 4.0;

		private long revision;

		private bool desired;

		private double expires;

		public bool IsFrozen(double now)
		{
			if (desired)
			{
				return now < expires;
			}
			return false;
		}

		public bool Receive(long receivedRevision, bool frozen, double now)
		{
			if (receivedRevision <= 0 || receivedRevision < revision || (receivedRevision == revision && frozen != desired))
			{
				return false;
			}
			revision = receivedRevision;
			desired = frozen;
			expires = now + 4.0;
			return true;
		}

		public void Clear()
		{
			revision = 0L;
			desired = false;
			expires = 0.0;
		}
	}
}
namespace ExtraPotions.Thing.Localization
{
	public readonly struct TextKey
	{
		public string Key { get; }

		public int Arguments { get; }

		public TextKey(string key, int arguments)
		{
			Key = key;
			Arguments = arguments;
		}
	}
	public static class ThingTextKeys
	{
		public const string OffNoCrucible = "off_no_crucible";

		public const string OffNoThing = "off_no_thing";

		public const string ImportDone = "import_done";

		public const string HintNotAdmin = "hint_not_admin";

		public const string Kicked = "kicked";

		public const string Banned = "banned";

		public const string BannedFor = "banned_for";

		public const string Warned = "warned";

		public const string MutedFor = "muted_for";

		public const string MutedUntilLifted = "muted_until_lifted";

		public const string Unmuted = "unmuted";

		public const string YouAreMuted = "you_are_muted";

		public const string ShutdownWarning = "shutdown_warning";

		public const string ShutdownSaving = "shutdown_saving";

		public const string ShutdownCancelled = "shutdown_canceled";

		public const string TimeReleased = "time_released";

		public const string TempBanLifted = "temp_ban_lifted";

		public const string NoReason = "no_reason";

		public const string CommandHelp = "cmd_help";

		public const string CommandDone = "cmd_done";

		public const string CommandUnknownPlayer = "cmd_unknown_player";

		public const string CommandUsage = "cmd_usage";

		public const string CommandReasonRequired = "cmd_reason_required";

		public const string CommandStatus = "cmd_status";

		public const string CommandUnknownVerb = "cmd_unknown_verb";

		public const string CommandFailed = "cmd_failed";

		public const string CommandRemoteSent = "cmd_remote_sent";

		public const string CommandRemoteFailed = "cmd_remote_failed";

		public static IReadOnlyList<TextKey> All { get; } = Array.AsReadOnly(new TextKey[347]
		{
			new TextKey("time_unavailable", 0),
			new TextKey("time_set", 1),
			new TextKey("time_frozen", 1),
			new TextKey("time_resumed", 0),
			new TextKey("step_aside_worldtools", 1),
			new TextKey("off_no_crucible", 0),
			new TextKey("off_no_thing", 0),
			new TextKey("refused_not_admin", 0),
			new TextKey("refused_no_other_players", 0),
			new TextKey("refused_needs_delve", 0),
			new TextKey("refused_disabled_by_server", 0),
			new TextKey("refused_product_off", 0),
			new TextKey("refused_needs_relay", 0),
			new TextKey("import_done", 2),
			new TextKey("hint_not_admin", 0),
			new TextKey("kicked", 1),
			new TextKey("player_frozen", 0),
			new TextKey("player_unfrozen", 0),
			new TextKey("banned", 1),
			new TextKey("banned_for", 2),
			new TextKey("warned", 1),
			new TextKey("muted_for", 1),
			new TextKey("muted_until_lifted", 0),
			new TextKey("unmuted", 0),
			new TextKey("you_are_muted", 0),
			new TextKey("shutdown_warning", 1),
			new TextKey("shutdown_saving", 0),
			new TextKey("shutdown_canceled", 0),
			new TextKey("time_released", 0),
			new TextKey("temp_ban_lifted", 1),
			new TextKey("no_reason", 0),
			new TextKey("cmd_help", 0),
			new TextKey("cmd_done", 1),
			new TextKey("cmd_unknown_player", 1),
			new TextKey("cmd_usage", 1),
			new TextKey("cmd_reason_required", 0),
			new TextKey("cmd_status", 4),
			new TextKey("cmd_unknown_verb", 1),
			new TextKey("cmd_failed", 1),
			new TextKey("cmd_remote_sent", 0),
			new TextKey("cmd_remote_failed", 1),
			new TextKey("terrain_usage", 0),
			new TextKey("terrain_incomplete", 0),
			new TextKey("terrain_ownership", 0),
			new TextKey("terrain_other_pieces", 0),
			new TextKey("terrain_canceled", 0),
			new TextKey("terrain_expired", 0),
			new TextKey("terrain_preview", 1),
			new TextKey("terrain_done", 1),
			new TextKey("terrain_unknown", 0),
			new TextKey("drops_usage", 0),
			new TextKey("drops_unavailable", 0),
			new TextKey("drops_canceled", 0),
			new TextKey("drops_expired", 0),
			new TextKey("drops_preview", 2),
			new TextKey("drops_done", 1),
			new TextKey("drops_unknown", 0),
			new TextKey("seed_value", 1),
			new TextKey("seed_unavailable", 0),
			new TextKey("ward_usage", 0),
			new TextKey("ward_unavailable", 0),
			new TextKey("ward_on", 0),
			new TextKey("ward_off", 0),
			new TextKey("ui_close", 0),
			new TextKey("ui_refresh", 0),
			new TextKey("ui_previous", 0),
			new TextKey("ui_next", 0),
			new TextKey("ui_ledger", 0),
			new TextKey("ui_audit", 0),
			new TextKey("ui_kick", 0),
			new TextKey("ui_ban", 0),
			new TextKey("ui_tempban", 0),
			new TextKey("ui_warn", 0),
			new TextKey("ui_unban", 0),
			new TextKey("ui_select_ban", 0),
			new TextKey("ui_select_player", 0),
			new TextKey("ui_duration", 0),
			new TextKey("ui_reason", 0),
			new TextKey("ui_broadcast", 0),
			new TextKey("ui_text", 0),
			new TextKey("ui_shutdown", 0),
			new TextKey("ui_minutes", 0),
			new TextKey("ui_cancel_shutdown", 0),
			new TextKey("ui_save_world", 0),
			new TextKey("ui_world_step_aside", 0),
			new TextKey("ui_seed", 0),
			new TextKey("ui_time", 0),
			new TextKey("ui_clock", 0),
			new TextKey("ui_freeze", 0),
			new TextKey("config_unavailable", 0),
			new TextKey("config_bound", 0),
			new TextKey("config_yaml", 0),
			new TextKey("ui_config_yaml_hint", 0),
			new TextKey("config_yaml_saved", 0),
			new TextKey("config_unbound", 0),
			new TextKey("config_readonly", 0),
			new TextKey("config_invalid", 0),
			new TextKey("config_stale", 0),
			new TextKey("config_saved", 0),
			new TextKey("config_unknown", 0),
			new TextKey("config_failed", 0),
			new TextKey("ui_config_back", 0),
			new TextKey("ui_config_hint", 0),
			new TextKey("ui_settings_delegation", 0),
			new TextKey("ui_config_open", 0),
			new TextKey("ui_config_select", 0),
			new TextKey("ui_config_write_warning", 0),
			new TextKey("ui_config_restart", 0),
			new TextKey("ui_config_choose_value", 0),
			new TextKey("teleport_usage", 0),
			new TextKey("teleport_unavailable", 0),
			new TextKey("teleport_unknown", 0),
			new TextKey("teleport_expired", 0),
			new TextKey("teleport_declined", 0),
			new TextKey("teleport_busy", 0),
			new TextKey("teleport_waiting", 0),
			new TextKey("teleport_accepted", 0),
			new TextKey("teleport_prompt_title", 0),
			new TextKey("teleport_prompt_goto", 1),
			new TextKey("teleport_prompt_bring", 1),
			new TextKey("teleport_accept", 0),
			new TextKey("teleport_decline", 0),
			new TextKey("teleport_unsafe", 0),
			new TextKey("teleport_arrived", 0),
			new TextKey("teleport_recovering", 0),
			new TextKey("ui_goto", 0),
			new TextKey("ui_bring", 0),
			new TextKey("delve_unavailable", 0),
			new TextKey("delve_not_checked", 0),
			new TextKey("delve_counts", 5),
			new TextKey("delve_schedule", 4),
			new TextKey("delve_none_active", 0),
			new TextKey("delve_requested_skip", 1),
			new TextKey("delve_requested_due", 1),
			new TextKey("ui_delve_actions", 0),
			new TextKey("ui_delve_kinds", 0),
			new TextKey("ui_delve_request", 0),
			new TextKey("ui_delve_select", 0),
			new TextKey("ui_delve_request_warning", 0),
			new TextKey("ui_delve_dryrun", 0),
			new TextKey("ui_delve_dryrun_hint", 0),
			new TextKey("ui_delve_scope", 0),
			new TextKey("delve_kind_fullreset", 0),
			new TextKey("delve_kind_chests", 0),
			new TextKey("delve_kind_mudpiles", 0),
			new TextKey("delve_kind_frostcavecrystals", 0),
			new TextKey("delve_kind_blackcores", 0),
			new TextKey("delve_kind_morkhalla", 0),
			new TextKey("delve_kind_hole", 0),
			new TextKey("delve_kind_ancientarmor", 0),
			new TextKey("delve_kind_obsidian", 0),
			new TextKey("delve_kind_flametal", 0),
			new TextKey("delve_kind_ice", 0),
			new TextKey("delve_kind_queen", 0),
			new TextKey("delve_kind_campspawners", 0),
			new TextKey("delve_kind_dungeonspawners", 0),
			new TextKey("ui_top_left", 0),
			new TextKey("ui_mute", 0),
			new TextKey("ui_unmute", 0),
			new TextKey("ui_freeze_player", 0),
			new TextKey("ui_unfreeze_player", 0),
			new TextKey("ui_mute_duration", 0),
			new TextKey("mute_persistence_unknown", 0),
			new TextKey("ui_on", 0),
			new TextKey("ui_off", 0),
			new TextKey("ui_resume_time", 0),
			new TextKey("ui_ward_on", 0),
			new TextKey("ui_ward_off", 0),
			new TextKey("ui_terrain", 0),
			new TextKey("ui_drops", 0),
			new TextKey("ui_world_console_result", 0),
			new TextKey("ui_invalid", 0),
			new TextKey("ui_request_failed", 0),
			new TextKey("ui_pending", 0),
			new TextKey("ui_apply", 0),
			new TextKey("ui_cancel", 0),
			new TextKey("ui_confirm", 0),
			new TextKey("ui_hold", 0),
			new TextKey("ui_hold_progress", 1),
			new TextKey("ui_read_invalid", 0),
			new TextKey("ui_read_failed", 0),
			new TextKey("ui_page", 3),
			new TextKey("ui_audit_bounded", 0),
			new TextKey("ui_radius", 0),
			new TextKey("ui_tab_people", 0),
			new TextKey("ui_tab_moderation", 0),
			new TextKey("ui_tab_messages", 0),
			new TextKey("ui_tab_world", 0),
			new TextKey("ui_tab_regeneration", 0),
			new TextKey("ui_tab_server_config", 0),
			new TextKey("ui_players", 0),
			new TextKey("ui_permitted", 0),
			new TextKey("ui_admins", 0),
			new TextKey("ui_permit", 0),
			new TextKey("ui_unpermit", 0),
			new TextKey("ui_admin_add", 0),
			new TextKey("ui_admin_remove", 0),
			new TextKey("ui_platform_id", 0),
			new TextKey("ui_admin_readonly", 0),
			new TextKey("ui_select_identity", 0),
			new TextKey("message_saved", 0),
			new TextKey("message_stale", 0),
			new TextKey("message_invalid", 0),
			new TextKey("message_unknown", 0),
			new TextKey("message_failed", 0),
			new TextKey("ui_motd", 0),
			new TextKey("ui_motd_hint", 0),
			new TextKey("ui_announcements", 0),
			new TextKey("ui_announcement_hint", 0),
			new TextKey("ui_add", 0),
			new TextKey("ui_edit", 0),
			new TextKey("ui_remove", 0),
			new TextKey("ui_clear", 0),
			new TextKey("ui_announcement_every", 1),
			new TextKey("ui_add_announcement", 0),
			new TextKey("ui_edit_announcement", 0),
			new TextKey("ui_select_announcement", 0),
			new TextKey("ui_repeat_minutes", 0),
			new TextKey("ui_remove_announcement", 0),
			new TextKey("ui_clear_announcements_warning", 0),
			new TextKey("ui_delve_due", 0),
			new TextKey("ui_delve_nearest", 0),
			new TextKey("delve_position_unknown", 0),
			new TextKey("delve_site_requested", 0),
			new TextKey("delve_site_unknown", 0),
			new TextKey("delve_site_due", 0),
			new TextKey("ui_delve_site_scope", 0),
			new TextKey("delve_nearest_none", 0),
			new TextKey("delve_nearest_queued", 2),
			new TextKey("delve_nearest_refused", 0),
			new TextKey("ui_delve_reset_nearest", 0),
			new TextKey("ui_delve_reset_nearest_warning", 0),
			new TextKey("ui_delve_nature", 0),
			new TextKey("ui_delve_nature_scope", 0),
			new TextKey("pickup_usage", 0),
			new TextKey("pickup_set", 1),
			new TextKey("pickup_reset", 1),
			new TextKey("ui_pickup_radius", 0),
			new TextKey("ui_pickup_radius_hint", 0),
			new TextKey("ui_regenerate_nature", 0),
			new TextKey("ui_regenerate_nature_warning", 0),
			new TextKey("ui_reset_resources", 0),
			new TextKey("ui_reset_resources_warning", 0),
			new TextKey("ui_settings_delegation_hint", 0),
			new TextKey("ui_freeze_hint", 0),
			new TextKey("ui_top_left_hint", 0),
			new TextKey("ui_clock_hint", 0),
			new TextKey("ui_reason_hint", 0),
			new TextKey("ui_minutes_hint", 0),
			new TextKey("ui_platform_id_hint", 0),
			new TextKey("ui_duration_hint", 0),
			new TextKey("ui_terrain_radius_hint", 0),
			new TextKey("ui_message_hint", 0),
			new TextKey("ui_apply_hint", 0),
			new TextKey("ui_cancel_hint", 0),
			new TextKey("ui_help_close", 0),
			new TextKey("ui_help_refresh", 0),
			new TextKey("ui_help_previous", 0),
			new TextKey("ui_help_next", 0),
			new TextKey("ui_help_identity_lists", 0),
			new TextKey("ui_help_delve_views", 0),
			new TextKey("ui_help_moderation_views", 0),
			new TextKey("ui_help_select", 0),
			new TextKey("ui_help_tab_people", 0),
			new TextKey("ui_help_tab_moderation", 0),
			new TextKey("ui_help_tab_messages", 0),
			new TextKey("ui_help_tab_world", 0),
			new TextKey("ui_help_tab_regeneration", 0),
			new TextKey("ui_help_kick", 0),
			new TextKey("ui_help_ban", 0),
			new TextKey("ui_help_tempban", 0),
			new TextKey("ui_help_warn", 0),
			new TextKey("ui_help_mute", 0),
			new TextKey("ui_help_unmute", 0),
			new TextKey("ui_help_freeze_player", 0),
			new TextKey("ui_help_unfreeze_player", 0),
			new TextKey("ui_help_goto", 0),
			new TextKey("ui_help_bring", 0),
			new TextKey("ui_help_unban", 0),
			new TextKey("ui_help_permit", 0),
			new TextKey("ui_help_unpermit", 0),
			new TextKey("ui_help_admin_add", 0),
			new TextKey("ui_help_admin_remove", 0),
			new TextKey("ui_help_broadcast", 0),
			new TextKey("ui_help_shutdown", 0),
			new TextKey("ui_help_cancel_shutdown", 0),
			new TextKey("ui_help_save_world", 0),
			new TextKey("ui_help_motd", 0),
			new TextKey("ui_help_announcements", 0),
			new TextKey("ui_help_seed", 0),
			new TextKey("ui_help_time", 0),
			new TextKey("ui_help_resume_time", 0),
			new TextKey("ui_help_ward_on", 0),
			new TextKey("ui_help_ward_off", 0),
			new TextKey("ui_help_terrain", 0),
			new TextKey("ui_help_drops", 0),
			new TextKey("ui_help_add", 0),
			new TextKey("ui_help_edit", 0),
			new TextKey("ui_help_remove", 0),
			new TextKey("ui_grants", 0),
			new TextKey("ui_help_grants", 0),
			new TextKey("ui_grant_world", 0),
			new TextKey("ui_help_grant_world", 0),
			new TextKey("ui_grant_spawn", 0),
			new TextKey("ui_help_grant_spawn", 0),
			new TextKey("ui_grant_teleport", 0),
			new TextKey("ui_help_grant_teleport", 0),
			new TextKey("ui_grant_freeze", 0),
			new TextKey("ui_help_grant_freeze", 0),
			new TextKey("ui_grant_inventory", 0),
			new TextKey("ui_help_grant_inventory", 0),
			new TextKey("ui_grant_ward", 0),
			new TextKey("ui_help_grant_ward", 0),
			new TextKey("ui_inventory", 0),
			new TextKey("ui_help_inventory", 0),
			new TextKey("ui_inventory_empty", 0),
			new TextKey("ui_inventory_take", 0),
			new TextKey("ui_inventory_delete", 0),
			new TextKey("ui_inventory_take_body", 2),
			new TextKey("ui_inventory_delete_body", 2),
			new TextKey("ui_inventory_delete_again", 2),
			new TextKey("ui_inventory_stored", 0),
			new TextKey("ui_inventory_dropped", 0),
			new TextKey("ui_inventory_deleted", 0),
			new TextKey("ui_inventory_missing", 0),
			new TextKey("ui_inventory_busy", 0),
			new TextKey("ui_inventory_denied", 0),
			new TextKey("ui_inventory_failed", 0),
			new TextKey("ui_inventory_offline", 0),
			new TextKey("ui_select_item", 0),
			new TextKey("ui_permissions_loading", 0),
			new TextKey("ui_permissions_failed", 0),
			new TextKey("ui_permissions_empty", 0),
			new TextKey("ui_grant_add", 0),
			new TextKey("ui_help_grant_add", 0),
			new TextKey("ui_grant_remove", 0),
			new TextKey("ui_help_grant_remove", 0),
			new TextKey("grant_saved", 0),
			new TextKey("grant_unchanged", 0),
			new TextKey("grant_unsaved", 0),
			new TextKey("ui_grant_subadmin", 0),
			new TextKey("ui_help_grant_subadmin", 0),
			new TextKey("ui_subadmin_confirm_1", 1),
			new TextKey("ui_subadmin_confirm_2", 1),
			new TextKey("ui_subadmin_revoke_self", 0),
			new TextKey("ui_subadmin_revoke_self_hint", 0),
			new TextKey("ui_subadmin_revoke_self_confirm", 0)
		});
	}
}
namespace ExtraPotions.Thing.Integration
{
	public enum ThingModule
	{
		WorldTools
	}
	public readonly struct InstalledPlugin
	{
		public string Guid { get; }

		public string Name { get; }

		public InstalledPlugin(string guid, string name)
		{
			Guid = guid ?? "";
			Name = name ?? "";
		}
	}
	public sealed class ModuleSource
	{
		public string Guid { get; }

		public string Name { get; }

		public ThingModule Module { get; }

		public IReadOnlyList<string> PluginNames { get; }

		public string ModuleId => Module.ToString().ToLowerInvariant();

		internal ModuleSource(string guid, string name, ThingModule module, params string[] pluginNames)
		{
			Guid = guid;
			Name = name;
			Module = module;
			PluginNames = pluginNames;
		}

		public bool Matches(InstalledPlugin plugin)
		{
			if (!string.Equals(plugin.Guid, Guid, StringComparison.Ordinal))
			{
				return PluginNames.Any((string n) => string.Equals(n, plugin.Name, StringComparison.OrdinalIgnoreCase));
			}
			return true;
		}
	}
	public readonly struct StepAsideNotice
	{
		public ThingModule Module { get; }

		public string SourceName { get; }

		public string SourceGuid { get; }

		public string Key => KeyOf(Module);

		public StepAsideNotice(ThingModule module, string sourceName, string sourceGuid)
		{
			Module = module;
			SourceName = sourceName;
			SourceGuid = sourceGuid;
		}

		public static string KeyOf(ThingModule module)
		{
			return "step_aside_" + module.ToString().ToLowerInvariant();
		}
	}
	public sealed class ModuleStepAsideDecision
	{
		private readonly HashSet<ThingModule> aside;

		public IReadOnlyList<ModuleSource> Present { get; }

		public bool Any => aside.Count > 0;

		public bool AdminToolLoaded => SteppedAside(ThingModule.WorldTools);

		public IReadOnlyList<StepAsideNotice> Notices { get; }

		internal ModuleStepAsideDecision(IReadOnlyList<ModuleSource> present)
		{
			Present = present;
			aside = new HashSet<ThingModule>(present.Select((ModuleSource p) => p.Module));
			Notices = (from p in present
				orderby p.Module
				select new StepAsideNotice(p.Module, p.Name, p.Guid)).ToList();
		}

		public bool SteppedAside(ThingModule module)
		{
			return aside.Contains(module);
		}
	}
	public static class ModuleStepAside
	{
		public static readonly ModuleSource AdminTool = new ModuleSource("com.icecub.valheimadmintool", "Valheim_Admin_Tool", ThingModule.WorldTools);

		public static IReadOnlyList<ModuleSource> Sources { get; } = Array.AsReadOnly(new ModuleSource[1] { AdminTool });

		public static ModuleStepAsideDecision Decide(IEnumerable<InstalledPlugin> installed)
		{
			if (installed == null)
			{
				throw new ArgumentNullException("installed");
			}
			List<InstalledPlugin> list = installed.ToList();
			return new ModuleStepAsideDecision(Sources.Where((ModuleSource s) => list.Any(s.Matches)).ToList());
		}
	}
}
namespace ExtraPotions.Thing.Conversion
{
	public readonly struct ImportValue
	{
		public string SettingId { get; }

		public string Value { get; }

		public string Source { get; }

		public ImportValue(string settingId, string value, string source)
		{
			SettingId = settingId;
			Value = value;
			Source = source;
		}
	}
	public sealed class ImportPlan
	{
		public IReadOnlyList<ImportValue> Values { get; }

		public IReadOnlyList<string> Notes { get; }

		internal ImportPlan(IReadOnlyList<ImportValue> values, IReadOnlyList<string> notes)
		{
			Values = values;
			Notes = notes;
		}

		public string Report()
		{
			return string.Join("\n", new string[1] { "Source: Valheim_Admin_Tool" }.Concat(Values.Select((ImportValue v) => "Set " + v.SettingId + " = " + v.Value + " (from " + v.Source + ")")).Concat(Notes.Select((string n) => "Note: " + n)));
		}
	}
	public readonly struct SourceEntry
	{
		public string Section { get; }

		public string Key { get; }

		public string Value { get; }

		public SourceEntry(string section, string key, string value)
		{
			Section = section;
			Key = key;
			Value = value;
		}
	}
	public static class SourceConfig
	{
		public static IReadOnlyList<SourceEntry> Parse(string? text)
		{
			List<SourceEntry> list = new List<SourceEntry>();
			string section = "";
			string[] array = (text ?? "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				if (text2[0] == '[' && text2[text2.Length - 1] == ']')
				{
					section = text2.Substring(1, text2.Length - 2).Trim();
					continue;
				}
				int num = text2.IndexOf('=');
				if (num > 0)
				{
					string text3 = text2.Substring(0, num).Trim();
					if (text3.Length != 0)
					{
						list.Add(new SourceEntry(section, text3, text2.Substring(num + 1).Trim()));
					}
				}
			}
			return list;
		}
	}
	public static class SourceImport
	{
		public const string AdminToolFile = "com.icecub.valheimadmintool.cfg";

		private const string HotkeySection = "Hotkeys";

		public static IReadOnlyDictionary<string, string> Targets { get; } = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			{
				"WardOverride",
				ThingSettings.Hotkeys.WardOverride.Id
			},
			{
				"RemoveDrops",
				ThingSettings.Hotkeys.RemoveDrops.Id
			}
		};

		public static ImportPlan Plan(string? text)
		{
			List<ImportValue> list = new List<ImportValue>();
			List<string> list2 = new List<string>();
			IReadOnlyList<SourceEntry> source = SourceConfig.Parse(text);
			foreach (SourceEntry item in source.Where((SourceEntry e) => e.Section == "Hotkeys"))
			{
				if (Targets.TryGetValue(item.Key, out string value) && item.Value.Length != 0 && !string.Equals(item.Value, "None", StringComparison.OrdinalIgnoreCase))
				{
					list.Add(new ImportValue(value, item.Value, "[Hotkeys] " + item.Key));
				}
			}
			if (source.Any((SourceEntry e) => e.Section == "Automatic resets"))
			{
				list2.Add("[Automatic resets]: dungeon and resource resets belong to Delve; its converter imports them");
			}
			SourceEntry sourceEntry = source.FirstOrDefault((SourceEntry e) => e.Section == "General" && e.Key == "Toggle menu");
			if (sourceEntry.Key != null)
			{
				list2.Add("[General] Toggle menu = " + sourceEntry.Value + ": not imported; that menu also holds the cheats (Hex), Thing keeps its own Admin Window Key");
			}
			return new ImportPlan(list, list2);
		}
	}
}
namespace ExtraPotions.Thing.Config
{
	public sealed class LockList
	{
		private readonly HashSet<string> locked;

		public static LockList Empty { get; } = new LockList(Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>());

		public IReadOnlyList<string> Locked { get; }

		public IReadOnlyList<string> Unknown { get; }

		public IReadOnlyList<string> NotLockable { get; }

		private LockList(IReadOnlyList<string> lockedIds, IReadOnlyList<string> unknown, IReadOnlyList<string> notLockable)
		{
			Locked = lockedIds;
			Unknown = unknown;
			NotLockable = notLockable;
			locked = new HashSet<string>(lockedIds, StringComparer.OrdinalIgnoreCase);
		}

		public static LockList Parse(string? text)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					ThingSetting thingSetting = ThingSettings.Find(text2);
					List<string> list4 = ((thingSetting == null) ? list2 : (thingSetting.Lockable ? list : list3));
					string text3 = thingSetting?.Id ?? text2;
					if (!list4.Contains<string>(text3, StringComparer.OrdinalIgnoreCase))
					{
						list4.Add(text3);
					}
				}
			}
			if (list.Count + list2.Count + list3.Count != 0)
			{
				return new LockList(list, list2, list3);
			}
			return Empty;
		}

		public bool IsLocked(string? id)
		{
			if (id != null)
			{
				return locked.Contains(id.Trim());
			}
			return false;
		}

		public string Describe()
		{
			string text = Locked.Count + " locked";
			if (Unknown.Count > 0)
			{
				text = text + "; unknown: " + string.Join(", ", Unknown);
			}
			if (NotLockable.Count > 0)
			{
				text = text + "; not lockable: " + string.Join(", ", NotLockable);
			}
			return text;
		}
	}
	public static class LockedValues
	{
		public static string Encode(IEnumerable<KeyValuePair<string, string>> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			return string.Join(";", values.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> v) => Escape(v.Key) + "=" + Escape(v.Value ?? "")));
		}

		public static IReadOnlyDictionary<string, string> Decode(string? text)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrEmpty(text))
			{
				return dictionary;
			}
			foreach (string item in Split(text, ';'))
			{
				List<string> list = Split(item, '=').ToList();
				if (list.Count == 2)
				{
					string text2 = Unescape(list[0]);
					string text3 = Unescape(list[1]);
					if (!string.IsNullOrWhiteSpace(text2) && text3 != null && !dictionary.ContainsKey(text2.Trim()))
					{
						dictionary.Add(text2.Trim(), text3);
					}
				}
			}
			return dictionary;
		}

		public static string Compose(LockList list, Func<string, string?> ownText)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (ownText == null)
			{
				throw new ArgumentNullException("ownText");
			}
			return Encode(from id in list.Locked
				select new KeyValuePair<string, string>(id, ownText(id)) into p
				where p.Value != null
				select new KeyValuePair<string, string>(p.Key, p.Value));
		}

		private static string Escape(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			foreach (char c in text)
			{
				if (c == '\\' || c == ';' || c == '=')
				{
					stringBuilder.Append('\\');
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}

		private static IEnumerable<string> Split(string text, char separator)
		{
			int num = 0;
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == '\\')
				{
					i++;
				}
				else if (text[i] == separator)
				{
					yield return text.Substring(num, i - num);
					num = i + 1;
				}
			}
			yield return text.Substring(num);
		}

		private static string? Unescape(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == '\\' && ++i >= text.Length)
				{
					return null;
				}
				stringBuilder.Append(text[i]);
			}
			return stringBuilder.ToString();
		}
	}
	public readonly struct PlayerLock
	{
		public bool Locked { get; }

		public string? ServerText { get; }

		public PlayerLock(bool locked, string? serverText)
		{
			Locked = locked;
			ServerText = (locked ? serverText : null);
		}

		public override string ToString()
		{
			if (!Locked)
			{
				return "Own";
			}
			return "Locked (" + ServerText + ")";
		}
	}
	public static class PlayerLocks
	{
		public static PlayerLock Evaluate(string id, bool serverBinds, LockList list, IReadOnlyDictionary<string, string> values)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (!serverBinds || !list.IsLocked(id) || !values.TryGetValue(id.Trim(), out string value))
			{
				return new PlayerLock(locked: false, null);
			}
			return new PlayerLock(locked: true, value);
		}
	}
	public enum SessionKind
	{
		SinglePlayer,
		Host,
		DedicatedServer,
		RemoteClient
	}
	public enum ServerKind
	{
		Unknown,
		Vanilla,
		CrucibleWithoutThing,
		Thing
	}
	public enum BlockReason
	{
		None,
		SetByServer,
		VanillaServer,
		ProductDisabled,
		AuthorityPending
	}
	public readonly struct SessionFacts
	{
		public SessionKind Kind { get; }

		public ServerKind Server { get; }

		public bool Admin { get; }

		public bool IsAuthority => Kind != SessionKind.RemoteClient;

		public SessionFacts(SessionKind kind, ServerKind server, bool admin)
		{
			Kind = kind;
			Server = server;
			Admin = admin;
		}
	}
	public static class SettingAccess
	{
		public static BlockReason Decide(SettingScope scope, SessionFacts facts)
		{
			if (facts.IsAuthority || scope == SettingScope.Local)
			{
				return BlockReason.None;
			}
			switch (facts.Server)
			{
			case ServerKind.Unknown:
				return BlockReason.AuthorityPending;
			case ServerKind.Vanilla:
				return BlockReason.VanillaServer;
			case ServerKind.CrucibleWithoutThing:
				return BlockReason.ProductDisabled;
			default:
				if (!facts.Admin)
				{
					return BlockReason.SetByServer;
				}
				return BlockReason.None;
			}
		}
	}
	public enum SettingScope
	{
		Local,
		ServerAuthoritative
	}
	public abstract class ThingSetting
	{
		private static readonly IReadOnlyList<string> NoChoices = Array.Empty<string>();

		public string Section { get; }

		public string Key { get; }

		public string Id => Section + "." + Key;

		public SettingScope Scope { get; }

		public string Description { get; }

		public IReadOnlyList<string> Choices { get; }

		public bool Hotkey { get; }

		public bool Lockable => Scope == SettingScope.Local;

		public abstract Type ValueType { get; }

		public abstract object DefaultValue { get; }

		public abstract object? Minimum { get; }

		public abstract object? Maximum { get; }

		private protected ThingSetting(string section, string key, SettingScope scope, string description, IReadOnlyList<string>? choices, bool hotkey)
		{
			if (string.IsNullOrWhiteSpace(section) || section.Trim() != section)
			{
				throw new ArgumentException("Expected a trimmed section name.", "section");
			}
			if (string.IsNullOrWhiteSpace(key) || key.Trim() != key)
			{
				throw new ArgumentException("Expected a trimmed key.", "key");
			}
			if (!Enum.IsDefined(typeof(SettingScope), scope))
			{
				throw new ArgumentException("Unknown scope.", "scope");
			}
			if (string.IsNullOrWhiteSpace(description))
			{
				throw new ArgumentException("Expected a description.", "description");
			}
			if (hotkey && scope != SettingScope.Local)
			{
				throw new ArgumentException(section + "." + key + ": a keyboard shortcut is a Local setting.", "hotkey");
			}
			Section = section;
			Key = key;
			Scope = scope;
			Description = description;
			Choices = choices ?? NoChoices;
			Hotkey = hotkey;
		}

		public abstract object NormalizeBoxed(object? value);

		public override string ToString()
		{
			return Id + " (" + Scope.ToString() + ")";
		}

		public static ThingSetting<bool> Toggle(string section, string key, bool defaultValue, SettingScope scope, string description)
		{
			return new ThingSetting<bool>(section, key, scope, description, defaultValue, null, (bool v) => v);
		}

		public static ThingSetting<int> Integer(string section, string key, int defaultValue, int min, int max, SettingScope scope, string description)
		{
			if (min > max)
			{
				throw new ArgumentException("Minimum above maximum.", "min");
			}
			return new ThingSetting<int>(section, key, scope, description, defaultValue, (min, max), (int v) => Math.Min(max, Math.Max(min, v)));
		}

		public static ThingSetting<TEnum> Choice<TEnum>(string section, string key, TEnum defaultValue, SettingScope scope, string description) where TEnum : struct, Enum
		{
			return new ThingSetting<TEnum>(section, key, scope, description, defaultValue, null, (TEnum v) => (!Enum.IsDefined(typeof(TEnum), v)) ? defaultValue : v, Enum.GetNames(typeof(TEnum)));
		}

		public static ThingSetting<string> Text(string section, string key, string defaultValue, SettingScope scope, string description, Func<string, string> normalize)
		{
			if (normalize == null)
			{
				throw new ArgumentNullException("normalize");
			}
			return new ThingSetting<string>(section, key, scope, description, defaultValue, null, normalize);
		}

		public static ThingSetting<string> Shortcut(string section, string key, string defaultValue, SettingScope scope, string description)
		{
			return new ThingSetting<string>(section, key, scope, description, defaultValue, null, (string v) => (v ?? "").Trim(), null, hotkey: true);
		}
	}
	public sealed class ThingSetting<T> : ThingSetting
	{
		private readonly Func<T, T> normalize;

		private readonly (T Min, T Max)? range;

		public T Default { get; }

		public override Type ValueType => typeof(T);

		public override object DefaultValue => Default;

		public override object? Minimum
		{
			get
			{
				if (!range.HasValue)
				{
					return null;
				}
				return range.Value.Min;
			}
		}

		public override object? Maximum
		{
			get
			{
				if (!range.HasValue)
				{
					return null;
				}
				return range.Value.Max;
			}
		}

		internal ThingSetting(string section, string key, SettingScope scope, string description, T defaultValue, (T, T)? range, Func<T, T> normalize, IReadOnlyList<string>? choices = null, bool hotkey = false)
			: base(section, key, scope, description, choices, hotkey)
		{
			this.normalize = normalize ?? throw new ArgumentNullException("normalize");
			this.range = range;
			if (!EqualityComparer<T>.Default.Equals(normalize(defaultValue), defaultValue))
			{
				throw new ArgumentException(base.Id + ": the default is outside its own rule.", "defaultValue");
			}
			Default = defaultValue;
		}

		public T Normalize(T value)
		{
			return normalize(value);
		}

		public override object NormalizeBoxed(object? value)
		{
			return (value is T value2) ? Normalize(value2) : Default;
		}
	}
	public enum RemoteConfigScope
	{
		MeadworksOnly,
		AllowList,
		AllConfigFiles
	}
	public static class ThingSettings
	{
		public static class General
		{
			public const string Section = "General";

			public static readonly ThingSetting<string> AdminWindowKey = ThingSetting.Shortcut("General", "Admin Window Key", "", SettingScope.Local, "Opens and closes the Thing admin window (admins only; others see a short hint). Empty: none.");

			public static readonly ThingSetting<bool> ConfirmDestructive = ThingSetting.Toggle("General", "Confirm Destructive Actions", defaultValue: true, SettingScope.Local, "Asks before kick, ban, terrain reset, remove drops and remote configuration writes.");

			public static readonly ThingSetting<bool> AdminListEditable = ThingSetting.Toggle("General", "Admin List Editable In Game", defaultValue: false, SettingScope.ServerAuthoritative, "Lets existing admins add and remove admins in game. Off: adminlist.txt is changed only on the server.");

			public static readonly ThingSetting<bool> AllowSubAdminDelegation = ThingSetting.Toggle("General", "Allow Sub-Admin Delegation", defaultValue: true, SettingScope.ServerAuthoritative, "Allows the server host or current admin to delegate all non-destructive permissions to online players as sub-admin.");

			public static readonly ThingSetting<int> AuditLogDays = ThingSetting.Integer("General", "Audit Log Days", 30, 1, 365, SettingScope.ServerAuthoritative, "Days the audit log keeps its daily files.");

			public static readonly ThingSetting<bool> ShowPlatformIds = ThingSetting.Toggle("General", "Show Platform IDs", defaultValue: true, SettingScope.ServerAuthoritative, "Shows platform IDs in the player list (to admins only either way).");

			public static readonly ThingSetting<string> LockedPlayerSettings = ThingSetting.Text("General", "Locked Player Settings", "", SettingScope.ServerAuthoritative, "Comma list of Local Thing settings (Section.Key) every player uses with the server's value.", NormalizeList);
		}

		public static class Moderation
		{
			public const string Section = "Moderation";

			public static readonly ThingSetting<bool> KickReasonRequired = ThingSetting.Toggle("Moderation", "Kick Reason Required", defaultValue: false, SettingScope.ServerAuthoritative, "Kicks, bans and warnings need a reason.");

			public static readonly ThingS