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.Versioning;
using System.Text;
using ExtraPotions.Kindle.Recipes;
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.25.0")]
[assembly: AssemblyInformationalVersion("0.1.25")]
[assembly: AssemblyProduct("Kindle.Core")]
[assembly: AssemblyTitle("Kindle.Core")]
[assembly: AssemblyVersion("0.1.25.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.Kindle
{
	public static class KindleCore
	{
		public const string ProductId = "com.meadworks.kindle";

		public const string CharacterDataPrefix = "Kindle.";
	}
}
namespace ExtraPotions.Kindle.Salvage
{
	public static class ChestTakeCodes
	{
		public const int Taken = 0;

		public const int Pending = 1;

		public const int Changed = 2;

		public const int Unavailable = 3;
	}
	public enum ChestTakeStep
	{
		Done,
		Retry,
		Changed,
		Busy
	}
	public sealed class ChestTakeRetry
	{
		public const double WaitSeconds = 5.0;

		private readonly double deadline;

		public ChestTakeRetry(double now)
		{
			deadline = now + 5.0;
		}

		public ChestTakeStep Next(int code, bool delivered, double now)
		{
			if (delivered)
			{
				return ChestTakeStep.Done;
			}
			switch (code)
			{
			case 0:
				return ChestTakeStep.Busy;
			case 1:
				if (!(now < deadline))
				{
					return ChestTakeStep.Busy;
				}
				return ChestTakeStep.Retry;
			default:
				return ChestTakeStep.Busy;
			case 2:
				return ChestTakeStep.Changed;
			}
		}
	}
	public static class SalvageDelivery
	{
		public static int Deliver<T>(IEnumerable<(T Material, int Amount, int MaxStack)> returns, Func<T, int, int> add, Action<T, int> drop, Func<T, int>? stock = null)
		{
			if (returns == null)
			{
				throw new ArgumentNullException("returns");
			}
			if (add == null)
			{
				throw new ArgumentNullException("add");
			}
			if (drop == null)
			{
				throw new ArgumentNullException("drop");
			}
			int num = 0;
			foreach (var @return in returns)
			{
				T item = @return.Material;
				int item2 = @return.Amount;
				int item3 = @return.MaxStack;
				int val = Math.Max(1, item3);
				int num2 = item2;
				while (num2 > 0)
				{
					int num3 = Math.Min(val, num2);
					int num4 = ReadStock(stock, item);
					int num5;
					try
					{
						num5 = Math.Max(0, Math.Min(num3, add(item, num3)));
					}
					catch (Exception)
					{
						int num6 = ReadStock(stock, item);
						num5 = ((stock != null) ? Math.Max(0, Math.Min(num3, num6 - num4)) : 0);
					}
					if (num5 < num3)
					{
						drop(item, num3 - num5);
						num += num3 - num5;
					}
					num2 -= num3;
				}
			}
			return num;
		}

		private static int ReadStock<T>(Func<T, int>? stock, T material)
		{
			if (stock == null)
			{
				return 0;
			}
			try
			{
				return Math.Max(0, stock(material));
			}
			catch (Exception)
			{
				return 0;
			}
		}
	}
}
namespace ExtraPotions.Kindle.Repair
{
	public struct RepairFacts
	{
		public bool CanBeRepaired;

		public bool NoCost;

		public string? Station;

		public int StationLevel;

		public bool HasRecipe;

		public string? CraftingStation;

		public string? RepairStation;

		public int MinStationLevel;

		public int ItemWorldLevel;

		public int GameWorldLevel;
	}
	public static class RepairRule
	{
		public const int LevelCap = 4;

		public static bool Qualifies(in RepairFacts item)
		{
			if (!item.CanBeRepaired)
			{
				return false;
			}
			if (item.NoCost)
			{
				return true;
			}
			if (item.Station == null || !item.HasRecipe)
			{
				return false;
			}
			if (item.CraftingStation == null && item.RepairStation == null)
			{
				return false;
			}
			if (item.RepairStation == item.Station || item.CraftingStation == item.Station || item.ItemWorldLevel < item.GameWorldLevel)
			{
				return Math.Min(item.StationLevel, 4) >= item.MinStationLevel;
			}
			return false;
		}
	}
	public static class StationStack
	{
		public const float Gap = 6f;

		public const float FallbackHeight = 44f;

		public const int SalvageSlot = 2;

		public const float BackingMargin = 8f;

		public static float Y(float repairY, float repairHeight, int stepsBelow)
		{
			return repairY - (float)stepsBelow * (((repairHeight > 1f) ? repairHeight : 44f) + 6f);
		}

		public static (float Width, float Height) Backing(float repairWidth, float repairHeight)
		{
			return (Width: repairWidth + 16f, Height: repairHeight + 16f);
		}
	}
}
namespace ExtraPotions.Kindle.Recipes
{
	public enum OnlyToggle
	{
		On,
		Off,
		RefusedNoFavourites
	}
	public sealed class FavouriteRecipes
	{
		public const string SetKey = "Kindle.favoriteRecipes";

		public const string OnlyKey = "Kindle.favoriteRecipesOnly";

		public const string OpenKeepSetKey = "OpenKeep.favouriteRecipes";

		public const string OpenKeepOnlyKey = "OpenKeep.favouriteRecipesOnly";

		private readonly List<string> order = new List<string>();

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

		public IReadOnlyList<string> Keys => order;

		public int Count => order.Count;

		public bool OnlyFlag { get; private set; }

		private FavouriteRecipes()
		{
		}

		public static FavouriteRecipes Parse(string? set, string? onlyFlag)
		{
			FavouriteRecipes favouriteRecipes = new FavouriteRecipes();
			if (!string.IsNullOrEmpty(set))
			{
				string[] array = set.Split(',');
				foreach (string key in array)
				{
					favouriteRecipes.Add(Clean(key));
				}
			}
			favouriteRecipes.OnlyFlag = onlyFlag == "1" || string.Equals(onlyFlag, "true", StringComparison.OrdinalIgnoreCase);
			return favouriteRecipes;
		}

		public bool Contains(string? key)
		{
			if (key != null)
			{
				return keys.Contains(key);
			}
			return false;
		}

		public bool Is(string? key, bool enabled)
		{
			if (enabled)
			{
				return Contains(key);
			}
			return false;
		}

		public bool OnlyFavourites(bool enabled)
		{
			if (enabled)
			{
				return OnlyFlag;
			}
			return false;
		}

		public bool Toggle(string? key)
		{
			string text = Clean(key);
			if (text.Length == 0)
			{
				return false;
			}
			if (keys.Remove(text))
			{
				order.Remove(text);
				if (order.Count == 0)
				{
					OnlyFlag = false;
				}
				return false;
			}
			Add(text);
			return true;
		}

		public OnlyToggle ToggleOnly()
		{
			if (OnlyFlag)
			{
				OnlyFlag = false;
				return OnlyToggle.Off;
			}
			if (order.Count == 0)
			{
				return OnlyToggle.RefusedNoFavourites;
			}
			OnlyFlag = true;
			return OnlyToggle.On;
		}

		public int Clear()
		{
			int count = order.Count;
			order.Clear();
			keys.Clear();
			OnlyFlag = false;
			return count;
		}

		public string? SerializeSet()
		{
			if (order.Count <= 0)
			{
				return null;
			}
			return string.Join(",", order);
		}

		public string? SerializeOnly()
		{
			if (!OnlyFlag)
			{
				return null;
			}
			return "1";
		}

		private void Add(string key)
		{
			if (key.Length > 0 && keys.Add(key))
			{
				order.Add(key);
			}
		}

		private static string Clean(string? key)
		{
			return (key ?? "").Replace(",", "").Replace("|", "").Trim();
		}
	}
	[Flags]
	public enum RecipeCategory
	{
		None = 0,
		Ammo = 1,
		Weapons = 2,
		Bows = 4,
		Armor = 8,
		Shields = 0x10,
		Tools = 0x20,
		Food = 0x40,
		Materials = 0x80
	}
	public static class RecipeCategories
	{
		public static IReadOnlyList<RecipeCategory> All { get; } = new RecipeCategory[8]
		{
			RecipeCategory.Ammo,
			RecipeCategory.Weapons,
			RecipeCategory.Bows,
			RecipeCategory.Armor,
			RecipeCategory.Shields,
			RecipeCategory.Tools,
			RecipeCategory.Food,
			RecipeCategory.Materials
		};

		public static RecipeCategory Toggle(RecipeCategory picked, RecipeCategory category)
		{
			return picked ^ category;
		}

		public static bool IsPicked(RecipeCategory picked, RecipeCategory category)
		{
			return (picked & category) != 0;
		}

		public static bool Shows(RecipeCategory picked, RecipeCategory category)
		{
			if (picked != RecipeCategory.None)
			{
				return (picked & category) != 0;
			}
			return true;
		}
	}
	public sealed class RecipeMaterial
	{
		public string Name { get; }

		public string PrefabName { get; }

		public int Amount { get; }

		public bool UpgraderResource { get; }

		public RecipeMaterial(string? name, string? prefabName, int amount, bool upgraderResource)
		{
			Name = name ?? "";
			PrefabName = prefabName ?? "";
			Amount = amount;
			UpgraderResource = upgraderResource;
		}
	}
	public sealed class RecipeFacts
	{
		private readonly string?[] searchText = new string[2];

		public string Key { get; }

		public string Name { get; }

		public string PrefabName { get; }

		public IReadOnlyList<RecipeMaterial> Materials { get; }

		public bool CanCraft { get; }

		public int SortWeight { get; }

		public int ItemQuality { get; }

		public RecipeCategory Category { get; }

		public RecipeFacts(string key, string? name, string? prefabName, IReadOnlyList<RecipeMaterial>? materials, bool canCraft = true, int sortWeight = 0, int itemQuality = 0, RecipeCategory category = RecipeCategory.None)
		{
			Key = key ?? "";
			Name = name ?? "";
			PrefabName = prefabName ?? "";
			Materials = materials ?? Array.Empty<RecipeMaterial>();
			CanCraft = canCraft;
			SortWeight = sortWeight;
			ItemQuality = itemQuality;
			Category = category;
		}

		internal string SearchText(bool ignoreAccents)
		{
			int num = (ignoreAccents ? 1 : 0);
			ref string reference = ref searchText[num];
			return reference ?? (reference = RecipeText.ItemText(Name, PrefabName, ignoreAccents));
		}

		public override string ToString()
		{
			return Key;
		}
	}
	public static class RecipeKeys
	{
		public static string Of(string? recipeName, string? itemPrefabName)
		{
			return ((!string.IsNullOrEmpty(recipeName)) ? recipeName : (itemPrefabName ?? "")).Replace(",", "").Replace("|", "").Trim();
		}
	}
	public sealed class RecipeKeyIndex<T> where T : class
	{
		private readonly Dictionary<string, T> byKey = new Dictionary<string, T>(StringComparer.Ordinal);

		private readonly Func<T, string?> keyOf;

		private readonly Func<T, bool> usable;

		private object? indexed;

		private int indexedCount = -1;

		public int Rebuilds { get; private set; }

		public RecipeKeyIndex(Func<T, string?> keyOf, Func<T, bool> usable)
		{
			this.keyOf = keyOf ?? throw new ArgumentNullException("keyOf");
			this.usable = usable ?? throw new ArgumentNullException("usable");
		}

		public T? Find(object? database, IReadOnlyList<T>? recipes, string? key)
		{
			if (database == null || recipes == null || string.IsNullOrEmpty(key))
			{
				return null;
			}
			if (database != indexed || recipes.Count != indexedCount)
			{
				Index(database, recipes);
			}
			if (!byKey.TryGetValue(key, out var value) || value == null || !usable(value))
			{
				return null;
			}
			return value;
		}

		private void Index(object database, IReadOnlyList<T> recipes)
		{
			byKey.Clear();
			indexed = database;
			indexedCount = recipes.Count;
			Rebuilds++;
			foreach (T recipe in recipes)
			{
				if (recipe != null && usable(recipe))
				{
					string text = keyOf(recipe) ?? "";
					if (text.Length > 0 && !byKey.ContainsKey(text))
					{
						byKey[text] = recipe;
					}
				}
			}
		}
	}
	public static class RecipeNeeds
	{
		public static bool Counts(RecipeMaterial? material, bool atUpgrader)
		{
			if (material != null && material.PrefabName.Length > 0 && material.UpgraderResource == atUpgrader)
			{
				return material.Amount > 0;
			}
			return false;
		}
	}
	public sealed class RecipeListState
	{
		public RecipeQuery Query { get; }

		public FavouriteRecipes Favourites { get; }

		public RecipeSort Sort { get; }

		public bool FavouritesEnabled { get; }

		public bool FavouritesFirst { get; }

		public bool AtUpgrader { get; }

		public CultureInfo? NameCulture { get; }

		public RecipeCategory Categories { get; }

		public RecipeListState(RecipeQuery query, FavouriteRecipes favourites, RecipeSort sort, bool favouritesEnabled, bool favouritesFirst, bool atUpgrader, CultureInfo? nameCulture = null, RecipeCategory categories = RecipeCategory.None)
		{
			Query = query ?? throw new ArgumentNullException("query");
			Favourites = favourites ?? throw new ArgumentNullException("favourites");
			Sort = sort;
			FavouritesEnabled = favouritesEnabled;
			FavouritesFirst = favouritesFirst;
			AtUpgrader = atUpgrader;
			NameCulture = nameCulture;
			Categories = categories;
		}
	}
	public readonly struct PipelineResult
	{
		public int Dropped { get; }

		public bool Reordered { get; }

		public PipelineResult(int dropped, bool reordered)
		{
			Dropped = dropped;
			Reordered = reordered;
		}
	}
	public static class RecipePipeline
	{
		public static PipelineResult Apply<T>(IList<T> rows, Func<T, RecipeFacts?> describe, RecipeListState state, Action<T>? dropped)
		{
			if (rows == null)
			{
				throw new ArgumentNullException("rows");
			}
			if (describe == null)
			{
				throw new ArgumentNullException("describe");
			}
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			int dropped2 = Filter(rows, describe, state, dropped);
			bool flag = false;
			if (state.Sort == RecipeSort.NameDescending)
			{
				CultureInfo culture = state.NameCulture ?? CultureInfo.CurrentCulture;
				flag |= Reorder(rows, describe, Comparer<RecipeFacts>.Create((RecipeFacts? a, RecipeFacts? b) => RecipeSorts.CompareDescending(a, b, culture)));
			}
			if (state.FavouritesEnabled && state.FavouritesFirst)
			{
				FavouriteRecipes favourites = state.Favourites;
				flag |= Reorder(rows, describe, Comparer<RecipeFacts>.Create((RecipeFacts? a, RecipeFacts? b) => Rank(favourites, a).CompareTo(Rank(favourites, b))));
			}
			return new PipelineResult(dropped2, flag);
		}

		private static int Filter<T>(IList<T> rows, Func<T, RecipeFacts?> describe, RecipeListState state, Action<T>? dropped)
		{
			bool flag = state.Favourites.OnlyFavourites(state.FavouritesEnabled);
			if (state.Query.Empty && !flag && state.Categories == RecipeCategory.None)
			{
				return 0;
			}
			int num = 0;
			for (int num2 = rows.Count - 1; num2 >= 0; num2--)
			{
				T val = rows[num2];
				RecipeFacts recipeFacts = describe(val);
				if ((flag && !state.Favourites.Contains(recipeFacts?.Key)) || !RecipeCategories.Shows(state.Categories, recipeFacts?.Category ?? RecipeCategory.None) || !state.Query.Matches(recipeFacts, state.AtUpgrader))
				{
					dropped?.Invoke(val);
					rows.RemoveAt(num2);
					num++;
				}
			}
			return num;
		}

		private static int Rank(FavouriteRecipes favourites, RecipeFacts? facts)
		{
			return (!favourites.Contains(facts?.Key)) ? 1 : 0;
		}

		private static bool Reorder<T>(IList<T> rows, Func<T, RecipeFacts?> describe, IComparer<RecipeFacts?> comparer)
		{
			if (rows.Count < 2)
			{
				return false;
			}
			List<T> list = rows.ToList();
			List<RecipeFacts?> facts = list.Select(describe).ToList();
			int[] array = Enumerable.Range(0, list.Count).OrderBy<int, RecipeFacts>((int i) => facts[i], comparer).ToArray();
			bool result = false;
			for (int num = 0; num < array.Length; num++)
			{
				if (array[num] != num)
				{
					result = true;
				}
				rows[num] = list[array[num]];
			}
			return result;
		}
	}
	public sealed class RecipeQuery
	{
		public static readonly RecipeQuery All = new RecipeQuery(ignoreAccents: true);

		private readonly List<string> names = new List<string>();

		private readonly List<string> materials = new List<string>();

		private readonly List<string> notNames = new List<string>();

		private readonly List<string> notMaterials = new List<string>();

		public bool IgnoreAccents { get; }

		public bool Empty => names.Count + materials.Count + notNames.Count + notMaterials.Count == 0;

		public IReadOnlyList<string> Names => names;

		public IReadOnlyList<string> Materials => materials;

		public IReadOnlyList<string> NotNames => notNames;

		public IReadOnlyList<string> NotMaterials => notMaterials;

		private RecipeQuery(bool ignoreAccents)
		{
			IgnoreAccents = ignoreAccents;
		}

		public static RecipeQuery Parse(string? text, bool ignoreAccents = true)
		{
			RecipeQuery recipeQuery = new RecipeQuery(ignoreAccents);
			if (string.IsNullOrEmpty(text))
			{
				return recipeQuery;
			}
			string[] array = text.Split(' ', '\t');
			foreach (string text2 in array)
			{
				recipeQuery.Add(text2.Trim());
			}
			return recipeQuery;
		}

		private void Add(string word)
		{
			bool flag = word.StartsWith("-");
			if (flag)
			{
				word = word.Substring(1);
			}
			bool flag2 = word.StartsWith("@");
			if (flag2)
			{
				word = word.Substring(1);
			}
			word = RecipeText.Fold(word, IgnoreAccents);
			if (word.Length != 0)
			{
				((!flag2) ? (flag ? notNames : names) : (flag ? notMaterials : materials)).Add(word);
			}
		}

		public bool Matches(RecipeFacts? recipe, bool atUpgrader)
		{
			if (Empty)
			{
				return true;
			}
			if (recipe == null)
			{
				return false;
			}
			string text = recipe.SearchText(IgnoreAccents);
			if (!AllIn(names, text) || AnyIn(notNames, text))
			{
				return false;
			}
			if (materials.Count == 0 && notMaterials.Count == 0)
			{
				return true;
			}
			List<string> held = MaterialTexts(recipe, atUpgrader);
			foreach (string word in materials)
			{
				if (!held.Exists((string text2) => text2.Contains(word)))
				{
					return false;
				}
			}
			return !notMaterials.Exists((string value) => held.Exists((string text2) => text2.Contains(value)));
		}

		private static bool AllIn(List<string> words, string text)
		{
			return words.TrueForAll(text.Contains);
		}

		private static bool AnyIn(List<string> words, string text)
		{
			return words.Exists(text.Contains);
		}

		private List<string> MaterialTexts(RecipeFacts recipe, bool atUpgrader)
		{
			List<string> list = new List<string>();
			foreach (RecipeMaterial material in recipe.Materials)
			{
				if (RecipeNeeds.Counts(material, atUpgrader))
				{
					list.Add(RecipeText.ItemText(material.Name, material.PrefabName, IgnoreAccents));
				}
			}
			return list;
		}
	}
	public enum RecipeSort
	{
		Default,
		NameAscending,
		NameDescending,
		Type,
		Weight
	}
	public static class RecipeSorts
	{
		public const string GameKey = "sortcraft";

		public const string DescendingKey = "kindle_sort_desc";

		public const string CraftingSearchDescendingKey = "craftingsearch_desc";

		private static readonly RecipeSort[] cycle = new RecipeSort[5]
		{
			RecipeSort.Default,
			RecipeSort.NameAscending,
			RecipeSort.NameDescending,
			RecipeSort.Type,
			RecipeSort.Weight
		};

		public static IReadOnlyList<RecipeSort> Cycle => cycle;

		public static RecipeSort Next(RecipeSort mode)
		{
			return cycle[(Index(mode) + 1) % cycle.Length];
		}

		public static RecipeSort Previous(RecipeSort mode)
		{
			return cycle[(Index(mode) + cycle.Length - 1) % cycle.Length];
		}

		private static int Index(RecipeSort mode)
		{
			return Math.Max(0, Array.IndexOf(cycle, mode));
		}

		public static RecipeSort FromStored(string? gameMethod, bool descending)
		{
			if (string.IsNullOrEmpty(gameMethod))
			{
				return RecipeSort.Default;
			}
			if (string.Equals(gameMethod, "Name", StringComparison.OrdinalIgnoreCase))
			{
				if (!descending)
				{
					return RecipeSort.NameAscending;
				}
				return RecipeSort.NameDescending;
			}
			if (string.Equals(gameMethod, "Type", StringComparison.OrdinalIgnoreCase))
			{
				return RecipeSort.Type;
			}
			if (string.Equals(gameMethod, "Weight", StringComparison.OrdinalIgnoreCase))
			{
				return RecipeSort.Weight;
			}
			return RecipeSort.Default;
		}

		public static (string? Game, bool Descending) ToStored(RecipeSort mode)
		{
			return mode switch
			{
				RecipeSort.NameAscending => (Game: "Name", Descending: false), 
				RecipeSort.NameDescending => (Game: "Name", Descending: true), 
				RecipeSort.Type => (Game: "Type", Descending: false), 
				RecipeSort.Weight => (Game: "Weight", Descending: false), 
				_ => (Game: null, Descending: false), 
			};
		}

		public static string Label(RecipeSort mode)
		{
			return mode switch
			{
				RecipeSort.NameAscending => "Sort: A-Z", 
				RecipeSort.NameDescending => "Sort: Z-A", 
				RecipeSort.Type => "Sort: Type", 
				RecipeSort.Weight => "Sort: Weight", 
				_ => "Sort: Default", 
			};
		}

		public static int CompareDescending(RecipeFacts? a, RecipeFacts? b, CultureInfo? culture = null)
		{
			if (a == null || b == null)
			{
				if (a != null)
				{
					return -1;
				}
				return (b != null) ? 1 : 0;
			}
			int num = b.CanCraft.CompareTo(a.CanCraft);
			if (num == 0)
			{
				num = a.SortWeight.CompareTo(b.SortWeight);
			}
			if (num == 0)
			{
				num = (culture ?? CultureInfo.CurrentCulture).CompareInfo.Compare(b.Name, a.Name, CompareOptions.None);
			}
			if (num == 0)
			{
				num = b.ItemQuality.CompareTo(a.ItemQuality);
			}
			return num;
		}

		public static List<RecipeFacts> SortDescending(IEnumerable<RecipeFacts> rows, CultureInfo? culture = null)
		{
			CultureInfo used = culture ?? CultureInfo.CurrentCulture;
			return rows.OrderBy((RecipeFacts row) => row, Comparer<RecipeFacts>.Create((RecipeFacts a, RecipeFacts b) => CompareDescending(a, b, used))).ToList();
		}
	}
	public static class RecipeText
	{
		public static string Fold(string? text, bool ignoreAccents)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			string text2 = text.ToLowerInvariant();
			if (!ignoreAccents)
			{
				return text2;
			}
			string text3 = text2.Normalize(NormalizationForm.FormD);
			StringBuilder stringBuilder = new StringBuilder(text3.Length);
			string text4 = text3;
			foreach (char c in text4)
			{
				if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
		}

		public static string ItemText(string? name, string? prefabName, bool ignoreAccents)
		{
			return Fold(name, ignoreAccents) + "\n" + Fold(prefabName, ignoreAccents);
		}
	}
	public readonly struct SearchButtonsState : IEquatable<SearchButtonsState>
	{
		public object? Row { get; }

		public bool Only { get; }

		public int View { get; }

		public bool ViewLocked { get; }

		public int Sort { get; }

		public long Revision { get; }

		public SearchButtonsState(object? row, bool only, int view, bool viewLocked, int sort, long revision)
		{
			Row = row;
			Only = only;
			View = view;
			ViewLocked = viewLocked;
			Sort = sort;
			Revision = revision;
		}

		public bool Equals(SearchButtonsState other)
		{
			if (Row != null && Row == other.Row && Only == other.Only && View == other.View && ViewLocked == other.ViewLocked && Sort == other.Sort)
			{
				return Revision == other.Revision;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return HashCode.Combine(Row, Only, View, ViewLocked, Sort, Revision);
		}
	}
	public readonly struct TrackLabelState : IEquatable<TrackLabelState>
	{
		public object? Button { get; }

		public bool Tracked { get; }

		public long Revision { get; }

		public TrackLabelState(object? button, bool tracked, long revision)
		{
			Button = button;
			Tracked = tracked;
			Revision = revision;
		}

		public bool Equals(TrackLabelState other)
		{
			if (Button != null && Button == other.Button && Tracked == other.Tracked)
			{
				return Revision == other.Revision;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return HashCode.Combine(Button, Tracked, Revision);
		}
	}
	public enum RecipeView
	{
		List,
		CompactList,
		SmallGrid,
		MediumGrid,
		LargeGrid
	}
	public static class RecipeViews
	{
		private static readonly RecipeView[] cycle = new RecipeView[5]
		{
			RecipeView.List,
			RecipeView.CompactList,
			RecipeView.SmallGrid,
			RecipeView.MediumGrid,
			RecipeView.LargeGrid
		};

		public static IReadOnlyList<RecipeView> Cycle => cycle;

		public static RecipeView Next(RecipeView view)
		{
			return cycle[(Index(view) + 1) % cycle.Length];
		}

		public static RecipeView Previous(RecipeView view)
		{
			return cycle[(Index(view) + cycle.Length - 1) % cycle.Length];
		}

		private static int Index(RecipeView view)
		{
			return Math.Max(0, Array.IndexOf(cycle, view));
		}

		public static RecipeView Parse(string? text)
		{
			RecipeView[] array = cycle;
			for (int i = 0; i < array.Length; i++)
			{
				RecipeView result = array[i];
				if (string.Equals(result.ToString(), text?.Trim(), StringComparison.OrdinalIgnoreCase))
				{
					return result;
				}
			}
			return RecipeView.List;
		}

		public static bool IsGrid(RecipeView view)
		{
			if (view != RecipeView.SmallGrid && view != RecipeView.MediumGrid)
			{
				return view == RecipeView.LargeGrid;
			}
			return true;
		}
	}
}
namespace ExtraPotions.Kindle.Config
{
	public static class KindleCheats
	{
		public static T Effective<T>(KindleSetting<T> setting, bool locked, T value)
		{
			if (setting == null)
			{
				throw new ArgumentNullException("setting");
			}
			if (setting.Scope != SettingScope.Cheat)
			{
				throw new ArgumentException(setting.Id + " is not a cheat.", "setting");
			}
			if (!locked)
			{
				return setting.Normalize(value);
			}
			return setting.Safe;
		}

		public static float CraftSpeed(bool locked, float value)
		{
			return Effective(KindleSettings.Batch.CraftSpeed, locked, value);
		}

		public static bool InstantCrafting(bool locked, bool value)
		{
			return Effective(KindleSettings.Batch.InstantCrafting, locked, value);
		}

		public static float CraftDuration(float gameSeconds, float speed, bool instant)
		{
			if (!instant)
			{
				return CraftDuration(gameSeconds, speed);
			}
			return 0f;
		}

		public static float CraftDuration(float gameSeconds, float speed)
		{
			if (!(gameSeconds > 0f) || float.IsInfinity(gameSeconds))
			{
				if (!(gameSeconds > 0f))
				{
					return 0f;
				}
				return gameSeconds;
			}
			return gameSeconds / CraftSpeed(locked: false, speed);
		}
	}
	public static class KindleDefaultsMigration
	{
		public const int Schema = 1;

		public static readonly IReadOnlyList<KeyValuePair<KindleSetting<string>, string>> Changes = new KeyValuePair<KindleSetting<string>, string>[3]
		{
			new KeyValuePair<KindleSetting<string>, string>(KindleSettings.RecipeList.FavouriteRecipeKey, "F"),
			new KeyValuePair<KindleSetting<string>, string>(KindleSettings.Salvage.SalvageKey, "Backspace"),
			new KeyValuePair<KindleSetting<string>, string>(KindleSettings.RecipeList.GamepadSortButton, "JoyLStick")
		};

		public static string? Migrate(KindleSetting<string> setting, string? stored)
		{
			if (setting == null)
			{
				throw new ArgumentNullException("setting");
			}
			foreach (KeyValuePair<KindleSetting<string>, string> change in Changes)
			{
				if (change.Key == setting)
				{
					return string.Equals(stored, change.Value, StringComparison.Ordinal) ? setting.Default : null;
				}
			}
			return null;
		}
	}
	public enum SettingScope
	{
		Local,
		ServerAuthoritative,
		Cheat
	}
	public enum SalvageRounding
	{
		Floor,
		Round,
		Ceil
	}
	public enum TrackerFont
	{
		Sans,
		Serif,
		Norse
	}
	public abstract class KindleSetting
	{
		private static readonly IReadOnlyList<string> NoChoices = Array.Empty<string>();

		public string Section { get; }

		public string Key { get; }

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

		public SettingScope Scope { get; }

		public string Description { get; }

		public bool Lockable => false;

		public IReadOnlyList<string> Choices { get; }

		public abstract Type ValueType { get; }

		public abstract object DefaultValue { get; }

		public abstract object? SafeValue { get; }

		public abstract object? Minimum { get; }

		public abstract object? Maximum { get; }

		private protected KindleSetting(string section, string key, SettingScope scope, string description, IReadOnlyList<string>? choices)
		{
			if (string.IsNullOrWhiteSpace(section) || section.Trim() != section)
			{
				throw new ArgumentException("Expected a trimmed section name.", "section");
			}
			if (string.IsNullOrWhiteSpace(key) || key.Trim() != key)
			{
				throw new ArgumentException("Expected a trimmed key.", "key");
			}
			if (!Enum.IsDefined(typeof(SettingScope), scope))
			{
				throw new ArgumentException("Unknown scope.", "scope");
			}
			if (string.IsNullOrWhiteSpace(description))
			{
				throw new ArgumentException("Expected a description.", "description");
			}
			Section = section;
			Key = key;
			Scope = scope;
			Description = description;
			Choices = choices ?? NoChoices;
		}

		public abstract object NormalizeBoxed(object? value);

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

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

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

		public static KindleSetting<float> Number(string section, string key, float defaultValue, float min, float max, SettingScope scope, string description, float? safe = null)
		{
			if (!(min <= max) || float.IsInfinity(min) || float.IsInfinity(max))
			{
				throw new ArgumentException("Expected a finite range.", "min");
			}
			return new KindleSetting<float>(section, key, scope, description, defaultValue, safe, (min, max), (float v) => (!float.IsNaN(v) && !float.IsInfinity(v)) ? Math.Min(max, Math.Max(min, v)) : defaultValue);
		}

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

		public static KindleSetting<string> Text(string section, string key, string defaultValue, SettingScope scope, string description, Func<string, string> normalize)
		{
			if (normalize == null)
			{
				throw new ArgumentNullException("normalize");
			}
			return new KindleSetting<string>(section, key, scope, description, defaultValue, null, null, normalize);
		}
	}
	public sealed class KindleSetting<T> : KindleSetting
	{
		private readonly Func<T, T> normalize;

		private readonly bool hasSafe;

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

		public T Default { get; }

		public T Safe { get; }

		public override Type ValueType => typeof(T);

		public override object DefaultValue => Default;

		public override object? SafeValue
		{
			get
			{
				if (!hasSafe)
				{
					return null;
				}
				return Safe;
			}
		}

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

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

		internal KindleSetting(string section, string key, SettingScope scope, string description, T defaultValue, object? safe, (T, T)? range, Func<T, T> normalize, IReadOnlyList<string>? choices = null)
			: base(section, key, scope, description, choices)
		{
			this.normalize = normalize ?? throw new ArgumentNullException("normalize");
			this.range = range;
			if (!EqualityComparer<T>.Default.Equals(normalize(defaultValue), defaultValue))
			{
				throw new ArgumentException(base.Id + ": the default is outside its own rule.", "defaultValue");
			}
			Default = defaultValue;
			if (scope == SettingScope.Cheat)
			{
				if (safe == null)
				{
					throw new ArgumentException(base.Id + ": a cheat needs a safe value.", "safe");
				}
				if (!EqualityComparer<T>.Default.Equals(defaultValue, (T)safe))
				{
					throw new ArgumentException(base.Id + ": a cheat must default to its safe value.", "defaultValue");
				}
				Safe = (T)safe;
				hasSafe = true;
			}
			else
			{
				if (safe != null)
				{
					throw new ArgumentException(base.Id + ": only cheats have a safe value.", "safe");
				}
				Safe = defaultValue;
			}
		}

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

		public override object NormalizeBoxed(object? value)
		{
			return (value is T value2) ? Normalize(value2) : Default;
		}
	}
	public static class KindleSettings
	{
		public static class RecipeList
		{
			public const string Section = "Recipe List";

			public static readonly KindleSetting<bool> Search = KindleSetting.Toggle("Recipe List", "Search", defaultValue: true, SettingScope.Local, "Show a search row above the recipe list on the Craft and Upgrade tabs.");

			public static readonly KindleSetting<string> SearchKey = KindleSetting.Text("Recipe List", "Search Key", "F + LeftControl", SettingScope.Local, "Focuses the search field (or opens Steam's on-screen keyboard). Empty: no key.", Shortcut);

			public static readonly KindleSetting<bool> ClearSearchOnClose = KindleSetting.Toggle("Recipe List", "Clear Search On Close", defaultValue: true, SettingScope.Local, "Clear the search text when the inventory closes.");

			public static readonly KindleSetting<bool> IgnoreAccents = KindleSetting.Toggle("Recipe List", "Ignore Accents", defaultValue: true, SettingScope.Local, "Search ignores accent marks, so plain letters also find accented names.");

			public static readonly KindleSetting<bool> Categories = KindleSetting.Toggle("Recipe List", "Categories", defaultValue: true, SettingScope.Local, "A row of category buttons under the search: Ammo, Weapons, Bows, Armor, Shields, Tools, Food and Materials. Click one to list only its recipes, click more to add them, click a lit one to take it away; with none lit every recipe shows.");

			public static readonly KindleSetting<bool> Favourites = KindleSetting.Toggle("Recipe List", "Favorites", defaultValue: true, SettingScope.Local, "Allow marking recipes as favorites (middle click, the favorite key or the star button).");

			public static readonly KindleSetting<bool> FavouritesFirst = KindleSetting.Toggle("Recipe List", "Favorites First", defaultValue: true, SettingScope.Local, "List favorite recipes before the others, keeping the chosen sort within each group.");

			public static readonly KindleSetting<string> FavouriteRecipeKey = KindleSetting.Text("Recipe List", "Favorite Recipe Key", "", SettingScope.Local, "Marks or unmarks the recipe under the pointer. Acts only over a recipe row. Unbound by default; middle click and the star button also mark favorites.", Shortcut);

			public static readonly KindleSetting<RecipeView> RecipeView = KindleSetting.Choice("Recipe List", "Recipe View", ExtraPotions.Kindle.Recipes.RecipeView.List, SettingScope.Local, "How recipes are laid out: List, CompactList, SmallGrid, MediumGrid or LargeGrid.");

			public static readonly KindleSetting<bool> SortButton = KindleSetting.Toggle("Recipe List", "Sort Button", defaultValue: true, SettingScope.Local, "Show the sort button. Off hides the button; the stored sort (the game's sortcraft) still applies.");

			public static readonly KindleSetting<bool> GamepadControls = KindleSetting.Toggle("Recipe List", "Gamepad Controls", defaultValue: true, SettingScope.Local, "Lets a gamepad move through and use the search, sort and favorite controls of the recipe list.");

			public static readonly KindleSetting<string> GamepadSortButton = KindleSetting.Text("Recipe List", "Gamepad Sort Button", "JoyBack", SettingScope.Local, "Gamepad button that cycles the sort while the crafting panel is selected (a Crucible pad button name). Default Back, which the game leaves free in the inventory; holding the left stick stays the game's multi-craft modifier. Empty: off.", Shortcut);
		}

		public static class Batch
		{
			public const string Section = "Batch Crafting";

			public static readonly KindleSetting<bool> Enabled = KindleSetting.Toggle("Batch Crafting", "Enabled", defaultValue: true, SettingScope.ServerAuthoritative, "Show the amount stepper left of Craft; Craft makes that many through the game's own multi-craft, at the same cost per item.");

			public static readonly KindleSetting<int> MaxAmount = KindleSetting.Integer("Batch Crafting", "Max Amount", 100, 1, 1000, SettingScope.ServerAuthoritative, "The most one press of Craft makes. Materials and free inventory space still limit the amount.");

			public static readonly KindleSetting<float> CraftSpeed = KindleSetting.Number("Batch Crafting", "Craft Speed", 1f, 0.1f, 10f, SettingScope.Cheat, "Cheat. How fast crafting completes: 2 takes half the game's time. Reads 1 whenever the server blocks cheats.", 1f);

			public static readonly KindleSetting<bool> InstantCrafting = KindleSetting.Toggle("Batch Crafting", "Instant Crafting", defaultValue: false, SettingScope.Cheat, "Cheat. Every craft and batch finishes at once, ignoring Craft Speed. Off whenever the server blocks cheats.", false);
		}

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

			public static readonly KindleSetting<bool> OnStationOpen = KindleSetting.Toggle("Repair", "Repair On Station Open", defaultValue: false, SettingScope.Local, "Opening a usable crafting station repairs all carried worn items that station can repair, using the same free repair-all action. Off by default.");
		}

		public static class Tracker
		{
			public const string Section = "Recipe Tracker";

			public static readonly KindleSetting<bool> Enabled = KindleSetting.Toggle("Recipe Tracker", "Enabled", defaultValue: true, SettingScope.Local, "Show tracked recipes and their materials on the HUD.");

			public static readonly KindleSetting<int> MaxTracked = KindleSetting.Integer("Recipe Tracker", "Max Tracked", 6, 1, 12, SettingScope.Local, "The most recipes tracked at once.");

			public static readonly KindleSetting<bool> CountNearbyChests = KindleSetting.Toggle("Recipe Tracker", "Count Nearby Chests", defaultValue: true, SettingScope.Local, "Count materials in nearby containers. Needs Burrow; without it only carried items count.");

			public static readonly KindleSetting<bool> UntrackWhenCrafted = KindleSetting.Toggle("Recipe Tracker", "Untrack When Crafted", defaultValue: true, SettingScope.Local, "Stop tracking a recipe once the tracked amount has been crafted.");

			public static readonly KindleSetting<bool> HideInCombat = KindleSetting.Toggle("Recipe Tracker", "Hide In Combat", defaultValue: true, SettingScope.Local, "Hide the tracker while in combat.");

			public static readonly KindleSetting<bool> HideWithMap = KindleSetting.Toggle("Recipe Tracker", "Hide With Map", defaultValue: true, SettingScope.Local, "Hide the tracker while the large map is open.");

			public static readonly KindleSetting<TrackerFont> Font = KindleSetting.Choice("Recipe Tracker", "Font", TrackerFont.Serif, SettingScope.Local, "Tracker font: Sans, Serif or Norse.");

			public static readonly KindleSetting<int> FontSize = KindleSetting.Integer("Recipe Tracker", "Font Size", 16, 10, 28, SettingScope.Local, "Text size of the recipe tracker on the HUD.");

			public static readonly KindleSetting<string> HaveColour = KindleSetting.Text("Recipe Tracker", "Have Color", "#FFFFFF", SettingScope.Local, "Color of materials you have enough of (HTML color, #RRGGBB or #RRGGBBAA).", (string t) => Colour(t, "#FFFFFF"));

			public static readonly KindleSetting<string> MissingColour = KindleSetting.Text("Recipe Tracker", "Missing Color", "#FF6A5A", SettingScope.Local, "Color of materials you are missing (HTML color).", (string t) => Colour(t, "#FF6A5A"));

			public static readonly KindleSetting<string> ReadyColour = KindleSetting.Text("Recipe Tracker", "Ready Color", "#FFB65C", SettingScope.Local, "Color of a recipe title once everything is gathered (HTML color).", (string t) => Colour(t, "#FFB65C"));

			public static readonly KindleSetting<float> BackgroundOpacity = KindleSetting.Number("Recipe Tracker", "Background Opacity", 1f, 0f, 1f, SettingScope.Local, "Opacity of the tracker panel background.");
		}

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

			public static readonly KindleSetting<bool> Enabled = KindleSetting.Toggle("Salvage", "Enabled", defaultValue: true, SettingScope.ServerAuthoritative, "Add a Salvage tab to crafting stations that turns unwanted gear back into materials.");

			public static readonly KindleSetting<float> ReturnFraction = KindleSetting.Number("Salvage", "Return Fraction", 0.75f, 0f, 1f, SettingScope.ServerAuthoritative, "Share of each material's total cost returned by salvage.");

			public static readonly KindleSetting<SalvageRounding> Rounding = KindleSetting.Choice("Salvage", "Rounding", SalvageRounding.Round, SettingScope.ServerAuthoritative, "How a share becomes a whole number: Floor, Round (halves up) or Ceil.");

			public static readonly KindleSetting<bool> AtLeastOne = KindleSetting.Toggle("Salvage", "At Least One", defaultValue: true, SettingScope.ServerAuthoritative, "Every material returns at least one.");

			public static readonly KindleSetting<bool> UpgradeMaterials = KindleSetting.Toggle("Salvage", "Upgrade Materials", defaultValue: true, SettingScope.ServerAuthoritative, "Include the materials spent on upgrades.");

			public static readonly KindleSetting<bool> RequireKnownRecipe = KindleSetting.Toggle("Salvage", "Require Known Recipe", defaultValue: true, SettingScope.ServerAuthoritative, "Only salvage items whose recipe the character knows. Found gear (loot, chest, trader or creature drops, which no one crafted) always counts as known, as does every recipe when the world unlocks all recipes.");

			public static readonly KindleSetting<bool> RequireStation = KindleSetting.Toggle("Salvage", "Require Station", defaultValue: false, SettingScope.ServerAuthoritative, "Only salvage at the item's own crafting station.");

			public static readonly KindleSetting<bool> SkipItemsWithModData = KindleSetting.Toggle("Salvage", "Skip Items With Mod Data", defaultValue: true, SettingScope.ServerAuthoritative, "Never salvage items carrying data from other mods (keys starting with Mod Data Prefixes).");

			public static readonly KindleSetting<string> ModDataPrefixes = KindleSetting.Text("Salvage", "Mod Data Prefixes", "ecf_", SettingScope.ServerAuthoritative, "Comma list of item data key prefixes (case-sensitive) that mark an item as carrying other mods' data.", ExtraPotions.Kindle.Config.ModDataPrefixes.Normalize);

			public static readonly KindleSetting<string> SalvageKey = KindleSetting.Text("Salvage", "Salvage Key", "", SettingScope.Local, "Salvages the item under the pointer on the Salvage tab. Unbound by default; the Salvage button does the same.", Shortcut);

			public static readonly KindleSetting<bool> ShowRarityBackgrounds = KindleSetting.Toggle("Salvage", "Show Rarity Backgrounds", defaultValue: true, SettingScope.Local, "Show rarity backgrounds on the Salvage tab (also obeys Epic Loot's own setting).");

			public static readonly KindleSetting<bool> NearbyChests = KindleSetting.Toggle("Salvage", "Nearby Chests", defaultValue: true, SettingScope.ServerAuthoritative, "The Salvage tab also lists gear in the nearby chests Burrow lets you craft from (needs Burrow: its range, wards and chest rules apply, and chests other players have open are skipped). Salvaged materials go to your inventory; what does not fit drops at your feet. Your own value applies in single player; on a server the host's value applies.");
		}

		public static class Cart
		{
			public const string Section = "Cart Workbench";

			public static readonly KindleSetting<bool> CartWorkbench = KindleSetting.Toggle("Cart Workbench", "Cart Workbench", defaultValue: false, SettingScope.Cheat, "Cheat. Every loaded cart carries a workbench; Shift + Use opens it. Off whenever the server blocks cheats.", false);

			public static readonly KindleSetting<int> CartStationLevel = KindleSetting.Integer("Cart Workbench", "Cart Station Level", 1, 1, 5, SettingScope.ServerAuthoritative, "Workbench level of a cart before extensions.");

			public static readonly KindleSetting<float> CartStationRange = KindleSetting.Number("Cart Workbench", "Cart Station Range", 10f, 1f, 50f, SettingScope.ServerAuthoritative, "Range of a cart's workbench in meters.");
		}

		public static class VirtualWorkbench
		{
			public const string Section = "Virtual Workbench";

			public static readonly KindleSetting<bool> Enabled = KindleSetting.Toggle("Virtual Workbench", "Virtual Workbench", defaultValue: false, SettingScope.ServerAuthoritative, "Host setting, off by default. Lets players reopen the crafting station they used last from anywhere it is still loaded, with Virtual Workbench Key. That station's own level, extensions, roof and fire rules apply, and crafting uses only carried materials, as at the station.");

			public static readonly KindleSetting<string> Key = KindleSetting.Text("Virtual Workbench", "Virtual Workbench Key", "", SettingScope.Local, "Your own key that reopens the crafting station you used last, when the host allows Virtual Workbench. Empty: no key.", Shortcut);
		}

		public static class Stations
		{
			public const string Section = "Crafting Stations";

			public static readonly KindleSetting<float> UseDistance = KindleSetting.Number("Crafting Stations", "Use Distance Multiplier", 1.5f, 1f, 3f, SettingScope.ServerAuthoritative, "How far you can stand from a crafting station and still use it, as a multiple of the game's distance for that station (1 is the game's). Your own value applies in single player; on a server the host's value applies.");
		}

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

			public static readonly KindleSetting<string> LockedPlayerSettings = KindleSetting.Text("Server", "Locked Player Settings", "", SettingScope.ServerAuthoritative, "Retained compatibility key. Server lock lists no longer override client-local settings.", (string t) => (t ?? "").Trim());
		}

		private static readonly Lazy<KindleSetting[]> all = new Lazy<KindleSetting[]>(() => new KindleSetting[48]
		{
			RecipeList.Search,
			RecipeList.SearchKey,
			RecipeList.ClearSearchOnClose,
			RecipeList.IgnoreAccents,
			RecipeList.Categories,
			RecipeList.Favourites,
			RecipeList.FavouritesFirst,
			RecipeList.FavouriteRecipeKey,
			RecipeList.RecipeView,
			RecipeList.SortButton,
			RecipeList.GamepadControls,
			RecipeList.GamepadSortButton,
			Batch.Enabled,
			Batch.MaxAmount,
			Batch.CraftSpeed,
			Batch.InstantCrafting,
			Repair.OnStationOpen,
			Tracker.Enabled,
			Tracker.MaxTracked,
			Tracker.CountNearbyChests,
			Tracker.UntrackWhenCrafted,
			Tracker.HideInCombat,
			Tracker.HideWithMap,
			Tracker.Font,
			Tracker.FontSize,
			Tracker.HaveColour,
			Tracker.MissingColour,
			Tracker.ReadyColour,
			Tracker.BackgroundOpacity,
			Salvage.Enabled,
			Salvage.ReturnFraction,
			Salvage.Rounding,
			Salvage.AtLeastOne,
			Salvage.UpgradeMaterials,
			Salvage.RequireKnownRecipe,
			Salvage.RequireStation,
			Salvage.SkipItemsWithModData,
			Salvage.ModDataPrefixes,
			Salvage.SalvageKey,
			Salvage.ShowRarityBackgrounds,
			Salvage.NearbyChests,
			Cart.CartWorkbench,
			Cart.CartStationLevel,
			Cart.CartStationRange,
			VirtualWorkbench.Enabled,
			VirtualWorkbench.Key,
			Stations.UseDistance,
			Server.LockedPlayerSettings
		});

		private static readonly Lazy<Dictionary<string, KindleSetting>> byId = new Lazy<Dictionary<string, KindleSetting>>(() => all.Value.ToDictionary<KindleSetting, string>((KindleSetting s) => s.Id, StringComparer.OrdinalIgnoreCase));

		public static IReadOnlyList<KindleSetting> All => all.Value;

		public static KindleSetting? Find(string? id)
		{
			if (id == null || !byId.Value.TryGetValue(id.Trim(), out KindleSetting value))
			{
				return null;
			}
			return value;
		}

		private static string Shortcut(string text)
		{
			return (text ?? "").Trim();
		}

		private static string Colour(string text, string fallback)
		{
			if (!HtmlColour.TryParse(text, out var colour))
			{
				return fallback;
			}
			return colour.ToString();
		}
	}
	public sealed class LockList
	{
		private readonly HashSet<string> locked;

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

		public IReadOnlyList<string> Locked { get; }

		public IReadOnlyList<string> Unknown { get; }

		public IReadOnlyList<string> NotLockable { get; }

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

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

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

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

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

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

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

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

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

		public string? ServerText { get; }

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

		public override string ToString()
		{
			if (!Locked)
			{
				return "Own";
			}
			return "Locked (" + ServerText + ")";
		}
	}
	public static class PlayerLocks
	{
		public static PlayerLock Evaluate(string id, bool serverBinds, LockList list, IReadOnlyDictionary<string, string> values)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (!serverBinds || !list.IsLocked(id) || !values.TryGetValue(id.Trim(), out string value))
			{
				return new PlayerLock(locked: false, null);
			}
			return new PlayerLock(locked: true, value);
		}
	}
	public readonly struct HtmlColour
	{
		private readonly bool hasAlpha;

		public byte R { get; }

		public byte G { get; }

		public byte B { get; }

		public byte A { get; }

		private HtmlColour(byte r, byte g, byte b, byte a, bool hasAlpha)
		{
			R = r;
			G = g;
			B = b;
			A = a;
			this.hasAlpha = hasAlpha;
		}

		public static bool TryParse(string? text, out HtmlColour colour)
		{
			colour = default(HtmlColour);
			string text2 = text?.Trim();
			if (text2 == null || text2.Length < 2 || text2[0] != '#')
			{
				return false;
			}
			string text3 = text2.Substring(1);
			if (text3.Length == 3)
			{
				text3 = new string(new char[6]
				{
					text3[0],
					text3[0],
					text3[1],
					text3[1],
					text3[2],
					text3[2]
				});
			}
			if (text3.Length != 6 && text3.Length != 8)
			{
				return false;
			}
			if (!uint.TryParse(text3, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (text3.Length == 6)
			{
				colour = new HtmlColour((byte)(result >> 16), (byte)(result >> 8), (byte)result, byte.MaxValue, hasAlpha: false);
			}
			else
			{
				colour = new HtmlColour((byte)(result >> 24), (byte)(result >> 16), (byte)(result >> 8), (byte)result, hasAlpha: true);
			}
			return true;
		}

		public override string ToString()
		{
			return "#" + R.ToString("X2", CultureInfo.InvariantCulture) + G.ToString("X2", CultureInfo.InvariantCulture) + B.ToString("X2", CultureInfo.InvariantCulture) + (hasAlpha ? A.ToString("X2", CultureInfo.InvariantCulture) : "");
		}
	}
	public static class ModDataPrefixes
	{
		public static IReadOnlyList<string> Parse(string? text)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			List<string> list = new List<string>();
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0 && hashSet.Add(text2))
				{
					list.Add(text2);
				}
			}
			return list;
		}

		public static string Normalize(string? text)
		{
			return string.Join(",", Parse(text));
		}

		public static bool Matches(IEnumerable<string> prefixes, string? key)
		{
			if (key != null)
			{
				return prefixes.Any((string p) => p.Length > 0 && key.StartsWith(p, StringComparison.Ordinal));
			}
			return false;
		}
	}
}