using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using ExtraPotions.Beacon.Secrets;
using ExtraPotions.Beacon.Servers;
using ExtraPotions.Beacon.Text;
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+4312080b663b50769f0cf52f9bd002c67886c90a")]
[assembly: AssemblyProduct("Beacon.Core")]
[assembly: AssemblyTitle("Beacon.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.Beacon
{
	public static class BeaconCore
	{
		public const string PluginGuid = "com.meadworks.beacon";

		public const string ProductName = "Beacon";

		public const string ProductVersion = "0.1.14";

		public const string Family = "Runestone";

		public const string TokenNamespace = "beacon";

		public const string TokenPrefix = "meadworks_beacon_";

		public const string DataFolder = "Meadworks/beacon";

		public const string ServerListFile = "servers.json";

		public const string WindowsSecretFile = "secrets.dat";

		public const string SupportedGameVersion = "1.0.17";
	}
}
namespace ExtraPotions.Beacon.Text
{
	public static class MiniJson
	{
		private const int MaxDepth = 32;

		public static object? Parse(string text)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			int i = 0;
			object? result = Value(text, ref i, 0);
			Skip(text, ref i);
			if (i != text.Length)
			{
				throw new FormatException("Trailing characters after JSON value.");
			}
			return result;
		}

		public static string Quote(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length + 2).Append('"');
			foreach (char c in value)
			{
				switch (c)
				{
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("x4", CultureInfo.InvariantCulture));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.Append('"').ToString();
		}

		private static void Skip(string s, ref int i)
		{
			while (i < s.Length && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r'))
			{
				i++;
			}
		}

		private static object? Value(string s, ref int i, int depth)
		{
			if (depth > 32)
			{
				throw new FormatException("JSON nested too deeply.");
			}
			Skip(s, ref i);
			if (i >= s.Length)
			{
				throw new FormatException("Unexpected end of JSON.");
			}
			switch (s[i])
			{
			case '{':
				return Obj(s, ref i, depth);
			case '[':
				return Arr(s, ref i, depth);
			case '"':
				return Str(s, ref i);
			default:
				if (Word(s, ref i, "true"))
				{
					return true;
				}
				if (Word(s, ref i, "false"))
				{
					return false;
				}
				if (Word(s, ref i, "null"))
				{
					return null;
				}
				return Num(s, ref i);
			}
		}

		private static bool Word(string s, ref int i, string word)
		{
			if (string.CompareOrdinal(s, i, word, 0, word.Length) != 0)
			{
				return false;
			}
			i += word.Length;
			return true;
		}

		private static Dictionary<string, object?> Obj(string s, ref int i, int depth)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
			i++;
			Skip(s, ref i);
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return dictionary;
			}
			while (true)
			{
				Skip(s, ref i);
				if (i >= s.Length || s[i] != '"')
				{
					throw new FormatException("Expected a property name.");
				}
				string key = Str(s, ref i);
				Skip(s, ref i);
				if (i >= s.Length || s[i] != ':')
				{
					throw new FormatException("Expected ':'.");
				}
				i++;
				dictionary[key] = Value(s, ref i, depth + 1);
				Skip(s, ref i);
				if (i >= s.Length || s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return dictionary;
			}
			throw new FormatException("Expected ',' or '}'.");
		}

		private static List<object?> Arr(string s, ref int i, int depth)
		{
			List<object> list = new List<object>();
			i++;
			Skip(s, ref i);
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			while (true)
			{
				list.Add(Value(s, ref i, depth + 1));
				Skip(s, ref i);
				if (i >= s.Length || s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			throw new FormatException("Expected ',' or ']'.");
		}

		private static string Str(string s, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
					break;
				}
				if (i >= s.Length)
				{
					break;
				}
				switch (s[i++])
				{
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case '/':
					stringBuilder.Append('/');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'u':
				{
					if (i + 4 > s.Length || !int.TryParse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
					{
						throw new FormatException("Bad \\u escape.");
					}
					stringBuilder.Append((char)result);
					i += 4;
					break;
				}
				default:
					throw new FormatException("Bad escape.");
				}
			}
			throw new FormatException("Unterminated string.");
		}

		private static double Num(string s, ref int i)
		{
			int num = i;
			while (i < s.Length && "+-0123456789.eE".IndexOf(s[i]) >= 0)
			{
				i++;
			}
			if (i == num || !double.TryParse(s.Substring(num, i - num), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				throw new FormatException("Unexpected character in JSON.");
			}
			return result;
		}
	}
}
namespace ExtraPotions.Beacon.Servers
{
	public static class FavoriteMove
	{
		public static bool Resolve(IReadOnlyList<int> visibleToFull, int fullCount, int selected, int offset, out int from, out int to)
		{
			from = -1;
			to = -1;
			if (visibleToFull == null || (offset != 1 && offset != -1))
			{
				return false;
			}
			int num = selected + offset;
			if (selected < 0 || selected >= visibleToFull.Count || num < 0 || num >= visibleToFull.Count)
			{
				return false;
			}
			from = visibleToFull[selected];
			to = visibleToFull[num];
			if (from < 0 || from >= fullCount || to < 0 || to >= fullCount || from == to)
			{
				from = -1;
				to = -1;
				return false;
			}
			return true;
		}
	}
	public enum AddressKind
	{
		Host,
		Steam,
		PlayFab
	}
	public sealed class ServerAddress : IEquatable<ServerAddress>
	{
		public const int DefaultPort = 2456;

		public AddressKind Kind { get; }

		public string Host { get; }

		public int Port { get; }

		private ServerAddress(AddressKind kind, string host, int port)
		{
			Kind = kind;
			Host = host;
			Port = port;
		}

		public static ServerAddress Parse(string text)
		{
			if (!TryParse(text, out ServerAddress address))
			{
				throw new FormatException("Not a server address.");
			}
			return address;
		}

		public static bool TryParse(string? text, out ServerAddress? address)
		{
			address = null;
			string text2 = (text ?? "").Trim();
			if (text2.Length == 0)
			{
				return false;
			}
			string text3 = text2.ToLowerInvariant();
			if (text3.StartsWith("steam:", StringComparison.Ordinal))
			{
				string text4 = text2.Substring(6);
				if (text4.Length == 0 || text4.Length > 20 || !AllDigits(text4))
				{
					return false;
				}
				address = new ServerAddress(AddressKind.Steam, text4, 0);
				return true;
			}
			if (text3.StartsWith("playfab:", StringComparison.Ordinal))
			{
				string text5 = text2.Substring(8);
				if (text5.Length == 0 || text5.Length > 64 || !AllAlphaNumeric(text5))
				{
					return false;
				}
				address = new ServerAddress(AddressKind.PlayFab, text5.ToUpperInvariant(), 0);
				return true;
			}
			int port = 2456;
			string text6;
			if (text3[0] == '[')
			{
				int num = text3.IndexOf(']');
				if (num < 2)
				{
					return false;
				}
				text6 = text3.Substring(1, num - 1);
				string text7 = text3.Substring(num + 1);
				if (text7.Length > 0 && (text7[0] != ':' || !TryPort(text7.Substring(1), out port)))
				{
					return false;
				}
				if (text6.IndexOf(':') < 0)
				{
					return false;
				}
			}
			else
			{
				int num2 = Count(text3, ':');
				if (num2 > 1)
				{
					text6 = text3;
				}
				else if (num2 == 1)
				{
					int num3 = text3.IndexOf(':');
					text6 = text3.Substring(0, num3);
					if (!TryPort(text3.Substring(num3 + 1), out port))
					{
						return false;
					}
				}
				else
				{
					text6 = text3;
				}
			}
			if (!ValidHost(text6))
			{
				return false;
			}
			address = new ServerAddress(AddressKind.Host, text6, port);
			return true;
		}

		public override string ToString()
		{
			return Kind switch
			{
				AddressKind.Steam => "steam:" + Host, 
				AddressKind.PlayFab => "playfab:" + Host, 
				_ => ((Host.IndexOf(':') >= 0) ? ("[" + Host + "]") : Host) + ":" + Port.ToString(CultureInfo.InvariantCulture), 
			};
		}

		public bool Equals(ServerAddress? other)
		{
			if ((object)other != null)
			{
				return string.Equals(ToString(), other.ToString(), StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return StringComparer.Ordinal.GetHashCode(ToString());
		}

		public static bool operator ==(ServerAddress? a, ServerAddress? b)
		{
			return a?.Equals(b) ?? ((object)b == null);
		}

		public static bool operator !=(ServerAddress? a, ServerAddress? b)
		{
			return !(a == b);
		}

		private static bool TryPort(string text, out int port)
		{
			if (int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out port) && port >= 1)
			{
				return port <= 65535;
			}
			return false;
		}

		private static int Count(string s, char c)
		{
			int num = 0;
			for (int i = 0; i < s.Length; i++)
			{
				if (s[i] == c)
				{
					num++;
				}
			}
			return num;
		}

		private static bool AllDigits(string s)
		{
			foreach (char c in s)
			{
				if (c < '0' || c > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static bool AllAlphaNumeric(string s)
		{
			foreach (char c in s)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z'))
				{
					return false;
				}
			}
			return true;
		}

		private static bool ValidHost(string host)
		{
			if (host.Length == 0 || host.Length > 253)
			{
				return false;
			}
			bool flag = host.IndexOf(':') >= 0;
			foreach (char c in host)
			{
				bool num;
				if (!flag)
				{
					if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || c == '.' || c == '-')
					{
						continue;
					}
					num = c == '_';
				}
				else
				{
					if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || c == ':')
					{
						continue;
					}
					num = c == '.';
				}
				if (!num)
				{
					return false;
				}
			}
			return true;
		}
	}
	public sealed class ServerEntry
	{
		public string Name { get; }

		public ServerAddress Address { get; }

		public IReadOnlyList<ServerAddress> Aliases { get; }

		public string SecretRef { get; }

		public bool IsDefault { get; internal set; }

		public IEnumerable<ServerAddress> AllAddresses => new ServerAddress[1] { Address }.Concat(Aliases);

		internal ServerEntry(string name, ServerAddress address, IReadOnlyList<ServerAddress> aliases, string secretRef)
		{
			Name = name;
			Address = address;
			Aliases = aliases;
			SecretRef = secretRef;
		}

		public bool Matches(ServerAddress address)
		{
			if (!(Address == address))
			{
				return Aliases.Any((ServerAddress a) => a == address);
			}
			return true;
		}
	}
	public sealed class ServerRemoval
	{
		public ServerEntry Entry { get; }

		public int Index { get; }

		public bool WasDefault { get; }

		internal ServerRemoval(ServerEntry entry, int index)
		{
			Entry = entry;
			Index = index;
			WasDefault = entry.IsDefault;
		}
	}
	public sealed class ServerList
	{
		private readonly List<ServerEntry> entries = new List<ServerEntry>();

		private readonly Func<string> newReference;

		private int revision;

		public IReadOnlyList<ServerEntry> Entries => entries;

		public int Count => entries.Count;

		public int Revision => revision;

		public ServerEntry? Default => entries.FirstOrDefault((ServerEntry e) => e.IsDefault);

		public ServerList(Func<string>? newReference = null)
		{
			this.newReference = newReference ?? ((Func<string>)(() => "s" + Guid.NewGuid().ToString("N")));
		}

		public ServerEntry? Find(ServerAddress address)
		{
			if (!(address == null))
			{
				return entries.FirstOrDefault((ServerEntry e) => e.Matches(address));
			}
			return null;
		}

		public ServerEntry? FindByName(string name)
		{
			return entries.FirstOrDefault((ServerEntry e) => string.Equals(e.Name, (name ?? "").Trim(), StringComparison.OrdinalIgnoreCase));
		}

		public ServerEntry Add(string name, ServerAddress address, IEnumerable<ServerAddress>? aliases = null)
		{
			return Insert(name, address, aliases, null);
		}

		internal ServerEntry Insert(string name, ServerAddress address, IEnumerable<ServerAddress>? aliases, string? secretRef)
		{
			string text = (name ?? "").Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("A server needs a name.", "name");
			}
			if (address == null)
			{
				throw new ArgumentNullException("address");
			}
			if (FindByName(text) != null)
			{
				throw new ArgumentException("A server named '" + text + "' is already saved.", "name");
			}
			List<ServerAddress> list = (aliases ?? Enumerable.Empty<ServerAddress>()).Where((ServerAddress a) => a != null && a != address).Distinct().ToList();
			foreach (ServerAddress item in new ServerAddress[1] { address }.Concat(list))
			{
				if (Find(item) != null)
				{
					throw new ArgumentException("Address " + item?.ToString() + " already belongs to another saved server.", "address");
				}
			}
			string reference = secretRef ?? NewUniqueReference();
			if (entries.Any((ServerEntry e) => e.SecretRef == reference))
			{
				throw new ArgumentException("Duplicate secret reference.", "secretRef");
			}
			ServerEntry serverEntry = new ServerEntry(text, address, list.AsReadOnly(), reference);
			entries.Add(serverEntry);
			revision++;
			return serverEntry;
		}

		public bool Remove(string name)
		{
			ServerEntry serverEntry = FindByName(name);
			if (serverEntry == null || !entries.Remove(serverEntry))
			{
				return false;
			}
			revision++;
			return true;
		}

		public ServerRemoval? RemoveForUndo(string name)
		{
			ServerEntry serverEntry = FindByName(name);
			if (serverEntry == null)
			{
				return null;
			}
			ServerRemoval result = new ServerRemoval(serverEntry, entries.IndexOf(serverEntry));
			entries.Remove(serverEntry);
			revision++;
			return result;
		}

		public ServerEntry Restore(ServerRemoval removal)
		{
			if (removal == null)
			{
				throw new ArgumentNullException("removal");
			}
			ServerEntry entry = removal.Entry;
			ServerEntry serverEntry = Insert(entry.Name, entry.Address, entry.Aliases, entry.SecretRef);
			Move(serverEntry.Name, removal.Index);
			if (removal.WasDefault && Default == null)
			{
				SetDefault(serverEntry.Name);
			}
			return serverEntry;
		}

		public ServerEntry Edit(string name, string nextName, ServerAddress address, IEnumerable<ServerAddress>? aliases = null)
		{
			ServerEntry original = FindByName(name) ?? throw new ArgumentException("Unknown saved server.", "name");
			string trimmed = (nextName ?? "").Trim();
			if (trimmed.Length == 0)
			{
				throw new ArgumentException("A server needs a name.", "nextName");
			}
			if (address == null)
			{
				throw new ArgumentNullException("address");
			}
			List<ServerAddress> list = (aliases ?? Enumerable.Empty<ServerAddress>()).Where((ServerAddress a) => a != null && a != address).Distinct().ToList();
			List<ServerEntry> remaining = entries.Where((ServerEntry e) => e != original).ToList();
			if (remaining.Any((ServerEntry e) => string.Equals(e.Name, trimmed, StringComparison.OrdinalIgnoreCase)))
			{
				throw new ArgumentException("Duplicate server name.", "nextName");
			}
			if (new ServerAddress[1] { address }.Concat(list).Any((ServerAddress a) => remaining.Any((ServerEntry e) => e.Matches(a))))
			{
				throw new ArgumentException("Address already belongs to another server.", "address");
			}
			ServerEntry serverEntry = new ServerEntry(trimmed, address, list.AsReadOnly(), original.SecretRef)
			{
				IsDefault = original.IsDefault
			};
			entries[entries.IndexOf(original)] = serverEntry;
			revision++;
			return serverEntry;
		}

		public void SetDefault(string? name)
		{
			ServerEntry serverEntry = ((name == null) ? null : FindByName(name));
			if (name != null && serverEntry == null)
			{
				throw new ArgumentException("No saved server named '" + name + "'.", "name");
			}
			foreach (ServerEntry entry in entries)
			{
				entry.IsDefault = entry == serverEntry;
			}
			revision++;
		}

		public void Move(string name, int index)
		{
			ServerEntry item = FindByName(name) ?? throw new ArgumentException("No saved server named '" + name + "'.", "name");
			entries.Remove(item);
			entries.Insert(Math.Max(0, Math.Min(entries.Count, index)), item);
			revision++;
		}

		private string NewUniqueReference()
		{
			for (int i = 0; i < 16; i++)
			{
				string r = newReference();
				if (entries.All((ServerEntry e) => e.SecretRef != r))
				{
					return r;
				}
			}
			throw new InvalidOperationException("Could not create a unique secret reference.");
		}
	}
	public static class ServerListCodec
	{
		public const int Schema = 1;

		public static IReadOnlyList<string> FieldNames { get; } = Array.AsReadOnly(new string[7] { "schema", "servers", "name", "address", "aliases", "default", "ref" });

		public static string Write(ServerList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{\n  \"schema\": ").Append(1.ToString(CultureInfo.InvariantCulture)).Append(",\n  \"servers\": [");
			for (int i = 0; i < list.Count; i++)
			{
				ServerEntry serverEntry = list.Entries[i];
				stringBuilder.Append((i == 0) ? "\n" : ",\n");
				stringBuilder.Append("    {\"name\": ").Append(MiniJson.Quote(serverEntry.Name)).Append(", \"address\": ")
					.Append(MiniJson.Quote(serverEntry.Address.ToString()))
					.Append(", \"aliases\": [")
					.Append(string.Join(", ", serverEntry.Aliases.Select((ServerAddress a) => MiniJson.Quote(a.ToString()))))
					.Append(']')
					.Append(", \"default\": ")
					.Append(serverEntry.IsDefault ? "true" : "false")
					.Append(", \"ref\": ")
					.Append(MiniJson.Quote(serverEntry.SecretRef))
					.Append('}');
			}
			stringBuilder.Append((list.Count == 0) ? "]\n}\n" : "\n  ]\n}\n");
			return stringBuilder.ToString();
		}

		public static ServerList Read(string text)
		{
			ServerList serverList = new ServerList();
			if (string.IsNullOrWhiteSpace(text))
			{
				return serverList;
			}
			Dictionary<string, object> obj = (MiniJson.Parse(text) as Dictionary<string, object>) ?? throw new FormatException("servers.json: expected an object.");
			if (!obj.TryGetValue("schema", out var value) || !(value is double num) || num != 1.0)
			{
				throw new FormatException("servers.json: unknown schema.");
			}
			if (!obj.TryGetValue("servers", out var value2) || value2 == null)
			{
				return serverList;
			}
			List<object> obj2 = (value2 as List<object>) ?? throw new FormatException("servers.json: 'servers' must be an array.");
			string text2 = null;
			bool flag = default(bool);
			foreach (object item in obj2)
			{
				if (!(item is Dictionary<string, object> dictionary))
				{
					throw new FormatException("servers.json: a server must be an object.");
				}
				string text3 = Str(dictionary, "name") ?? throw new FormatException("servers.json: a server has no name.");
				ServerAddress address = Address(Str(dictionary, "address"));
				List<ServerAddress> list = new List<ServerAddress>();
				if (dictionary.TryGetValue("aliases", out var value3) && value3 is List<object> list2)
				{
					foreach (object item2 in list2)
					{
						list.Add(Address(item2 as string));
					}
				}
				string text4 = Str(dictionary, "ref");
				if (!SecretReference.IsValid(text4))
				{
					throw new FormatException("servers.json: server '" + text3 + "' has no valid ref.");
				}
				try
				{
					serverList.Insert(text3, address, list, text4);
				}
				catch (ArgumentException ex)
				{
					throw new FormatException("servers.json: " + ex.Message);
				}
				int num2;
				if (dictionary.TryGetValue("default", out var value4))
				{
					if (value4 is bool)
					{
						flag = (bool)value4;
						num2 = 1;
					}
					else
					{
						num2 = 0;
					}
				}
				else
				{
					num2 = 0;
				}
				if (((uint)num2 & (flag ? 1u : 0u)) != 0)
				{
					text2 = text3;
				}
			}
			if (text2 != null)
			{
				serverList.SetDefault(text2);
			}
			return serverList;
		}

		private static string? Str(Dictionary<string, object?> o, string key)
		{
			if (!o.TryGetValue(key, out object value))
			{
				return null;
			}
			return value as string;
		}

		private static ServerAddress Address(string? text)
		{
			if (!ServerAddress.TryParse(text, out ServerAddress address))
			{
				throw new FormatException("servers.json: invalid address.");
			}
			return address;
		}
	}
}
namespace ExtraPotions.Beacon.Secrets
{
	public readonly struct SecretReadResult
	{
		private readonly string? secret;

		public bool Found { get; }

		public string Secret => secret ?? "";

		public SecretReadResult(bool found, string secret)
		{
			Found = found;
			this.secret = (found ? secret : "");
		}
	}
	public interface IAsyncSecretStore : ISecretStore
	{
		Task<bool> RefreshAsync(CancellationToken cancellation = default(CancellationToken));

		Task<bool> StoreAsync(string reference, string secret, CancellationToken cancellation = default(CancellationToken));

		Task<SecretReadResult> ReadAsync(string reference, CancellationToken cancellation = default(CancellationToken));

		Task<bool> ForgetAsync(string reference, CancellationToken cancellation = default(CancellationToken));

		Task<int> ForgetAllAsync(CancellationToken cancellation = default(CancellationToken));
	}
	public sealed class DpapiSecretStore : ISecretStore
	{
		private struct DataBlob
		{
			public int Size;

			public IntPtr Data;

			public static DataBlob From(byte[] bytes)
			{
				DataBlob result = new DataBlob
				{
					Size = bytes.Length,
					Data = Marshal.AllocHGlobal(Math.Max(1, bytes.Length))
				};
				Marshal.Copy(bytes, 0, result.Data, bytes.Length);
				return result;
			}

			public void Free(bool clear)
			{
				if (!(Data == IntPtr.Zero))
				{
					if (clear)
					{
						Zero(Data, Size);
					}
					Marshal.FreeHGlobal(Data);
					Data = IntPtr.Zero;
				}
			}
		}

		private const int UiForbidden = 1;

		private static readonly byte[] Entropy = Encoding.UTF8.GetBytes("com.meadworks.beacon/secrets/1");

		private readonly Func<string?> readFile;

		private readonly Action<string> writeFile;

		private readonly SortedDictionary<string, string> blobs = new SortedDictionary<string, string>(StringComparer.Ordinal);

		public static bool IsSupported => RuntimeInformation.IsOSPlatform(OSPlatform.Windows);

		public SecretBackend Backend => SecretBackend.WindowsDataProtection;

		public SecretAvailability Availability
		{
			get
			{
				if (!IsSupported)
				{
					return SecretAvailability.Unavailable;
				}
				return SecretAvailability.Available;
			}
		}

		public SecretFailure LastFailure { get; private set; }

		public DpapiSecretStore(Func<string?> readFile, Action<string> writeFile)
		{
			this.readFile = readFile ?? throw new ArgumentNullException("readFile");
			this.writeFile = writeFile ?? throw new ArgumentNullException("writeFile");
			Load();
		}

		public bool Store(string reference, string secret)
		{
			SecretReference.Require(reference, secret);
			LastFailure = SecretFailure.None;
			if (!IsSupported)
			{
				LastFailure = SecretFailure.Unavailable;
				return false;
			}
			byte[] bytes = Encoding.UTF8.GetBytes(secret);
			try
			{
				byte[] array = Transform(bytes, protect: true);
				if (array == null)
				{
					LastFailure = SecretFailure.ProtectFailed;
					return false;
				}
				blobs[reference] = Convert.ToBase64String(array);
				Save();
				return true;
			}
			finally
			{
				Array.Clear(bytes, 0, bytes.Length);
			}
		}

		public bool TryRead(string reference, out string secret)
		{
			SecretReference.Require(reference);
			secret = "";
			LastFailure = SecretFailure.None;
			if (!blobs.TryGetValue(reference, out string value))
			{
				return false;
			}
			if (!IsSupported)
			{
				LastFailure = SecretFailure.Unavailable;
				return false;
			}
			byte[] array = Transform(Convert.FromBase64String(value), protect: false);
			if (array == null)
			{
				LastFailure = SecretFailure.StoredElsewhere;
				return false;
			}
			try
			{
				secret = Encoding.UTF8.GetString(array);
				return true;
			}
			finally
			{
				Array.Clear(array, 0, array.Length);
			}
		}

		public bool Contains(string reference)
		{
			if (SecretReference.IsValid(reference))
			{
				return blobs.ContainsKey(reference);
			}
			return false;
		}

		public bool Forget(string reference)
		{
			SecretReference.Require(reference);
			if (!blobs.Remove(reference))
			{
				return false;
			}
			Save();
			return true;
		}

		public int ForgetAll()
		{
			int count = blobs.Count;
			blobs.Clear();
			Save();
			return count;
		}

		private void Load()
		{
			string[] array = (readFile() ?? "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = text.Substring(0, num);
					string text3 = text.Substring(num + 1);
					if (SecretReference.IsValid(text2) && IsBase64(text3))
					{
						blobs[text2] = text3;
					}
				}
			}
		}

		private void Save()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, string> blob in blobs)
			{
				stringBuilder.Append(blob.Key).Append('=').Append(blob.Value)
					.Append('\n');
			}
			writeFile(stringBuilder.ToString());
		}

		private static bool IsBase64(string text)
		{
			if (text.Length == 0)
			{
				return false;
			}
			try
			{
				Convert.FromBase64String(text);
				return true;
			}
			catch (FormatException)
			{
				return false;
			}
		}

		private static byte[]? Transform(byte[] input, bool protect)
		{
			DataBlob dataIn = default(DataBlob);
			DataBlob entropy = default(DataBlob);
			DataBlob dataOut = default(DataBlob);
			try
			{
				dataIn = DataBlob.From(input);
				entropy = DataBlob.From(Entropy);
				if (!(protect ? CryptProtectData(ref dataIn, null, ref entropy, IntPtr.Zero, IntPtr.Zero, 1, ref dataOut) : CryptUnprotectData(ref dataIn, IntPtr.Zero, ref entropy, IntPtr.Zero, IntPtr.Zero, 1, ref dataOut)) || dataOut.Data == IntPtr.Zero)
				{
					return null;
				}
				byte[] array = new byte[dataOut.Size];
				Marshal.Copy(dataOut.Data, array, 0, dataOut.Size);
				return array;
			}
			finally
			{
				dataIn.Free(clear: true);
				entropy.Free(clear: false);
				if (dataOut.Data != IntPtr.Zero)
				{
					Zero(dataOut.Data, dataOut.Size);
					LocalFree(dataOut.Data);
				}
			}
		}

		private static void Zero(IntPtr data, int size)
		{
			for (int i = 0; i < size; i++)
			{
				Marshal.WriteByte(data, i, 0);
			}
		}

		[DllImport("crypt32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		private static extern bool CryptProtectData(ref DataBlob dataIn, string? description, ref DataBlob entropy, IntPtr reserved, IntPtr prompt, int flags, ref DataBlob dataOut);

		[DllImport("crypt32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		private static extern bool CryptUnprotectData(ref DataBlob dataIn, IntPtr description, ref DataBlob entropy, IntPtr reserved, IntPtr prompt, int flags, ref DataBlob dataOut);

		[DllImport("kernel32.dll")]
		private static extern IntPtr LocalFree(IntPtr memory);
	}
	internal static class LibSecretNative
	{
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate uint Hash(IntPtr text);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate int Equal(IntPtr a, IntPtr b);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void Free(IntPtr value);

		private struct ListNode
		{
			internal IntPtr Data;

			internal IntPtr Next;

			internal IntPtr Previous;
		}

		private sealed class Call : IDisposable
		{
			internal IntPtr Schema;

			internal IntPtr Attributes;

			internal IntPtr Cancellable;

			private CancellationTokenRegistration registration;

			internal Call(string? reference, CancellationToken token)
			{
				token.ThrowIfCancellationRequested();
				try
				{
					IntPtr intPtr = g_hash_table_new_full(hash, equal, free, null);
					try
					{
						g_hash_table_insert(intPtr, g_strdup("ref"), IntPtr.Zero);
						Schema = secret_schema_newv("com.meadworks.beacon", 0, intPtr);
					}
					finally
					{
						g_hash_table_unref(intPtr);
					}
					Attributes = g_hash_table_new_full(hash, equal, free, free);
					if (reference != null)
					{
						g_hash_table_insert(Attributes, g_strdup("ref"), g_strdup(reference));
					}
					Cancellable = g_cancellable_new();
					if (Schema == IntPtr.Zero || Attributes == IntPtr.Zero || Cancellable == IntPtr.Zero)
					{
						throw new KeyringUnavailableException();
					}
					registration = token.Register(delegate
					{
						g_cancellable_cancel(Cancellable);
					});
				}
				catch
				{
					Dispose();
					throw;
				}
			}

			public void Dispose()
			{
				registration.Dispose();
				if (Cancellable != IntPtr.Zero)
				{
					g_object_unref(Cancellable);
					Cancellable = IntPtr.Zero;
				}
				if (Attributes != IntPtr.Zero)
				{
					g_hash_table_unref(Attributes);
					Attributes = IntPtr.Zero;
				}
				if (Schema != IntPtr.Zero)
				{
					secret_schema_unref(Schema);
					Schema = IntPtr.Zero;
				}
			}
		}

		private const string Secret = "libsecret-1.so.0";

		private const string Glib = "libglib-2.0.so.0";

		private const string Gio = "libgio-2.0.so.0";

		private const string Gobject = "libgobject-2.0.so.0";

		private const int SearchAll = 2;

		private static readonly Hash hash = g_str_hash;

		private static readonly Equal equal = g_str_equal;

		private static readonly Free free = g_free;

		internal static bool Store(string reference, string password, CancellationToken token)
		{
			using Call call = new Call(reference, token);
			IntPtr error;
			int num = secret_password_storev_sync(call.Schema, call.Attributes, "default", "Meadworks Beacon server password", password, call.Cancellable, out error);
			Check(error, token);
			return num != 0;
		}

		internal static SecretReadResult Read(string reference, CancellationToken token)
		{
			using Call call = new Call(reference, token);
			IntPtr error;
			IntPtr intPtr = secret_password_lookupv_sync(call.Schema, call.Attributes, call.Cancellable, out error);
			try
			{
				Check(error, token);
				return (intPtr == IntPtr.Zero) ? default(SecretReadResult) : new SecretReadResult(found: true, Marshal.PtrToStringUTF8(intPtr) ?? "");
			}
			finally
			{
				if (intPtr != IntPtr.Zero)
				{
					secret_password_free(intPtr);
				}
			}
		}

		internal static bool Forget(string reference, CancellationToken token)
		{
			using Call call = new Call(reference, token);
			IntPtr error;
			int num = secret_password_clearv_sync(call.Schema, call.Attributes, call.Cancellable, out error);
			Check(error, token);
			return num != 0;
		}

		internal static HashSet<string> References(CancellationToken token)
		{
			using Call call = new Call(null, token);
			IntPtr error;
			IntPtr intPtr = secret_password_searchv_sync(call.Schema, call.Attributes, 2, call.Cancellable, out error);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			try
			{
				Check(error, token);
				IntPtr intPtr2 = intPtr;
				while (intPtr2 != IntPtr.Zero)
				{
					ListNode listNode = Marshal.PtrToStructure<ListNode>(intPtr2);
					IntPtr intPtr3 = secret_retrievable_get_attributes(listNode.Data);
					try
					{
						string text = Marshal.PtrToStringUTF8(g_hash_table_lookup(intPtr3, "ref"));
						if (SecretReference.IsValid(text))
						{
							hashSet.Add(text);
						}
					}
					finally
					{
						if (intPtr3 != IntPtr.Zero)
						{
							g_hash_table_unref(intPtr3);
						}
					}
					intPtr2 = listNode.Next;
				}
				return hashSet;
			}
			finally
			{
				IntPtr intPtr4 = intPtr;
				while (intPtr4 != IntPtr.Zero)
				{
					ListNode listNode2 = Marshal.PtrToStructure<ListNode>(intPtr4);
					g_object_unref(listNode2.Data);
					intPtr4 = listNode2.Next;
				}
				if (intPtr != IntPtr.Zero)
				{
					g_list_free(intPtr);
				}
			}
		}

		private static void Check(IntPtr error, CancellationToken token)
		{
			if (error != IntPtr.Zero)
			{
				g_error_free(error);
			}
			token.ThrowIfCancellationRequested();
			if (error != IntPtr.Zero)
			{
				throw new KeyringUnavailableException();
			}
		}

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr secret_schema_newv([MarshalAs(UnmanagedType.LPUTF8Str)] string name, int flags, IntPtr types);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void secret_schema_unref(IntPtr schema);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern int secret_password_storev_sync(IntPtr schema, IntPtr attrs, [MarshalAs(UnmanagedType.LPUTF8Str)] string collection, [MarshalAs(UnmanagedType.LPUTF8Str)] string label, [MarshalAs(UnmanagedType.LPUTF8Str)] string password, IntPtr cancel, out IntPtr error);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr secret_password_lookupv_sync(IntPtr schema, IntPtr attrs, IntPtr cancel, out IntPtr error);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern int secret_password_clearv_sync(IntPtr schema, IntPtr attrs, IntPtr cancel, out IntPtr error);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr secret_password_searchv_sync(IntPtr schema, IntPtr attrs, int flags, IntPtr cancel, out IntPtr error);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr secret_retrievable_get_attributes(IntPtr item);

		[DllImport("libsecret-1.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void secret_password_free(IntPtr secret);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr g_hash_table_new_full(Hash hash, Equal equal, Free keyFree, Free? valueFree);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern int g_hash_table_insert(IntPtr table, IntPtr key, IntPtr value);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr g_hash_table_lookup(IntPtr table, [MarshalAs(UnmanagedType.LPUTF8Str)] string key);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void g_hash_table_unref(IntPtr table);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern uint g_str_hash(IntPtr value);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern int g_str_equal(IntPtr a, IntPtr b);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr g_strdup([MarshalAs(UnmanagedType.LPUTF8Str)] string value);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void g_free(IntPtr value);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void g_error_free(IntPtr error);

		[DllImport("libglib-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void g_list_free(IntPtr list);

		[DllImport("libgio-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr g_cancellable_new();

		[DllImport("libgio-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void g_cancellable_cancel(IntPtr value);

		[DllImport("libgobject-2.0.so.0", CallingConvention = CallingConvention.Cdecl)]
		private static extern void g_object_unref(IntPtr value);
	}
	public sealed class LinuxKeyringStore : IAsyncSecretStore, ISecretStore, IDisposable
	{
		private readonly ISecretStore session = MemorySecretStore.SessionOnly();

		private readonly ISecretStore disabled = new DisabledSecretStore();

		private LinuxFallback selectedFallback;

		private long fallbackRevision;

		private readonly SemaphoreSlim gate = new SemaphoreSlim(1);

		private readonly CancellationTokenSource lifetime = new CancellationTokenSource();

		private readonly HashSet<string> references = new HashSet<string>(StringComparer.Ordinal);

		private volatile bool unavailable;

		private volatile bool disposed;

		private ISecretStore FallbackStore
		{
			get
			{
				if (selectedFallback != LinuxFallback.Disabled)
				{
					return session;
				}
				return disabled;
			}
		}

		public SecretBackend Backend
		{
			get
			{
				lock (references)
				{
					return (!unavailable) ? SecretBackend.LinuxKeyring : FallbackStore.Backend;
				}
			}
		}

		public SecretAvailability Availability
		{
			get
			{
				lock (references)
				{
					return unavailable ? FallbackStore.Availability : SecretAvailability.Available;
				}
			}
		}

		public long FallbackRevision
		{
			get
			{
				lock (references)
				{
					return fallbackRevision;
				}
			}
		}

		public SecretFailure LastFailure { get; private set; }

		public LinuxKeyringStore(LinuxFallback selectedFallback)
		{
			SetFallback(selectedFallback);
		}

		public void SetFallback(LinuxFallback policy)
		{
			if (policy != LinuxFallback.SessionOnly && policy != LinuxFallback.Disabled)
			{
				throw new ArgumentOutOfRangeException("policy");
			}
			lock (references)
			{
				if (!disposed && selectedFallback != policy)
				{
					selectedFallback = policy;
					fallbackRevision++;
				}
			}
		}

		public bool IsReadCurrent(long revision)
		{
			lock (references)
			{
				return !disposed && (!unavailable || (selectedFallback == LinuxFallback.SessionOnly && fallbackRevision == revision));
			}
		}

		public bool Contains(string reference)
		{
			if (!SecretReference.IsValid(reference) || disposed)
			{
				return false;
			}
			lock (references)
			{
				return unavailable ? FallbackStore.Contains(reference) : references.Contains(reference);
			}
		}

		public bool Store(string reference, string secret)
		{
			SecretReference.Require(reference, secret);
			return false;
		}

		public bool TryRead(string reference, out string secret)
		{
			SecretReference.Require(reference);
			secret = "";
			return false;
		}

		public bool Forget(string reference)
		{
			SecretReference.Require(reference);
			return false;
		}

		public int ForgetAll()
		{
			return 0;
		}

		public Task<bool> RefreshAsync(CancellationToken cancellation = default(CancellationToken))
		{
			return Run(delegate(CancellationToken token)
			{
				HashSet<string> other = LibSecretNative.References(token);
				lock (references)
				{
					if (disposed || token.IsCancellationRequested)
					{
						return false;
					}
					references.Clear();
					references.UnionWith(other);
				}
				return true;
			}, () => false, canceled: false, cancellation);
		}

		public Task<bool> StoreAsync(string reference, string secret, CancellationToken cancellation = default(CancellationToken))
		{
			SecretReference.Require(reference, secret);
			if (secret.IndexOf('\0') >= 0)
			{
				throw new ArgumentException("A password cannot contain a NUL character.", "secret");
			}
			return Run(delegate(CancellationToken token)
			{
				bool flag = LibSecretNative.Store(reference, secret, token);
				if (flag)
				{
					lock (references)
					{
						if (disposed || token.IsCancellationRequested)
						{
							return false;
						}
						references.Add(reference);
					}
				}
				return flag;
			}, delegate
			{
				lock (references)
				{
					return FallbackStore.Store(reference, secret);
				}
			}, canceled: false, cancellation);
		}

		public Task<SecretReadResult> ReadAsync(string reference, CancellationToken cancellation = default(CancellationToken))
		{
			SecretReference.Require(reference);
			return Run((CancellationToken token) => LibSecretNative.Read(reference, token), delegate
			{
				lock (references)
				{
					string secret;
					return FallbackStore.TryRead(reference, out secret) ? new SecretReadResult(found: true, secret) : default(SecretReadResult);
				}
			}, default(SecretReadResult), cancellation);
		}

		public Task<bool> ForgetAsync(string reference, CancellationToken cancellation = default(CancellationToken))
		{
			SecretReference.Require(reference);
			return Run(delegate(CancellationToken token)
			{
				bool flag = LibSecretNative.Forget(reference, token);
				if (flag)
				{
					lock (references)
					{
						references.Remove(reference);
					}
				}
				return flag;
			}, delegate
			{
				lock (references)
				{
					return FallbackStore.Forget(reference);
				}
			}, canceled: false, cancellation);
		}

		public Task<int> ForgetAllAsync(CancellationToken cancellation = default(CancellationToken))
		{
			return Run(delegate(CancellationToken token)
			{
				HashSet<string> hashSet = LibSecretNative.References(token);
				int num = 0;
				foreach (string item in hashSet)
				{
					if (LibSecretNative.Forget(item, token))
					{
						num++;
						lock (references)
						{
							references.Remove(item);
						}
					}
				}
				return num;
			}, delegate
			{
				lock (references)
				{
					return FallbackStore.ForgetAll();
				}
			}, 0, cancellation);
		}

		private Task<T> Run<T>(Func<CancellationToken, T> operation, Func<T> onUnavailable, T canceled, CancellationToken cancellation)
		{
			long revision;
			lock (references)
			{
				if (disposed || cancellation.IsCancellationRequested)
				{
					return Task.FromResult(canceled);
				}
				revision = fallbackRevision;
			}
			return Task.Run(async delegate
			{
				CancellationTokenSource linked = CancellationTokenSource.CreateLinkedTokenSource(cancellation, lifetime.Token);
				try
				{
					bool entered = false;
					try
					{
						await gate.WaitAsync(linked.Token).ConfigureAwait(continueOnCapturedContext: false);
						entered = true;
						if (disposed || linked.IsCancellationRequested)
						{
							return canceled;
						}
						if (unavailable)
						{
							return Fallback();
						}
						using CancellationTokenSource cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { linked.Token });
						cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(5.0));
						try
						{
							T result = operation(cancellationTokenSource.Token);
							if (disposed || linked.IsCancellationRequested)
							{
								return canceled;
							}
							LastFailure = SecretFailure.None;
							return result;
						}
						catch (Exception ex) when (ex is DllNotFoundException || ex is EntryPointNotFoundException || ex is BadImageFormatException || ex is KeyringUnavailableException || ex is OperationCanceledException)
						{
							if (linked.IsCancellationRequested)
							{
								return canceled;
							}
							unavailable = true;
							LastFailure = SecretFailure.Unavailable;
							return Fallback();
						}
					}
					catch (OperationCanceledException)
					{
						return canceled;
					}
					finally
					{
						if (entered)
						{
							gate.Release();
						}
					}
				}
				finally
				{
					if (linked != null)
					{
						((IDisposable)linked).Dispose();
					}
				}
			});
			T Fallback()
			{
				lock (references)
				{
					if (disposed || P_0.linked.IsCancellationRequested || revision != fallbackRevision)
					{
						return canceled;
					}
					return onUnavailable();
				}
			}
		}

		public void Dispose()
		{
			if (disposed)
			{
				return;
			}
			disposed = true;
			lifetime.Cancel();
			lock (references)
			{
				references.Clear();
				session.ForgetAll();
			}
		}
	}
	internal sealed class KeyringUnavailableException : Exception
	{
	}
	public sealed class SecretRedactor
	{
		public const string Mask = "***";

		private readonly Dictionary<string, int> secrets = new Dictionary<string, int>(StringComparer.Ordinal);

		public void Track(string? secret)
		{
			if (!string.IsNullOrEmpty(secret))
			{
				secrets[secret] = ((!secrets.TryGetValue(secret, out var value)) ? 1 : (value + 1));
			}
		}

		public void Untrack(string? secret)
		{
			if (!string.IsNullOrEmpty(secret) && secrets.TryGetValue(secret, out var value))
			{
				if (value > 1)
				{
					secrets[secret] = value - 1;
				}
				else
				{
					secrets.Remove(secret);
				}
			}
		}

		public void Clear()
		{
			secrets.Clear();
		}

		public string Clean(string? message)
		{
			if (string.IsNullOrEmpty(message))
			{
				return "";
			}
			string text = message;
			foreach (string item in secrets.Keys.OrderByDescending((string s) => s.Length))
			{
				text = text.Replace(item, "***");
			}
			return text;
		}
	}
	public enum SecretAvailability
	{
		Available,
		SessionOnly,
		Unavailable
	}
	public enum SecretBackend
	{
		WindowsDataProtection,
		LinuxKeyring,
		SessionOnly,
		Disabled,
		Memory
	}
	public enum SecretPlatform
	{
		Windows,
		Linux,
		Other
	}
	public enum LinuxFallback
	{
		SessionOnly,
		Disabled
	}
	public enum SecretFailure
	{
		None,
		StoredElsewhere,
		ProtectFailed,
		Unavailable
	}
	public interface ISecretStore
	{
		SecretBackend Backend { get; }

		SecretAvailability Availability { get; }

		SecretFailure LastFailure { get; }

		bool Store(string reference, string secret);

		bool TryRead(string reference, out string secret);

		bool Contains(string reference);

		bool Forget(string reference);

		int ForgetAll();
	}
	public static class SecretReference
	{
		public static bool IsValid(string? reference)
		{
			if (string.IsNullOrEmpty(reference) || reference.Length > 64)
			{
				return false;
			}
			foreach (char c in reference)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && c != '-' && c != '_')
				{
					return false;
				}
			}
			return true;
		}

		public static void Require(string reference, string secret)
		{
			if (!IsValid(reference))
			{
				throw new ArgumentException("Invalid secret reference.", "reference");
			}
			if (string.IsNullOrEmpty(secret))
			{
				throw new ArgumentException("An empty secret is not stored.", "secret");
			}
		}

		public static void Require(string reference)
		{
			if (!IsValid(reference))
			{
				throw new ArgumentException("Invalid secret reference.", "reference");
			}
		}
	}
	public sealed class MemorySecretStore : ISecretStore
	{
		private readonly Dictionary<string, string> secrets = new Dictionary<string, string>(StringComparer.Ordinal);

		public SecretBackend Backend { get; }

		public SecretAvailability Availability { get; }

		public SecretFailure LastFailure => SecretFailure.None;

		public MemorySecretStore(SecretBackend backend = SecretBackend.Memory, SecretAvailability availability = SecretAvailability.Available)
		{
			Backend = backend;
			Availability = availability;
		}

		public static MemorySecretStore SessionOnly()
		{
			return new MemorySecretStore(SecretBackend.SessionOnly, SecretAvailability.SessionOnly);
		}

		public bool Store(string reference, string secret)
		{
			SecretReference.Require(reference, secret);
			secrets[reference] = secret;
			return true;
		}

		public bool TryRead(string reference, out string secret)
		{
			SecretReference.Require(reference);
			if (secrets.TryGetValue(reference, out string value))
			{
				secret = value;
				return true;
			}
			secret = "";
			return false;
		}

		public bool Contains(string reference)
		{
			if (SecretReference.IsValid(reference))
			{
				return secrets.ContainsKey(reference);
			}
			return false;
		}

		public bool Forget(string reference)
		{
			SecretReference.Require(reference);
			return secrets.Remove(reference);
		}

		public int ForgetAll()
		{
			int count = secrets.Count;
			secrets.Clear();
			return count;
		}
	}
	public sealed class DisabledSecretStore : ISecretStore
	{
		public SecretBackend Backend => SecretBackend.Disabled;

		public SecretAvailability Availability => SecretAvailability.Unavailable;

		public SecretFailure LastFailure { get; private set; }

		public bool Store(string reference, string secret)
		{
			SecretReference.Require(reference, secret);
			LastFailure = SecretFailure.Unavailable;
			return false;
		}

		public bool TryRead(string reference, out string secret)
		{
			SecretReference.Require(reference);
			secret = "";
			return false;
		}

		public bool Contains(string reference)
		{
			return false;
		}

		public bool Forget(string reference)
		{
			return false;
		}

		public int ForgetAll()
		{
			return 0;
		}
	}
	public static class SecretStores
	{
		public const LinuxFallback DefaultLinuxFallback = LinuxFallback.SessionOnly;

		public static SecretBackend Choose(SecretPlatform platform, bool keyringUsable, LinuxFallback fallback)
		{
			if (platform == SecretPlatform.Windows)
			{
				return SecretBackend.WindowsDataProtection;
			}
			if (platform == SecretPlatform.Linux && keyringUsable)
			{
				return SecretBackend.LinuxKeyring;
			}
			if (fallback != LinuxFallback.Disabled)
			{
				return SecretBackend.SessionOnly;
			}
			return SecretBackend.Disabled;
		}

		public static string StorageLineKey(SecretBackend backend)
		{
			return backend switch
			{
				SecretBackend.WindowsDataProtection => "storage_windows", 
				SecretBackend.LinuxKeyring => "storage_keyring", 
				SecretBackend.Disabled => "storage_disabled", 
				_ => "storage_session", 
			};
		}
	}
}
namespace ExtraPotions.Beacon.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 BeaconTextKeys
	{
		public const string StepAsideJoin = "step_aside_join";

		public const string StorageWindows = "storage_windows";

		public const string StorageKeyring = "storage_keyring";

		public const string StorageSession = "storage_session";

		public const string StorageDisabled = "storage_disabled";

		public const string SecretStoreFailed = "secret_store_failed";

		public const string SecretStoredElsewhere = "secret_stored_elsewhere";

		public const string OfferSave = "offer_save";

		public const string PasswordSaved = "password_saved";

		public const string PasswordForgotten = "password_forgotten";

		public const string PasswordsForgottenAll = "passwords_forgotten_all";

		public const string AutoJoinCountdown = "autojoin_countdown";

		public const string AutoJoinCancelled = "autojoin_canceled";

		public const string AutoJoinUnknownServer = "autojoin_unknown_server";

		public const string Reconnecting = "reconnecting";

		public const string ReconnectLocked = "reconnect_locked";

		public const string FavoriteRemoved = "favorite_removed";

		public const string ImportNone = "import_none";

		public const string ImportDone = "import_done";

		public const string ImportPasswordNotStored = "import_password_not_stored";

		public const string ImportSourcePlain = "import_source_plain";

		public const string ImportBlankDone = "import_blank_done";

		public const string CommandHelp = "cmd_help";

		public const string CommandStatus = "cmd_status";

		public const string CommandUsage = "cmd_usage";

		public const string CommandUnknownVerb = "cmd_unknown_verb";

		public const string CommandConfirmBlank = "cmd_confirm_blank";

		public const string CommandJoinUnknown = "cmd_join_unknown";

		public const string CommandJoinNotReady = "cmd_join_not_ready";

		public const string CommandJoinStarted = "cmd_join_started";

		public const string ReconnectCancelled = "reconnect_canceled";

		public const string ReconnectStopped = "reconnect_stopped";

		public const string CommandCancelNone = "cmd_cancel_none";

		public const string AutoJoinUnknownCharacter = "autojoin_unknown_character";

		public const string CardAutoJoin = "card_autojoin";

		public const string CardReconnect = "card_reconnect";

		public const string CardCancelHint = "card_cancel_hint";

		public static IReadOnlyList<TextKey> All { get; } = Array.AsReadOnly(new TextKey[102]
		{
			new TextKey("step_aside_join", 1),
			new TextKey("storage_windows", 0),
			new TextKey("storage_keyring", 0),
			new TextKey("storage_session", 0),
			new TextKey("storage_disabled", 0),
			new TextKey("secret_store_failed", 0),
			new TextKey("secret_stored_elsewhere", 1),
			new TextKey("offer_save", 1),
			new TextKey("password_saved", 1),
			new TextKey("password_forgotten", 1),
			new TextKey("passwords_forgotten_all", 1),
			new TextKey("autojoin_countdown", 2),
			new TextKey("autojoin_canceled", 0),
			new TextKey("autojoin_unknown_server", 1),
			new TextKey("reconnecting", 2),
			new TextKey("reconnect_locked", 0),
			new TextKey("favorite_removed", 1),
			new TextKey("import_none", 0),
			new TextKey("import_done", 2),
			new TextKey("import_password_not_stored", 1),
			new TextKey("import_source_plain", 0),
			new TextKey("import_blank_done", 1),
			new TextKey("cmd_help", 0),
			new TextKey("cmd_status", 3),
			new TextKey("cmd_usage", 0),
			new TextKey("cmd_unknown_verb", 1),
			new TextKey("cmd_confirm_blank", 0),
			new TextKey("cmd_join_unknown", 1),
			new TextKey("cmd_join_not_ready", 0),
			new TextKey("cmd_join_started", 1),
			new TextKey("reconnect_canceled", 0),
			new TextKey("reconnect_stopped", 1),
			new TextKey("cmd_cancel_none", 0),
			new TextKey("autojoin_unknown_character", 1),
			new TextKey("card_autojoin", 2),
			new TextKey("card_reconnect", 3),
			new TextKey("card_cancel_hint", 0),
			new TextKey("ui_servers", 0),
			new TextKey("ui_previous", 0),
			new TextKey("ui_next", 0),
			new TextKey("ui_add", 0),
			new TextKey("ui_edit", 0),
			new TextKey("ui_join", 0),
			new TextKey("ui_remove", 0),
			new TextKey("ui_up", 0),
			new TextKey("ui_down", 0),
			new TextKey("ui_default", 0),
			new TextKey("ui_close", 0),
			new TextKey("ui_forget", 0),
			new TextKey("ui_forget_all", 0),
			new TextKey("ui_confirm", 0),
			new TextKey("ui_cancel", 0),
			new TextKey("ui_save", 0),
			new TextKey("ui_name", 0),
			new TextKey("ui_address", 0),
			new TextKey("ui_aliases", 0),
			new TextKey("ui_password", 0),
			new TextKey("ui_password_hint", 0),
			new TextKey("ui_stored", 0),
			new TextKey("ui_empty", 0),
			new TextKey("ui_read_only", 0),
			new TextKey("ui_step_aside", 0),
			new TextKey("ui_write_failed", 0),
			new TextKey("ui_invalid", 0),
			new TextKey("ui_forget_all_confirm", 0),
			new TextKey("ui_alias_count", 1),
			new TextKey("ui_remove_confirm", 1),
			new TextKey("ui_forget_confirm", 1),
			new TextKey("ui_import", 0),
			new TextKey("import_preview_again", 0),
			new TextKey("import_write_failed", 0),
			new TextKey("import_password_pending", 0),
			new TextKey("ui_import_apply", 0),
			new TextKey("ui_import_blank", 0),
			new TextKey("ui_import_blank_confirm", 0),
			new TextKey("ui_import_results", 0),
			new TextKey("ui_undo", 0),
			new TextKey("ui_undo_conflict", 0),
			new TextKey("ui_favorite_save_failed", 0),
			new TextKey("ui_help_servers", 0),
			new TextKey("ui_help_previous", 0),
			new TextKey("ui_help_next", 0),
			new TextKey("ui_help_add", 0),
			new TextKey("ui_help_edit", 0),
			new TextKey("ui_help_join", 0),
			new TextKey("ui_help_remove", 0),
			new TextKey("ui_help_up", 0),
			new TextKey("ui_help_down", 0),
			new TextKey("ui_help_default", 0),
			new TextKey("ui_help_close", 0),
			new TextKey("ui_help_forget", 0),
			new TextKey("ui_help_forget_all", 0),
			new TextKey("ui_help_import", 0),
			new TextKey("ui_help_select", 0),
			new TextKey("ui_help_cancel", 0),
			new TextKey("ui_help_save", 0),
			new TextKey("ui_help_name", 0),
			new TextKey("ui_help_address", 0),
			new TextKey("ui_help_aliases", 0),
			new TextKey("ui_help_save_password", 0),
			new TextKey("ui_help_undo", 0),
			new TextKey("ui_help_import_apply", 0)
		});
	}
}
namespace ExtraPotions.Beacon.Joining
{
	public enum AutoJoinSkip
	{
		None,
		Disabled,
		LaunchConnect,
		AlreadyRan,
		NoServer,
		UnknownServer
	}
	public readonly struct AutoJoinDecision
	{
		public AutoJoinSkip Skip { get; }

		public ServerEntry? Target { get; }

		public AutoJoinDecision(AutoJoinSkip skip, ServerEntry? target)
		{
			Skip = skip;
			Target = target;
		}
	}
	public static class AutoJoinRules
	{
		public static AutoJoinDecision Decide(bool enabled, string? serverName, ServerList list, bool launchedWithConnect, bool alreadyRan)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (!enabled)
			{
				return new AutoJoinDecision(AutoJoinSkip.Disabled, null);
			}
			if (launchedWithConnect)
			{
				return new AutoJoinDecision(AutoJoinSkip.LaunchConnect, null);
			}
			if (alreadyRan)
			{
				return new AutoJoinDecision(AutoJoinSkip.AlreadyRan, null);
			}
			string text = (serverName ?? "").Trim();
			if (text.Length == 0)
			{
				ServerEntry serverEntry = list.Default;
				if (serverEntry != null)
				{
					return new AutoJoinDecision(AutoJoinSkip.None, serverEntry);
				}
				return new AutoJoinDecision(AutoJoinSkip.NoServer, null);
			}
			ServerEntry serverEntry2 = list.FindByName(text);
			if (serverEntry2 != null)
			{
				return new AutoJoinDecision(AutoJoinSkip.None, serverEntry2);
			}
			return new AutoJoinDecision(AutoJoinSkip.UnknownServer, null);
		}

		public static bool LaunchJoins(IReadOnlyList<string> args)
		{
			if (args == null)
			{
				throw new ArgumentNullException("args");
			}
			for (int i = 0; i < args.Count - 1; i++)
			{
				switch (args[i])
				{
				case "+connect":
				case "+connect_lobby":
				case "-joinserverwithcharacter":
				case "-joincode":
					return true;
				}
			}
			return false;
		}

		public static int PickCharacter(IReadOnlyList<string> names, IReadOnlyList<string> files, string? wanted, int selected)
		{
			if (names == null)
			{
				throw new ArgumentNullException("names");
			}
			if (files == null)
			{
				throw new ArgumentNullException("files");
			}
			if (names.Count == 0)
			{
				return -1;
			}
			string text = (wanted ?? "").Trim();
			if (text.Length == 0)
			{
				if (selected < 0 || selected >= names.Count)
				{
					return 0;
				}
				return selected;
			}
			for (int i = 0; i < names.Count; i++)
			{
				if (string.Equals((names[i] ?? "").Trim(), text, StringComparison.OrdinalIgnoreCase))
				{
					return i;
				}
			}
			for (int j = 0; j < files.Count && j < names.Count; j++)
			{
				if (string.Equals((files[j] ?? "").Trim(), text, StringComparison.OrdinalIgnoreCase))
				{
					return j;
				}
			}
			return -1;
		}
	}
	public enum CountdownState
	{
		Counting,
		Join,
		Cancelled
	}
	public sealed class AutoJoinCountdown
	{
		public const int MaxSeconds = 30;

		private float remaining;

		private CountdownState state;

		public int SecondsShown => (int)Math.Ceiling(Math.Max(0f, remaining));

		public CountdownState State => state;

		public AutoJoinCountdown(int seconds)
		{
			remaining = Math.Max(0, Math.Min(30, seconds));
		}

		public CountdownState Tick(float deltaSeconds)
		{
			if (state != CountdownState.Counting)
			{
				return state;
			}
			remaining -= Math.Max(0f, deltaSeconds);
			if (remaining <= 0f)
			{
				state = CountdownState.Join;
			}
			return state;
		}

		public void Cancel()
		{
			if (state == CountdownState.Counting)
			{
				state = CountdownState.Cancelled;
			}
		}
	}
	public enum DisconnectKind
	{
		Unexpected,
		Kicked,
		Banned,
		PlayerQuit,
		WrongPassword,
		VersionMismatch,
		ServerFull,
		ConnectFailed,
		Refused,
		Unknown
	}
	public enum ReconnectDecision
	{
		Reconnect,
		Off,
		Locked,
		NotAfterThis,
		OutOfAttempts
	}
	public static class ReconnectRules
	{
		public const int MinAttempts = 1;

		public const int MaxAttempts = 10;

		public static ReconnectDecision Decide(bool enabled, bool lockedByServer, DisconnectKind kind, int attemptsSoFar, int maxAttempts)
		{
			if (!enabled)
			{
				return ReconnectDecision.Off;
			}
			if (lockedByServer)
			{
				return ReconnectDecision.Locked;
			}
			if (kind != DisconnectKind.Unexpected)
			{
				return ReconnectDecision.NotAfterThis;
			}
			int num = Math.Max(1, Math.Min(10, maxAttempts));
			if (attemptsSoFar < num)
			{
				return ReconnectDecision.Reconnect;
			}
			return ReconnectDecision.OutOfAttempts;
		}

		public static int DelaySeconds(int attemptIndex)
		{
			if (attemptIndex > 0)
			{
				if (attemptIndex < 4)
				{
					return 5 << attemptIndex;
				}
				return 60;
			}
			return 5;
		}
	}
	public readonly struct CardLine
	{
		public string Key { get; }

		public IReadOnlyList<object> Arguments { get; }

		public CardLine(string key, params object[] arguments)
		{
			Key = key;
			Arguments = Array.AsReadOnly(arguments ?? Array.Empty<object>());
		}
	}
	public static class JoinCard
	{
		public static IReadOnlyList<CardLine> Countdown(string serverName, int seconds)
		{
			return new CardLine[2]
			{
				new CardLine("card_autojoin", serverName ?? "", Math.Max(0, seconds)),
				new CardLine("card_cancel_hint")
			};
		}

		public static IReadOnlyList<CardLine> Reconnect(int attempt, int limit, int seconds)
		{
			return new CardLine[2]
			{
				new CardLine("card_reconnect", attempt, limit, Math.Max(0, seconds)),
				new CardLine("card_cancel_hint")
			};
		}
	}
	public enum JoinAction
	{
		None,
		SendStored,
		AskPlayer,
		ReconnectAndAsk,
		StoreTyped,
		OfferSave
	}
	public sealed class JoinAttempt
	{
		private readonly bool hasStored;

		private readonly bool skipPrompt;

		private readonly bool offerToSave;

		private readonly bool alreadyOffered;

		private readonly bool storedRejected;

		private bool sentStored;

		private bool typed;

		public ServerEntry? Entry { get; }

		public JoinAttempt(ServerEntry? entry, bool hasStored, bool skipPrompt, bool offerToSave, bool alreadyOffered)
			: this(entry, hasStored, skipPrompt, offerToSave, alreadyOffered, storedRejected: false)
		{
		}

		private JoinAttempt(ServerEntry? entry, bool hasStored, bool skipPrompt, bool offerToSave, bool alreadyOffered, bool storedRejected)
		{
			Entry = entry;
			this.hasStored = hasStored;
			this.skipPrompt = skipPrompt;
			this.offerToSave = offerToSave;
			this.alreadyOffered = alreadyOffered;
			this.storedRejected = storedRejected;
		}

		public JoinAction OnPasswordRequested()
		{
			if (Entry != null && hasStored && skipPrompt && !storedRejected)
			{
				sentStored = true;
				return JoinAction.SendStored;
			}
			return JoinAction.AskPlayer;
		}

		public void OnPlayerTyped()
		{
			typed = true;
		}

		public JoinAction OnRejected()
		{
			if (sentStored)
			{
				sentStored = false;
				return JoinAction.ReconnectAndAsk;
			}
			typed = false;
			return JoinAction.None;
		}

		public JoinAction OnAccepted()
		{
			if (!typed)
			{
				return JoinAction.None;
			}
			if (Entry != null)
			{
				return JoinAction.StoreTyped;
			}
			if (!offerToSave || alreadyOffered)
			{
				return JoinAction.None;
			}
			return JoinAction.OfferSave;
		}

		public JoinAttempt AfterRejection()
		{
			return new JoinAttempt(Entry, hasStored, skipPrompt, offerToSave, alreadyOffered, storedRejected: true);
		}
	}
	public enum GameStatus
	{
		None,
		Connecting,
		Connected,
		ErrorVersion,
		ErrorDisconnected,
		ErrorConnectFailed,
		ErrorPassword,
		ErrorAlreadyConnected,
		ErrorBanned,
		ErrorFull,
		ErrorPlatformExcluded,
		ErrorCrossplayPrivilege,
		ErrorKicked,
		Unknown
	}
	public static class ConnectionOutcomes
	{
		public static GameStatus Parse(string? name)
		{
			string text = (name ?? "").Trim();
			if (text.Length == 0 || !char.IsLetter(text[0]))
			{
				return GameStatus.Unknown;
			}
			if (!Enum.TryParse<GameStatus>(text, ignoreCase: false, out var result))
			{
				return GameStatus.Unknown;
			}
			return result;
		}

		public static DisconnectKind Classify(GameStatus status, bool wasConnected)
		{
			return status switch
			{
				GameStatus.Connected => DisconnectKind.PlayerQuit, 
				GameStatus.ErrorPassword => DisconnectKind.WrongPassword, 
				GameStatus.ErrorKicked => DisconnectKind.Kicked, 
				GameStatus.ErrorBanned => DisconnectKind.Banned, 
				GameStatus.ErrorVersion => DisconnectKind.VersionMismatch, 
				GameStatus.ErrorFull => DisconnectKind.ServerFull, 
				GameStatus.ErrorAlreadyConnected => DisconnectKind.Refused, 
				GameStatus.ErrorPlatformExcluded => DisconnectKind.Refused, 
				GameStatus.ErrorCrossplayPrivilege => DisconnectKind.Refused, 
				GameStatus.ErrorDisconnected => (!wasConnected) ? DisconnectKind.ConnectFailed : DisconnectKind.Unexpected, 
				GameStatus.ErrorConnectFailed => (!wasConnected) ? DisconnectKind.ConnectFailed : DisconnectKind.Unexpected, 
				_ => DisconnectKind.Unknown, 
			};
		}
	}
	public static class JoinTargets
	{
		public static ServerAddress? FromHost(string? host, int port)
		{
			string text = (host ?? "").Trim();
			if (text.Length == 0 || port < 1 || port > 65535)
			{
				return null;
			}
			int num = 0;
			string text2 = text;
			for (int i = 0; i < text2.Length; i++)
			{
				if (text2[i] == ':')
				{
					num++;
				}
			}
			if (num == 1)
			{
				return null;
			}
			string text3 = port.ToString(CultureInfo.InvariantCulture);
			if (!ServerAddress.TryParse((num > 1 && text[0] != '[') ? ("[" + text + "]:" + text3) : (text + ":" + text3), out ServerAddress address))
			{
				return null;
			}
			return address;
		}

		public static ServerAddress? FromSteam(ulong id)
		{
			if (id == 0L || !ServerAddress.TryParse("steam:" + id.ToString(CultureInfo.InvariantCulture), out ServerAddress address))
			{
				return null;
			}
			return address;
		}

		public static ServerAddress? FromPlayFab(string? id)
		{
			if (!ServerAddress.TryParse("playfab:" + (id ?? "").Trim(), out ServerAddress address))
			{
				return null;
			}
			return address;
		}

		public static bool TryGetSteamId(ServerAddress address, out ulong id)
		{
			id = 0uL;
			if (address != null && address.Kind == AddressKind.Steam && ulong.TryParse(address.Host, NumberStyles.None, CultureInfo.InvariantCulture, out id))
			{
				return id != 0;
			}
			return false;
		}
	}
	public readonly struct JoinOptions
	{
		public bool SkipPrompt { get; }

		public bool OfferToSave { get; }

		public JoinOptions(bool skipPrompt, bool offerToSave)
		{
			SkipPrompt = skipPrompt;
			OfferToSave = offerToSave;
		}
	}
	public enum MenuStep
	{
		None,
		RejoinForPassword
	}
	public readonly struct MenuOutcome
	{
		public DisconnectKind Kind { get; }

		public ServerAddress? Target { get; }

		public MenuStep Step { get; }

		public bool WasConnected { get; }

		public MenuOutcome(DisconnectKind kind, ServerAddress? target, MenuStep step, bool wasConnected)
		{
			Kind = kind;
			Target = target;
			Step = step;
			WasConnected = wasConnected;
		}
	}
	public sealed class JoinCoordinator
	{
		private readonly HashSet<ServerAddress> offered = new HashSet<ServerAddress>();

		private JoinAttempt? attempt;

		private ServerAddress? rejoinForPassword;

		private bool requested;

		public ServerAddress? Target { get; private set; }

		public ServerEntry? Entry => attempt?.Entry;

		public bool Connected { get; private set; }

		public bool AwaitingConnection
		{
			get
			{
				if (Target != null && attempt != null)
				{
					return !Connected;
				}
				return false;
			}
		}

		public void OnJoinStarted(ServerAddress? target, ServerList list, Func<ServerEntry, bool> hasStored, JoinOptions options)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (hasStored == null)
			{
				throw new ArgumentNullException("hasStored");
			}
			if (target != null && target == Target && attempt != null && !requested && !Connected)
			{
				return;
			}
			Target = target;
			Connected = false;
			requested = false;
			if (target == null)
			{
				attempt = null;
				rejoinForPassword = null;
				return;
			}
			ServerEntry serverEntry = list.Find(target);
			JoinAttempt joinAttempt = new JoinAttempt(serverEntry, serverEntry != null && hasStored(serverEntry), options.SkipPrompt, options.OfferToSave, offered.Contains(target));
			if (rejoinForPassword == target)
			{
				joinAttempt = joinAttempt.AfterRejection();
			}
			rejoinForPassword = null;
			attempt = joinAttempt;
		}

		public JoinAction OnPasswordRequested()
		{
			if (attempt == null || Connected)
			{
				return JoinAction.None;
			}
			requested = true;
			return attempt.OnPasswordRequested();
		}

		public void OnStoredUnreadable()
		{
			if (attempt != null)
			{
				attempt = attempt.AfterRejection();
			}
		}

		public void OnPlayerTyped()
		{
			attempt?.OnPlayerTyped();
		}

		public JoinAction OnConnected()
		{
			if (attempt == null || Connected)
			{
				return JoinAction.None;
			}
			Connected = true;
			JoinAction num = attempt.OnAccepted();
			if (num == JoinAction.OfferSave)
			{
				offered.Add(Target);
			}
			return num;
		}

		public MenuOutcome OnReturnedToMenu(GameStatus status)
		{
			ServerAddress target = Target;
			bool connected = Connected;
			JoinAttempt joinAttempt = attempt;
			Target = null;
			attempt = null;
			Connected = false;
			requested = false;
			if (target == null)
			{
				return new MenuOutcome(DisconnectKind.Unknown, null, MenuStep.None, wasConnected: false);
			}
			DisconnectKind disconnectKind = ConnectionOutcomes.Classify(status, connected);
			if (disconnectKind == DisconnectKind.WrongPassword && joinAttempt != null && joinAttempt.OnRejected() == JoinAction.ReconnectAndAsk)
			{
				rejoinForPassword = target;
				return new MenuOutcome(disconnectKind, target, MenuStep.RejoinForPassword, connected);
			}
			return new MenuOutcome(disconnectKind, target, MenuStep.None, connected);
		}

		public void Reset()
		{
			offered.Clear();
			attempt = null;
			rejoinForPassword = null;
			Target = null;
			Connected = false;
			requested = false;
		}
	}
	public enum MenuBackAction
	{
		None,
		CloseDialog,
		DeclineSaveOffer,
		ClosePanel,
		CancelWait
	}
	public struct MenuBackState
	{
		public bool Escape;

		public bool Typing;

		public bool TypedLastFrame;

		public bool DialogOpen;

		public bool DialogTyping;

		public bool SaveOfferOpen;

		public bool PanelOpen;

		public bool WaitPending;
	}
	public static class MenuBack
	{
		public static MenuBackAction Decide(MenuBackState state)
		{
			if (!state.Escape || state.Typing || state.TypedLastFrame)
			{
				return MenuBackAction.None;
			}
			if (state.DialogOpen)
			{
				if (!state.DialogTyping)
				{
					return MenuBackAction.CloseDialog;
				}
				return MenuBackAction.None;
			}
			if (state.SaveOfferOpen)
			{
				return MenuBackAction.DeclineSaveOffer;
			}
			if (state.PanelOpen)
			{
				return MenuBackAction.ClosePanel;
			}
			if (!state.WaitPending)
			{
				return MenuBackAction.None;
			}
			return MenuBackAction.CancelWait;
		}
	}
	public sealed class ReconnectServerPolicy
	{
		private bool denied;

		public ServerAddress? Target { get; private set; }

		public void Begin(ServerAddress? target)
		{
			Target = target;
			denied = false;
		}

		public void Observe(ServerAddress? target, bool authenticated, bool allowsReconnect)
		{
			if (authenticated && !(target == null) && !(target != Target))
			{
				denied = !allowsReconnect;
			}
		}

		public bool LockedFor(ServerAddress? target)
		{
			if (denied && target != null)
			{
				return target == Target;
			}
			return false;
		}

		public void Reset()
		{
			Target = null;
			denied = false;
		}
	}
	public enum ReconnectStep
	{
		None,
		Scheduled,
		Stopped,
		Locked
	}
	public readonly struct ReconnectPlan
	{
		public ReconnectStep Step { get; }

		public ReconnectDecision Decision { get; }

		public int Attempt { get; }

		public int Limit { get; }

		public int DelaySeconds { get; }

		public ReconnectPlan(ReconnectStep step, ReconnectDecision decision, int attempt, int limit, int delaySeconds)
		{
			Step = step;
			Decision = decision;
			Attempt = attempt;
			Limit = limit;
			DelaySeconds = delaySeconds;
		}
	}
	public sealed class ReconnectSession
	{
		public const double StableSeconds = 60.0;

		private int attempts;

		private double connectedAt = -1.0;

		private double due = -1.0;

		public ServerAddress? Target { get; private set; }

		public bool Pending => due >= 0.0;

		public int SecondsLeft(double now)
		{
			if (!(due < 0.0))
			{
				return (int)Math.Ceiling(Math.Max(0.0, due - now));
			}
			return 0;
		}

		public void OnJoinStarted(ServerAddress? joining)
		{
			if (Target != null && joining != Target)
			{
				Cancel();
			}
		}

		public void OnConnected(double now)
		{
			connectedAt = now;
		}

		public ReconnectPlan OnDisconnected(ServerAddress target, DisconnectKind kind, bool wasConnected, bool enabled, bool lockedByServer, int maxAttempts, double now)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			due = -1.0;
			if (Target != target)
			{
				Target = target;
				attempts = 0;
			}
			if (wasConnected && connectedAt >= 0.0 && now - connectedAt >= 60.0)
			{
				attempts = 0;
			}
			connectedAt = -1.0;
			DisconnectKind disconnectKind = ((kind != DisconnectKind.ConnectFailed || attempts <= 0) ? kind : DisconnectKind.Unexpected);
			int limit = Math.Max(1, Math.Min(10, maxAttempts));
			ReconnectDecision reconnectDecision = ReconnectRules.Decide(enabled, lockedByServer, disconnectKind, attempts, maxAttempts);
			if (reconnectDecision == ReconnectDecision.Reconnect)
			{
				int num = ReconnectRules.DelaySeconds(attempts);
				attempts++;
				due = now + (double)num;
				return new ReconnectPlan(ReconnectStep.Scheduled, reconnectDecision, attempts, limit, num);
			}
			bool flag = attempts > 0;
			Cancel();
			if (reconnectDecision == ReconnectDecision.Locked && disconnectKind == DisconnectKind.Unexpected)
			{
				return new ReconnectPlan(ReconnectStep.Locked, reconnectDecision, 0, limit, 0);
			}
			return new ReconnectPlan(flag ? ReconnectStep.Stopped : ReconnectStep.None, reconnectDecision, 0, limit, 0);
		}

		public bool Tick(double now)
		{
			if (due < 0.0 || now < due)
			{
				return false;
			}
			due = -1.0;
			return true;
		}

		public bool Cancel()
		{
			bool result = due >= 0.0 || attempts > 0;
			due = -1.0;
			attempts = 0;
			connectedAt = -1.0;
			Target = null;
			return result;
		}
	}
}
namespace ExtraPotions.Beacon.Integration
{
	public enum BeaconModule
	{
		Join
	}
	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 BeaconModule Module { get; }

		public IReadOnlyList<string> PluginNames { get; }

		internal ModuleSource(string guid, string name, BeaconModule 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 BeaconModule Module { get; }

		public string SourceName { get; }

		public string SourceGuid { get; }

		public string Key => KeyOf(Module);

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

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

		public IReadOnlyList<ModuleSource> Present { get; }

		public bool Any => aside.Count > 0;

		public IReadOnlyList<StepAsideNotice> Notices { get; }

		internal ModuleStepAsideDecision(IReadOnlyList<ModuleSource> present)
		{
			Present = present;
			aside = new HashSet<BeaconModule>(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(BeaconModule module)
		{
			return aside.Contains(module);
		}
	}
	public static class ModuleStepAside
	{
		public static readonly ModuleSource AutoConnector = new ModuleSource("MidnightsFX.Autoconnect", "AutoConnector", BeaconModule.Join, "AutoConnector");

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

		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.Beacon.Conversion
{
	public enum ImportProblem
	{
		None,
		MissingAddress,
		InvalidAddress
	}
	public sealed class ImportedServer
	{
		public string Name { get; }

		public string? AddressText { get; }

		public ServerAddress? Address { get; }

		public IReadOnlyList<ServerAddress> Aliases { get; }

		public ImportProblem Problem { get; }

		public bool HasPassword => Password != null;

		public string? Password { get; }

		internal ImportedServer(string name, string? addressText, IReadOnlyList<string> aliasTexts, string? password)
		{
			Name = name;
			AddressText = addressText;
			Password = (string.IsNullOrEmpty(password) ? null : password);
			ServerAddress address;
			if (string.IsNullOrWhiteSpace(addressText))
			{
				Problem = ImportProblem.MissingAddress;
			}
			else if (!ServerAddress.TryParse(addressText, out address))
			{
				Problem = ImportProblem.InvalidAddress;
			}
			else
			{
				Address = address;
			}
			Aliases = (from t in aliasTexts
				select (!ServerAddress.TryParse(t, out ServerAddress address2)) ? null : address2 into x
				where x != null
				select (x)).ToList();
		}

		public override string ToString()
		{
			return Name + " (" + (Address?.ToString() ?? "no address") + "), " + (HasPassword ? "password present" : "no password");
		}
	}
	public enum ImportOutcome
	{
		Add,
		SameName,
		AddressTaken,
		Invalid
	}
	public sealed class ImportPlanItem
	{
		public ImportedServer Server { get; }

		public ImportOutcome Outcome { get; }

		internal ImportPlanItem(ImportedServer server, ImportOutcome outcome)
		{
			Server = server;
			Outcome = outcome;
		}

		public override string ToString()
		{
			return Outcome.ToString() + ": " + Server;
		}
	}
	public sealed class ImportResult
	{
		public int Added { get; }

		public int Skipped { get; }

		public IReadOnlyList<string> PasswordNotStored { get; }

		internal ImportResult(int added, int skipped, IReadOnlyList<string> passwordNotStored)
		{
			Added = added;
			Skipped = skipped;
			PasswordNotStored = passwordNotStored;
		}
	}
	public static class AutoConnectorImport
	{
		public const string SourceGuid = "MidnightsFX.Autoconnect";

		public const string SourceFile = "AutoConnector/servers.yaml";

		private const string AddressKey = "ServerAddress";

		private const string AliasesKey = "ServerAliases";

		private const string PassKey = "ServerPass";

		public static IReadOnlyList<ImportedServer> Parse(string yaml)
		{
			List<ImportedServer> result = new List<ImportedServer>();
			string name = null;
			string address = null;
			string pass = null;
			string listKey = null;
			List<string> aliases = new List<string>();
			string[] array = (yaml ?? "").Replace("\r\n", "\n").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].TrimEnd('\r', ' ', '\t');
				string text2 = text.TrimStart(' ');
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				if (text.Length - text2.Length == 0 && text2[0] != '-')
				{
					Flush();
					name = TopKey(text2);
				}
				else
				{
					if (name == null)
					{
						continue;
					}
					if (text2.StartsWith("- ", StringComparison.Ordinal) || text2 == "-")
					{
						if (listKey == "ServerAliases")
						{
							aliases.Add(Scalar(text2.Substring(1)));
						}
						continue;
					}
					int num = text2.IndexOf(':');
					if (num <= 0)
					{
						continue;
					}
					string text3 = text2.Substring(0, num).Trim();
					string text4 = text2.Substring(num + 1);
					listKey = text3;
					switch (text3)
					{
					case "ServerAddress":
						address = Scalar(text4);
						break;
					case "ServerPass":
						pass = Scalar(text4);
						break;
					case "ServerAliases":
					{
						string text5 = text4.Trim();
						if (text5.StartsWith("[", StringComparison.Ordinal) && text5.EndsWith("]", StringComparison.Ordinal))
						{
							aliases.AddRange(from s in text5.Substring(1, text5.Length - 2).Split(',').Select(Scalar)
								where s.Length > 0
								select s);
						}
						break;
					}
					}
				}
			}
			Flush();
			return result;
			void Flush()
			{
				if (name != null)
				{
					result.Add(new ImportedServer(name, address, aliases.ToList(), pass));
				}
				name = (address = (pass = (listKey = null)));
				aliases.Clear();
			}
		}

		public static IReadOnlyList<ImportPlanItem> Plan(ServerList existing, IEnumerable<ImportedServer> servers)
		{
			if (existing == null)
			{
				throw new ArgumentNullException("existing");
			}
			HashSet<string> hashSet = new HashSet<string>(existing.Entries.Select((ServerEntry e) => e.Name), StringComparer.OrdinalIgnoreCase);
			HashSet<ServerAddress> hashSet2 = new HashSet<ServerAddress>(existing.Entries.SelectMany((ServerEntry e) => e.AllAddresses));
			List<ImportPlanItem> list = new List<ImportPlanItem>();
			foreach (ImportedServer server in servers)
			{
				ImportOutcome outcome;
				if (server.Address == null || server.Name.Trim().Length == 0)
				{
					outcome = ImportOutcome.Invalid;
				}
				else if (hashSet.Contains(server.Name.Trim()))
				{
					outcome = ImportOutcome.SameName;
				}
				else if (new ServerAddress[1] { server.Address }.Concat(server.Aliases).Any(hashSet2.Contains))
				{
					outcome = ImportOutcome.AddressTaken;
				}
				else
				{
					outcome = ImportOutcome.Add;
					hashSet.Add(server.Name.Trim());
					foreach (ServerAddress item in new ServerAddress[1] { server.Address }.Concat(server.Aliases))
					{
						hashSet2.Add(item);
					}
				}
				list.Add(new ImportPlanItem(server, outcome));
			}
			return list;
		}

		public static IReadOnlyList<string> Preview(IEnumerable<ImportPlanItem> plan)
		{
			return plan.Select(delegate(ImportPlanItem p)
			{
				ImportedServer server = p.Server;
				string text = ((server.Aliases.Count == 0) ? "" : (" (+" + server.Aliases.Count + ((server.Aliases.Count == 1) ? " alias)" : " aliases)")));
				string text2 = p.Outcome switch
				{
					ImportOutcome.Add => "import", 
					ImportOutcome.SameName => "skip, a server with this name is saved", 
					ImportOutcome.AddressTaken => "skip, this address is saved", 
					_ => (server.Problem == ImportProblem.MissingAddress) ? "skip, no address" : "skip, invalid address", 
				};
				return server.Name + "  " + (server.Address?.ToString() ?? "-") + text + ", " + (server.HasPassword ? "password present" : "no password") + ": " + text2;
			}).ToList();
		}

		public static ImportResult Apply(ServerList list, ISecretStore store, IEnumerable<ImportPlanItem> plan)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			int num = 0;
			int num2 = 0;
			List<string> list2 = new List<string>();
			foreach (ImportPlanItem item in plan)
			{
				if (item.Outcome != ImportOutcome.Add)
				{
					num2++;
					continue;
				}
				ImportedServer server = item.Server;
				ServerEntry serverEntry;
				try
				{
					serverEntry = list.Add(server.Name, server.Address, server.Aliases);
				}
				catch (ArgumentException)
				{
					num2++;
					continue;
				}
				num++;
				if (server.Password != null && !store.Store(serverEntry.SecretRef, server.Password))
				{
					list2.Add(serverEntry.Name);
				}
			}
			return new ImportResult(num, num2, list2);
		}

		public static string BlankPasswords(string yaml, out int blanked)
		{
			blanked = 0;
			string text = yaml ?? "";
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			int num = 0;
			while (num <= text.Length)
			{
				int num2 = text.IndexOf('\n', num);
				int num3 = ((num2 < 0) ? text.Length : num2);
				string text2 = text.Substring(num, num3 - num);
				bool num4 = text2.EndsWith("\r", StringComparison.Ordinal);
				string text3 = (num4 ? text2.Substring(0, text2.Length - 1) : text2);
				string text4 = text3.TrimStart(' ');
				if (text3.Length > text4.Length && text4.StartsWith("ServerPass:", StringComparison.Ordinal) && Scalar(text4.Substring("ServerPass".Length + 1)).Length > 0)
				{
					text3 = text3.Substring(0, text3.Length - text4.Length) + "ServerPass: ''";
					blanked++;
				}
				stringBuilder.Append(text3);
				if (num4)
				{
					stringBuilder.Append('\r');
				}
				if (num2 < 0)
				{
					break;
				}
				stringBuilder.Append('\n');
				num = num2 + 1;
			}
			return stringBuilder.ToString();
		}

		private static string TopKey(string body)
		{
			if (body[0] == '\'' || body[0] == '"')
			{
				return Scalar(body);
			}
			for (int i = 0; i < body.Length; i++)
			{
				if (body[i] == ':' && (i + 1 == body.Length || body[i + 1] == ' '))
				{
					return body.Substring(0, i).Trim();
				}
			}
			return body.Trim();
		}

		private static string Scalar(string raw)
		{
			string text = raw.Trim();
			if (text.Length == 0)
			{
				return "";
			}
			if (text[0] == '\'')
			{
				StringBuilder stringBuilder = new StringBuilder();
				for (int i = 1; i < text.Length; i++)
				{
					if (text[i] != '\'')
					{
						stringBuilder.Append(text[i]);
						continue;
					}
					if (i + 1 >= text.Length || text[i + 1] != '\'')
					{
						break;
					}
					stringBuilder.Append('\'');
					i++;
				}
				return stringBuilder.ToString();
			}
			if (text[0] == '"')
			{
				StringBuilder stringBuilder2 = new StringBuilder();
				for (int j = 1; j < text.Length; j++)
				{
					char c = text[j];
					if (c == '"')
					{
						break;
					}
					if (c == '\\' && j + 1 < text.Length)
					{
						char c2 = text[++j];
						stringBuilder2.Append(c2 switch
						{
							't' => '\t', 
							'n' => '\n', 
							_ => c2, 
						});
					}
					else
					{
						stringBuilder2.Append(c);
					}
				}
				return stringBuilder2.ToString();
			}
			if (text[0] == '#')
			{
				return "";
			}
			int num = text.IndexOf(" #", StringComparison.Ordinal);
			return ((num < 0) ? text : text.Substring(0, num)).Trim();
		}
	}
}
namespace ExtraPotions.Beacon.Config
{
	public enum SettingScope
	{
		Local,
		ServerAuthoritative
	}
	public abstract class BeaconSetting
	{
		public string Section { get; }

		public string Key { get; }

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

		public SettingScope Scope { get; }

		public string Description { get; }

		public bool Hotkey { get; }

		public bool ServerLockable { get; }

		public abstract Type ValueType { get; }

		public abstract object DefaultValue { get; }

		public abstract object? Minimum { get; }

		public abstract object? Maximum { get; }

		private protected BeaconSetting(string section, string key, string description, bool hotkey, bool serverLockable, SettingScope scope)
		{
			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 (string.IsNullOrWhiteSpace(description))
			{
				throw new ArgumentException("Expected a description.", "description");
			}
			Section = section;
			Key = key;
			Description = description;
			Hotkey = hotkey;
			ServerLockable = serverLockable;
			Scope = scope;
		}

		public override string ToString()
		{
			return Id;
		}
	}
	public sealed class BeaconSetting<T> : BeaconSetting
	{
		private readonly Func<T, T> normalize;

		public T Default { get; }

		public override Type ValueType => typeof(T);

		public override object DefaultValue => Default;

		public override object? Minimum { get; }

		public override object? Maximum { get; }

		internal BeaconSetting(string section, string key, T defaultValue, string description, Func<T, T> normalize, object? minimum = null, object? maximum = null, bool hotkey = false, bool serverLockable = false, SettingScope scope = SettingScope.Local)
			: base(section, key, description, hotkey, serverLockable, scope)
		{
			Default = defaultValue;
			this.normalize = normalize;
			Minimum = minimum;
			Maximum = maximum;
		}

		public T Normalize(T value)
		{
			return normalize(value);
		}
	}
	public static class BeaconSettings
	{
		public static class General
		{
			public const string Section = "General";

			public static readonly BeaconSetting<bool> AddToFavorites = Toggle("General", "Add To Favorites", value: true, "Adds every saved server to the Favorite tab of the Join Game screen.");

			public static readonly BeaconSetting<bool> SkipPasswordPrompt = Toggle("General", "Skip Password Prompt", value: true, "Sends a saved server's stored password when the game asks for it, so the prompt is not shown.");

			public static readonly BeaconSetting<bool> OfferToSavePasswords = Toggle("General", "Offer To Save Passwords", value: true, "After a server accepts a password you typed, asks once per server whether Beacon should save it.");

			public static readonly BeaconSetting<bool> RemoveEntryWithFavorite = Toggle("General", "Remove Entry With Favorite", value: true, "Removing a saved server from the game's favorites also removes it from Beacon (with an undo message).");

			public static readonly BeaconSetting<string> PanelKey = Text("General", "Panel Key", "Keyboard shortcut that opens the Beacon panel. Empty: only the Join Game screen button opens it.", hotkey: true);
		}

		public static class AutoJoin
		{
			public const string Section = "Auto Join";

			public static readonly BeaconSetting<bool> Enabled = Toggle("Auto Join", "Auto Join", value: false, "Joins a saved server automatically after the game reaches the main menu, after a short countdown you can cancel.");

			public static readonly BeaconSetting<string> Server = Text("Auto Join", "Auto Join Server", "Name of the saved server to join. Empty: the server marked as default.");

			public static readonly BeaconSetting<string> Character = Text("Auto Join", "Auto Join Character", "Character to join with. Empty: the last character used.");

			public static readonly BeaconSetting<int> CountdownSeconds = Integer("Auto Join", "Auto Join Countdown Seconds", 5, 0, 30, "Seconds of countdown before the automatic join; Escape or the pad's B button cancels.");
		}

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

			public static readonly BeaconSetting<bool> Enabled = Toggle("Reconnect", "Reconnect On Disconnect", value: false, "Reconnects after an unexpected disconnect. Never after a kick or ban. A server running Beacon may turn this off.", lockable: true);

			public static readonly BeaconSetting<int> Attempts = Integer("Reconnect", "Reconnect Attempts", 3, 1, 10, "Most reconnect attempts after one disconnect.");
		}

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

			public static readonly BeaconSetting<LinuxFallback> LinuxFallback = new BeaconSetting<LinuxFallback>("Passwords", "Linux Fallback", ExtraPotions.Beacon.Secrets.LinuxFallback.SessionOnly, "On Linux without a usable keyring: SessionOnly remembers passwords until the game closes; Disabled never stores them. On Linux a change applies right away. On systems other than Windows and Linux, restart the game after changing it.", (LinuxFallback v) => Enum.IsDefined(typeof(LinuxFallback), v) ? v : ExtraPotions.Beacon.Secrets.LinuxFallback.SessionOnly);
		}

		public static class Server
		{
			public static readonly BeaconSetting<bool> AllowReconnect = new BeaconSetting<bool>("Server", "Allow Automatic Reconnect", defaultValue: true, "Server policy: false prevents Beacon clients from automatically reconnecting after an unexpected disconnect. True leaves each player's preference unchanged.", (bool v) => v, null, null, hotkey: false, serverLockable: false, SettingScope.ServerAuthoritative);
		}

		public static IReadOnlyList<BeaconSetting> All { get; } = Array.AsReadOnly(new BeaconSetting[13]
		{
			General.AddToFavorites,
			General.SkipPasswordPrompt,
			General.OfferToSavePasswords,
			General.RemoveEntryWithFavorite,
			General.PanelKey,
			AutoJoin.Enabled,
			AutoJoin.Server,
			AutoJoin.Character,
			AutoJoin.CountdownSeconds,
			Reconnect.Enabled,
			Reconnect.Attempts,
			Passwords.LinuxFallback,
			Server.AllowReconnect
		});

		private static BeaconSetting<bool> Toggle(string section, string key, bool value, string description, bool lockable = false)
		{
			return new BeaconSetting<bool>(section, key, value, description, (bool v) => v, null, null, hotkey: false, lockable);
		}

		private static BeaconSetting<int> Integer(string section, string key, int value, int min, int max, string description)
		{
			return new BeaconSetting<int>(section, key, value, description, (int v) => Math.Max(min, Math.Min(max, v)), min, max);
		}

		private static BeaconSetting<string> Text(string section, string key, string description, bool hotkey = false)
		{
			return new BeaconSetting<string>(section, key, "", description, (string v) => (v ?? "").Trim(), null, null, hotkey);
		}
	}
}