using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using ExtraPotions.Barter.Availability;
using ExtraPotions.Barter.Config;
using ExtraPotions.Barter.Lists;
using ExtraPotions.Barter.Trading;
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.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4")]
[assembly: AssemblyProduct("Barter.Core")]
[assembly: AssemblyTitle("Barter.Core")]
[assembly: AssemblyVersion("0.1.4.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.Barter
{
	public static class BarterCore
	{
		public const string ProductId = "com.meadworks.barter";

		public const string LegacyProductId = "com.extrapotions.barter";

		public const string FilePrefix = "Barter.";

		public const string VanillaCurrency = "Coins";

		public const string CommonTrader = "common";

		public const int QualityStackMultiplier = 1000000;
	}
	public enum LegacyFileOutcome
	{
		None,
		Migrated,
		KeptNew,
		Failed
	}
	public sealed class LegacyFileResult
	{
		public LegacyFileOutcome Outcome { get; }

		public string? Backup { get; }

		public string? Problem { get; }

		internal LegacyFileResult(LegacyFileOutcome outcome, string? backup = null, string? problem = null)
		{
			Outcome = outcome;
			Backup = backup;
			Problem = problem;
		}
	}
	public static class LegacyFileMigration
	{
		public static LegacyFileResult PrepareSettings(string directory, string legacyName, string currentName)
		{
			LegacyFileResult legacyFileResult = Run(directory, legacyName, currentName);
			if (legacyFileResult.Outcome == LegacyFileOutcome.Failed)
			{
				throw new IOException("Legacy settings could not be carried over; initialization stopped before defaults were saved. " + legacyFileResult.Problem);
			}
			return legacyFileResult;
		}

		public static LegacyFileResult Run(string directory, string legacyName, string currentName)
		{
			if (string.IsNullOrEmpty(directory))
			{
				throw new ArgumentException("A config directory is required.", "directory");
			}
			if (string.IsNullOrEmpty(legacyName) || string.IsNullOrEmpty(currentName) || string.Equals(legacyName, currentName, StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("Two different file names are required.");
			}
			string text = Path.Combine(directory, legacyName);
			string text2 = Path.Combine(directory, currentName);
			if (!File.Exists(text))
			{
				return new LegacyFileResult(LegacyFileOutcome.None);
			}
			if (File.Exists(text2))
			{
				return new LegacyFileResult(LegacyFileOutcome.KeptNew);
			}
			string text3 = text2 + ".migrate-" + Guid.NewGuid().ToString("N");
			try
			{
				byte[] array = File.ReadAllBytes(text);
				File.WriteAllBytes(text3, array);
				if (!((ReadOnlySpan<byte>)array).SequenceEqual((ReadOnlySpan<byte>)File.ReadAllBytes(text3)))
				{
					throw new IOException("The copied settings failed readback.");
				}
				if (File.Exists(text2))
				{
					return new LegacyFileResult(LegacyFileOutcome.KeptNew);
				}
				File.Move(text3, text2);
			}
			catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
			{
				return File.Exists(text2) ? new LegacyFileResult(LegacyFileOutcome.KeptNew) : new LegacyFileResult(LegacyFileOutcome.Failed, null, ex.Message);
			}
			finally
			{
				try
				{
					if (File.Exists(text3))
					{
						File.Delete(text3);
					}
				}
				catch (IOException)
				{
				}
				catch (UnauthorizedAccessException)
				{
				}
			}
			try
			{
				string text4 = FreeBackupName(text);
				File.Move(text, text4);
				return new LegacyFileResult(LegacyFileOutcome.Migrated, text4);
			}
			catch (Exception ex4) when (ex4 is IOException || ex4 is UnauthorizedAccessException)
			{
				return new LegacyFileResult(LegacyFileOutcome.Migrated, null, "The old file kept its name: " + ex4.Message);
			}
		}

		private static string FreeBackupName(string path)
		{
			string text = path + ".bak";
			if (!File.Exists(text))
			{
				return text;
			}
			for (int i = 1; i < 1000; i++)
			{
				string text2 = path + "." + i + ".bak";
				if (!File.Exists(text2))
				{
					return text2;
				}
			}
			throw new IOException("No free backup name for " + Path.GetFileName(path) + ".");
		}
	}
	public readonly struct PanelBox
	{
		public float X { get; }

		public float Y { get; }

		public float Width { get; }

		public float Height { get; }

		public float Right => X + Width;

		public float Top => Y + Height;

		public bool Usable
		{
			get
			{
				if (Finite(X) && Finite(Y) && Finite(Width) && Finite(Height) && Width > 0f)
				{
					return Height > 0f;
				}
				return false;
			}
		}

		public PanelBox(float x, float y, float width, float height)
		{
			X = x;
			Y = y;
			Width = width;
			Height = height;
		}

		public static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public enum SidePanelSide
	{
		Left,
		Right,
		Below
	}
	public readonly struct SidePlace
	{
		public SidePanelSide Side { get; }

		public PanelBox Box { get; }

		public SidePlace(SidePanelSide side, PanelBox box)
		{
			Side = side;
			Box = box;
		}
	}
	public readonly struct OpenPlace
	{
		public bool HasSell { get; }

		public SidePlace Sell { get; }

		public bool HasPurse { get; }

		public SidePlace Purse { get; }

		public OpenPlace(bool hasSell, SidePlace sell, bool hasPurse, SidePlace purse)
		{
			HasSell = hasSell;
			Sell = sell;
			HasPurse = hasPurse;
			Purse = purse;
		}
	}
	public static class SidePanelFit
	{
		public static SidePlace Place(PanelBox canvas, PanelBox store, PanelBox? beside, float width, float height, float gap, float frame)
		{
			width = NonNegative(width);
			height = NonNegative(height);
			gap = NonNegative(gap);
			frame = NonNegative(frame);
			if (!canvas.Usable)
			{
				return new SidePlace(SidePanelSide.Left, new PanelBox(0f, 0f, width, height));
			}
			PanelBox other = (store.Usable ? store : canvas);
			PanelBox panelBox = NudgeY(canvas, Box(other.X - gap - width, other.Top - height, width, height), frame);
			if (Inside(canvas, panelBox, frame) && !Hits(panelBox, other) && !Hits(panelBox, beside))
			{
				return new SidePlace(SidePanelSide.Left, panelBox);
			}
			float num = other.Right;
			if (beside.HasValue)
			{
				PanelBox valueOrDefault = beside.GetValueOrDefault();
				if (valueOrDefault.Usable)
				{
					num = Math.Max(num, valueOrDefault.Right);
				}
			}
			PanelBox panelBox2 = NudgeY(canvas, Box(num + gap, other.Top - height, width, height), frame);
			if (Inside(canvas, panelBox2, frame) && !Hits(panelBox2, other) && !Hits(panelBox2, beside))
			{
				return new SidePlace(SidePanelSide.Right, panelBox2);
			}
			float num2 = other.Y;
			if (beside.HasValue)
			{
				PanelBox valueOrDefault2 = beside.GetValueOrDefault();
				if (valueOrDefault2.Usable)
				{
					num2 = Math.Min(num2, valueOrDefault2.Y);
				}
			}
			PanelBox panel = NudgeX(canvas, Box(other.X, num2 - gap - height, width, height), frame);
			return new SidePlace(SidePanelSide.Below, Clamp(canvas, panel, frame));
		}

		public static SidePlace PlaceSell(PanelBox canvas, PanelBox store, float width, float height, float gap, float frame)
		{
			width = NonNegative(width);
			height = NonNegative(height);
			gap = NonNegative(gap);
			frame = NonNegative(frame);
			if (!canvas.Usable)
			{
				return new SidePlace(SidePanelSide.Right, new PanelBox(0f, 0f, width, height));
			}
			PanelBox other = (store.Usable ? store : canvas);
			PanelBox panelBox = NudgeY(canvas, Box(other.Right + gap, other.Top - height, width, height), frame);
			if (Inside(canvas, panelBox, frame) && !Hits(panelBox, other))
			{
				return new SidePlace(SidePanelSide.Right, panelBox);
			}
			PanelBox panelBox2 = NudgeY(canvas, Box(other.X - gap - width, other.Top - height, width, height), frame);
			if (Inside(canvas, panelBox2, frame) && !Hits(panelBox2, other))
			{
				return new SidePlace(SidePanelSide.Left, panelBox2);
			}
			PanelBox panel = NudgeX(canvas, Box(other.X, other.Y - gap - height, width, height), frame);
			return new SidePlace(SidePanelSide.Below, Clamp(canvas, panel, frame));
		}

		public static OpenPlace PlaceBoth(PanelBox canvas, PanelBox store, bool sell, float sellWidth, float sellHeight, bool purse, float purseWidth, float purseHeight, float gap, float frame)
		{
			gap = NonNegative(gap);
			frame = NonNegative(frame);
			sell = sell && sellWidth > 0f && sellHeight > 0f && PanelBox.Finite(sellWidth) && PanelBox.Finite(sellHeight);
			purse = purse && purseWidth > 0f && purseHeight > 0f && PanelBox.Finite(purseWidth) && PanelBox.Finite(purseHeight);
			SidePlace sidePlace = default(SidePlace);
			bool flag = false;
			if (sell)
			{
				sidePlace = PlaceSell(canvas, store, sellWidth, sellHeight, gap, frame);
				flag = sidePlace.Side != SidePanelSide.Below;
			}
			SidePlace sidePlace2 = default(SidePlace);
			if (purse)
			{
				PanelBox? beside = ((sell && flag) ? new PanelBox?(sidePlace.Box) : ((PanelBox?)null));
				sidePlace2 = Place(canvas, store, beside, purseWidth, purseHeight, gap, frame);
			}
			if (sell && purse && Hits(sidePlace.Box, sidePlace2.Box))
			{
				if (flag)
				{
					sidePlace2 = Yield(canvas, store, sidePlace2, sidePlace.Box, gap, frame);
				}
				else
				{
					sidePlace = Yield(canvas, store, sidePlace, sidePlace2.Box, gap, frame);
				}
			}
			if (sell && purse && Hits(sidePlace.Box, sidePlace2.Box))
			{
				if (flag)
				{
					sidePlace = Yield(canvas, store, sidePlace, sidePlace2.Box, gap, frame);
				}
				else
				{
					sidePlace2 = Yield(canvas, store, sidePlace2, sidePlace.Box, gap, frame);
				}
			}
			return new OpenPlace(sell, sidePlace, purse, sidePlace2);
		}

		private static SidePlace Yield(PanelBox canvas, PanelBox store, SidePlace panel, PanelBox obstacle, float gap, float frame)
		{
			PanelBox panelBox = Separate(canvas, store, panel.Box, obstacle, gap, frame);
			if (!Hits(panelBox, obstacle))
			{
				return new SidePlace(panel.Side, panelBox);
			}
			return panel;
		}

		private static PanelBox Separate(PanelBox canvas, PanelBox store, PanelBox panel, PanelBox obstacle, float gap, float frame)
		{
			if (!Hits(panel, obstacle) || !canvas.Usable || !obstacle.Usable)
			{
				return panel;
			}
			bool found = false;
			PanelBox best = panel;
			float bestArea = 0f;
			float bestDist = 0f;
			Consider(obstacle.X - gap - panel.Width, panel.Y);
			Consider(obstacle.Right + gap, panel.Y);
			Consider(panel.X, obstacle.Top + gap);
			Consider(panel.X, obstacle.Y - gap - panel.Height);
			Consider(canvas.X + frame, canvas.Y + frame);
			Consider(canvas.Right - frame - panel.Width, canvas.Y + frame);
			Consider(canvas.X + frame, canvas.Top - frame - panel.Height);
			Consider(canvas.Right - frame - panel.Width, canvas.Top - frame - panel.Height);
			if (store.Usable)
			{
				Consider(store.X - gap - panel.Width, store.Top - panel.Height);
				Consider(store.Right + gap, store.Top - panel.Height);
			}
			if (!found)
			{
				return panel;
			}
			return best;
			void Consider(float x, float y)
			{
				PanelBox panelBox = Clamp(canvas, new PanelBox(x, y, panel.Width, panel.Height), frame);
				if (Inside(canvas, panelBox, frame) && !Hits(panelBox, obstacle))
				{
					float num = OverlapArea(panelBox, store);
					float num2 = panelBox.X - panel.X;
					float num3 = panelBox.Y - panel.Y;
					float num4 = num2 * num2 + num3 * num3;
					if (!found || num < bestArea - 0.5f || (Math.Abs(num - bestArea) <= 0.5f && num4 < bestDist))
					{
						found = true;
						best = panelBox;
						bestArea = num;
						bestDist = num4;
					}
				}
			}
		}

		private static float OverlapArea(PanelBox panel, PanelBox other)
		{
			if (!panel.Usable || !other.Usable)
			{
				return 0f;
			}
			float num = Math.Min(panel.Right, other.Right) - Math.Max(panel.X, other.X);
			float num2 = Math.Min(panel.Top, other.Top) - Math.Max(panel.Y, other.Y);
			if (num <= 0.5f || num2 <= 0.5f)
			{
				return 0f;
			}
			return num * num2;
		}

		private static PanelBox Box(float x, float y, float width, float height)
		{
			return new PanelBox(x, y, width, height);
		}

		private static float NonNegative(float value)
		{
			if (!PanelBox.Finite(value) || !(value > 0f))
			{
				return 0f;
			}
			return value;
		}

		private static PanelBox NudgeY(PanelBox canvas, PanelBox panel, float frame)
		{
			float num = canvas.Y + frame;
			float num2 = canvas.Top - frame;
			if (num2 - num < panel.Height)
			{
				return panel;
			}
			float num3 = panel.Y;
			if (num3 < num)
			{
				num3 = num;
			}
			if (num3 + panel.Height > num2)
			{
				num3 = num2 - panel.Height;
			}
			return new PanelBox(panel.X, num3, panel.Width, panel.Height);
		}

		private static PanelBox NudgeX(PanelBox canvas, PanelBox panel, float frame)
		{
			float num = canvas.X + frame;
			float num2 = canvas.Right - frame;
			if (num2 - num < panel.Width)
			{
				return panel;
			}
			float num3 = panel.X;
			if (num3 < num)
			{
				num3 = num;
			}
			if (num3 + panel.Width > num2)
			{
				num3 = num2 - panel.Width;
			}
			return new PanelBox(num3, panel.Y, panel.Width, panel.Height);
		}

		private static bool Inside(PanelBox canvas, PanelBox panel, float frame)
		{
			if (panel.X >= canvas.X + frame - 0.51f && panel.Y >= canvas.Y + frame - 0.51f && panel.Right <= canvas.Right - frame + 0.51f)
			{
				return panel.Top <= canvas.Top - frame + 0.51f;
			}
			return false;
		}

		private static bool Hits(PanelBox panel, PanelBox? other)
		{
			if (!other.HasValue || !other.Value.Usable)
			{
				return false;
			}
			PanelBox value = other.Value;
			float num = Math.Max(panel.X, value.X);
			float num2 = Math.Min(panel.Right, value.Right);
			float num3 = Math.Max(panel.Y, value.Y);
			float num4 = Math.Min(panel.Top, value.Top);
			if (num2 - num > 0.5f)
			{
				return num4 - num3 > 0.5f;
			}
			return false;
		}

		private static bool Hits(PanelBox panel, PanelBox other)
		{
			return Hits(panel, (PanelBox?)other);
		}

		private static PanelBox Clamp(PanelBox canvas, PanelBox panel, float frame)
		{
			float num = frame;
			float num2 = frame;
			if (canvas.Width <= panel.Width + frame * 2f)
			{
				num = 0f;
			}
			if (canvas.Height <= panel.Height + frame * 2f)
			{
				num2 = 0f;
			}
			float num3 = canvas.X + num;
			float num4 = canvas.Y + num2;
			float num5 = canvas.Right - num;
			float num6 = canvas.Top - num2;
			float x = panel.X;
			float y = panel.Y;
			x = ((!(num5 - num3 >= panel.Width)) ? num3 : Math.Max(num3, Math.Min(x, num5 - panel.Width)));
			y = ((!(num6 - num4 >= panel.Height)) ? (num6 - panel.Height) : Math.Max(num4, Math.Min(y, num6 - panel.Height)));
			return new PanelBox(x, y, panel.Width, panel.Height);
		}
	}
}
namespace ExtraPotions.Barter.Trading
{
	public interface IAuthorityStorage
	{
		bool Exists(string path);

		byte[] Read(string path, int maximumBytes);

		void WriteNew(string path, byte[] bytes);

		void Promote(string pending, string current, string backup);

		IEnumerable<string> Files(string directory, string pattern);

		void Delete(string path);
	}
	public sealed class AuthenticatedStateStore
	{
		private sealed class Record
		{
			internal string Object = "";

			internal string Field = "";

			internal string Value = "";
		}

		private sealed class LocalStorage : IAuthorityStorage
		{
			public bool Exists(string path)
			{
				return File.Exists(path);
			}

			public byte[] Read(string path, int maximumBytes)
			{
				using (RefillTiming.Measure(RefillTiming.Operation.LocalRead))
				{
					if (new FileInfo(path).Length > maximumBytes)
					{
						throw new InvalidDataException("Authority file bound");
					}
					byte[] array = File.ReadAllBytes(path);
					if (array.Length > maximumBytes)
					{
						throw new InvalidDataException("Authority file bound");
					}
					return array;
				}
			}

			public void WriteNew(string path, byte[] bytes)
			{
				using (RefillTiming.Measure(RefillTiming.Operation.LocalWrite))
				{
					Directory.CreateDirectory(Path.GetDirectoryName(path));
					using FileStream fileStream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.None);
					fileStream.Write(bytes, 0, bytes.Length);
					using (RefillTiming.Measure(RefillTiming.Operation.Flush))
					{
						fileStream.Flush(flushToDisk: true);
					}
				}
			}

			public void Promote(string pending, string current, string backup)
			{
				using (RefillTiming.Measure(RefillTiming.Operation.Promote))
				{
					if (File.Exists(current))
					{
						File.Replace(pending, current, backup);
					}
					else
					{
						File.Move(pending, current);
					}
				}
			}

			public IEnumerable<string> Files(string directory, string pattern)
			{
				if (!Directory.Exists(directory))
				{
					return Array.Empty<string>();
				}
				return Directory.EnumerateFiles(directory, pattern);
			}

			public void Delete(string path)
			{
				File.Delete(path);
			}
		}

		public const int MaximumValueLength = 1048576;

		private const int MaximumRecordBytes = 4198400;

		private readonly string directory;

		private readonly IAuthorityStorage files;

		private readonly bool requireExistingKey;

		public AuthenticatedStateStore(string directory, IAuthorityStorage? storage = null, bool requireExistingKey = false)
		{
			this.directory = ((storage == null) ? Path.GetFullPath(directory) : directory);
			files = storage ?? new LocalStorage();
			this.requireExistingKey = requireExistingKey;
		}

		private string WorldDirectory(long world)
		{
			if (world == 0L)
			{
				throw new InvalidDataException("Authority world is unavailable");
			}
			return Path.Combine(directory, world.ToString(CultureInfo.InvariantCulture));
		}

		private static void Identity(string objectId, string field)
		{
			if (string.IsNullOrEmpty(objectId) || objectId.Length > 128 || string.IsNullOrEmpty(field) || field.Length > 256)
			{
				throw new InvalidDataException("Authority state identity bound");
			}
		}

		private string RecordPath(long world, string objectId, string field)
		{
			Identity(objectId, field);
			using SHA256 sHA = SHA256.Create();
			return Path.Combine(WorldDirectory(world), BitConverter.ToString(sHA.ComputeHash(Encoding.UTF8.GetBytes(objectId + "\0" + field))).Replace("-", "") + ".state");
		}

		private byte[] Key(long world, bool create)
		{
			string path = WorldDirectory(world);
			string text = Path.Combine(path, "authority.key");
			if (files.Exists(text + ".pending"))
			{
				byte[] array = null;
				string[] array2 = new string[2]
				{
					text,
					text + ".backup"
				};
				foreach (string path2 in array2)
				{
					if (!files.Exists(path2))
					{
						continue;
					}
					try
					{
						byte[] array3 = files.Read(path2, 32);
						if (array3.Length == 32)
						{
							array = array3;
							break;
						}
					}
					catch (InvalidDataException)
					{
					}
				}
				if (array != null)
				{
					byte[] array4 = null;
					try
					{
						array4 = files.Read(text + ".pending", 32);
					}
					catch (InvalidDataException)
					{
					}
					if (array4 == null || !((ReadOnlySpan<byte>)array4).SequenceEqual((ReadOnlySpan<byte>)array))
					{
						Quarantine(text + ".pending");
					}
				}
			}
			byte[] array5 = Recover(text, delegate(string p)
			{
				byte[] array6 = files.Read(p, 32);
				if (array6.Length != 32)
				{
					throw new InvalidDataException("Authority key bound");
				}
				return array6;
			});
			if (array5 != null)
			{
				return array5;
			}
			if (files.Files(path, "*.state*").Any())
			{
				throw new InvalidDataException("Authority key missing for existing state");
			}
			string path3 = Path.Combine(path, "allow-new-authority-key");
			bool flag = files.Exists(path3) && Encoding.UTF8.GetString(files.Read(path3, 64)).Trim() == world.ToString(CultureInfo.InvariantCulture);
			if (requireExistingKey && !flag)
			{
				throw new InvalidDataException("Existing world is missing Barter authority state. Restore Barter.Authority or create allow-new-authority-key containing the world UID to authorize its initial balance.");
			}
			if (!create)
			{
				return Array.Empty<byte>();
			}
			array5 = new byte[32];
			using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())
			{
				randomNumberGenerator.GetBytes(array5);
			}
			AtomicWrite(text, array5);
			AtomicWrite(text + ".backup", array5);
			if (flag)
			{
				files.Delete(path3);
			}
			return array5;
		}

		private Record Decode(string path, long world, byte[] key, string? objectId = null, string? field = null)
		{
			byte[] array = files.Read(path, 4198400);
			if (array.Length < 48 || array.Length > 4198400)
			{
				throw new InvalidDataException("Authority record bound");
			}
			byte[] array2;
			using (HMACSHA256 hMACSHA = new HMACSHA256(key))
			{
				array2 = hMACSHA.ComputeHash(array, 32, array.Length - 32);
			}
			int num = 0;
			for (int i = 0; i < 32; i++)
			{
				num |= array2[i] ^ array[i];
			}
			if (num != 0)
			{
				throw new InvalidDataException("Authority state authentication failed");
			}
			using MemoryStream memoryStream = new MemoryStream(array, 32, array.Length - 32);
			using BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8);
			if (binaryReader.ReadInt32() != 1 || binaryReader.ReadInt64() != world)
			{
				throw new InvalidDataException("Authority world mismatch");
			}
			Record record = new Record
			{
				Object = binaryReader.ReadString(),
				Field = binaryReader.ReadString(),
				Value = binaryReader.ReadString()
			};
			Identity(record.Object, record.Field);
			if (objectId != null)
			{
				if (record.Object != objectId || record.Field != field)
				{
					throw new InvalidDataException("Authority state identity mismatch");
				}
			}
			else
			{
				string text = RecordPath(world, record.Object, record.Field).Replace('\\', '/');
				string text2 = path.Replace('\\', '/');
				if (text2 != text && text2 != text + ".pending" && text2 != text + ".backup")
				{
					throw new InvalidDataException("Authority record filename mismatch");
				}
			}
			if (record.Value.Length > 1048576 || memoryStream.Position != memoryStream.Length)
			{
				throw new InvalidDataException("Authority state value bound");
			}
			return record;
		}

		public string Read(long world, string objectId, string field)
		{
			return Read(world, objectId, field, RecordPath(world, objectId, field));
		}

		private string Read(long world, string objectId, string field, string path)
		{
			byte[] key = Key(world, create: false);
			return Recover(path, delegate(string p)
			{
				if (key.Length != 32)
				{
					throw new InvalidDataException("Authority key missing");
				}
				return Decode(p, world, key, objectId, field);
			})?.Value ?? "";
		}

		private T? Recover<T>(string path, Func<string, T> validate) where T : class
		{
			string text = path + ".pending";
			string text2 = path + ".backup";
			bool flag = false;
			if (files.Exists(text))
			{
				T val = null;
				try
				{
					val = validate(text);
				}
				catch (Exception ex) when (ex is InvalidDataException || ex is EndOfStreamException || ex is FormatException)
				{
					flag = true;
				}
				if (val != null)
				{
					files.Promote(text, path, text2);
					return val;
				}
				Quarantine(text);
			}
			if (files.Exists(path))
			{
				try
				{
					return validate(path);
				}
				catch (Exception ex2) when (ex2 is InvalidDataException || ex2 is EndOfStreamException || ex2 is FormatException)
				{
					flag = true;
				}
			}
			if (files.Exists(text2))
			{
				T result = validate(text2);
				byte[] bytes = files.Read(text2, 4198400);
				if (files.Exists(path))
				{
					Quarantine(path);
				}
				files.WriteNew(text, bytes);
				files.Promote(text, path, path + ".replaced");
				return result;
			}
			if (flag || files.Exists(path))
			{
				throw new InvalidDataException("No valid authority state remains; restore the world backup");
			}
			return null;
		}

		private void Quarantine(string path)
		{
			files.Promote(path, path + ".quarantine-" + Guid.NewGuid().ToString("N"), path + ".unused");
		}

		public void Write(long world, string objectId, string field, string value)
		{
			if (value == null || value.Length > 1048576)
			{
				throw new InvalidDataException("Authority state value bound");
			}
			string path = RecordPath(world, objectId, field);
			Read(world, objectId, field);
			byte[] key = Key(world, create: true);
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8);
				binaryWriter.Write(1);
				binaryWriter.Write(world);
				binaryWriter.Write(objectId);
				binaryWriter.Write(field);
				binaryWriter.Write(value);
				array = memoryStream.ToArray();
			}
			using MemoryStream memoryStream2 = new MemoryStream();
			using (HMACSHA256 hMACSHA = new HMACSHA256(key))
			{
				byte[] array2 = hMACSHA.ComputeHash(array);
				memoryStream2.Write(array2, 0, array2.Length);
			}
			memoryStream2.Write(array, 0, array.Length);
			AtomicWrite(path, memoryStream2.ToArray());
		}

		public string[] Fields(long world, string objectId, string prefix)
		{
			Identity(objectId, string.IsNullOrEmpty(prefix) ? "*" : prefix);
			byte[] key = Key(world, create: false);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (string item in RecordFiles(WorldDirectory(world)))
			{
				Record record = Recover(item, (string p) => Decode(p, world, key));
				if (record != null && record.Object == objectId && record.Field.StartsWith(prefix ?? "", StringComparison.Ordinal))
				{
					Read(world, objectId, record.Field, item);
					hashSet.Add(record.Field);
				}
			}
			return hashSet.ToArray();
		}

		private IEnumerable<string> RecordFiles(string folder)
		{
			return (from path in files.Files(folder, "*.state*")
				where path.EndsWith(".state", StringComparison.Ordinal) || path.EndsWith(".state.pending", StringComparison.Ordinal) || path.EndsWith(".state.backup", StringComparison.Ordinal)
				select (!path.EndsWith(".pending", StringComparison.Ordinal)) ? ((!path.EndsWith(".backup", StringComparison.Ordinal)) ? path : path.Substring(0, path.Length - 7)) : path.Substring(0, path.Length - 8)).Distinct<string>(StringComparer.Ordinal).ToArray();
		}

		public void Remove(long world, string objectId, string field)
		{
			string text = RecordPath(world, objectId, field);
			Read(world, objectId, field, text);
			string[] array = new string[3] { ".pending", ".backup", "" };
			foreach (string text2 in array)
			{
				files.Delete(text + text2);
			}
		}

		public void ImportLocal(long world, string legacyDirectory)
		{
			string path = WorldDirectory(world);
			string path2 = Path.Combine(legacyDirectory, world.ToString(CultureInfo.InvariantCulture));
			if (!files.Exists(Path.Combine(path, "authority.key")) && Directory.Exists(path2))
			{
				ImportFrom(world, new AuthenticatedStateStore(legacyDirectory));
			}
		}

		public void ImportFrom(long world, AuthenticatedStateStore old, bool replaceExisting = false)
		{
			string path = WorldDirectory(world);
			string folder = old.WorldDirectory(world);
			byte[] key = old.Key(world, create: false);
			if (key.Length != 32)
			{
				return;
			}
			string path2 = Path.Combine(path, "authority.key");
			if (files.Exists(path2) && !((ReadOnlySpan<byte>)Key(world, create: false)).SequenceEqual((ReadOnlySpan<byte>)key))
			{
				throw new InvalidDataException("Authority world migration key conflict");
			}
			Dictionary<string, byte[]> dictionary = new Dictionary<string, byte[]>(StringComparer.Ordinal);
			foreach (string item in old.RecordFiles(folder))
			{
				Record record = old.Recover(item, (string p) => old.Decode(p, world, key));
				if (record != null)
				{
					old.Read(world, record.Object, record.Field);
					string path3 = old.RecordPath(world, record.Object, record.Field);
					dictionary[Path.GetFileName(path3)] = old.files.Read(path3, 4198400);
				}
			}
			foreach (KeyValuePair<string, byte[]> item2 in dictionary)
			{
				string path4 = Path.Combine(path, item2.Key);
				if (replaceExisting && files.Exists(path4) && !((ReadOnlySpan<byte>)files.Read(path4, 4198400)).SequenceEqual((ReadOnlySpan<byte>)item2.Value))
				{
					Recover(path4, (string p) => Decode(p, world, key));
					AtomicWrite(path4, item2.Value);
				}
				else
				{
					ImportFile(path4, item2.Value);
				}
			}
			ImportFile(Path.Combine(path, "authority.key.backup"), key);
			ImportFile(Path.Combine(path, "authority.key"), key);
		}

		private void ImportFile(string path, byte[] bytes)
		{
			if (files.Exists(path))
			{
				if (!((ReadOnlySpan<byte>)files.Read(path, 4198400)).SequenceEqual((ReadOnlySpan<byte>)bytes))
				{
					throw new InvalidDataException("Authority import conflicts with existing world state");
				}
				return;
			}
			if (files.Exists(path + ".pending"))
			{
				bool flag = false;
				try
				{
					flag = ((ReadOnlySpan<byte>)files.Read(path + ".pending", 4198400)).SequenceEqual((ReadOnlySpan<byte>)bytes);
				}
				catch (InvalidDataException)
				{
				}
				if (flag)
				{
					files.Promote(path + ".pending", path, path + ".backup");
					return;
				}
				Quarantine(path + ".pending");
			}
			AtomicWrite(path, bytes);
		}

		private void AtomicWrite(string path, byte[] bytes)
		{
			string text = path + ".pending";
			files.WriteNew(text, bytes);
			files.Promote(text, path, path + ".backup");
		}
	}
	public sealed class PurseLedger
	{
		public int Balance { get; private set; }

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

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

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

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

		public long Delta { get; private set; }

		public bool Pending { get; private set; }

		public bool Committed { get; private set; }

		public bool Quarantined { get; private set; }

		public long ReservedAt { get; private set; }

		public PurseLedger(int initial)
		{
			Balance = Math.Max(initial, 0);
		}

		public bool Reserve(string actor, string token, string epoch, string fingerprint, long delta, out string reason)
		{
			reason = "InvalidReservation";
			if (string.IsNullOrEmpty(actor) || string.IsNullOrEmpty(token) || string.IsNullOrEmpty(epoch) || string.IsNullOrEmpty(fingerprint) || delta < -2147483647 || delta > int.MaxValue)
			{
				return false;
			}
			if (Actor == actor && Token == token && Epoch == epoch)
			{
				reason = ((Pending && Fingerprint == fingerprint && Delta == delta) ? "Reserved" : "AlreadyFinished");
				if (Pending && Fingerprint == fingerprint)
				{
					return Delta == delta;
				}
				return false;
			}
			if (Pending)
			{
				reason = "TraderBusy";
				return false;
			}
			if (Balance + Math.Min(delta, 0L) < 0)
			{
				reason = "TraderPoor";
				return false;
			}
			if (Balance + Math.Max(delta, 0L) > int.MaxValue)
			{
				reason = "PurseOverflow";
				return false;
			}
			Actor = actor;
			Token = token;
			Epoch = epoch;
			Fingerprint = fingerprint;
			Delta = delta;
			Balance += (int)Math.Min(delta, 0L);
			Pending = true;
			Committed = false;
			Quarantined = false;
			ReservedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			reason = "Reserved";
			return true;
		}

		public bool Finish(string actor, string token, string epoch, bool committed, bool inventoryVerified = false)
		{
			if (!inventoryVerified || Quarantined || Actor != actor || Token != token || Epoch != epoch)
			{
				return false;
			}
			if (!Pending)
			{
				return Committed == committed;
			}
			Settle(committed);
			return true;
		}

		public bool FinishReported(string actor, string token, string epoch, bool committed)
		{
			if (Quarantined || Actor != actor || Token != token || Epoch != epoch)
			{
				return false;
			}
			if (Pending)
			{
				Settle(committed);
			}
			return true;
		}

		private void Settle(bool committed)
		{
			Balance += (int)(committed ? Math.Max(Delta, 0L) : (-Math.Min(Delta, 0L)));
			Pending = false;
			Committed = committed;
		}

		public bool QuarantineExpired(long now, int timeoutSeconds = 120)
		{
			if (!Pending || timeoutSeconds < 1 || now < ReservedAt || now - ReservedAt < timeoutSeconds)
			{
				return false;
			}
			Pending = false;
			Quarantined = true;
			return true;
		}

		public bool Refill(int next)
		{
			if (Pending || next < 0)
			{
				return false;
			}
			Balance = next;
			return true;
		}

		public string Encode()
		{
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write(2);
			binaryWriter.Write(Balance);
			binaryWriter.Write(Actor);
			binaryWriter.Write(Token);
			binaryWriter.Write(Epoch);
			binaryWriter.Write(Fingerprint);
			binaryWriter.Write(Delta);
			binaryWriter.Write(Pending);
			binaryWriter.Write(Committed);
			binaryWriter.Write(Quarantined);
			binaryWriter.Write(ReservedAt);
			return Convert.ToBase64String(memoryStream.ToArray());
		}

		public static PurseLedger Decode(string encoded)
		{
			if (encoded == null || encoded.Length > 4096)
			{
				throw new InvalidDataException("Ledger exceeds bounds.");
			}
			using MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(encoded));
			using BinaryReader binaryReader = new BinaryReader(memoryStream);
			int num = binaryReader.ReadInt32();
			if (num != 1 && num != 2)
			{
				throw new InvalidDataException("Unsupported ledger version.");
			}
			int num2 = binaryReader.ReadInt32();
			PurseLedger purseLedger = new PurseLedger(num2)
			{
				Actor = binaryReader.ReadString(),
				Token = binaryReader.ReadString(),
				Epoch = binaryReader.ReadString(),
				Fingerprint = binaryReader.ReadString(),
				Delta = binaryReader.ReadInt64(),
				Pending = binaryReader.ReadBoolean(),
				Committed = binaryReader.ReadBoolean()
			};
			if (num == 2)
			{
				purseLedger.Quarantined = binaryReader.ReadBoolean();
				purseLedger.ReservedAt = binaryReader.ReadInt64();
			}
			if (num2 < 0 || purseLedger.ReservedAt < 0 || (purseLedger.Quarantined && (purseLedger.Pending || purseLedger.Committed)) || purseLedger.Delta < -2147483647 || purseLedger.Delta > int.MaxValue || (purseLedger.Pending && num2 + Math.Abs(purseLedger.Delta) > int.MaxValue) || purseLedger.Actor.Length > 128 || purseLedger.Token.Length > 128 || purseLedger.Epoch.Length > 128 || purseLedger.Fingerprint.Length > 128 || memoryStream.Position != memoryStream.Length || (purseLedger.Pending && (purseLedger.Actor.Length == 0 || purseLedger.Token.Length == 0 || purseLedger.Epoch.Length == 0 || purseLedger.Fingerprint.Length == 0)))
			{
				throw new InvalidDataException("Invalid ledger state.");
			}
			return purseLedger;
		}
	}
	public static class RefillTiming
	{
		public enum Operation
		{
			AuthorityRead,
			AuthorityWrite,
			LocalRead,
			LocalWrite,
			CloudRead,
			CloudWrite,
			Promote,
			Flush,
			CloudFinish
		}

		public struct Cost
		{
			public long Ticks;

			public int Count;
		}

		public struct Result
		{
			public long TotalTicks;

			public int Day;

			public int Scanned;

			public int Traders;

			public int Refilled;

			public Cost AuthorityRead;

			public Cost AuthorityWrite;

			public Cost LocalRead;

			public Cost LocalWrite;

			public Cost CloudRead;

			public Cost CloudWrite;

			public Cost Promote;

			public Cost Flush;

			public Cost CloudFinish;
		}

		public readonly struct Span : IDisposable
		{
			private readonly Operation operation;

			private readonly long start;

			private readonly bool enabled;

			internal Span(Operation operation, bool enabled)
			{
				this.operation = operation;
				this.enabled = enabled;
				start = (enabled ? Stopwatch.GetTimestamp() : 0);
			}

			public void Dispose()
			{
				if (enabled)
				{
					long ticks = Stopwatch.GetTimestamp() - start;
					switch (operation)
					{
					case Operation.AuthorityRead:
						Add(ref result.AuthorityRead, ticks);
						break;
					case Operation.AuthorityWrite:
						Add(ref result.AuthorityWrite, ticks);
						break;
					case Operation.LocalRead:
						Add(ref result.LocalRead, ticks);
						break;
					case Operation.LocalWrite:
						Add(ref result.LocalWrite, ticks);
						break;
					case Operation.CloudRead:
						Add(ref result.CloudRead, ticks);
						break;
					case Operation.CloudWrite:
						Add(ref result.CloudWrite, ticks);
						break;
					case Operation.Promote:
						Add(ref result.Promote, ticks);
						break;
					case Operation.Flush:
						Add(ref result.Flush, ticks);
						break;
					case Operation.CloudFinish:
						Add(ref result.CloudFinish, ticks);
						break;
					}
				}
			}
		}

		[ThreadStatic]
		private static bool active;

		[ThreadStatic]
		private static long started;

		[ThreadStatic]
		private static Result result;

		public static void Begin()
		{
			result = default(Result);
			started = Stopwatch.GetTimestamp();
			active = true;
		}

		public static Result End()
		{
			result.TotalTicks = Stopwatch.GetTimestamp() - started;
			active = false;
			return result;
		}

		public static void SetDay(int day)
		{
			if (active)
			{
				result.Day = day;
			}
		}

		public static void Scanned()
		{
			if (active)
			{
				result.Scanned++;
			}
		}

		public static void Trader()
		{
			if (active)
			{
				result.Traders++;
			}
		}

		public static void Refilled()
		{
			if (active)
			{
				result.Refilled++;
			}
		}

		public static Span Measure(Operation operation)
		{
			return new Span(operation, active);
		}

		private static void Add(ref Cost cost, long ticks)
		{
			cost.Ticks += ticks;
			cost.Count++;
		}
	}
	public static class SellCursor
	{
		public static int Move(int current, int count, int direction)
		{
			if (count > 0)
			{
				return Math.Max(0, Math.Min(count - 1, (current >= 0) ? (current + Math.Sign(direction)) : 0));
			}
			return -1;
		}
	}
	public sealed class HeldItem
	{
		public object Id { get; }

		public string Prefab { get; }

		public int Stack { get; }

		public int Quality { get; }

		public int MaxStack { get; }

		public HeldItem(object id, string prefab, int stack, int quality, int maxStack)
		{
			Id = id ?? throw new ArgumentNullException("id");
			Prefab = prefab ?? throw new ArgumentNullException("prefab");
			Stack = stack;
			Quality = quality;
			MaxStack = maxStack;
		}
	}
	public enum SellKind
	{
		Single,
		Stack,
		Combined
	}
	public sealed class SellSettings
	{
		public float PriceFactor { get; }

		public float QualityMultiplier { get; }

		public SellSettings(float priceFactor, float qualityMultiplier)
		{
			PriceFactor = priceFactor;
			QualityMultiplier = qualityMultiplier;
		}
	}
	public sealed class SellOffer
	{
		private readonly List<object> sources = new List<object>();

		public SellKind Kind { get; }

		public string Prefab { get; }

		public int Stack { get; internal set; }

		public int Amount { get; internal set; }

		public int Quality { get; }

		public int PricePerItem { get; }

		public int Price { get; internal set; }

		public string Currency { get; }

		public IReadOnlyList<object> Sources => sources;

		public int Lots
		{
			get
			{
				if (Kind != SellKind.Single)
				{
					if (Kind != SellKind.Combined)
					{
						return Amount / Math.Max(Stack, 1);
					}
					return Amount;
				}
				return 1;
			}
		}

		internal SellOffer(SellKind kind, string prefab, int stack, int amount, int quality, int pricePerItem, int price, string currency)
		{
			Kind = kind;
			Prefab = prefab;
			Stack = stack;
			Amount = amount;
			Quality = quality;
			PricePerItem = pricePerItem;
			Price = price;
			Currency = currency;
		}

		internal void AddSource(object source)
		{
			sources.Add(source);
		}
	}
	public static class SellPlanner
	{
		public static List<SellOffer> Plan(IEnumerable<HeldItem> held, SellPriceTable table, SellSettings settings, Func<string, string?> resolveCurrency)
		{
			List<SellOffer> list = new List<SellOffer>();
			foreach (HeldItem item in held)
			{
				int configuredQuality;
				IReadOnlyDictionary<int, SellPrice> readOnlyDictionary = table.Lookup(item.Prefab, item.Quality, out configuredQuality);
				if (readOnlyDictionary == null)
				{
					continue;
				}
				foreach (int item2 in readOnlyDictionary.Keys.OrderBy((int x) => x))
				{
					SellPrice sellPrice = readOnlyDictionary[item2];
					string text = resolveCurrency(sellPrice.Currency);
					if (text != null && !string.Equals(item.Prefab, text, StringComparison.Ordinal))
					{
						if (item2 == 1)
						{
							Add(list, item, (item.MaxStack == 1) ? 1 : item.Stack, sellPrice.Price, settings, configuredQuality, (item.MaxStack != 1) ? SellKind.Combined : SellKind.Single, text);
						}
						else
						{
							Add(list, item, item2, sellPrice.Price, settings, configuredQuality, SellKind.Stack, text);
						}
					}
				}
			}
			list.RemoveAll((SellOffer offer) => offer.Amount != 0 && offer.Amount < offer.Stack);
			return list;
		}

		private static void Add(List<SellOffer> offers, HeldItem item, int itemStack, int itemPrice, SellSettings settings, int configuredQuality, SellKind kind, string currency)
		{
			int effectiveQuality = ((configuredQuality > 0) ? configuredQuality : item.Quality);
			int adjustedPrice = itemPrice;
			if ((kind != SellKind.Stack && settings.QualityMultiplier != 0f && configuredQuality == 0 && item.Quality > 1 && !TradeAmounts.TryGetQualityPrice(itemPrice, item.Quality, settings.QualityMultiplier, out adjustedPrice)) || !TradeAmounts.TryGetPrice(adjustedPrice, (kind != SellKind.Combined) ? 1 : itemStack, settings.PriceFactor, out var price, roundUp: false))
			{
				return;
			}
			if (kind == SellKind.Single)
			{
				SellOffer sellOffer = new SellOffer(kind, item.Prefab, itemStack, 0, effectiveQuality, adjustedPrice, price, currency);
				sellOffer.AddSource(item.Id);
				offers.Add(sellOffer);
				return;
			}
			if (kind == SellKind.Stack)
			{
				SellOffer sellOffer2 = offers.Find((SellOffer o) => o.Kind == kind && o.Stack == itemStack && o.Prefab == item.Prefab && o.Quality == effectiveQuality && o.Price == price && o.Currency == currency);
				if (sellOffer2 != null)
				{
					sellOffer2.Amount = TradeAmounts.ClampBalance((long)sellOffer2.Amount + (long)item.Stack);
					sellOffer2.AddSource(item.Id);
				}
				else
				{
					SellOffer sellOffer3 = new SellOffer(kind, item.Prefab, itemStack, item.Stack, effectiveQuality, adjustedPrice, price, currency);
					sellOffer3.AddSource(item.Id);
					offers.Add(sellOffer3);
				}
				return;
			}
			SellOffer sellOffer4 = offers.Find((SellOffer o) => o.Kind == kind && o.Prefab == item.Prefab && o.Quality == effectiveQuality && o.Stack == 1 && o.PricePerItem == adjustedPrice && o.Currency == currency);
			if (sellOffer4 != null)
			{
				int num = TradeAmounts.ClampBalance((long)sellOffer4.Amount + (long)itemStack);
				if (!TradeAmounts.TryGetPrice(sellOffer4.PricePerItem, num, settings.PriceFactor, out var price2, roundUp: false))
				{
					offers.Remove(sellOffer4);
					return;
				}
				sellOffer4.Amount = num;
				sellOffer4.Price = price2;
				sellOffer4.AddSource(item.Id);
			}
			else
			{
				SellOffer sellOffer5 = new SellOffer(kind, item.Prefab, 1, itemStack, effectiveQuality, adjustedPrice, price, currency);
				sellOffer5.AddSource(item.Id);
				offers.Add(sellOffer5);
			}
		}
	}
	public sealed class SellPrice
	{
		public int Price { get; }

		public string Currency { get; }

		public SellPrice(int price, string currency)
		{
			Price = price;
			Currency = currency ?? string.Empty;
		}
	}
	public sealed class SellPriceTable
	{
		private readonly Dictionary<string, Dictionary<int, SellPrice>> prices;

		public static SellPriceTable Empty { get; } = new SellPriceTable(new Dictionary<string, Dictionary<int, SellPrice>>());

		public int Count => prices.Count;

		private SellPriceTable(Dictionary<string, Dictionary<int, SellPrice>> prices)
		{
			this.prices = prices;
		}

		public static SellPriceTable Build(IEnumerable<TradeEntry> entries, ITradeContext context)
		{
			Dictionary<string, Dictionary<int, SellPrice>> dictionary = new Dictionary<string, Dictionary<int, SellPrice>>(StringComparer.Ordinal);
			foreach (TradeEntry entry in entries)
			{
				if (EntryAvailability.CanPrice(entry, context))
				{
					string key = Key(entry.Prefab, entry.Quality);
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = new Dictionary<int, SellPrice>();
						dictionary.Add(key, value);
					}
					value[entry.Stack] = new SellPrice(entry.Price, entry.Currency);
				}
			}
			return new SellPriceTable(dictionary);
		}

		public IReadOnlyDictionary<int, SellPrice>? Lookup(string prefab, int itemQuality, out int configuredQuality)
		{
			configuredQuality = itemQuality;
			if (prices.TryGetValue(Key(prefab, itemQuality), out Dictionary<int, SellPrice> value))
			{
				return value;
			}
			configuredQuality = 0;
			if (!prices.TryGetValue(Key(prefab, 0), out Dictionary<int, SellPrice> value2))
			{
				return null;
			}
			return value2;
		}

		private static string Key(string prefab, int quality)
		{
			return prefab + "|" + quality;
		}
	}
	public static class ServiceRules
	{
		public static bool RepairPrice(int basePrice, int quality, float durability, float maximum, float factor, out int price)
		{
			price = 0;
			if (basePrice <= 0 || quality <= 0 || float.IsNaN(durability) || float.IsInfinity(durability) || float.IsNaN(maximum) || float.IsInfinity(maximum) || maximum <= 0f || durability < 0f || durability >= maximum || float.IsNaN(factor) || float.IsInfinity(factor) || factor < 0f)
			{
				return false;
			}
			double num = Math.Ceiling((double)basePrice * (double)quality * (double)((maximum - durability) / maximum) * (double)factor);
			if (num > 2147483647.0)
			{
				return false;
			}
			price = Math.Max(1, (int)num);
			return true;
		}
	}
	public static class TradeAmounts
	{
		public const int MaximumSliderLots = 16777216;

		public static bool TryGetItemCount(int lotSize, int lots, out int amount)
		{
			long num = (long)lotSize * (long)lots;
			amount = 0;
			if (lotSize <= 0 || lots <= 0 || num > int.MaxValue)
			{
				return false;
			}
			amount = (int)num;
			return true;
		}

		public static bool TryGetPrice(int pricePerLot, int lots, float factor, out int price, bool roundUp = true)
		{
			return TryGetPrice(pricePerLot, lots, Math.Round(factor, 2), out price, roundUp);
		}

		public static bool TryGetPrice(int pricePerLot, int lots, double factor, out int price, bool roundUp = true)
		{
			price = 0;
			if (pricePerLot <= 0 || lots <= 0 || double.IsNaN(factor) || double.IsInfinity(factor) || factor < 0.0 || factor > 2147483647.0)
			{
				return false;
			}
			decimal d = (decimal)pricePerLot * (decimal)lots * ToDecimal(factor);
			decimal num = Math.Max(roundUp ? decimal.Ceiling(d) : decimal.Floor(d), 1m);
			if (num > 2147483647m)
			{
				return false;
			}
			price = (int)num;
			return true;
		}

		public static bool TryGetQualityPrice(int basePrice, int quality, float multiplier, out int price)
		{
			price = 0;
			if (basePrice <= 0 || quality <= 0 || float.IsNaN(multiplier) || float.IsInfinity(multiplier) || Math.Abs((double)multiplier) > 2147483647.0)
			{
				return false;
			}
			decimal num = (decimal)basePrice * (1m + ToDecimal(multiplier) * (decimal)((long)quality - 1L));
			if (num < 1m || num > 2147483647m)
			{
				return false;
			}
			price = (int)num;
			return true;
		}

		public static decimal ToDecimal(double value)
		{
			if (double.IsNaN(value) || double.IsInfinity(value) || Math.Abs(value) < 1E-09)
			{
				return 0m;
			}
			return decimal.Parse(value.ToString("R", CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture);
		}

		public static decimal ToDecimal(float value)
		{
			if (float.IsNaN(value) || float.IsInfinity(value) || Math.Abs(value) < 1E-09f)
			{
				return 0m;
			}
			return decimal.Parse(value.ToString("R", CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture);
		}

		public static int MaximumBuyLots(int lotSize, int pricePerLot, int currency, int capacity)
		{
			if (lotSize <= 0 || pricePerLot <= 0 || currency <= 0 || capacity <= 0)
			{
				return 0;
			}
			return Math.Min(16777216, Math.Min(capacity / lotSize, currency / pricePerLot));
		}

		public static int MaximumSellLots(int lotSize, int pricePerLot, int availableItems, float factor, int budget)
		{
			return MaximumSellLots(lotSize, pricePerLot, availableItems, Math.Round(factor, 2), budget);
		}

		public static int MaximumSellLots(int lotSize, int pricePerLot, int availableItems, double factor, int budget)
		{
			if (lotSize <= 0 || pricePerLot <= 0 || availableItems <= 0 || budget <= 0)
			{
				return 0;
			}
			int num = 0;
			int num2 = Math.Min(16777216, availableItems / lotSize);
			while (num < num2)
			{
				int num3 = num + (num2 - num + 1) / 2;
				if (TryGetPrice(pricePerLot, num3, factor, out var price, roundUp: false) && price <= budget)
				{
					num = num3;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return num;
		}

		public static bool TryEncodeStack(int stack, int quality, int multiplier, out int encoded)
		{
			encoded = 0;
			long num = stack + (long)multiplier * (long)quality;
			if (multiplier <= 1 || stack <= 0 || stack >= multiplier || quality < 0 || num > int.MaxValue)
			{
				return false;
			}
			encoded = (int)num;
			return true;
		}

		public static bool TryEncodeStack(int stack, int quality, out int encoded)
		{
			return TryEncodeStack(stack, quality, 1000000, out encoded);
		}

		public static void DecodeStack(int encoded, out int stack, out int quality)
		{
			stack = encoded % 1000000;
			quality = encoded / 1000000;
		}

		public static int ClampBalance(long amount)
		{
			return (int)Math.Max(0L, Math.Min(2147483647L, amount));
		}
	}
	public sealed class JournalEntry
	{
		public string Token = "";

		public string Actor = "";

		public string BeforeInventory = "";

		public string AfterInventory = "";

		public long World;

		public byte Phase;

		public bool Consumed;

		public byte[] Request = Array.Empty<byte>();
	}
	public sealed class TradeJournal
	{
		private readonly string directory;

		public TradeJournal(string directory)
		{
			this.directory = Path.GetFullPath(directory);
		}

		private string PathFor(string token)
		{
			if (!Guid.TryParseExact(token, "N", out var _))
			{
				throw new InvalidDataException("Invalid receipt token");
			}
			return Path.Combine(directory, token + ".receipt");
		}

		public void Save(JournalEntry entry)
		{
			if (entry == null || entry.World == 0L || entry.Actor.Length == 0 || entry.Actor.Length > 128 || entry.Phase > 3 || entry.Request.Length > 98304 || entry.BeforeInventory.Length > 2097152 || entry.AfterInventory.Length > 2097152)
			{
				throw new InvalidDataException("Invalid journal entry");
			}
			string text = PathFor(entry.Token);
			Directory.CreateDirectory(directory);
			if (!File.Exists(text))
			{
				int num = 0;
				foreach (JournalEntry item in Read())
				{
					if (item.World == entry.World && ++num >= 256)
					{
						throw new InvalidDataException("Journal receipt bound");
					}
				}
			}
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
				binaryWriter.Write(3);
				binaryWriter.Write(entry.Token);
				binaryWriter.Write(entry.World);
				binaryWriter.Write(entry.Actor);
				binaryWriter.Write(entry.Phase);
				binaryWriter.Write(entry.Request.Length);
				binaryWriter.Write(entry.Request);
				binaryWriter.Write(entry.BeforeInventory);
				binaryWriter.Write(entry.AfterInventory);
				binaryWriter.Write(entry.Consumed);
				array = memoryStream.ToArray();
			}
			string text2 = text + ".pending";
			using (FileStream fileStream = new FileStream(text2, FileMode.Create, FileAccess.Write, FileShare.None))
			{
				using (SHA256 sHA = SHA256.Create())
				{
					byte[] array2 = sHA.ComputeHash(array);
					fileStream.Write(array2, 0, array2.Length);
				}
				fileStream.Write(array, 0, array.Length);
				fileStream.Flush(flushToDisk: true);
			}
			if (File.Exists(text))
			{
				File.Replace(text2, text, null);
			}
			else
			{
				File.Move(text2, text);
			}
		}

		public IReadOnlyList<JournalEntry> Read()
		{
			List<JournalEntry> list = new List<JournalEntry>();
			if (!Directory.Exists(directory))
			{
				return list;
			}
			using (IEnumerator<string> enumerator = Directory.EnumerateFiles(directory, "*.pending").GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					_ = enumerator.Current;
					throw new InvalidDataException("Incomplete journal write");
				}
			}
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			Dictionary<long, long> dictionary2 = new Dictionary<long, long>();
			foreach (string item in Directory.EnumerateFiles(directory, "*.receipt"))
			{
				long length = new FileInfo(item).Length;
				if (length < 40 || length > 4400000)
				{
					throw new InvalidDataException("Journal size");
				}
				byte[] array = File.ReadAllBytes(item);
				if (array.Length < 40 || array.Length > 4400000)
				{
					throw new InvalidDataException("Journal size");
				}
				byte[] array2 = new byte[array.Length - 32];
				Buffer.BlockCopy(array, 32, array2, 0, array2.Length);
				using (SHA256 sHA = SHA256.Create())
				{
					byte[] array3 = sHA.ComputeHash(array2);
					for (int i = 0; i < 32; i++)
					{
						if (array3[i] != array[i])
						{
							throw new InvalidDataException("Journal checksum");
						}
					}
				}
				using MemoryStream memoryStream = new MemoryStream(array2);
				using BinaryReader binaryReader = new BinaryReader(memoryStream);
				int num = binaryReader.ReadInt32();
				if (num < 1 || num > 3)
				{
					throw new InvalidDataException("Journal version");
				}
				JournalEntry journalEntry = new JournalEntry
				{
					Token = binaryReader.ReadString(),
					World = binaryReader.ReadInt64(),
					Actor = binaryReader.ReadString(),
					Phase = binaryReader.ReadByte()
				};
				int num2 = binaryReader.ReadInt32();
				if (num2 < 0 || num2 > 98304)
				{
					throw new InvalidDataException("Journal request");
				}
				journalEntry.Request = binaryReader.ReadBytes(num2);
				journalEntry.BeforeInventory = binaryReader.ReadString();
				if (num >= 2)
				{
					journalEntry.AfterInventory = binaryReader.ReadString();
				}
				journalEntry.Consumed = ((num >= 3) ? binaryReader.ReadBoolean() : (journalEntry.Phase == 2));
				if (journalEntry.Request.Length != num2 || memoryStream.Position != memoryStream.Length || journalEntry.Actor.Length == 0 || journalEntry.Actor.Length > 128 || journalEntry.World == 0L || journalEntry.Phase > 3 || journalEntry.BeforeInventory.Length > 2097152 || journalEntry.AfterInventory.Length > 2097152 || !string.Equals(item, PathFor(journalEntry.Token), StringComparison.OrdinalIgnoreCase))
				{
					throw new InvalidDataException("Journal identity");
				}
				dictionary.TryGetValue(journalEntry.World, out var value);
				dictionary2.TryGetValue(journalEntry.World, out var value2);
				if (++value > 256 || (value2 += length) > 67108864)
				{
					throw new InvalidDataException("Journal world bound");
				}
				dictionary[journalEntry.World] = value;
				dictionary2[journalEntry.World] = value2;
				list.Add(journalEntry);
			}
			return list;
		}

		public void Remove(string token, bool characterSaved = false)
		{
			if (!characterSaved)
			{
				foreach (JournalEntry item in Read())
				{
					if (item.Token == token && (item.Phase == 1 || item.Phase == 2))
					{
						throw new InvalidOperationException("Character-save proof required before discarding inventory evidence");
					}
				}
			}
			File.Delete(PathFor(token));
		}
	}
	public static class TradeQuoteRules
	{
		public static bool BuyMatches(IEnumerable<TradeEntry> entries, ITradeContext context, DiscoveryRule discovery, bool personalStateAvailable, string prefab, int amount, int quality, int price, string currency, int defaultQuality, float factor, Func<string, string?> resolveCurrency)
		{
			if (amount <= 0 || quality <= 0 || price <= 0 || string.IsNullOrEmpty(currency))
			{
				return false;
			}
			int price2;
			return entries.Any((TradeEntry entry) => entry.Prefab == prefab && entry.Stack == amount && ((entry.Quality > 0) ? entry.Quality : defaultQuality) == quality && (personalStateAvailable || !NeedsPersonalKeys(entry)) && EntryAvailability.CanOffer(entry, context, discovery) && resolveCurrency(entry.Currency) == currency && TradeAmounts.TryGetPrice(entry.Price, 1, factor, out price2) && price2 == price);
		}

		public static bool SellMatches(IEnumerable<TradeEntry> entries, ITradeContext context, bool personalStateAvailable, string prefab, int amount, int quality, int lotSize, int maxStack, int price, string currency, float factor, float qualityMultiplier, Func<string, string?> resolveCurrency)
		{
			if (amount <= 0 || quality <= 0 || lotSize <= 0 || maxStack <= 0 || price <= 0 || string.IsNullOrEmpty(currency))
			{
				return false;
			}
			SellPriceTable table = SellPriceTable.Build(entries.Where((TradeEntry entry) => personalStateAvailable || !NeedsPersonalKeys(entry)), context);
			return SellPlanner.Plan(new HeldItem[1]
			{
				new HeldItem(new object(), prefab, amount, quality, maxStack)
			}, table, new SellSettings(factor, qualityMultiplier), resolveCurrency).Any((SellOffer offer) => offer.Stack == lotSize && offer.Price == price && offer.Currency == currency && ((offer.Kind != SellKind.Single) ? ((offer.Kind != SellKind.Stack) ? (amount == offer.Amount) : (amount == offer.Stack)) : (amount == 1)));
		}

		private static bool NeedsPersonalKeys(TradeEntry entry)
		{
			if (TradeEntry.SplitKeys(entry.RequiredPlayerKey).Count == 0)
			{
				return TradeEntry.SplitKeys(entry.NotRequiredPlayerKey).Count != 0;
			}
			return true;
		}
	}
	public sealed class TradeRecovery
	{
		private readonly long world;

		private readonly string actor;

		private bool awaitingReservation = true;

		private bool inFlight;

		private double retryAt;

		public bool? Outcome { get; private set; } = false;

		public bool Done { get; private set; }

		public TradeRecovery(long world, string actor)
		{
			if (world == 0L || string.IsNullOrEmpty(actor))
			{
				throw new ArgumentException("Missing recovery identity.");
			}
			this.world = world;
			this.actor = actor;
		}

		public void ReservationEnded()
		{
			awaitingReservation = false;
		}

		public void InventoryStarting()
		{
			awaitingReservation = false;
			Outcome = null;
		}

		public void InventoryFinished(bool success)
		{
			awaitingReservation = false;
			Outcome = success;
		}

		public bool TryDispatch(long currentWorld, string currentActor, double now)
		{
			if (Done || awaitingReservation || inFlight || !Outcome.HasValue || currentWorld != world || currentActor != actor || now < retryAt)
			{
				return false;
			}
			inFlight = true;
			retryAt = now + 2.0;
			return true;
		}

		public void Reply(bool acknowledged)
		{
			inFlight = false;
			Done |= acknowledged;
		}

		public void Suspend()
		{
			awaitingReservation = false;
			inFlight = false;
		}

		public static bool CanConfirm(JournalEntry entry, string loadedInventory)
		{
			if (entry.Phase == 2 && entry.AfterInventory.Length > 0)
			{
				return entry.AfterInventory == loadedInventory;
			}
			return false;
		}
	}
}
namespace ExtraPotions.Barter.Pricing
{
	public static class PriceCurve
	{
		public static float BuyFactor(int balance, PurseRules rules)
		{
			if (!rules.Enabled || !rules.Flexible)
			{
				return 1f;
			}
			rules.Range(out var minimum, out var maximum);
			if (balance < minimum)
			{
				float t = ((minimum > 0) ? Clamp01((float)balance / (float)minimum) : 1f);
				return RoundToPercent(Lerp(rules.Markup, 1f, t));
			}
			float t2 = Clamp01((float)(balance - minimum) / (float)Math.Max(maximum - minimum, 1));
			return RoundToPercent(Lerp(1f, rules.Discount, t2));
		}

		public static float SellFactor(int balance, PurseRules rules)
		{
			if (!rules.Enabled || !rules.Flexible)
			{
				return 1f;
			}
			rules.Range(out var minimum, out var maximum);
			if (balance < minimum)
			{
				float t = ((minimum > 0) ? Clamp01((float)balance / (float)minimum) : 1f);
				return RoundToPercent(Lerp(rules.Discount, 1f, t));
			}
			float t2 = Clamp01((float)(balance - minimum) / (float)Math.Max(maximum - minimum, 1));
			return RoundToPercent(Lerp(1f, rules.Markup, t2));
		}

		public static float RoundToPercent(float factor)
		{
			if (float.IsNaN(factor) || float.IsInfinity(factor) || factor < 0f)
			{
				return 1f;
			}
			return (float)(Math.Round((double)factor * 100.0) / 100.0);
		}

		public static string Describe(float factor, bool reversed, out bool favourable)
		{
			favourable = true;
			if (factor == 1f)
			{
				return string.Empty;
			}
			favourable = (reversed && factor < 1f) || (!reversed && factor > 1f);
			double num = (factor - 1f) * 100f;
			return ((num >= 0.0) ? "+" : "-") + Math.Abs(Math.Round(num)).ToString("0", CultureInfo.InvariantCulture);
		}

		private static float Clamp01(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}

		private static float Lerp(float a, float b, float t)
		{
			return a + (b - a) * Clamp01(t);
		}
	}
	public static class PurseRefill
	{
		public static int Initial(PurseRules rules)
		{
			rules.Range(out var minimum, out var _);
			return minimum;
		}

		public static bool TryReplenish(int current, int lastDay, int today, PurseRules rules, out int next)
		{
			next = current;
			if (today - lastDay < Math.Max(rules.ReplenishDays, 1))
			{
				return false;
			}
			rules.Range(out var minimum, out var maximum);
			if (current >= maximum && rules.DailyDecrease <= 0)
			{
				return false;
			}
			next = ((current >= maximum) ? Math.Max(maximum, current - Math.Max(rules.DailyDecrease, 0)) : Math.Max(minimum, Math.Min(maximum, TradeAmounts.ClampBalance((long)current + (long)rules.DailyIncrease))));
			return true;
		}
	}
	public sealed class PurseRules
	{
		public bool Enabled { get; set; }

		public bool Flexible { get; set; }

		public int Minimum { get; set; }

		public int Maximum { get; set; }

		public int DailyIncrease { get; set; }

		public int DailyDecrease { get; set; }

		public float Discount { get; set; }

		public float Markup { get; set; }

		public int ReplenishDays { get; set; }

		public static PurseRules Defaults()
		{
			return new PurseRules
			{
				Enabled = BarterSettings.Purse.Enabled.Default,
				Flexible = BarterSettings.Purse.FlexiblePricing.Default,
				Minimum = BarterSettings.Purse.MinimumBalance.Default,
				Maximum = BarterSettings.Purse.MaximumBalance.Default,
				DailyIncrease = BarterSettings.Purse.DailyIncrease.Default,
				DailyDecrease = BarterSettings.Purse.DailyDecrease.Default,
				Discount = BarterSettings.Purse.Discount.Default,
				Markup = BarterSettings.Purse.Markup.Default,
				ReplenishDays = BarterSettings.Purse.ReplenishDays.Default
			};
		}

		internal void Range(out int minimum, out int maximum)
		{
			minimum = Math.Max(Minimum, 0);
			maximum = Math.Max(Maximum, minimum);
		}
	}
}
namespace ExtraPotions.Barter.Lists
{
	public static class ListEditRules
	{
		public static string Revision(IReadOnlyDictionary<string, string> files)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
			using SHA256 sHA = SHA256.Create();
			foreach (KeyValuePair<string, string> item in files.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> p) => p.Key, StringComparer.Ordinal))
			{
				binaryWriter.Write(item.Key);
				binaryWriter.Write(item.Value);
			}
			binaryWriter.Flush();
			return Convert.ToBase64String(sHA.ComputeHash(memoryStream.ToArray()));
		}

		public static string OwnedPath(string root, string relative)
		{
			if (string.IsNullOrWhiteSpace(relative) || relative.Contains("..") || relative.Contains("\\") || Path.IsPathRooted(relative))
			{
				throw new ArgumentException("Invalid list path.");
			}
			string text = Path.GetFullPath(root).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
			string fullPath = Path.GetFullPath(Path.Combine(text, relative.Replace('/', Path.DirectorySeparatorChar)));
			if (!fullPath.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("List outside config root.");
			}
			string text2 = fullPath;
			while (text2 != null && text2.Length >= text.TrimEnd(Path.DirectorySeparatorChar).Length)
			{
				if ((File.Exists(text2) || Directory.Exists(text2)) && (File.GetAttributes(text2) & FileAttributes.ReparsePoint) != FileAttributes.None)
				{
					throw new IOException("Linked config paths cannot be edited.");
				}
				text2 = Path.GetDirectoryName(text2);
			}
			return fullPath;
		}

		public static bool AtomicReplace(string path, string expected, string replacement)
		{
			if (!File.Exists(path) || File.ReadAllText(path) != expected)
			{
				return false;
			}
			string text = path + ".barter-edit-" + Guid.NewGuid().ToString("N");
			string destinationBackupFileName = path + ".barter-backup-" + Guid.NewGuid().ToString("N");
			try
			{
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					byte[] bytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(replacement);
					fileStream.Write(bytes, 0, bytes.Length);
					fileStream.Flush(flushToDisk: true);
				}
				if (File.ReadAllText(path) != expected)
				{
					return false;
				}
				File.Replace(text, path, destinationBackupFileName);
				return true;
			}
			finally
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
		}
	}
	public sealed class ListFileName
	{
		public string FileName { get; }

		public string Trader { get; }

		public ListKind Kind { get; }

		public string Identifier { get; }

		public ListFormat Format { get; }

		public string ListKey => TraderNames.ListKey(Trader, Kind);

		private ListFileName(string fileName, string trader, ListKind kind, string identifier, ListFormat format)
		{
			FileName = fileName;
			Trader = trader;
			Kind = kind;
			Identifier = identifier;
			Format = format;
		}

		public static bool IsSupportedExtension(string? extension)
		{
			if (!string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase) && !string.Equals(extension, ".yaml", StringComparison.OrdinalIgnoreCase) && !string.Equals(extension, ".yml", StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(extension, ".csv", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		public static bool TryParse(string? fileName, out ListFileName? parsed, bool allowUnprefixed = false)
		{
			parsed = null;
			if (string.IsNullOrWhiteSpace(fileName))
			{
				return false;
			}
			string fileName2 = Path.GetFileName(fileName);
			string extension = Path.GetExtension(fileName2);
			if (!IsSupportedExtension(extension))
			{
				return false;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName2);
			bool flag = fileNameWithoutExtension.StartsWith("Barter.", StringComparison.OrdinalIgnoreCase);
			if (!flag && !allowUnprefixed)
			{
				return false;
			}
			string[] array = (flag ? fileNameWithoutExtension.Substring("Barter.".Length) : fileNameWithoutExtension).Split('.');
			int num = 1;
			while (num < array.Length)
			{
				ListKind kind;
				if (string.Equals(array[num], "Buy", StringComparison.OrdinalIgnoreCase))
				{
					kind = ListKind.Buy;
				}
				else
				{
					if (!string.Equals(array[num], "Sell", StringComparison.OrdinalIgnoreCase))
					{
						num++;
						continue;
					}
					kind = ListKind.Sell;
				}
				string text = TraderNames.Normalize(string.Join(".", array.Take(num)));
				if (text.Length == 0)
				{
					return false;
				}
				string identifier = string.Join(".", array.Skip(num + 1));
				ListFormat format = (string.Equals(extension, ".csv", StringComparison.OrdinalIgnoreCase) ? ListFormat.Csv : (string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase) ? ListFormat.Json : ListFormat.Yaml));
				parsed = new ListFileName(fileName2, text, kind, identifier, format);
				return true;
			}
			return false;
		}

		public static IEnumerable<ListSourceFile> Order(IEnumerable<ListSourceFile> files)
		{
			return files.OrderBy((ListSourceFile file) => (!file.Embedded) ? 1 : 0).ThenBy<ListSourceFile, string>((ListSourceFile file) => file.FileName, StringComparer.OrdinalIgnoreCase).ThenBy<ListSourceFile, string>((ListSourceFile file) => file.FileName, StringComparer.Ordinal);
		}
	}
	public sealed class ListSourceFile
	{
		public string FileName { get; }

		public bool Embedded { get; }

		public ListSourceFile(string fileName, bool embedded)
		{
			FileName = fileName ?? throw new ArgumentNullException("fileName");
			Embedded = embedded;
		}
	}
	public enum ListKind
	{
		Buy,
		Sell
	}
	public enum ListFormat
	{
		Yaml,
		Json,
		Csv
	}
	public sealed class ListContribution
	{
		public ListFileName Name { get; }

		public IReadOnlyList<TradeEntry> Entries { get; }

		public string SourceName { get; }

		public bool Embedded { get; }

		public ListContribution(ListFileName name, IReadOnlyList<TradeEntry> entries, string? sourceName = null, bool embedded = false)
		{
			Name = name ?? throw new ArgumentNullException("name");
			Entries = entries ?? throw new ArgumentNullException("entries");
			SourceName = (string.IsNullOrEmpty(sourceName) ? name.FileName : sourceName);
			Embedded = embedded;
		}
	}
	public sealed class TradeBook
	{
		private static readonly IReadOnlyList<TradeEntry> None = Array.Empty<TradeEntry>();

		private readonly Dictionary<string, List<TradeEntry>> lists;

		public static TradeBook Empty { get; } = new TradeBook(new Dictionary<string, List<TradeEntry>>(StringComparer.OrdinalIgnoreCase));

		public long Revision { get; }

		public IReadOnlyList<string> Traders => (from key in lists.Keys
			select key.Substring(0, key.LastIndexOf('.')) into trader
			where !TraderNames.IsCommon(trader)
			select trader).Distinct<string>(StringComparer.OrdinalIgnoreCase).OrderBy<string, string>((string trader) => trader, StringComparer.Ordinal).ToList();

		private TradeBook(Dictionary<string, List<TradeEntry>> lists)
		{
			this.lists = lists;
			Revision = ComputeRevision(lists);
		}

		public static TradeBook Build(IEnumerable<ListContribution> files)
		{
			Dictionary<string, List<TradeEntry>> dictionary = new Dictionary<string, List<TradeEntry>>(StringComparer.OrdinalIgnoreCase);
			foreach (ListContribution item in files.OrderBy((ListContribution file) => (!file.Embedded) ? 1 : 0).ThenBy<ListContribution, string>((ListContribution file) => file.SourceName, StringComparer.OrdinalIgnoreCase).ThenBy<ListContribution, string>((ListContribution file) => file.SourceName, StringComparer.Ordinal))
			{
				string listKey = item.Name.ListKey;
				if (!dictionary.TryGetValue(listKey, out var value))
				{
					value = new List<TradeEntry>();
					dictionary.Add(listKey, value);
				}
				value.AddRange(item.Entries.Select((TradeEntry entry) => entry.Clone()));
			}
			return new TradeBook(dictionary);
		}

		public TradeBook WithAutomatic(IEnumerable<TradeEntry> automatic)
		{
			Dictionary<string, List<TradeEntry>> dictionary = lists.ToDictionary<KeyValuePair<string, List<TradeEntry>>, string, List<TradeEntry>>((KeyValuePair<string, List<TradeEntry>> pair) => pair.Key, (KeyValuePair<string, List<TradeEntry>> pair) => pair.Value.Select((TradeEntry entry) => entry.Clone()).ToList(), StringComparer.OrdinalIgnoreCase);
			string key = TraderNames.CommonKey(ListKind.Sell);
			if (!dictionary.TryGetValue(key, out var value))
			{
				value = new List<TradeEntry>();
				dictionary.Add(key, value);
			}
			value.AddRange(automatic.Select(delegate(TradeEntry entry)
			{
				TradeEntry tradeEntry = entry.Clone();
				tradeEntry.Automatic = true;
				return tradeEntry;
			}));
			return new TradeBook(dictionary);
		}

		public IReadOnlyList<TradeEntry> Buy(string? trader)
		{
			return Combined(trader, ListKind.Buy, includeAutomatic: true);
		}

		public IReadOnlyList<TradeEntry> Sell(string? trader, bool includeAutomatic = true)
		{
			return Combined(trader, ListKind.Sell, includeAutomatic);
		}

		private IReadOnlyList<TradeEntry> Combined(string? trader, ListKind kind, bool includeAutomatic)
		{
			List<TradeEntry> list = new List<TradeEntry>();
			if (lists.TryGetValue(TraderNames.CommonKey(kind), out List<TradeEntry> value))
			{
				list.AddRange(value.Where((TradeEntry entry) => includeAutomatic || !entry.Automatic));
			}
			if (!TraderNames.IsCommon(trader) && lists.TryGetValue(TraderNames.ListKey(trader, kind), out List<TradeEntry> value2))
			{
				list.AddRange(value2.Where((TradeEntry entry) => includeAutomatic || !entry.Automatic));
			}
			if (list.Count != 0)
			{
				return list;
			}
			return None;
		}

		private static long ComputeRevision(Dictionary<string, List<TradeEntry>> lists)
		{
			ulong hash = 14695981039346656037uL;
			foreach (string item in lists.Keys.OrderBy<string, string>((string k) => k, StringComparer.OrdinalIgnoreCase))
			{
				Mix(item.ToLowerInvariant());
				foreach (TradeEntry item2 in lists[item])
				{
					Mix(item2.Prefab);
					Mix(item2.Stack.ToString());
					Mix(item2.Price.ToString());
					Mix(item2.Quality.ToString());
					Mix(item2.Currency);
					Mix(item2.RequiredGlobalKey);
					Mix(item2.NotRequiredGlobalKey);
					Mix(item2.RequiredPlayerKey);
					Mix(item2.NotRequiredPlayerKey);
					Mix(item2.Automatic ? "1" : "0");
				}
			}
			return (long)hash;
			void Mix(string text)
			{
				foreach (char c in text)
				{
					hash ^= c;
					hash *= 1099511628211uL;
				}
				hash ^= 31uL;
				hash *= 1099511628211uL;
			}
		}
	}
	public static class CommonValuables
	{
		public static List<TradeEntry> Build(IEnumerable<(string Prefab, int Value)> items, IEnumerable<string> alreadyListed, string currencyPrefab)
		{
			HashSet<string> hashSet = new HashSet<string>(alreadyListed ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase);
			List<TradeEntry> list = new List<TradeEntry>();
			foreach (var (text, num) in items)
			{
				if (!string.IsNullOrWhiteSpace(text) && num > 0 && !string.Equals(text, "Coins", StringComparison.OrdinalIgnoreCase) && !string.Equals(text, currencyPrefab, StringComparison.OrdinalIgnoreCase) && hashSet.Add(text))
				{
					list.Add(new TradeEntry
					{
						Prefab = text,
						Price = num,
						Stack = 1,
						Automatic = true
					});
				}
			}
			return list;
		}
	}
	public sealed class TradeEntry
	{
		public string Prefab { get; set; } = string.Empty;

		public int Stack { get; set; } = 1;

		public int Price { get; set; } = 1;

		public int Quality { get; set; }

		public string Currency { get; set; } = string.Empty;

		public string RequiredGlobalKey { get; set; } = string.Empty;

		public string NotRequiredGlobalKey { get; set; } = string.Empty;

		public string RequiredPlayerKey { get; set; } = string.Empty;

		public string NotRequiredPlayerKey { get; set; } = string.Empty;

		public bool Automatic { get; set; }

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(Prefab))
			{
				list.Add("prefab is empty");
			}
			int encoded;
			if (Price <= 0)
			{
				encoded = Price;
				list.Add("price must be above 0, found " + encoded);
			}
			if (Stack <= 0 || Stack >= 1000000)
			{
				string text = 999999.ToString();
				encoded = Stack;
				list.Add("stack must be from 1 to " + text + ", found " + encoded);
			}
			if (Quality < 0)
			{
				list.Add("quality must not be negative, found " + Quality);
			}
			else if (Stack > 0 && Stack < 1000000 && !TradeAmounts.TryEncodeStack(Stack, Quality, out encoded))
			{
				list.Add("quality " + Quality + " is too large to combine with stack " + Stack);
			}
			return list;
		}

		public static IReadOnlyList<string> SplitKeys(string? value)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(value))
			{
				return list;
			}
			string[] array = value.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					list.Add(text);
				}
			}
			return list;
		}

		public TradeEntry Clone()
		{
			return new TradeEntry
			{
				Prefab = Prefab,
				Stack = Stack,
				Price = Price,
				Quality = Quality,
				Currency = Currency,
				RequiredGlobalKey = RequiredGlobalKey,
				NotRequiredGlobalKey = NotRequiredGlobalKey,
				RequiredPlayerKey = RequiredPlayerKey,
				NotRequiredPlayerKey = NotRequiredPlayerKey,
				Automatic = Automatic
			};
		}
	}
	public sealed class ListReadResult
	{
		public List<TradeEntry> Entries { get; } = new List<TradeEntry>();

		public List<string> Errors { get; } = new List<string>();

		public List<string> Warnings { get; } = new List<string>();

		public bool Ok => Errors.Count == 0;
	}
	public static class TradeListReader
	{
		private static readonly string[] Fields = new string[9] { "prefab", "stack", "price", "quality", "currency", "requiredGlobalKey", "notRequiredGlobalKey", "requiredPlayerKey", "notRequiredPlayerKey" };

		public static ListReadResult FromRows(IEnumerable<IReadOnlyDictionary<string, string>>? rows, string source)
		{
			ListReadResult listReadResult = new ListReadResult();
			if (rows == null)
			{
				return listReadResult;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			int num = 0;
			foreach (IReadOnlyDictionary<string, string> row in rows)
			{
				num++;
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				foreach (KeyValuePair<string, string> item in row)
				{
					if (item.Key == null)
					{
						continue;
					}
					if (!Fields.Contains<string>(item.Key, StringComparer.OrdinalIgnoreCase))
					{
						if (hashSet.Add(item.Key))
						{
							listReadResult.Warnings.Add("Ignored unknown field '" + item.Key + "' in '" + source + "'.");
						}
					}
					else
					{
						dictionary[item.Key] = item.Value ?? string.Empty;
					}
				}
				TradeEntry tradeEntry = new TradeEntry();
				try
				{
					tradeEntry.Prefab = Text(dictionary, "prefab");
					tradeEntry.Stack = Number(dictionary, "stack", tradeEntry.Stack, source, num);
					tradeEntry.Price = Number(dictionary, "price", tradeEntry.Price, source, num);
					tradeEntry.Quality = Number(dictionary, "quality", tradeEntry.Quality, source, num);
				}
				catch (FormatException ex)
				{
					listReadResult.Errors.Add(ex.Message);
					continue;
				}
				tradeEntry.Currency = Text(dictionary, "currency");
				tradeEntry.RequiredGlobalKey = Text(dictionary, "requiredGlobalKey");
				tradeEntry.NotRequiredGlobalKey = Text(dictionary, "notRequiredGlobalKey");
				tradeEntry.RequiredPlayerKey = Text(dictionary, "requiredPlayerKey");
				tradeEntry.NotRequiredPlayerKey = Text(dictionary, "notRequiredPlayerKey");
				if (string.IsNullOrWhiteSpace(tradeEntry.Prefab))
				{
					listReadResult.Warnings.Add($"Skipped row {num} of '{source}': it has no prefab.");
					continue;
				}
				IReadOnlyList<string> readOnlyList = tradeEntry.Validate();
				if (readOnlyList.Count > 0)
				{
					listReadResult.Warnings.Add(string.Format("Skipped row {0} of '{1}' ({2}): {3}.", num, source, tradeEntry.Prefab, string.Join("; ", readOnlyList)));
				}
				else
				{
					listReadResult.Entries.Add(tradeEntry);
				}
			}
			return listReadResult;
		}

		public static ListReadResult FromCsv(string? content, string source)
		{
			try
			{
				List<List<string>> list = ParseCsvRecords(content ?? string.Empty);
				if (list.Count == 0)
				{
					return new ListReadResult();
				}
				string[] array = list[0].Select((string header, int index) => (index != 0) ? (header ?? string.Empty).Trim() : (header ?? string.Empty).TrimStart('\ufeff').Trim()).ToArray();
				if (!array.Any((string header) => string.Equals(header, "prefab", StringComparison.OrdinalIgnoreCase)))
				{
					throw new FormatException("CSV list '" + source + "' must contain the 'prefab' header.");
				}
				if (array.Where((string header) => header.Length > 0).GroupBy<string, string>((string header) => header, StringComparer.OrdinalIgnoreCase).Any((IGrouping<string, string> group) => group.Count() > 1))
				{
					throw new FormatException("CSV list '" + source + "' contains a duplicate column header.");
				}
				List<IReadOnlyDictionary<string, string>> list2 = new List<IReadOnlyDictionary<string, string>>();
				for (int num = 1; num < list.Count; num++)
				{
					List<string> list3 = list[num];
					if (list3.All(string.IsNullOrWhiteSpace))
					{
						continue;
					}
					if (list3.Skip(array.Length).Any((string value2) => !string.IsNullOrWhiteSpace(value2)))
					{
						throw new FormatException($"CSV row {num + 1} of '{source}' has more values than its header.");
					}
					Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
					for (int num2 = 0; num2 < array.Length; num2++)
					{
						if (array[num2].Length != 0)
						{
							string value = ((num2 < list3.Count) ? (list3[num2] ?? string.Empty) : string.Empty);
							dictionary[array[num2]] = value;
						}
					}
					list2.Add(dictionary);
				}
				return FromRows(list2, source);
			}
			catch (FormatException ex)
			{
				return new ListReadResult
				{
					Errors = { ex.Message }
				};
			}
		}

		private static string Text(Dictionary<string, string> row, string field)
		{
			if (!row.TryGetValue(field, out string value))
			{
				return string.Empty;
			}
			return (value ?? string.Empty).Trim();
		}

		private static int Number(Dictionary<string, string> row, string field, int fallback, string source, int rowNumber)
		{
			string text = Text(row, field);
			if (text.Length == 0)
			{
				return fallback;
			}
			if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			throw new FormatException($"Invalid integer '{text}' in row {rowNumber}, field '{field}' of '{source}'.");
		}

		internal static List<List<string>> ParseCsvRecords(string content)
		{
			List<List<string>> list = new List<List<string>>();
			List<string> list2 = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			bool flag2 = false;
			content = (content ?? string.Empty).TrimStart('\ufeff');
			for (int i = 0; i < content.Length; i++)
			{
				char c = content[i];
				if (flag)
				{
					if (c != '"')
					{
						stringBuilder.Append(c);
					}
					else if (i + 1 < content.Length && content[i + 1] == '"')
					{
						stringBuilder.Append('"');
						i++;
					}
					else
					{
						flag = false;
						flag2 = true;
					}
					continue;
				}
				switch (c)
				{
				case '\n':
				case '\r':
				case ',':
					list2.Add(stringBuilder.ToString());
					stringBuilder.Clear();
					flag2 = false;
					if (c != ',')
					{
						if (c == '\r' && i + 1 < content.Length && content[i + 1] == '\n')
						{
							i++;
						}
						list.Add(list2);
						list2 = new List<string>();
					}
					continue;
				case '"':
					if (stringBuilder.Length == 0 && !flag2)
					{
						flag = true;
						continue;
					}
					break;
				}
				if (flag2 || c == '"')
				{
					throw new FormatException("CSV contains unexpected text outside a quoted field.");
				}
				stringBuilder.Append(c);
			}
			if (flag)
			{
				throw new FormatException("CSV contains an unterminated quote in a quoted field.");
			}
			if (stringBuilder.Length > 0 || flag2 || list2.Count > 0)
			{
				list2.Add(stringBuilder.ToString());
				list.Add(list2);
			}
			return list;
		}
	}
	public static class TraderNames
	{
		public static readonly IReadOnlyList<string> Vanilla = new string[3] { "Haldor", "Hildir", "BogWitch" };

		public static string Normalize(string? name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return string.Empty;
			}
			return name.Trim().ToLowerInvariant().Replace("$npc_", string.Empty)
				.Replace("npc_", string.Empty);
		}

		public static string ListKey(string? trader, ListKind kind)
		{
			return Normalize(trader) + "." + kind;
		}

		public static string CommonKey(ListKind kind)
		{
			return ListKey("common", kind);
		}

		public static bool IsCommon(string? trader)
		{
			return string.Equals(Normalize(trader), "common", StringComparison.Ordinal);
		}

		public static IEnumerable<string> SplitList(string? value)
		{
			string[] array = (value ?? string.Empty).Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					yield return text;
				}
			}
		}

		public static bool ListContains(string? value, string? trader)
		{
			string b = Normalize(trader);
			foreach (string item in SplitList(value))
			{
				if (string.Equals(Normalize(item), b, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace ExtraPotions.Barter.Currency
{
	public static class CurrencyRules
	{
		public static string ForTrader(string? overrides, string? trader, out string? warning)
		{
			warning = null;
			if (string.IsNullOrWhiteSpace(overrides))
			{
				return string.Empty;
			}
			string text = overrides.Trim();
			if (text.IndexOf(':') < 0 && text.IndexOf('=') < 0 && text.IndexOf(',') < 0 && text.IndexOf(';') < 0 && text.IndexOf('\n') < 0 && text.IndexOf('\r') < 0)
			{
				warning = "Ignored invalid trader currency override '" + text + "'. Expected TraderPrefab:CurrencyPrefab.";
				return string.Empty;
			}
			string b = TraderNames.Normalize(trader);
			string[] array = text.Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				int num = text2.IndexOf(':');
				if (num < 0)
				{
					num = text2.IndexOf('=');
				}
				if (num > 0 && num < text2.Length - 1 && string.Equals(TraderNames.Normalize(text2.Substring(0, num)), b, StringComparison.OrdinalIgnoreCase))
				{
					return text2.Substring(num + 1).Trim();
				}
			}
			return string.Empty;
		}

		public static string Effective(string? entryCurrency, string? traderCurrency)
		{
			string text = (entryCurrency ?? string.Empty).Trim();
			if (text.Length <= 0)
			{
				return (traderCurrency ?? string.Empty).Trim();
			}
			return text;
		}

		public static bool IsVanilla(string? currency)
		{
			if (!string.IsNullOrWhiteSpace(currency))
			{
				return string.Equals(currency.Trim(), "Coins", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		public static string PrefabOrVanilla(string? currency)
		{
			if (!string.IsNullOrWhiteSpace(currency))
			{
				return currency.Trim();
			}
			return "Coins";
		}
	}
}
namespace ExtraPotions.Barter.Config
{
	public enum SettingScope
	{
		Local,
		ServerAuthoritative
	}
	public abstract class BarterSetting
	{
		public string Section { get; }

		public string Key { get; }

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

		public SettingScope Scope { get; }

		public string Description { get; }

		public abstract Type ValueType { get; }

		public abstract object DefaultValue { get; }

		public abstract object? Minimum { get; }

		public abstract object? Maximum { get; }

		private protected BarterSetting(string section, string key, SettingScope scope, string description)
		{
			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;
		}

		public abstract object NormalizeBoxed(object? value);

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

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

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

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

		public static BarterSetting<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 BarterSetting<string>(section, key, scope, description, defaultValue, null, normalize);
		}
	}
	public sealed class BarterSetting<T> : BarterSetting
	{
		private readonly Func<T, T> normalize;

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

		public T Default { get; }

		public override Type ValueType => typeof(T);

		public override object DefaultValue => Default;

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

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

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

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

		public override object NormalizeBoxed(object? value)
		{
			return (value is T value2) ? Normalize(value2) : Default;
		}
	}
	public static class BarterSettings
	{
		public static class Purse
		{
			public const string Section = "Trader Purse";

			public static readonly BarterSetting<bool> Enabled = BarterSetting.Toggle("Trader Purse", "Enabled", defaultValue: true, SettingScope.ServerAuthoritative, "Traders that have a Barter list (Haldor, Hildir and the Bog Witch with the shipped lists, Custom Traders, and any trader you write a list for) have a limited balance that goes down when they pay you and up when you buy, and refills each morning. Other mods' traders keep the game's prices.");

			public static readonly BarterSetting<bool> FlexiblePricing = BarterSetting.Toggle("Trader Purse", "Flexible Pricing", defaultValue: true, SettingScope.ServerAuthoritative, "Prices follow the trader's balance: a poor trader charges more and pays less, a rich one the opposite.");

			public static readonly BarterSetting<int> MinimumBalance = BarterSetting.Integer("Trader Purse", "Minimum Balance", 2000, 0, 1000000, SettingScope.ServerAuthoritative, "The balance a trader starts with and never refills below; prices are neutral at this balance.");

			public static readonly BarterSetting<int> MaximumBalance = BarterSetting.Integer("Trader Purse", "Maximum Balance", 6000, 0, 1000000, SettingScope.ServerAuthoritative, "The balance a trader refills up to; prices reach the discount and the markup at this balance.");

			public static readonly BarterSetting<int> DailyIncrease = BarterSetting.Integer("Trader Purse", "Daily Increase", 1000, 0, 1000000, SettingScope.ServerAuthoritative, "How much a trader's balance grows at each refill, up to the maximum.");

			public static readonly BarterSetting<int> DailyDecrease = BarterSetting.Integer("Trader Purse", "Daily Decrease", 0, 0, 1000000, SettingScope.ServerAuthoritative, "How much a balance above the maximum shrinks at each refill, down to the maximum.");

			public static readonly BarterSetting<float> Discount = BarterSetting.Number("Trader Purse", "Discount", 0.7f, 0f, 10f, SettingScope.ServerAuthoritative, "The price you pay at the maximum balance, as a factor (0.7 is 30 percent off); also what an empty purse pays you.");

			public static readonly BarterSetting<float> Markup = BarterSetting.Number("Trader Purse", "Markup", 1.5f, 0f, 10f, SettingScope.ServerAuthoritative, "The price you pay at an empty purse, as a factor (1.5 is 50 percent more); also what a full purse pays you.");

			public static readonly BarterSetting<int> ReplenishDays = BarterSetting.Integer("Trader Purse", "Replenish Days", 1, 1, 365, SettingScope.ServerAuthoritative, "How many in-game days pass between refills of a trader's balance.");

			public static readonly BarterSetting<bool> ReplenishMessage = BarterSetting.Toggle("Trader Purse", "Replenish Message", defaultValue: true, SettingScope.ServerAuthoritative, "Tell everyone in the morning when trader balances were refilled.");
		}

		public static class Lists
		{
			public const string Section = "Trade Lists";

			public static readonly BarterSetting<bool> SellOnlyDiscovered = BarterSetting.Toggle("Trade Lists", "Sell Only Discovered", defaultValue: true, SettingScope.ServerAuthoritative, "A trader does not offer items you have not discovered yet.");

			public static readonly BarterSetting<string> AlwaysOffered = BarterSetting.Text("Trade Lists", "Always Offered", "", SettingScope.ServerAuthoritative, "Comma list of item prefabs a trader offers even when you have not discovered them. Items the game's own traders sell are always included.", Trim);

			public static readonly BarterSetting<bool> DisableVanillaItems = BarterSetting.Toggle("Trade Lists", "Disable Vanilla Items", defaultValue: false, SettingScope.ServerAuthoritative, "Remove the game's own items from trader buy lists, so only Barter's lists remain. Progress purchases such as inventory rows stay.");

			public static readonly BarterSetting<bool> DisableOtherModsItems = BarterSetting.Toggle("Trade Lists", "Disable Other Mods Items", defaultValue: false, SettingScope.ServerAuthoritative, "Remove items other mods added to trader buy lists before Barter adds its own.");

			public static readonly BarterSetting<float> QualityPriceMultiplier = BarterSetting.Number("Trade Lists", "Quality Price Multiplier", 0f, 0f, 10f, SettingScope.ServerAuthoritative, "Extra price per quality level above one when you sell gear, as a share of the listed price (0.5 adds half per level). 0 ignores quality.");

			public static readonly BarterSetting<bool> CommonValuables = BarterSetting.Toggle("Trade Lists", "Common Valuables", defaultValue: true, SettingScope.ServerAuthoritative, "Every item the game gives a value can be sold to any trader at that value, unless a Sell list prices it.");

			public static readonly BarterSetting<string> CustomTraders = BarterSetting.Text("Trade Lists", "Custom Traders", "", SettingScope.ServerAuthoritative, "Comma list of extra trader prefab names (case sensitive in the game) that get a balance and use Barter's lists.", Trim);

			public static readonly BarterSetting<string> TraderCurrencies = BarterSetting.Text("Trade Lists", "Trader Currencies", "", SettingScope.ServerAuthoritative, "Comma list of Trader:Currency pairs, for example Haldor:Coins,Hildir:SilverCoin. The item is that trader's currency unless a list entry names its own.", Trim);
		}

		public static class Services
		{
			public const string Section = "Trader Services";

			public static readonly BarterSetting<bool> BuybackEnabled = BarterSetting.Toggle("Trader Services", "Buyback Enabled", defaultValue: true, SettingScope.ServerAuthoritative, "Keep exact sold items available to their seller until the next in-game day. The server owns receipts; buying back costs the original payout.");

			public static readonly BarterSetting<bool> RepairEnabled = BarterSetting.Toggle("Trader Services", "Repair Enabled", defaultValue: true, SettingScope.ServerAuthoritative, "Let traders repair carried equipment for their own currency. The server owns eligibility and prices.");

			public static readonly BarterSetting<int> RepairBasePrice = BarterSetting.Integer("Trader Services", "Repair Base Price", 10, 1, 1000000, SettingScope.ServerAuthoritative, "Base price for repairing a fully damaged quality-one item; scales with quality, missing durability and the trader's buy price.");
		}

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

			public static readonly BarterSetting<bool> PriceTips = BarterSetting.Toggle("Interface", "Price Tips", defaultValue: true, SettingScope.Local, "Append this trader's current effective buy and sell prices to item tooltips while trading. Prices are quotes and may change before a trade.");

			public static readonly BarterSetting<bool> SellPanel = BarterSetting.Toggle("Interface", "Sell Panel", defaultValue: true, SettingScope.Local, "Show the sell list beside the trader's window.");

			public static readonly BarterSetting<bool> ShowPurse = BarterSetting.Toggle("Interface", "Show Purse", defaultValue: true, SettingScope.Local, "Show the trader's balance, currency and price change beside the trader's window.");

			public static readonly BarterSetting<bool> HideEquipped = BarterSetting.Toggle("Interface", "Hide Equipped Items", defaultValue: true, SettingScope.Local, "Leave unequipped hotbar gear out of the sell list. Equipped gear and protected extra slots are always kept.");
		}

		private static readonly Lazy<BarterSetting[]> all = new Lazy<BarterSetting[]>(() => new BarterSetting[25]
		{
			Purse.Enabled,
			Purse.FlexiblePricing,
			Purse.MinimumBalance,
			Purse.MaximumBalance,
			Purse.DailyIncrease,
			Purse.DailyDecrease,
			Purse.Discount,
			Purse.Markup,
			Purse.ReplenishDays,
			Purse.ReplenishMessage,
			Lists.SellOnlyDiscovered,
			Lists.AlwaysOffered,
			Lists.DisableVanillaItems,
			Lists.DisableOtherModsItems,
			Lists.QualityPriceMultiplier,
			Lists.CommonValuables,
			Lists.CustomTraders,
			Lists.TraderCurrencies,
			Services.BuybackEnabled,
			Services.RepairEnabled,
			Services.RepairBasePrice,
			Interface.PriceTips,
			Interface.SellPanel,
			Interface.ShowPurse,
			Interface.HideEquipped
		});

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

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

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