using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ModSettings.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+6baae216dc75e3d6f6ceb0a73f81536dbb0fb0e6")]
[assembly: AssemblyProduct("ModSettings.Core")]
[assembly: AssemblyTitle("ModSettings.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ModSettings.Core
{
	public readonly record struct NumberRange(double Min, double Max);
	public sealed record CfgSetting(string Section, string Key, string RawValue, int Line, string Description, string? TypeName, string? DefaultValue, IReadOnlyList<string> AcceptableValues, NumberRange? Range, bool IsFlags);
	public sealed class CfgDocument
	{
		private sealed class Pending
		{
			private readonly List<string> _description = new List<string>();

			private string? _type;

			private string? _default;

			private IReadOnlyList<string> _values = Array.Empty<string>();

			private NumberRange? _range;

			private bool _flags;

			public void Read(string line)
			{
				if (line.StartsWith("##"))
				{
					List<string> description = _description;
					string text = line;
					description.Add(text.Substring(2, text.Length - 2).Trim());
					return;
				}
				if (line.StartsWith("# Setting type:"))
				{
					string text = line;
					int length = "# Setting type:".Length;
					_type = text.Substring(length, text.Length - length).Trim();
					return;
				}
				if (line.StartsWith("# Default value:"))
				{
					string text = line;
					int length = "# Default value:".Length;
					_default = text.Substring(length, text.Length - length).Trim();
					return;
				}
				if (line.StartsWith("# Acceptable values:"))
				{
					string text = line;
					int length = "# Acceptable values:".Length;
					_values = (from v in text.Substring(length, text.Length - length).Split(',')
						select v.Trim() into v
						where v.Length > 0
						select v).ToArray();
					return;
				}
				if (line.StartsWith("# Multiple values can be set at the same time"))
				{
					_flags = true;
					return;
				}
				Match match = RangeLine.Match(line);
				if (match == null || !match.Success)
				{
					return;
				}
				double? num = ParseNumber(match.Groups[1].Value);
				if (num.HasValue)
				{
					double valueOrDefault = num.GetValueOrDefault();
					num = ParseNumber(match.Groups[2].Value);
					if (num.HasValue)
					{
						double valueOrDefault2 = num.GetValueOrDefault();
						_range = new NumberRange(valueOrDefault, valueOrDefault2);
					}
				}
			}

			public CfgSetting ToSetting(string section, string key, string value, int line)
			{
				return new CfgSetting(section, key, value, line, string.Join("\n", _description).Trim(), _type, _default, _values, _range, _flags);
			}
		}

		private static readonly Regex CreatedBy = new Regex("^## Settings file was created by plugin (.+) v(\\S+)$");

		private static readonly Regex RangeLine = new Regex("^# Acceptable value range: From (.+) to (.+)$");

		private const string GuidPrefix = "## Plugin GUID:";

		private const string TypePrefix = "# Setting type:";

		private const string DefaultPrefix = "# Default value:";

		private const string ValuesPrefix = "# Acceptable values:";

		private const string FlagsPrefix = "# Multiple values can be set at the same time";

		private readonly string[] _lines;

		public string? PluginName { get; private init; }

		public string? PluginVersion { get; private init; }

		public string? PluginGuid { get; private init; }

		public IReadOnlyList<CfgSetting> Settings { get; }

		private CfgDocument(string[] lines, IReadOnlyList<CfgSetting> settings)
		{
			_lines = lines;
			Settings = settings;
		}

		public string WithValue(CfgSetting setting, string rawValue)
		{
			if (rawValue.Contains('\n') || rawValue.Contains('\r'))
			{
				throw new ArgumentException("A value must fit on one line.", "rawValue");
			}
			string text = ((setting.Line < _lines.Length) ? _lines[setting.Line] : "");
			int num = text.IndexOf('=');
			if (num < 0 || text.Substring(0, num).Trim() != setting.Key)
			{
				throw new InvalidOperationException($"Line {setting.Line + 1} does not hold {setting.Key}.");
			}
			string[] array = (string[])_lines.Clone();
			string text2 = (text.EndsWith('\r') ? "\r" : "");
			array[setting.Line] = text.Substring(0, num).TrimEnd() + " = " + rawValue + text2;
			return string.Join('\n', array);
		}

		public static CfgDocument Parse(string text)
		{
			string[] array = text.Split('\n');
			List<CfgSetting> list = new List<CfgSetting>();
			string pluginName = null;
			string pluginVersion = null;
			string pluginGuid = null;
			string section = "";
			bool flag = true;
			Pending pending = new Pending();
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				if (text2.StartsWith('#'))
				{
					if (flag)
					{
						Match match = CreatedBy.Match(text2);
						if (match != null && match.Success)
						{
							pluginName = match.Groups[1].Value;
							pluginVersion = match.Groups[2].Value;
							continue;
						}
					}
					if (flag && text2.StartsWith("## Plugin GUID:"))
					{
						string text3 = text2;
						int length = "## Plugin GUID:".Length;
						pluginGuid = text3.Substring(length, text3.Length - length).Trim();
					}
					else
					{
						pending.Read(text2);
					}
				}
				else if (text2.StartsWith('[') && text2.EndsWith(']'))
				{
					string text3 = text2;
					section = text3.Substring(1, text3.Length - 1 - 1);
					flag = false;
					pending = new Pending();
				}
				else
				{
					string[] array2 = text2.Split('=', 2);
					if (array2.Length == 2)
					{
						list.Add(pending.ToSetting(section, array2[0].Trim(), array2[1].Trim(), i));
						pending = new Pending();
					}
				}
			}
			return new CfgDocument(array, list)
			{
				PluginName = pluginName,
				PluginVersion = pluginVersion,
				PluginGuid = pluginGuid
			};
		}

		internal static double? ParseNumber(string text)
		{
			text = text.Trim();
			if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			if (double.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out result))
			{
				return result;
			}
			return null;
		}
	}
	public enum ControlKind
	{
		Toggle,
		Cycle,
		Slider,
		Text,
		Key
	}
	public static class Controls
	{
		public static ControlKind For(CfgSetting setting)
		{
			if (setting.TypeName == "Boolean")
			{
				return ControlKind.Toggle;
			}
			if (KeyNames.IsKeyType(setting.TypeName))
			{
				return ControlKind.Key;
			}
			if (setting.AcceptableValues.Count > 0 && !setting.IsFlags)
			{
				return ControlKind.Cycle;
			}
			if (setting.Range.HasValue && ValueRules.IsNumeric(setting.TypeName))
			{
				return ControlKind.Slider;
			}
			return ControlKind.Text;
		}
	}
	public sealed record KeyBinding(string Id, string Label, IReadOnlySet<string> Keys, bool FromGame);
	public static class KeyClashes
	{
		public static string IdOf(ModEntry mod, SettingView view)
		{
			return mod.Source.RelativePath + "\n" + view.Setting.Section + "\n" + view.Setting.Key;
		}

		public static IEnumerable<KeyBinding> FromMods(IEnumerable<ModEntry> mods)
		{
			foreach (ModEntry mod in mods)
			{
				foreach (SettingView item in mod.Sections.SelectMany((SectionView s) => s.Settings))
				{
					if (item.Control == ControlKind.Key)
					{
						IReadOnlyList<string> readOnlyList = KeyNames.Parse(item.Setting.TypeName, item.Setting.RawValue);
						if (readOnlyList != null)
						{
							yield return new KeyBinding(IdOf(mod, item), mod.Title + ": " + item.Label, new HashSet<string>(readOnlyList, StringComparer.OrdinalIgnoreCase), FromGame: false);
						}
					}
				}
			}
		}

		public static IReadOnlyDictionary<string, IReadOnlyList<string>> Find(IEnumerable<KeyBinding> bindings)
		{
			List<KeyBinding> source = bindings.ToList();
			Dictionary<string, IReadOnlyList<string>> dictionary = new Dictionary<string, IReadOnlyList<string>>();
			foreach (KeyBinding binding in source.Where((KeyBinding b) => !b.FromGame))
			{
				List<string> list = (from other in source
					where other.Id != binding.Id && other.Keys.SetEquals(binding.Keys)
					select other.Label).ToList();
				if (list.Count > 0)
				{
					dictionary[binding.Id] = list;
				}
			}
			return dictionary;
		}
	}
	public static class GameBindings
	{
		public static IReadOnlyList<KeyBinding> FromJson(IEnumerable<string> assetJsons, string? overridesJson)
		{
			Dictionary<string, string> dictionary = Overrides(overridesJson);
			List<KeyBinding> list = new List<KeyBinding>();
			foreach (string assetJson in assetJsons)
			{
				try
				{
					using JsonDocument jsonDocument = JsonDocument.Parse(assetJson);
					if (!jsonDocument.RootElement.TryGetProperty("maps", out var value))
					{
						continue;
					}
					foreach (JsonElement item in value.EnumerateArray())
					{
						string value2 = Text(item, "name");
						if (!item.TryGetProperty("bindings", out var value3))
						{
							continue;
						}
						foreach (JsonElement item2 in value3.EnumerateArray())
						{
							if (!Flag(item2, "isComposite"))
							{
								string text = Text(item2, "id");
								string value4;
								string text2 = KeyNames.FromControlPath(dictionary.TryGetValue(text, out value4) ? value4 : Text(item2, "path"));
								if (text2 != null)
								{
									string value5 = ((Flag(item2, "isPartOfComposite") && Text(item2, "name").Length > 0) ? (" (" + Text(item2, "name") + ")") : "");
									list.Add(new KeyBinding("game\n" + text, $"Game: {value2}/{Text(item2, "action")}{value5}", new HashSet<string>(new string[1] { text2 }, StringComparer.OrdinalIgnoreCase), FromGame: true));
								}
							}
						}
					}
				}
				catch (JsonException)
				{
				}
			}
			return list;
		}

		private static Dictionary<string, string> Overrides(string? json)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (string.IsNullOrWhiteSpace(json))
			{
				return dictionary;
			}
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(json);
				if (!jsonDocument.RootElement.TryGetProperty("bindings", out var value))
				{
					return dictionary;
				}
				foreach (JsonElement item in value.EnumerateArray())
				{
					string text = Text(item, "id");
					if (text.Length > 0)
					{
						dictionary[text] = Text(item, "path");
					}
				}
			}
			catch (JsonException)
			{
			}
			return dictionary;
		}

		private static string Text(JsonElement element, string name)
		{
			if (!element.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.String)
			{
				return "";
			}
			return value.GetString() ?? "";
		}

		private static bool Flag(JsonElement element, string name)
		{
			if (element.TryGetProperty(name, out var value))
			{
				return value.ValueKind == JsonValueKind.True;
			}
			return false;
		}
	}
	public static class KeyNames
	{
		public const string Unbound = "None";

		private static readonly string[] KeyTypes = new string[3] { "Key", "KeyCode", "KeyboardShortcut" };

		private static readonly string[] Modifiers = new string[9] { "LeftShift", "RightShift", "LeftCtrl", "RightCtrl", "LeftAlt", "RightAlt", "AltGr", "LeftMeta", "RightMeta" };

		private static readonly (string KeyCode, string Key)[] Renames = BuildRenames();

		private static readonly Dictionary<string, string> KeyCodeToKey = Renames.ToDictionary<(string, string), string, string>(((string KeyCode, string Key) r) => r.KeyCode, ((string KeyCode, string Key) r) => r.Key, StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string> KeyToKeyCode = Renames.GroupBy<(string, string), string>(((string KeyCode, string Key) r) => r.Key, StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, (string, string)>, string, string>((IGrouping<string, (string KeyCode, string Key)> g) => g.Key, (IGrouping<string, (string KeyCode, string Key)> g) => g.First().KeyCode, StringComparer.OrdinalIgnoreCase);

		public static bool IsKeyType(string? typeName)
		{
			if (typeName != null)
			{
				return KeyTypes.Contains<string>(typeName);
			}
			return false;
		}

		public static bool IsModifier(string key)
		{
			return Modifiers.Contains<string>(key, StringComparer.OrdinalIgnoreCase);
		}

		public static IReadOnlyList<string>? Parse(string? typeName, string raw)
		{
			if (!IsKeyType(typeName))
			{
				return null;
			}
			List<string> list = ((typeName == "KeyboardShortcut") ? ((IEnumerable<string>)raw.Split(new char[5] { ' ', '+', ',', ';', '|' }, StringSplitOptions.RemoveEmptyEntries)) : ((IEnumerable<string>)new string[1] { raw.Trim() })).Where((string p) => p.Length > 0 && !string.Equals(p, "None", StringComparison.OrdinalIgnoreCase)).Select(ToKey).Distinct<string>(StringComparer.OrdinalIgnoreCase)
				.OrderBy<string, string>((string k) => k, StringComparer.OrdinalIgnoreCase)
				.ToList();
			if (list.Count != 0)
			{
				return list;
			}
			return null;
		}

		public static string? FromControlPath(string path)
		{
			if (!path.StartsWith("<Keyboard>/", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			string text = path;
			int length = "<Keyboard>/".Length;
			string text2 = text.Substring(length, text.Length - length);
			if (text2.Length == 0 || text2.StartsWith('#') || text2.Contains('/') || text2 == "anyKey")
			{
				return null;
			}
			if (text2.Length == 1 && char.IsDigit(text2[0]))
			{
				return "Digit" + text2;
			}
			switch (text2)
			{
			case "ctrl":
				return "LeftCtrl";
			case "shift":
				return "LeftShift";
			case "alt":
				return "LeftAlt";
			default:
			{
				string text3 = char.ToUpperInvariant(text2[0]).ToString();
				string text4 = text2;
				return text3 + text4.Substring(1, text4.Length - 1);
			}
			}
		}

		public static ValueCheck Capture(CfgSetting setting, string key, IReadOnlyList<string> heldModifiers)
		{
			string typeName = setting.TypeName;
			string text = ((typeName == "KeyCode") ? ToKeyCode(key) : ((!(typeName == "KeyboardShortcut")) ? key : string.Join(" + ", new string[1] { ToKeyCode(key) }.Concat(heldModifiers.Where((string m) => !string.Equals(m, key, StringComparison.OrdinalIgnoreCase)).Select(ToKeyCode)))));
			string raw = text;
			if (setting.AcceptableValues.Count > 0)
			{
				string text2 = setting.AcceptableValues.FirstOrDefault((string v) => string.Equals(v, raw, StringComparison.OrdinalIgnoreCase));
				if (text2 == null)
				{
					return ValueCheck.Invalid(key + " cannot be used for this setting.");
				}
				raw = text2;
			}
			return ValueCheck.Valid(raw);
		}

		private static string ToKey(string name)
		{
			if (!KeyCodeToKey.TryGetValue(name, out string value))
			{
				return name;
			}
			return value;
		}

		private static string ToKeyCode(string key)
		{
			if (!KeyToKeyCode.TryGetValue(key, out string value))
			{
				return key;
			}
			return value;
		}

		private static (string, string)[] BuildRenames()
		{
			List<(string, string)> list = new List<(string, string)>
			{
				("Return", "Enter"),
				("LeftControl", "LeftCtrl"),
				("RightControl", "RightCtrl"),
				("LeftWindows", "LeftMeta"),
				("RightWindows", "RightMeta"),
				("LeftCommand", "LeftMeta"),
				("RightCommand", "RightMeta"),
				("LeftApple", "LeftMeta"),
				("RightApple", "RightMeta"),
				("Print", "PrintScreen"),
				("Menu", "ContextMenu"),
				("KeypadDivide", "NumpadDivide"),
				("KeypadMultiply", "NumpadMultiply"),
				("KeypadMinus", "NumpadMinus"),
				("KeypadPlus", "NumpadPlus"),
				("KeypadPeriod", "NumpadPeriod"),
				("KeypadEquals", "NumpadEquals"),
				("KeypadEnter", "NumpadEnter")
			};
			for (int i = 0; i <= 9; i++)
			{
				list.Add(("Alpha" + i, "Digit" + i));
				list.Add(("Keypad" + i, "Numpad" + i));
			}
			return list.ToArray();
		}
	}
	public sealed record SettingTags(bool Hidden = false, bool ReadOnly = false, int? Order = null, string? DisplayName = null)
	{
		public static SettingTags None { get; } = new SettingTags();

		[CompilerGenerated]
		private SettingTags(SettingTags original)
		{
			Hidden = original.Hidden;
			ReadOnly = original.ReadOnly;
			Order = original.Order;
			DisplayName = original.DisplayName;
		}
	}
	public enum SourceKind
	{
		Loaded,
		NotLoaded,
		Loader
	}
	public sealed record ConfigSource(string RelativePath, string? Text, string? ReadError, SourceKind Kind, string? LoadedName = null, string? LoadedVersion = null, IReadOnlySet<string>? BoundKeys = null, IReadOnlyDictionary<string, SettingTags>? Tags = null)
	{
		public static string KeyOf(string section, string key)
		{
			return section + "\n" + key;
		}
	}
	public sealed record SettingView(CfgSetting Setting, string Label, ControlKind Control, bool ReadOnly, bool AppliesLive);
	public sealed record SectionView(string Name, IReadOnlyList<SettingView> Settings);
	public sealed record ModEntry(string Title, string Version, SourceKind Kind, ConfigSource Source, string? Error, IReadOnlyList<SectionView> Sections)
	{
		public string Status => Kind switch
		{
			SourceKind.Loaded => "loaded", 
			SourceKind.Loader => "mod loader", 
			_ => "not loaded", 
		};
	}
	public static class ModList
	{
		public static IReadOnlyList<ModEntry> Build(IEnumerable<ConfigSource> sources)
		{
			return (from m in sources.Select(Entry)
				orderby m.Kind switch
				{
					SourceKind.Loaded => 0, 
					SourceKind.NotLoaded => 1, 
					_ => 2, 
				}
				select m).ThenBy<ModEntry, string>((ModEntry m) => m.Title, StringComparer.OrdinalIgnoreCase).ToList();
		}

		private static ModEntry Entry(ConfigSource source)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(source.RelativePath);
			if (source.Text == null)
			{
				return new ModEntry(source.LoadedName ?? fileNameWithoutExtension, source.LoadedVersion ?? "", source.Kind, source, source.ReadError ?? "Could not read the file.", Array.Empty<SectionView>());
			}
			CfgDocument cfgDocument = CfgDocument.Parse(source.Text);
			List<SectionView> sections = (from s in cfgDocument.Settings.Select((CfgSetting setting, int index) => (Setting: setting, Index: index, Tags: TagsOf(source, setting)))
				where !s.Tags.Hidden
				group s by s.Setting.Section into @group
				select new SectionView(@group.Key, (from s in @group
					orderby s.Tags.Order.GetValueOrDefault() descending, s.Index
					select View(source, s.Setting, s.Tags)).ToList())).ToList();
			return new ModEntry(source.LoadedName ?? cfgDocument.PluginName ?? fileNameWithoutExtension, source.LoadedVersion ?? cfgDocument.PluginVersion ?? "", source.Kind, source, null, sections);
		}

		private static SettingTags TagsOf(ConfigSource source, CfgSetting setting)
		{
			if (source.Tags == null || !source.Tags.TryGetValue(ConfigSource.KeyOf(setting.Section, setting.Key), out SettingTags value))
			{
				return SettingTags.None;
			}
			return value;
		}

		private static SettingView View(ConfigSource source, CfgSetting setting, SettingTags tags)
		{
			bool appliesLive = source.Kind == SourceKind.Loaded && (source.BoundKeys?.Contains(ConfigSource.KeyOf(setting.Section, setting.Key)) ?? false);
			return new SettingView(setting, tags.DisplayName ?? setting.Key, Controls.For(setting), tags.ReadOnly, appliesLive);
		}
	}
	public static class TomlString
	{
		private static readonly Regex WindowsPath = new Regex("^\"?\\w:\\\\(?!\\\\)(?!.+\\\\\\\\)");

		public static string Escape(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length + 2);
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				StringBuilder stringBuilder2 = stringBuilder;
				stringBuilder2.Append(c switch
				{
					'\0' => "\\0", 
					'\a' => "\\a", 
					'\b' => "\\b", 
					'\t' => "\\t", 
					'\n' => "\\n", 
					'\v' => "\\v", 
					'\f' => "\\f", 
					'\r' => "\\r", 
					'\'' => "\\'", 
					'"' => "\\\"", 
					_ => c.ToString(), 
				});
			}
			return stringBuilder.ToString();
		}

		public static string Unescape(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			int num = 0;
			while (num < text.Length)
			{
				int num2 = text.IndexOf('\\', num);
				if (num2 < 0 || num2 == text.Length - 1)
				{
					num2 = text.Length;
				}
				stringBuilder.Append(text, num, num2 - num);
				if (num2 >= text.Length)
				{
					break;
				}
				char c = text[num2 + 1];
				switch (c)
				{
				case '0':
					stringBuilder.Append('\0');
					break;
				case 'a':
					stringBuilder.Append('\a');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'v':
					stringBuilder.Append('\v');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case '\'':
					stringBuilder.Append('\'');
					break;
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				default:
					stringBuilder.Append('\\').Append(c);
					break;
				}
				num = num2 + 2;
			}
			return stringBuilder.ToString();
		}

		public static string Read(string raw)
		{
			if (!WindowsPath.IsMatch(raw))
			{
				return Unescape(raw);
			}
			return raw;
		}
	}
	public readonly record struct ValueCheck(string? Raw, string? Error)
	{
		public bool Ok => Error == null;

		public static ValueCheck Valid(string raw)
		{
			return new ValueCheck(raw, null);
		}

		public static ValueCheck Invalid(string error)
		{
			return new ValueCheck(null, error);
		}
	}
	public static class ValueRules
	{
		private static readonly CultureInfo Invariant = CultureInfo.InvariantCulture;

		private static readonly Dictionary<string, (decimal Min, decimal Max)> Integers = new Dictionary<string, (decimal, decimal)>
		{
			["Byte"] = (0m, 255m),
			["SByte"] = (-128m, 127m),
			["Int16"] = (-32768m, 32767m),
			["UInt16"] = (0m, 65535m),
			["Int32"] = (-2147483648m, 2147483647m),
			["UInt32"] = (0m, 4294967295m),
			["Int64"] = (-9223372036854775808m, 9223372036854775807m),
			["UInt64"] = (0m, 18446744073709551615m)
		};

		private static readonly HashSet<string> Fractions = new HashSet<string> { "Single", "Double", "Decimal" };

		public static bool IsInteger(string? typeName)
		{
			if (typeName != null)
			{
				return Integers.ContainsKey(typeName);
			}
			return false;
		}

		public static bool IsNumeric(string? typeName)
		{
			if (!IsInteger(typeName))
			{
				if (typeName != null)
				{
					return Fractions.Contains(typeName);
				}
				return false;
			}
			return true;
		}

		public static string Display(CfgSetting setting)
		{
			return Readable(setting, setting.RawValue);
		}

		public static ValueCheck Check(CfgSetting setting, string input)
		{
			bool flag = setting.TypeName == "String";
			if (flag && setting.AcceptableValues.Count == 0)
			{
				return ValueCheck.Valid(TomlString.Escape(input));
			}
			string text = input.Trim();
			if (text.Contains('\n') || text.Contains('\r'))
			{
				return ValueCheck.Invalid("Must fit on one line.");
			}
			if (setting.TypeName == "Boolean")
			{
				if (!bool.TryParse(text, out var result))
				{
					return ValueCheck.Invalid("Must be true or false.");
				}
				return ValueCheck.Valid(result ? "true" : "false");
			}
			if (setting.AcceptableValues.Count > 0)
			{
				if (setting.IsFlags)
				{
					return CheckFlags(setting, text);
				}
				string text2 = Match(setting, text);
				if (text2 == null)
				{
					return ValueCheck.Invalid("Must be one of: " + Allowed(setting) + ".");
				}
				return ValueCheck.Valid(flag ? TomlString.Escape(text2) : text2);
			}
			if (setting.TypeName != null && Integers.TryGetValue(setting.TypeName, out (decimal, decimal) value))
			{
				return CheckInteger(setting, text, value);
			}
			if (setting.TypeName != null && Fractions.Contains(setting.TypeName))
			{
				return CheckFraction(setting, text);
			}
			return ValueCheck.Valid(text);
		}

		public static string Cycle(CfgSetting setting, int step)
		{
			IReadOnlyList<string> acceptableValues = setting.AcceptableValues;
			if (acceptableValues.Count == 0)
			{
				return Display(setting);
			}
			string b = Display(setting).Trim();
			int num = -1;
			for (int i = 0; i < acceptableValues.Count; i++)
			{
				if (string.Equals(acceptableValues[i], b, StringComparison.OrdinalIgnoreCase))
				{
					num = i;
				}
			}
			if (num < 0)
			{
				return acceptableValues[0];
			}
			return acceptableValues[((num + step) % acceptableValues.Count + acceptableValues.Count) % acceptableValues.Count];
		}

		public static double? ParseNumber(CfgSetting setting)
		{
			if (!double.TryParse(setting.RawValue, NumberStyles.Float, Invariant, out var result))
			{
				return null;
			}
			return result;
		}

		public static string SliderText(CfgSetting setting, double position)
		{
			NumberRange? range = setting.Range;
			if (range.HasValue)
			{
				NumberRange valueOrDefault = range.GetValueOrDefault();
				double num = Math.Clamp(position, valueOrDefault.Min, valueOrDefault.Max);
				if (IsInteger(setting.TypeName))
				{
					return Math.Round(num).ToString(Invariant);
				}
				double num2 = valueOrDefault.Max - valueOrDefault.Min;
				int digits = ((num2 <= 0.0) ? 2 : Math.Clamp(2 - (int)Math.Floor(Math.Log10(num2)), 0, 6));
				return Math.Round(num, digits).ToString(Invariant);
			}
			return FormatNumber(position);
		}

		public static string FormatNumber(double value)
		{
			return value.ToString("0.######", Invariant);
		}

		public static string Details(CfgSetting setting)
		{
			List<string> list = new List<string>();
			if (!string.IsNullOrWhiteSpace(setting.Description))
			{
				list.Add(setting.Description.Trim());
			}
			List<string> list2 = new List<string>();
			if (setting.DefaultValue != null)
			{
				string text = Readable(setting, setting.DefaultValue);
				list2.Add("Default: " + ((text.Length == 0) ? "(empty)" : text));
			}
			NumberRange? range = setting.Range;
			if (range.HasValue)
			{
				NumberRange valueOrDefault = range.GetValueOrDefault();
				list2.Add("Range: " + FormatNumber(valueOrDefault.Min) + " to " + FormatNumber(valueOrDefault.Max));
			}
			if (setting.IsFlags)
			{
				list2.Add("Several allowed, separated by commas: " + Allowed(setting));
			}
			if (list2.Count > 0)
			{
				list.Add(string.Join(". ", list2) + ".");
			}
			return string.Join("\n", list);
		}

		private static string Readable(CfgSetting setting, string raw)
		{
			if (!(setting.TypeName == "String"))
			{
				return raw;
			}
			return TomlString.Read(raw);
		}

		private static string? Match(CfgSetting setting, string text)
		{
			return setting.AcceptableValues.FirstOrDefault((string v) => string.Equals(v, text, StringComparison.OrdinalIgnoreCase));
		}

		private static string Allowed(CfgSetting setting)
		{
			return string.Join(", ", setting.AcceptableValues);
		}

		private static ValueCheck CheckFlags(CfgSetting setting, string text)
		{
			List<string> list = new List<string>();
			foreach (string item in from p in text.Split(',')
				select p.Trim() into p
				where p.Length > 0
				select p)
			{
				string text2 = Match(setting, item);
				if (text2 == null)
				{
					return ValueCheck.Invalid($"'{item}' is not one of: {Allowed(setting)}.");
				}
				if (!list.Contains(text2))
				{
					list.Add(text2);
				}
			}
			if (list.Count != 0)
			{
				return ValueCheck.Valid(string.Join(", ", list));
			}
			return ValueCheck.Invalid("Pick at least one of: " + Allowed(setting) + ".");
		}

		private static ValueCheck CheckInteger(CfgSetting setting, string text, (decimal Min, decimal Max) bounds)
		{
			if (!decimal.TryParse(text, NumberStyles.AllowLeadingSign, Invariant, out var result))
			{
				return ValueCheck.Invalid("Must be a whole number.");
			}
			if (result < bounds.Min || result > bounds.Max)
			{
				return ValueCheck.Invalid($"Must be a whole number from {bounds.Min.ToString(Invariant)} to {bounds.Max.ToString(Invariant)}.");
			}
			return InRange(setting, (double)result, result.ToString(Invariant));
		}

		private static ValueCheck CheckFraction(CfgSetting setting, string text)
		{
			string s = (text.Contains('.') ? text : text.Replace(',', '.'));
			if (setting.TypeName == "Decimal")
			{
				if (!decimal.TryParse(s, NumberStyles.Float, Invariant, out var result))
				{
					return ValueCheck.Invalid("Must be a number.");
				}
				return InRange(setting, (double)result, result.ToString(Invariant));
			}
			if (!double.TryParse(s, NumberStyles.Float, Invariant, out var result2))
			{
				return ValueCheck.Invalid("Must be a number.");
			}
			if (setting.TypeName == "Single")
			{
				float num = (float)result2;
				if (!float.IsFinite(num))
				{
					return ValueCheck.Invalid("Must be a number.");
				}
				return InRange(setting, num, num.ToString(Invariant));
			}
			if (!double.IsFinite(result2))
			{
				return ValueCheck.Invalid("Must be a number.");
			}
			return InRange(setting, result2, result2.ToString("R", Invariant));
		}

		private static ValueCheck InRange(CfgSetting setting, double value, string raw)
		{
			NumberRange? range = setting.Range;
			if (range.HasValue)
			{
				NumberRange valueOrDefault = range.GetValueOrDefault();
				if (value < valueOrDefault.Min || value > valueOrDefault.Max)
				{
					return ValueCheck.Invalid($"Must be from {FormatNumber(valueOrDefault.Min)} to {FormatNumber(valueOrDefault.Max)}.");
				}
			}
			return ValueCheck.Valid(raw);
		}
	}
}