using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;
using MimirsWell.Core.Domain;
using MimirsWell.Core.Indexing;
using MimirsWell.Core.Planning;
using MimirsWell.Core.Resolution;
using MimirsWell.Core.Services;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("MimirsWell.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Pure domain, indexing, interpretation, and query logic for Mimir's Well.")]
[assembly: AssemblyFileVersion("0.5.4.0")]
[assembly: AssemblyInformationalVersion("0.5.4+e9ead6b8be5d9ac71509b88d6e713cfa6d095cc3")]
[assembly: AssemblyProduct("MimirsWell.Core")]
[assembly: AssemblyTitle("MimirsWell.Core")]
[assembly: AssemblyVersion("0.5.4.0")]
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;
		}
	}
}
namespace MimirsWell.Core.Services
{
	internal enum ComparisonMetricId
	{
		ListedDamage,
		Blunt,
		Slash,
		Pierce,
		Fire,
		Frost,
		Lightning,
		Poison,
		Spirit,
		PrimaryAttackStamina,
		SecondaryAttackStamina,
		Durability,
		Block,
		ParryBonus,
		Armor,
		FoodHealth,
		FoodStamina,
		FoodEitr,
		FoodDuration,
		FoodRegeneration,
		MovementModifier,
		Weight
	}
	internal sealed class ComparisonMetricDefinition
	{
		public ComparisonMetricId Id { get; }

		public string Name { get; }

		public bool HigherRanksFirst { get; }

		public string Suffix { get; }

		public string Caveat { get; }

		public string DirectionLabel
		{
			get
			{
				if (!HigherRanksFirst)
				{
					return "lower ranks first";
				}
				return "higher ranks first";
			}
		}

		public ComparisonMetricDefinition(ComparisonMetricId id, string name, bool higherRanksFirst, string suffix, string caveat)
		{
			Id = id;
			Name = name;
			HigherRanksFirst = higherRanksFirst;
			Suffix = suffix;
			Caveat = caveat;
		}
	}
	internal static class ComparisonMetricCatalog
	{
		private const string DamageCaveat = "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS.";

		private const string StaminaCaveat = "Not considered: damage per attack, attack timing or chains, regeneration, skill scaling, or real DPS.";

		private const string DefenseCaveat = "Not considered: resistances, stagger behavior, enemy attack mix, player skill, or effective survivability.";

		private const string FoodCaveat = "Not considered: meal combinations, acquisition difficulty, progression, or effects outside the selected loaded field.";

		private const string SingleFieldCaveat = "This is a single loaded field, not an overall item score.";

		private static readonly IReadOnlyDictionary<string, ComparisonMetricId> Aliases = new Dictionary<string, ComparisonMetricId>(StringComparer.OrdinalIgnoreCase)
		{
			["damage"] = ComparisonMetricId.ListedDamage,
			["listed damage"] = ComparisonMetricId.ListedDamage,
			["total damage"] = ComparisonMetricId.ListedDamage,
			["attack damage"] = ComparisonMetricId.ListedDamage,
			["listed combat damage"] = ComparisonMetricId.ListedDamage,
			["blunt"] = ComparisonMetricId.Blunt,
			["blunt damage"] = ComparisonMetricId.Blunt,
			["slash"] = ComparisonMetricId.Slash,
			["slash damage"] = ComparisonMetricId.Slash,
			["pierce"] = ComparisonMetricId.Pierce,
			["pierce damage"] = ComparisonMetricId.Pierce,
			["fire"] = ComparisonMetricId.Fire,
			["fire damage"] = ComparisonMetricId.Fire,
			["frost"] = ComparisonMetricId.Frost,
			["frost damage"] = ComparisonMetricId.Frost,
			["lightning"] = ComparisonMetricId.Lightning,
			["lightning damage"] = ComparisonMetricId.Lightning,
			["poison"] = ComparisonMetricId.Poison,
			["poison damage"] = ComparisonMetricId.Poison,
			["spirit"] = ComparisonMetricId.Spirit,
			["spirit damage"] = ComparisonMetricId.Spirit,
			["primary stamina"] = ComparisonMetricId.PrimaryAttackStamina,
			["primary attack stamina"] = ComparisonMetricId.PrimaryAttackStamina,
			["attack stamina"] = ComparisonMetricId.PrimaryAttackStamina,
			["stamina cost"] = ComparisonMetricId.PrimaryAttackStamina,
			["secondary stamina"] = ComparisonMetricId.SecondaryAttackStamina,
			["secondary attack stamina"] = ComparisonMetricId.SecondaryAttackStamina,
			["durability"] = ComparisonMetricId.Durability,
			["block"] = ComparisonMetricId.Block,
			["block power"] = ComparisonMetricId.Block,
			["parry"] = ComparisonMetricId.ParryBonus,
			["parry bonus"] = ComparisonMetricId.ParryBonus,
			["armor"] = ComparisonMetricId.Armor,
			["armour"] = ComparisonMetricId.Armor,
			["health"] = ComparisonMetricId.FoodHealth,
			["food health"] = ComparisonMetricId.FoodHealth,
			["eitr"] = ComparisonMetricId.FoodEitr,
			["food eitr"] = ComparisonMetricId.FoodEitr,
			["duration"] = ComparisonMetricId.FoodDuration,
			["food duration"] = ComparisonMetricId.FoodDuration,
			["regeneration"] = ComparisonMetricId.FoodRegeneration,
			["regen"] = ComparisonMetricId.FoodRegeneration,
			["food regeneration"] = ComparisonMetricId.FoodRegeneration,
			["movement"] = ComparisonMetricId.MovementModifier,
			["movement modifier"] = ComparisonMetricId.MovementModifier,
			["movement penalty"] = ComparisonMetricId.MovementModifier,
			["weight"] = ComparisonMetricId.Weight
		};

		public static string SupportedSummary => "damage, a listed combat-damage type, primary/secondary stamina, durability, block, parry, armor, food health/stamina/eitr/duration/regeneration, movement, or weight";

		public static bool TryResolve(string metricText, WikiItem left, WikiItem right, out ComparisonMetricDefinition? metric, out string diagnostic)
		{
			string text = TextNormalizer.Normalize(metricText);
			if (text == "stamina")
			{
				if (left.Kind == WikiItemKind.Food && right.Kind == WikiItemKind.Food)
				{
					return Resolved(ComparisonMetricId.FoodStamina, out metric, out diagnostic);
				}
				if (left.Kind == WikiItemKind.Weapon && right.Kind == WikiItemKind.Weapon)
				{
					return Resolved(ComparisonMetricId.PrimaryAttackStamina, out metric, out diagnostic);
				}
				metric = null;
				diagnostic = "'stamina' is contextual: compare two foods for food stamina or two weapons for primary attack stamina.";
				return false;
			}
			if (!Aliases.TryGetValue(text, out var value))
			{
				metric = null;
				diagnostic = "Unsupported comparison metric '" + metricText + "'. Supported metrics: " + SupportedSummary + ". DPS and composite best scores are not supported.";
				return false;
			}
			return Resolved(value, out metric, out diagnostic);
		}

		public static bool TryValue(ComparisonMetricDefinition metric, WikiItem item, WikiQualityStats stats, out double value)
		{
			double? num = null;
			switch (metric.Id)
			{
			case ComparisonMetricId.ListedDamage:
				if (item.Kind == WikiItemKind.Weapon)
				{
					num = stats.Damage?.ListedCombatTotal;
				}
				break;
			case ComparisonMetricId.Blunt:
				num = Damage(item, stats, DamageKind.Blunt);
				break;
			case ComparisonMetricId.Slash:
				num = Damage(item, stats, DamageKind.Slash);
				break;
			case ComparisonMetricId.Pierce:
				num = Damage(item, stats, DamageKind.Pierce);
				break;
			case ComparisonMetricId.Fire:
				num = Damage(item, stats, DamageKind.Fire);
				break;
			case ComparisonMetricId.Frost:
				num = Damage(item, stats, DamageKind.Frost);
				break;
			case ComparisonMetricId.Lightning:
				num = Damage(item, stats, DamageKind.Lightning);
				break;
			case ComparisonMetricId.Poison:
				num = Damage(item, stats, DamageKind.Poison);
				break;
			case ComparisonMetricId.Spirit:
				num = Damage(item, stats, DamageKind.Spirit);
				break;
			case ComparisonMetricId.PrimaryAttackStamina:
				if (item.Kind == WikiItemKind.Weapon)
				{
					num = stats.PrimaryAttackStamina;
				}
				break;
			case ComparisonMetricId.SecondaryAttackStamina:
				if (item.Kind == WikiItemKind.Weapon)
				{
					num = stats.SecondaryAttackStamina;
				}
				break;
			case ComparisonMetricId.Durability:
				num = stats.Durability;
				break;
			case ComparisonMetricId.Block:
			{
				WikiItemKind kind = item.Kind;
				if ((uint)(kind - 1) <= 1u)
				{
					num = stats.Block;
				}
				break;
			}
			case ComparisonMetricId.ParryBonus:
			{
				WikiItemKind kind = item.Kind;
				if ((uint)(kind - 1) <= 1u)
				{
					num = item.ParryBonus;
				}
				break;
			}
			case ComparisonMetricId.Armor:
				if (item.Kind == WikiItemKind.Armor)
				{
					num = stats.Armor;
				}
				break;
			case ComparisonMetricId.FoodHealth:
				if (item.Kind == WikiItemKind.Food)
				{
					num = item.FoodHealth;
				}
				break;
			case ComparisonMetricId.FoodStamina:
				if (item.Kind == WikiItemKind.Food)
				{
					num = item.FoodStamina;
				}
				break;
			case ComparisonMetricId.FoodEitr:
				if (item.Kind == WikiItemKind.Food)
				{
					num = item.FoodEitr;
				}
				break;
			case ComparisonMetricId.FoodDuration:
				if (item.Kind == WikiItemKind.Food)
				{
					num = item.FoodDurationSeconds;
				}
				break;
			case ComparisonMetricId.FoodRegeneration:
				if (item.Kind == WikiItemKind.Food)
				{
					num = item.FoodRegeneration;
				}
				break;
			case ComparisonMetricId.MovementModifier:
				num = item.MovementModifier * 100.0;
				break;
			case ComparisonMetricId.Weight:
				num = item.Weight;
				break;
			}
			value = num.GetValueOrDefault();
			if (num.HasValue && !double.IsNaN(value))
			{
				return !double.IsInfinity(value);
			}
			return false;
		}

		public static int Compare(ComparisonMetricDefinition metric, double left, double right)
		{
			int num = left.CompareTo(right);
			if (!metric.HigherRanksFirst)
			{
				return -num;
			}
			return num;
		}

		public static double Improvement(ComparisonMetricDefinition metric, double candidate, double baseline)
		{
			if (!metric.HigherRanksFirst)
			{
				return baseline - candidate;
			}
			return candidate - baseline;
		}

		private static bool Resolved(ComparisonMetricId id, out ComparisonMetricDefinition? metric, out string diagnostic)
		{
			metric = Definition(id);
			diagnostic = string.Empty;
			return true;
		}

		private static double? Damage(WikiItem item, WikiQualityStats stats, DamageKind kind)
		{
			if (item.Kind != WikiItemKind.Weapon || stats.Damage == null)
			{
				return null;
			}
			return stats.Damage.Get(kind);
		}

		private static ComparisonMetricDefinition Definition(ComparisonMetricId id)
		{
			return id switch
			{
				ComparisonMetricId.ListedDamage => new ComparisonMetricDefinition(id, "Listed combat damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Blunt => new ComparisonMetricDefinition(id, "Blunt damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Slash => new ComparisonMetricDefinition(id, "Slash damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Pierce => new ComparisonMetricDefinition(id, "Pierce damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Fire => new ComparisonMetricDefinition(id, "Fire damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Frost => new ComparisonMetricDefinition(id, "Frost damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Lightning => new ComparisonMetricDefinition(id, "Lightning damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Poison => new ComparisonMetricDefinition(id, "Poison damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.Spirit => new ComparisonMetricDefinition(id, "Spirit damage", higherRanksFirst: true, string.Empty, "Not considered: enemy resistance, status effects, skill scaling, attack timing or chains, stamina efficiency, or real DPS."), 
				ComparisonMetricId.PrimaryAttackStamina => new ComparisonMetricDefinition(id, "Primary attack stamina", higherRanksFirst: false, string.Empty, "Not considered: damage per attack, attack timing or chains, regeneration, skill scaling, or real DPS."), 
				ComparisonMetricId.SecondaryAttackStamina => new ComparisonMetricDefinition(id, "Secondary attack stamina", higherRanksFirst: false, string.Empty, "Not considered: damage per attack, attack timing or chains, regeneration, skill scaling, or real DPS."), 
				ComparisonMetricId.Durability => new ComparisonMetricDefinition(id, "Durability", higherRanksFirst: true, string.Empty, "This is a single loaded field, not an overall item score."), 
				ComparisonMetricId.Block => new ComparisonMetricDefinition(id, "Block", higherRanksFirst: true, string.Empty, "Not considered: resistances, stagger behavior, enemy attack mix, player skill, or effective survivability."), 
				ComparisonMetricId.ParryBonus => new ComparisonMetricDefinition(id, "Parry bonus", higherRanksFirst: true, "x", "Not considered: resistances, stagger behavior, enemy attack mix, player skill, or effective survivability."), 
				ComparisonMetricId.Armor => new ComparisonMetricDefinition(id, "Armor", higherRanksFirst: true, string.Empty, "Not considered: resistances, stagger behavior, enemy attack mix, player skill, or effective survivability."), 
				ComparisonMetricId.FoodHealth => new ComparisonMetricDefinition(id, "Food health", higherRanksFirst: true, string.Empty, "Not considered: meal combinations, acquisition difficulty, progression, or effects outside the selected loaded field."), 
				ComparisonMetricId.FoodStamina => new ComparisonMetricDefinition(id, "Food stamina", higherRanksFirst: true, string.Empty, "Not considered: meal combinations, acquisition difficulty, progression, or effects outside the selected loaded field."), 
				ComparisonMetricId.FoodEitr => new ComparisonMetricDefinition(id, "Food eitr", higherRanksFirst: true, string.Empty, "Not considered: meal combinations, acquisition difficulty, progression, or effects outside the selected loaded field."), 
				ComparisonMetricId.FoodDuration => new ComparisonMetricDefinition(id, "Food duration", higherRanksFirst: true, " s", "Not considered: meal combinations, acquisition difficulty, progression, or effects outside the selected loaded field."), 
				ComparisonMetricId.FoodRegeneration => new ComparisonMetricDefinition(id, "Food regeneration", higherRanksFirst: true, string.Empty, "Not considered: meal combinations, acquisition difficulty, progression, or effects outside the selected loaded field."), 
				ComparisonMetricId.MovementModifier => new ComparisonMetricDefinition(id, "Movement modifier", higherRanksFirst: true, "%", "This is a single loaded field, not an overall item score."), 
				_ => new ComparisonMetricDefinition(id, "Weight", higherRanksFirst: false, string.Empty, "This is a single loaded field, not an overall item score."), 
			};
		}
	}
	public enum WikiContextKind
	{
		Held,
		Equipped,
		ActiveFood,
		CurrentStation
	}
	public sealed class WikiContextItem
	{
		public string ItemId { get; }

		public string Role { get; }

		public double? CurrentHealth { get; }

		public double? CurrentStamina { get; }

		public double? CurrentEitr { get; }

		public double? RemainingSeconds { get; }

		public WikiContextItem(string itemId, string role, double? currentHealth = null, double? currentStamina = null, double? currentEitr = null, double? remainingSeconds = null)
		{
			ItemId = itemId ?? string.Empty;
			Role = (string.IsNullOrWhiteSpace(role) ? "context item" : role);
			CurrentHealth = Finite(currentHealth);
			CurrentStamina = Finite(currentStamina);
			CurrentEitr = Finite(currentEitr);
			RemainingSeconds = Finite(remainingSeconds, nonNegative: true);
		}

		private static double? Finite(double? value, bool nonNegative = false)
		{
			if (value.HasValue && !double.IsNaN(value.Value) && !double.IsInfinity(value.Value) && (!nonNegative || !(value.Value < 0.0)))
			{
				return value;
			}
			return null;
		}
	}
	public sealed class WikiContextSnapshot
	{
		private readonly IReadOnlyList<WikiContextItem> items;

		public WikiContextKind Kind { get; }

		public bool PlayerContextAvailable { get; }

		public IReadOnlyList<WikiContextItem> Items => items;

		public string? StationName { get; }

		public string? StationInternalName { get; }

		public int IsolatedErrors { get; }

		public WikiContextSnapshot(WikiContextKind kind, bool playerContextAvailable, IEnumerable<WikiContextItem>? items = null, string? stationName = null, string? stationInternalName = null, int isolatedErrors = 0)
		{
			Kind = kind;
			PlayerContextAvailable = playerContextAvailable;
			this.items = Array.AsReadOnly((items ?? Array.Empty<WikiContextItem>()).OfType<WikiContextItem>().ToArray());
			StationName = (string.IsNullOrWhiteSpace(stationName) ? null : stationName);
			StationInternalName = (string.IsNullOrWhiteSpace(stationInternalName) ? null : stationInternalName);
			IsolatedErrors = Math.Max(0, isolatedErrors);
		}
	}
	public sealed class WikiEngineOptions
	{
		public bool ShowInternalNames { get; set; }

		public bool ShowSourceMod { get; set; } = true;

		public bool ShowComparisonAssumptions { get; set; } = true;

		public int MaximumAlternativeResults { get; set; } = 5;

		public bool FuzzyMatchingEnabled { get; set; } = true;

		public double FuzzyMatchThreshold { get; set; } = 0.82;

		public double AmbiguityMargin { get; set; } = 0.05;
	}
	public sealed class WikiEngine
	{
		private sealed class FilterExpression
		{
			private static readonly Dictionary<string, string> Categories = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
			{
				["sword"] = "sword",
				["swords"] = "sword",
				["axe"] = "axe",
				["axes"] = "axe",
				["bow"] = "bow",
				["bows"] = "bow",
				["spear"] = "spear",
				["spears"] = "spear",
				["mace"] = "club",
				["maces"] = "club",
				["club"] = "club",
				["clubs"] = "club",
				["knife"] = "knife",
				["knives"] = "knife",
				["polearm"] = "polearm",
				["polearms"] = "polearm"
			};

			private static readonly Dictionary<string, WikiItemKind> Kinds = new Dictionary<string, WikiItemKind>(StringComparer.OrdinalIgnoreCase)
			{
				["weapon"] = WikiItemKind.Weapon,
				["weapons"] = WikiItemKind.Weapon,
				["shield"] = WikiItemKind.Shield,
				["shields"] = WikiItemKind.Shield,
				["armor"] = WikiItemKind.Armor,
				["armour"] = WikiItemKind.Armor,
				["food"] = WikiItemKind.Food,
				["foods"] = WikiItemKind.Food,
				["material"] = WikiItemKind.Material,
				["materials"] = WikiItemKind.Material,
				["tool"] = WikiItemKind.Tool,
				["tools"] = WikiItemKind.Tool
			};

			private static readonly Dictionary<string, DamageKind> Damages = (from DamageKind kind in Enum.GetValues(typeof(DamageKind))
				where kind != DamageKind.Chop && kind != DamageKind.Pickaxe
				select kind).ToDictionary<DamageKind, string, DamageKind>((DamageKind kind) => kind.ToString(), (DamageKind kind) => kind, StringComparer.OrdinalIgnoreCase);

			public bool IsSupported { get; private set; }

			public string Diagnostic { get; private set; } = string.Empty;

			public WikiItemKind? Kind { get; private set; }

			public string? Category { get; private set; }

			public DamageKind? Damage { get; private set; }

			public string? NumericField { get; private set; }

			public string? Operator { get; private set; }

			public double? NumericValue { get; private set; }

			public static FilterExpression Parse(string expression)
			{
				FilterExpression filterExpression = new FilterExpression();
				string text = TextNormalizer.Normalize(expression);
				string[] array = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
				foreach (string key in array)
				{
					if (Categories.TryGetValue(key, out string value))
					{
						filterExpression.Category = value;
					}
					if (Kinds.TryGetValue(key, out var value2))
					{
						filterExpression.Kind = value2;
					}
					if (Damages.TryGetValue(key, out var value3))
					{
						filterExpression.Damage = value3;
					}
				}
				Match match = Regex.Match(text, "(?<op>above|below|at least|at most)\\s+(?<value>-?[0-9]+(?:\\.[0-9]+)?)\\s+(?<field>primary stamina|secondary stamina|total damage|listed damage|health|stamina|eitr|duration|regeneration|regen|armor|block|durability|weight|movement|blunt|slash|pierce|fire|frost|lightning|poison|spirit)\\b", RegexOptions.IgnoreCase);
				if (!match.Success)
				{
					match = Regex.Match(text, "(?<field>primary stamina|secondary stamina|total damage|listed damage|health|stamina|eitr|duration|regeneration|regen|armor|block|durability|weight|movement|blunt|slash|pierce|fire|frost|lightning|poison|spirit)\\s+(?<op>above|below|at least|at most)\\s+(?<value>-?[0-9]+(?:\\.[0-9]+)?)\\b", RegexOptions.IgnoreCase);
				}
				if (match.Success && double.TryParse(match.Groups["value"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					filterExpression.NumericField = NormalizeNumericField(match.Groups["field"].Value);
					filterExpression.Operator = match.Groups["op"].Value.ToLowerInvariant();
					filterExpression.NumericValue = result;
					if (!filterExpression.Kind.HasValue && filterExpression.Category == null)
					{
						bool flag;
						switch (filterExpression.NumericField)
						{
						case "health":
						case "eitr":
						case "duration":
						case "regeneration":
							flag = true;
							break;
						default:
							flag = false;
							break;
						}
						if (flag)
						{
							filterExpression.Kind = WikiItemKind.Food;
						}
						switch (filterExpression.NumericField)
						{
						case "poison":
						case "spirit":
						case "damage":
						case "pierce":
						case "blunt":
						case "frost":
						case "slash":
						case "primary stamina":
						case "secondary stamina":
						case "fire":
						case "lightning":
							flag = true;
							break;
						default:
							flag = false;
							break;
						}
						if (flag)
						{
							filterExpression.Kind = WikiItemKind.Weapon;
						}
						if (filterExpression.NumericField == "armor")
						{
							filterExpression.Kind = WikiItemKind.Armor;
						}
					}
				}
				filterExpression.IsSupported = filterExpression.Kind.HasValue || filterExpression.Category != null || filterExpression.Damage.HasValue || filterExpression.NumericValue.HasValue;
				filterExpression.Diagnostic = (filterExpression.IsSupported ? "Supported filter parsed." : "Supported filters are item category, combat damage type, and loaded numeric fields such as damage, stamina, armor, block, durability, weight, movement, health, eitr, duration, or regeneration using above, below, at least, or at most.");
				return filterExpression;
			}

			private static string NormalizeNumericField(string field)
			{
				string text = TextNormalizer.Normalize(field);
				if ((text == "total damage" || text == "listed damage") ? true : false)
				{
					return "damage";
				}
				if (text == "regen")
				{
					return "regeneration";
				}
				return text;
			}
		}

		private sealed class StationResolution
		{
			public ResolutionStatus Status { get; }

			public IReadOnlyList<string> Names { get; }

			public string Diagnostic { get; }

			public StationResolution(ResolutionStatus status, IEnumerable<string> names, string diagnostic)
			{
				Status = status;
				Names = Array.AsReadOnly(names.ToArray());
				Diagnostic = diagnostic;
			}
		}

		private sealed class SourceEntityResolution
		{
			public ResolutionStatus Status { get; }

			public IReadOnlyList<string> Names { get; }

			public SourceEntityResolution(ResolutionStatus status, IEnumerable<string> names)
			{
				Status = status;
				Names = Array.AsReadOnly(names.ToArray());
			}
		}

		private sealed class SourceDisplayGroup
		{
			public WikiAcquisitionSource Source { get; }

			public int VariantCount { get; }

			public SourceDisplayGroup(WikiAcquisitionSource source, int variantCount)
			{
				Source = source;
				VariantCount = Math.Max(1, variantCount);
			}
		}

		private const int MaximumContextEntries = 16;

		private const int MaximumDiagnosticRows = 20;

		private static readonly DamageKind[] CombatDamageOrder = new DamageKind[8]
		{
			DamageKind.Blunt,
			DamageKind.Slash,
			DamageKind.Pierce,
			DamageKind.Fire,
			DamageKind.Frost,
			DamageKind.Lightning,
			DamageKind.Poison,
			DamageKind.Spirit
		};

		private readonly EntityResolver resolver;

		private readonly WikiEngineOptions options;

		public WikiEngine(EntityResolver resolver, WikiEngineOptions options)
		{
			this.resolver = resolver ?? throw new ArgumentNullException("resolver");
			this.options = options ?? throw new ArgumentNullException("options");
		}

		public WikiAnswer Execute(WikiIndex index, WikiQuery query)
		{
			return Execute(index, query, WikiVisibilitySnapshot.AllLoaded);
		}

		public WikiAnswer Execute(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (index == null)
			{
				throw new ArgumentNullException("index");
			}
			if (query == null)
			{
				throw new ArgumentNullException("query");
			}
			if (visibility == null)
			{
				throw new ArgumentNullException("visibility");
			}
			if (visibility.IsRestricted && !visibility.CharacterStateAvailable && query.Intent != WikiIntent.Help && query.Intent != WikiIntent.Status)
			{
				return new WikiAnswer("Character knowledge unavailable", new string[2]
				{
					$"{visibility.Policy} requires an active local character.",
					"The complete runtime index remains loaded, but this query was not allowed to read it."
				}, null, new string[1] { "Enter a world with a character or set SpoilerPolicy = AllLoaded." });
			}
			switch (query.Intent)
			{
			case WikiIntent.Help:
				return Help(visibility);
			case WikiIntent.Status:
				return Status(index, visibility);
			case WikiIntent.ItemInfo:
				return WithItem(index, query, visibility, (WikiItem item) => ItemInfo(index, item, query.Quality ?? 1));
			case WikiIntent.RecipeLookup:
				return WithItem(index, query, visibility, (WikiItem item) => Recipes(index, item, visibility));
			case WikiIntent.UpgradeLookup:
				return WithItem(index, query, visibility, (WikiItem item) => Upgrades(index, item, visibility));
			case WikiIntent.MaterialUsage:
				return WithItem(index, query, visibility, (WikiItem item) => Uses(index, item, visibility));
			case WikiIntent.CraftingPlan:
				return WithItem(index, query, visibility, (WikiItem item) => Plan(index, item, query.Quantity ?? 1, query.Quality ?? 1, visibility));
			case WikiIntent.AcquisitionSource:
				return WithItem(index, query, visibility, (WikiItem item) => AcquisitionSources(index, item, SourceKindFilter(query), visibility));
			case WikiIntent.SourceInventory:
				return SourceInventory(index, query, visibility);
			case WikiIntent.CraftingStation:
				return StationQuery(index, query, visibility);
			case WikiIntent.StrongerAlternatives:
				return WithItem(index, query, visibility, (WikiItem item) => Stronger(index, item, query, visibility));
			case WikiIntent.ItemComparison:
				return Compare(index, query, visibility);
			case WikiIntent.CategoryRanking:
				return RankCategory(index, query, visibility);
			case WikiIntent.ComparisonExplanation:
				return ExplainComparison(index, query, visibility);
			case WikiIntent.Find:
				return Find(index, query, visibility);
			case WikiIntent.Diagnostics:
				return Diagnostics(index, visibility);
			case WikiIntent.ModReport:
				return ModReport(index, visibility);
			case WikiIntent.UnsupportedReport:
				return UnsupportedReport(index, visibility);
			case WikiIntent.ContextHeld:
			case WikiIntent.ContextEquipped:
			case WikiIntent.ContextFood:
			case WikiIntent.ContextStation:
				return new WikiAnswer("Context adapter required", new string[1] { "This shortcut requires the read-only in-game context adapter." });
			case WikiIntent.More:
				return new WikiAnswer("Pagination", new string[1] { "No pagination context was supplied to the query engine." });
			case WikiIntent.Reindex:
				return new WikiAnswer("Reindex", new string[1] { "Reindexing is handled by the game lifecycle adapter." });
			case WikiIntent.Reload:
				return new WikiAnswer("Reload", new string[1] { "Configuration reload is handled by the plugin adapter." });
			default:
				return new WikiAnswer("Unsupported question", new string[1] { query.Diagnostic }, null, new string[1] { "Use /wiki help for supported forms." });
			}
		}

		public WikiAnswer ExecuteContext(WikiIndex index, WikiQuery query, WikiContextSnapshot context, WikiVisibilitySnapshot visibility)
		{
			if (index == null)
			{
				throw new ArgumentNullException("index");
			}
			if (query == null)
			{
				throw new ArgumentNullException("query");
			}
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			if (visibility == null)
			{
				throw new ArgumentNullException("visibility");
			}
			if (!IsContextIntent(query.Intent))
			{
				return new WikiAnswer("Invalid context query", new string[1] { "The supplied query is not a context shortcut." });
			}
			if (visibility.IsRestricted && !visibility.CharacterStateAvailable)
			{
				return new WikiAnswer("Character knowledge unavailable", new string[1] { $"{visibility.Policy} requires an active local character." });
			}
			if (!context.PlayerContextAvailable)
			{
				return new WikiAnswer("Player context unavailable", new string[1] { "Enter a world with an active local character before using this shortcut." });
			}
			if (!ContextKindMatches(query.Intent, context.Kind))
			{
				return new WikiAnswer("Context mismatch", new string[1] { "The runtime context did not match the requested shortcut; no fallback lookup was attempted." });
			}
			return query.Intent switch
			{
				WikiIntent.ContextHeld => HeldContext(index, context, visibility), 
				WikiIntent.ContextEquipped => ItemContextList(index, context, visibility, "Equipped items"), 
				WikiIntent.ContextFood => FoodContext(index, context, visibility), 
				_ => StationContext(index, context, visibility), 
			};
		}

		private WikiAnswer HeldContext(WikiIndex index, WikiContextSnapshot context, WikiVisibilitySnapshot visibility)
		{
			if (context.Items.Count == 0)
			{
				return new WikiAnswer("Held item", new string[1] { "No item is reported in either direct hand slot or among equipped hand-capable items." });
			}
			WikiContextItem wikiContextItem = context.Items[0];
			if (!index.Items.TryGetValue(wikiContextItem.ItemId, out WikiItem value))
			{
				return ContextUnavailableItem("Held item", context, "The current held item is not represented in the runtime wiki index.");
			}
			if (!visibility.IsVisible(value))
			{
				return ContextUnavailableItem("Held item", context, $"The current held item is hidden by {visibility.Policy}.");
			}
			WikiAnswer wikiAnswer = ItemInfo(index, value, 1);
			string[] warnings = wikiAnswer.Warnings.Concat(ContextWarnings(context)).ToArray();
			return new WikiAnswer("Held: " + wikiAnswer.Title, new string[1] { "Context: " + wikiContextItem.Role + "." }.Concat(wikiAnswer.Lines), warnings, wikiAnswer.Suggestions);
		}

		private WikiAnswer ItemContextList(WikiIndex index, WikiContextSnapshot context, WikiVisibilitySnapshot visibility, string title)
		{
			List<(WikiContextItem, WikiItem)> list = new List<(WikiContextItem, WikiItem)>();
			int num = 0;
			int num2 = 0;
			foreach (WikiContextItem item in context.Items.Take(16))
			{
				if (!index.Items.TryGetValue(item.ItemId, out WikiItem value))
				{
					num2++;
				}
				else if (!visibility.IsVisible(value))
				{
					num++;
				}
				else
				{
					list.Add((item, value));
				}
			}
			List<string> list2 = list.Select<(WikiContextItem, WikiItem), string>(((WikiContextItem Entry, WikiItem Item) tuple) => "- " + Label(tuple.Item) + " | " + tuple.Item.Category + " | " + tuple.Entry.Role).ToList();
			if (context.Items.Count == 0)
			{
				list2.Add("No equipped items are reported by the active character inventory.");
			}
			if (num > 0)
			{
				list2.Add(string.Format("{0} equipped item{1} hidden by {2}.", num, (num == 1) ? " is" : "s are", visibility.Policy));
			}
			if (num2 > 0)
			{
				list2.Add(string.Format("{0} equipped item{1} not represented in the runtime wiki index.", num2, (num2 == 1) ? " is" : "s are"));
			}
			if (context.Items.Count > 16)
			{
				list2.Add($"Only the first {16} context entries were evaluated.");
			}
			list2.AddRange(ContextWarnings(context));
			return new WikiAnswer($"{title} ({list.Count} visible)", list2);
		}

		private WikiAnswer FoodContext(WikiIndex index, WikiContextSnapshot context, WikiVisibilitySnapshot visibility)
		{
			List<(WikiContextItem, WikiItem)> list = new List<(WikiContextItem, WikiItem)>();
			int num = 0;
			int num2 = 0;
			foreach (WikiContextItem item in context.Items.Take(16))
			{
				if (!index.Items.TryGetValue(item.ItemId, out WikiItem value))
				{
					num2++;
				}
				else if (!visibility.IsVisible(value))
				{
					num++;
				}
				else
				{
					list.Add((item, value));
				}
			}
			List<string> list2 = list.Select<(WikiContextItem, WikiItem), string>(delegate((WikiContextItem Entry, WikiItem Item) tuple)
			{
				List<string> list3 = new List<string>();
				if (tuple.Entry.CurrentHealth.HasValue)
				{
					list3.Add("health " + Number(tuple.Entry.CurrentHealth.Value));
				}
				if (tuple.Entry.CurrentStamina.HasValue)
				{
					list3.Add("stamina " + Number(tuple.Entry.CurrentStamina.Value));
				}
				if (tuple.Entry.CurrentEitr.HasValue)
				{
					list3.Add("eitr " + Number(tuple.Entry.CurrentEitr.Value));
				}
				if (tuple.Entry.RemainingSeconds.HasValue)
				{
					list3.Add("remaining " + Number(tuple.Entry.RemainingSeconds.Value / 60.0) + " min");
				}
				return "- " + Label(tuple.Item) + ": " + ((list3.Count == 0) ? "current contribution unavailable" : string.Join(" | ", list3));
			}).ToList();
			if (context.Items.Count == 0)
			{
				list2.Add("No active consumed foods are reported by the current character.");
			}
			if (num > 0)
			{
				list2.Add(string.Format("{0} active food item{1} hidden by {2}.", num, (num == 1) ? " is" : "s are", visibility.Policy));
			}
			if (num2 > 0)
			{
				list2.Add(string.Format("{0} active food item{1} not represented in the runtime wiki index.", num2, (num2 == 1) ? " is" : "s are"));
			}
			list2.AddRange(ContextWarnings(context));
			return new WikiAnswer($"Active food ({list.Count} visible)", list2, new string[1] { "Values are the character's loaded current food contributions and remaining time; no food state is changed." });
		}

		private WikiAnswer StationContext(WikiIndex index, WikiContextSnapshot context, WikiVisibilitySnapshot visibility)
		{
			if (string.IsNullOrWhiteSpace(context.StationName))
			{
				return new WikiAnswer("Current station", new string[2] { "No current crafting-station interaction is active.", "For this shortcut, 'nearby' means the station currently being used; Mimir's Well does not scan the scene or infer distance." }.Concat(ContextWarnings(context)));
			}
			WikiAnswer wikiAnswer = StationContents(index, context.StationName, visibility);
			return new WikiAnswer("Current station: " + wikiAnswer.Title, wikiAnswer.Lines, wikiAnswer.Warnings.Concat(ContextWarnings(context)), wikiAnswer.Suggestions);
		}

		private static WikiAnswer ContextUnavailableItem(string title, WikiContextSnapshot context, string message)
		{
			return new WikiAnswer(title, new string[1] { message }.Concat(ContextWarnings(context)));
		}

		private static IEnumerable<string> ContextWarnings(WikiContextSnapshot context)
		{
			if (context.IsolatedErrors > 0)
			{
				yield return string.Format("{0} malformed context entr{1} isolated.", context.IsolatedErrors, (context.IsolatedErrors == 1) ? "y was" : "ies were");
			}
		}

		private static bool IsContextIntent(WikiIntent intent)
		{
			if ((uint)(intent - 15) <= 3u)
			{
				return true;
			}
			return false;
		}

		private static bool ContextKindMatches(WikiIntent intent, WikiContextKind kind)
		{
			if ((intent != WikiIntent.ContextHeld || kind != WikiContextKind.Held) && (intent != WikiIntent.ContextEquipped || kind != WikiContextKind.Equipped) && (intent != WikiIntent.ContextFood || kind != WikiContextKind.ActiveFood))
			{
				if (intent == WikiIntent.ContextStation)
				{
					return kind == WikiContextKind.CurrentStation;
				}
				return false;
			}
			return true;
		}

		private WikiAnswer WithItem(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility, Func<WikiItem, WikiAnswer> answer)
		{
			if (query.EntityTexts.Count == 0)
			{
				return new WikiAnswer("Missing item", new string[1] { "Please provide an item name." });
			}
			ResolutionResult resolutionResult = resolver.Resolve(index, query.EntityTexts[0], visibility.IsVisible);
			if (resolutionResult.Status == ResolutionStatus.Resolved && resolutionResult.Item != null)
			{
				return answer(resolutionResult.Item);
			}
			return ResolutionAnswer(query.EntityTexts[0], resolutionResult);
		}

		private static WikiAnswer Help(WikiVisibilitySnapshot visibility)
		{
			return new WikiAnswer("Commands", new string[16]
			{
				"/wiki <item> or /wiki info <item>", "/wiki recipe <item> | upgrades <item> | uses <material>", "/wiki plan <item> | plan <quantity> <item> quality <n>", "/wiki source <item> | what drops <item>", "/wiki drops <creature> | what does <trader> sell", "/wiki mine <item> | fish <item> | what produces <item>", "/wiki station <item or station> | compare <item> and <item>", "/wiki compare <item> and <item> by <metric> quality <n>", "/wiki compare foods by stamina | compare shields by block", "/wiki why <item> is stronger than <item> by <metric>",
				"/wiki stronger <weapon> | find <category/filter>", "/wiki held | equipped | food | station nearby", "/wiki diagnostics | mods | unsupported", "/wiki status | more | reload | reindex", "Natural example: /wiki how do I make an iron sword", "Quote an exact name when needed: /wiki recipe \"Iron Sword\""
			}, new string[2]
			{
				"Coverage includes crafting, build pieces, processing conversions, reliable direct sources, deterministic environmental drops, and direct fish pickup. Acquisition sources remain separate from recipe methods.",
				$"Knowledge visibility: {visibility.Policy} ({visibility.Description})."
			});
		}

		private static WikiAnswer Plan(WikiIndex index, WikiItem item, long quantity, int quality, WikiVisibilitySnapshot visibility)
		{
			ProductionPlan productionPlan = new ProductionPlanner().Plan(index, item, quantity, quality, visibility);
			return new WikiAnswer(productionPlan.Title, productionPlan.Lines, null, null, isPaginated: true);
		}

		private static WikiAnswer Status(WikiIndex index, WikiVisibilitySnapshot visibility)
		{
			int num = (visibility.IsRestricted ? index.Items.Values.Count(visibility.IsVisible) : index.Items.Count);
			return new WikiAnswer("Index ready", new string[12]
			{
				$"Items: {index.Items.Count} | recipes: {index.Recipes.Count} | conversions: {index.Conversions.Count} | build pieces: {index.Pieces.Count}",
				string.Format("Knowledge visibility: {0} | visible items: {1}/{2} | character state: {3} | isolated evaluation errors: {4}.", visibility.Policy, num, index.Items.Count, visibility.CharacterStateAvailable ? "available" : "unavailable", visibility.EvaluationErrors),
				"The complete loaded index is immutable; visibility is applied only while answering each query.",
				$"Diagnostics: {index.Diagnostics.Count} retained issue records | {index.OmittedDiagnostics} omitted by the 256-record bound.",
				$"Sources: {index.Sources.Count} | creature: {index.Sources.Count((WikiAcquisitionSource source) => source.Kind == WikiSourceKind.CreatureDrop)} | purchased: {index.Sources.Count((WikiAcquisitionSource source) => source.Kind == WikiSourceKind.Purchased)} | passive: {index.Sources.Count((WikiAcquisitionSource source) => source.Kind == WikiSourceKind.PassivelyProduced)} | harvested: {index.Sources.Count((WikiAcquisitionSource source) => source.Kind == WikiSourceKind.Harvested)}",
				$"Environmental: {index.Sources.Count((WikiAcquisitionSource source) => source.Kind == WikiSourceKind.MinedOrDestroyed)} mined/destroyed ({index.Sources.Count((WikiAcquisitionSource source) => source.QuantitySemantics == WikiQuantitySemantics.ExactLoadedRange)} guaranteed-variable) | fishing: {index.Sources.Count((WikiAcquisitionSource source) => source.Kind == WikiSourceKind.Fishing)}",
				"Planner: enabled | bounds: depth 12, nodes 256, alternatives 8, target 1,000,000, computed 1,000,000,000, lines 200, time 50 ms.",
				"Comparisons: deterministic explicit metrics and explanations enabled; no DPS or composite best score.",
				$"Language: {index.Language} | build: {index.BuildDuration.TotalMilliseconds:0} ms",
				$"Skipped entries: {index.SkippedEntries} | unavailable optional stats: {index.UnavailableStatistics}",
				index.WorldContextAvailable ? "Runtime calculators: world context available." : "Runtime calculators: menu context; a world-entry refresh is pending.",
				index.CoverageNote
			}.Where((string line) => !string.IsNullOrWhiteSpace(line)));
		}

		private WikiAnswer ItemInfo(WikiIndex index, WikiItem item, int requestedQuality)
		{
			int num = ClampQuality(item, requestedQuality);
			WikiQualityStats wikiQualityStats = item.StatsAt(num);
			List<string> list = new List<string>
			{
				$"Category: {item.Category} | quality: {num}/{item.MaxQuality}",
				$"Weight: {Number(item.Weight)} | stack: {item.MaxStack}"
			};
			if (item.Kind == WikiItemKind.Weapon)
			{
				if (wikiQualityStats.Damage != null)
				{
					list.Add("Listed total attack damage: " + Number(wikiQualityStats.Damage.ListedCombatTotal) + " (" + DamageSummary(wikiQualityStats.Damage) + ")");
				}
				else
				{
					list.Add("Listed total attack damage: unavailable for this quality.");
				}
				AddNullable(list, "Primary attack stamina", wikiQualityStats.PrimaryAttackStamina);
				AddNullable(list, "Secondary attack stamina", wikiQualityStats.SecondaryAttackStamina);
				AddNullable(list, "Durability", wikiQualityStats.Durability);
				AddNullable(list, "Block", wikiQualityStats.Block);
				AddNullable(list, "Parry bonus", item.ParryBonus, "x");
			}
			else if (item.Kind == WikiItemKind.Armor || item.Kind == WikiItemKind.Shield)
			{
				AddNullable(list, "Armor", wikiQualityStats.Armor);
				AddNullable(list, "Block", wikiQualityStats.Block);
				AddNullable(list, "Durability", wikiQualityStats.Durability);
				AddNullable(list, "Parry bonus", item.ParryBonus, "x");
			}
			else if (item.Kind == WikiItemKind.Food)
			{
				AddNullable(list, "Food health", item.FoodHealth);
				AddNullable(list, "Food stamina", item.FoodStamina);
				AddNullable(list, "Food eitr", item.FoodEitr);
				AddNullable(list, "Duration", item.FoodDurationSeconds, " s");
				AddNullable(list, "Regeneration", item.FoodRegeneration);
			}
			if (Math.Abs(item.MovementModifier) > 0.0001)
			{
				list.Add("Movement modifier: " + Number(item.MovementModifier * 100.0) + "%");
			}
			int count = index.RecipesForOutput(item.Id).Count;
			int count2 = index.ConversionsForOutput(item.Id).Count;
			int count3 = index.SourcesForOutput(item.Id).Count;
			list.Add((count == 0 && count2 == 0 && count3 == 0) ? "Production/acquisition: no indexed method found." : string.Format("Production/acquisition: {0} crafting recipe{1}, {2} processing method{3}, {4} direct source{5}.", count, (count == 1) ? string.Empty : "s", count2, (count2 == 1) ? string.Empty : "s", count3, (count3 == 1) ? string.Empty : "s"));
			AddIdentity(list, item);
			return new WikiAnswer(item.DisplayName, list, (requestedQuality == num) ? null : new string[1] { $"Requested quality {requestedQuality} was clamped to {num}." });
		}

		private static WikiAnswer Recipes(WikiIndex index, WikiItem item, WikiVisibilitySnapshot visibility)
		{
			IReadOnlyList<WikiRecipe> readOnlyList = index.RecipesForOutput(item.Id);
			IReadOnlyList<WikiConversion> readOnlyList2 = index.ConversionsForOutput(item.Id);
			if (readOnlyList.Count == 0 && readOnlyList2.Count == 0)
			{
				int count = index.SourcesForOutput(item.Id).Count;
				return new WikiAnswer(item.DisplayName, new string[1] { "No indexed crafting or input-processing method was found." }, (count <= 0) ? new string[1] { "The item may come from a currently unsupported source system." } : new string[1] { string.Format("{0} direct acquisition source{1} indexed; use /wiki source \"{2}\".", count, (count == 1) ? " is" : "s are", item.DisplayName) });
			}
			List<string> list = new List<string>();
			if (readOnlyList.Count > 0 && readOnlyList2.Count > 0)
			{
				list.Add("Crafting:");
			}
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				WikiRecipe wikiRecipe = readOnlyList[i];
				if (readOnlyList.Count > 1)
				{
					list.Add($"Recipe {i + 1}: {wikiRecipe.Id}");
				}
				list.Add(CraftAt(wikiRecipe, 1));
				list.Add("Initial cost: " + Requirements(wikiRecipe.Requirements, 1, wikiRecipe.RequireOnlyOneIngredient, visibility));
				list.Add($"Output: {wikiRecipe.OutputAmount} | maximum quality: {item.MaxQuality}");
			}
			if (readOnlyList2.Count > 0)
			{
				if (readOnlyList.Count > 0)
				{
					list.Add("Processing:");
				}
				for (int j = 0; j < readOnlyList2.Count; j++)
				{
					WikiConversion wikiConversion = readOnlyList2[j];
					if (readOnlyList2.Count > 1)
					{
						list.Add($"Method {j + 1}: {wikiConversion.StationName} ({ProcessLabel(wikiConversion.Kind)})");
					}
					else
					{
						list.Add("Process at: " + wikiConversion.StationName + " (" + ProcessLabel(wikiConversion.Kind) + ")");
					}
					list.Add(ConversionRequirements(wikiConversion, visibility));
					string arg = (wikiConversion.DurationSeconds.HasValue ? (" | time: " + Number(wikiConversion.DurationSeconds.Value) + " s") : string.Empty);
					list.Add($"Output: {wikiConversion.OutputAmount} {wikiConversion.OutputName}{arg}");
				}
			}
			string[] suggestions = ((item.MaxQuality <= 1) ? null : new string[1] { "Use /wiki upgrades \"" + item.DisplayName + "\" for per-quality costs." });
			return new WikiAnswer(item.DisplayName, list, null, suggestions);
		}

		private static WikiAnswer Upgrades(WikiIndex index, WikiItem item, WikiVisibilitySnapshot visibility)
		{
			if (item.MaxQuality <= 1)
			{
				return new WikiAnswer(item.DisplayName, new string[1] { "This item has no meaningful quality progression." });
			}
			IReadOnlyList<WikiRecipe> readOnlyList = index.RecipesForOutput(item.Id);
			if (readOnlyList.Count == 0)
			{
				return new WikiAnswer(item.DisplayName, new string[1] { "No enabled ObjectDB recipe is available for upgrade costs." });
			}
			List<string> list = new List<string>();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				WikiRecipe wikiRecipe = readOnlyList[i];
				if (readOnlyList.Count > 1)
				{
					list.Add($"Recipe {i + 1}: {wikiRecipe.Id}");
				}
				for (int j = 2; j <= item.MaxQuality; j++)
				{
					list.Add($"To quality {j}: {Requirements(wikiRecipe.Requirements, j, wikiRecipe.RequireOnlyOneIngredient, visibility)} | {CraftAt(wikiRecipe, j)}");
				}
			}
			return new WikiAnswer(item.DisplayName + " upgrades", list, new string[1] { "Costs are per target quality, calculated by Valheim's loaded Requirement.GetAmount data." });
		}

		private static WikiAnswer Uses(WikiIndex index, WikiItem material, WikiVisibilitySnapshot visibility)
		{
			WikiRecipe[] array = (from recipe in index.RecipesUsing(material.Id)
				where visibility.IsVisible(recipe.OutputItemId)
				select recipe).OrderBy<WikiRecipe, string>((WikiRecipe recipe) => recipe.OutputName, StringComparer.CurrentCultureIgnoreCase).ToArray();
			WikiPiece[] array2 = index.PiecesUsing(material.Id).Where(visibility.IsVisible).OrderBy<WikiPiece, string>((WikiPiece piece) => piece.DisplayName, StringComparer.CurrentCultureIgnoreCase)
				.ToArray();
			WikiConversion[] array3 = (from conversion in index.ConversionsUsing(material.Id)
				where visibility.IsVisible(conversion.OutputItemId)
				select conversion).OrderBy<WikiConversion, string>((WikiConversion conversion) => conversion.OutputName, StringComparer.CurrentCultureIgnoreCase).ToArray();
			List<string> list = new List<string>();
			if (array.Length != 0)
			{
				list.Add("Crafting:");
				list.AddRange(array.Select((WikiRecipe recipe) => $"- {recipe.OutputName}: {RequirementAmount(recipe, material.Id, 1)} {material.DisplayName} | {StationText(recipe.StationName, recipe.StationLevelForTargetQuality(1))}"));
			}
			if (array2.Length != 0)
			{
				list.Add("Building:");
				list.AddRange(array2.Select((WikiPiece piece) => $"- {piece.DisplayName}: {piece.Requirements.First((WikiPieceRequirement requirement) => requirement.ItemId.Equals(material.Id, StringComparison.OrdinalIgnoreCase)).Amount} {material.DisplayName}"));
			}
			if (array3.Length != 0)
			{
				list.Add("Processing:");
				list.AddRange(array3.Select((WikiConversion conversion) => "- " + conversion.OutputName + ": " + ConversionUse(conversion, material.Id) + " | " + conversion.StationName + " (" + ProcessLabel(conversion.Kind) + ")"));
			}
			if (list.Count == 0)
			{
				list.Add("No indexed crafting recipe, build piece, or input-processing method consumes this item.");
			}
			return new WikiAnswer("Uses for " + material.DisplayName, list);
		}

		private WikiAnswer AcquisitionSources(WikiIndex index, WikiItem item, WikiSourceKind? sourceKind, WikiVisibilitySnapshot visibility)
		{
			WikiAcquisitionSource[] source = (from wikiAcquisitionSource in index.SourcesForOutput(item.Id)
				where !sourceKind.HasValue || wikiAcquisitionSource.Kind == sourceKind.Value
				orderby wikiAcquisitionSource.Kind
				select wikiAcquisitionSource).ThenBy<WikiAcquisitionSource, string>((WikiAcquisitionSource wikiAcquisitionSource) => wikiAcquisitionSource.SourceName, StringComparer.CurrentCultureIgnoreCase).ThenBy<WikiAcquisitionSource, string>((WikiAcquisitionSource wikiAcquisitionSource) => wikiAcquisitionSource.Id, StringComparer.OrdinalIgnoreCase).ToArray();
			WikiRecipe[] array = (sourceKind.HasValue ? Array.Empty<WikiRecipe>() : index.RecipesForOutput(item.Id).ToArray());
			WikiConversion[] array2 = (sourceKind.HasValue ? Array.Empty<WikiConversion>() : index.ConversionsForOutput(item.Id).ToArray());
			List<string> list = new List<string>();
			if (array.Length != 0)
			{
				list.Add("Crafted:");
				list.AddRange(array.Select((WikiRecipe recipe) => $"- {StationText(recipe.StationName, recipe.StationLevelForTargetQuality(1))}: {Requirements(recipe.Requirements, 1, recipe.RequireOnlyOneIngredient, visibility)} -> {recipe.OutputAmount} {item.DisplayName}"));
			}
			if (array2.Length != 0)
			{
				list.Add("Processed:");
				list.AddRange(array2.Select((WikiConversion conversion) => "- " + conversion.StationName + " (" + ProcessLabel(conversion.Kind) + "): " + ConversionSummary(conversion, visibility)));
			}
			foreach (IGrouping<WikiSourceKind, WikiAcquisitionSource> item2 in from wikiAcquisitionSource in source
				group wikiAcquisitionSource by wikiAcquisitionSource.Kind)
			{
				list.Add(SourceKindLabel(item2.Key) + ":");
				list.AddRange(from display in CollapseSourceVariants(item2)
					select "- " + SourceLabel(display.Source) + ": " + SourceDetails(display.Source, includeOutputName: false, visibility, display.VariantCount));
			}
			if (list.Count == 0)
			{
				string text = (sourceKind.HasValue ? SourceKindLabel(sourceKind.Value).ToLowerInvariant() : "acquisition");
				list.Add("No indexed " + text + " source was found.");
			}
			string[] warnings = ((!sourceKind.HasValue) ? new string[1] { "Chance-based, weighted, multi-output, or zero-minimum environmental tables, fish extra drops/bait probabilities, containers, locations, biome inference, and procedural loot are excluded." } : new string[1] { "Only " + SourceKindLabel(sourceKind.Value).ToLowerInvariant() + " sources were requested; other acquisition categories were not shown." });
			return new WikiAnswer("Sources for " + item.DisplayName, list, warnings);
		}

		private WikiAnswer SourceInventory(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (query.EntityTexts.Count == 0)
			{
				return new WikiAnswer("Missing source", new string[1] { "Please provide a creature or trader name." });
			}
			WikiSourceKind? kind = SourceKindFilter(query);
			WikiAcquisitionSource[] array = (from source in index.Sources
				where visibility.IsVisible(source.OutputItemId)
				where !kind.HasValue || source.Kind == kind.Value
				select source).ToArray();
			if (array.Length == 0)
			{
				return new WikiAnswer("No indexed sources", new string[1] { "No source entries of the requested category are present in the runtime index." });
			}
			string text = query.EntityTexts[0];
			string text2 = TextNormalizer.Normalize(text);
			if (kind == WikiSourceKind.Purchased)
			{
				switch (text2)
				{
				case "trader":
				case "traders":
				case "all traders":
					return SourceInventoryAnswer("Trader goods", array, visibility);
				}
			}
			SourceEntityResolution resolution = ResolveSourceEntity(array, text);
			if (resolution.Status == ResolutionStatus.Resolved)
			{
				WikiAcquisitionSource[] values = array.Where((WikiAcquisitionSource source) => string.Equals(source.SourceName, resolution.Names[0], StringComparison.CurrentCultureIgnoreCase)).ToArray();
				return SourceInventoryAnswer(resolution.Names[0] + " sources", values, visibility);
			}
			if (resolution.Status == ResolutionStatus.Ambiguous)
			{
				return new WikiAnswer("Several possible sources", resolution.Names.Select((string name, int indexValue) => $"{indexValue + 1}. {name}"), null, new string[1] { "Try an exact source name, for example /wiki " + ((kind == WikiSourceKind.Purchased) ? "sells" : "drops") + " \"" + resolution.Names[0] + "\"." });
			}
			return new WikiAnswer("Source not found", new string[1] { "No confident source match for '" + text + "'." }, null, new string[1] { (kind == WikiSourceKind.Purchased) ? "Try /wiki what does the trader sell." : "Check the creature name or use /wiki source <item>." });
		}

		private WikiAnswer SourceInventoryAnswer(string title, IEnumerable<WikiAcquisitionSource> values, WikiVisibilitySnapshot visibility)
		{
			IReadOnlyList<SourceDisplayGroup> readOnlyList = CollapseSourceVariants(values.OrderBy<WikiAcquisitionSource, string>((WikiAcquisitionSource source) => source.SourceName, StringComparer.CurrentCultureIgnoreCase).ThenBy<WikiAcquisitionSource, string>((WikiAcquisitionSource source) => source.OutputName, StringComparer.CurrentCultureIgnoreCase).ToArray());
			List<string> list = new List<string>();
			foreach (IGrouping<string, SourceDisplayGroup> item in readOnlyList.GroupBy<SourceDisplayGroup, string>((SourceDisplayGroup display) => display.Source.SourceName, StringComparer.CurrentCultureIgnoreCase))
			{
				if (readOnlyList.Select((SourceDisplayGroup display) => display.Source.SourceName).Distinct<string>(StringComparer.CurrentCultureIgnoreCase).Skip(1)
					.Any())
				{
					list.Add(SourceLabel(item.First().Source) + ":");
				}
				list.AddRange(item.Select((SourceDisplayGroup display) => "- " + SourceDetails(display.Source, includeOutputName: true, visibility, display.VariantCount)));
			}
			return new WikiAnswer($"{title} ({readOnlyList.Count})", list);
		}

		private SourceEntityResolution ResolveSourceEntity(IEnumerable<WikiAcquisitionSource> values, string text)
		{
			bool wasQuoted;
			string query = TextNormalizer.Unquote(text, out wasQuoted);
			string normalized = TextNormalizer.Normalize(query);
			var source = (from @group in values.GroupBy<WikiAcquisitionSource, string>((WikiAcquisitionSource wikiAcquisitionSource) => wikiAcquisitionSource.SourceName, StringComparer.CurrentCultureIgnoreCase)
				select new
				{
					Name = @group.Key,
					InternalNames = @group.Select((WikiAcquisitionSource wikiAcquisitionSource) => wikiAcquisitionSource.SourceInternalName).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToArray()
				}).OrderBy(entity => entity.Name, StringComparer.CurrentCultureIgnoreCase).ToArray();
			string[] array = (from entity in source
				where string.Equals(entity.Name, query, StringComparison.CurrentCultureIgnoreCase) || TextNormalizer.Normalize(entity.Name) == normalized || entity.InternalNames.Any((string name) => string.Equals(name, query, StringComparison.OrdinalIgnoreCase) || TextNormalizer.Normalize(name) == normalized)
				select entity.Name).ToArray();
			if (array.Length != 0)
			{
				return new SourceEntityResolution((array.Length != 1) ? ResolutionStatus.Ambiguous : ResolutionStatus.Resolved, array);
			}
			if (wasQuoted || !options.FuzzyMatchingEnabled)
			{
				return new SourceEntityResolution(ResolutionStatus.NotFound, Array.Empty<string>());
			}
			var array2 = (from entity in source
				select new
				{
					Name = entity.Name,
					Score = new double[1] { FuzzyMatcher.Similarity(query, entity.Name) }.Concat(entity.InternalNames.Select((string name) => FuzzyMatcher.Similarity(query, name))).Max()
				} into candidate
				where candidate.Score >= options.FuzzyMatchThreshold
				orderby candidate.Score descending
				select candidate).ThenBy(candidate => candidate.Name, StringComparer.CurrentCultureIgnoreCase).Take(5).ToArray();
			if (array2.Length == 0)
			{
				return new SourceEntityResolution(ResolutionStatus.NotFound, Array.Empty<string>());
			}
			bool flag = array2.Length > 1 && array2[0].Score - array2[1].Score <= options.AmbiguityMargin;
			int status = (flag ? 1 : 0);
			IEnumerable<string> names;
			if (!flag)
			{
				IEnumerable<string> enumerable = new string[1] { array2[0].Name };
				names = enumerable;
			}
			else
			{
				names = array2.Select(candidate => candidate.Name);
			}
			return new SourceEntityResolution((ResolutionStatus)status, names);
		}

		private string SourceLabel(WikiAcquisitionSource source)
		{
			if (!options.ShowSourceMod || string.IsNullOrWhiteSpace(source.SourceMod))
			{
				return source.SourceName;
			}
			return source.SourceName + " [" + source.SourceMod + "]";
		}

		private static string SourceDetails(WikiAcquisitionSource source, bool includeOutputName, WikiVisibilitySnapshot visibility, int variantCount = 1)
		{
			string text = ((source.MinimumAmount == source.MaximumAmount) ? source.MinimumAmount.ToString(CultureInfo.InvariantCulture) : $"{source.MinimumAmount}-{source.MaximumAmount}");
			string text2 = (includeOutputName ? (" " + source.OutputName) : string.Empty);
			List<string> list = new List<string>();
			switch (source.Kind)
			{
			case WikiSourceKind.Purchased:
			{
				string text4 = (source.Price.HasValue ? string.Format(" for {0} {1}", source.Price.Value, (source.CostItemId == null) ? (source.CostItemName ?? "currency") : visibility.ItemName(source.CostItemId, source.CostItemName ?? "currency")) : string.Empty);
				list.Add(text + text2 + text4);
				break;
			}
			case WikiSourceKind.PassivelyProduced:
			{
				string text3 = (source.ProductionIntervalSeconds.HasValue ? (" per " + Number(source.ProductionIntervalSeconds.Value) + " s") : string.Empty);
				list.Add(text + text2 + text3);
				break;
			}
			case WikiSourceKind.Harvested:
				list.Add(source.WorldScaled ? ("base yield " + text + text2) : (text + text2));
				break;
			case WikiSourceKind.MinedOrDestroyed:
				list.Add(source.ConfiguredMinimumAmount.HasValue ? ("loaded yield " + text + text2) : (source.WorldScaled ? ("base yield " + text + text2) : (text + text2)));
				break;
			case WikiSourceKind.Fishing:
				list.Add(text + text2);
				break;
			default:
				list.Add(text + text2);
				break;
			}
			if (source.Chance.HasValue)
			{
				list.Add("chance " + Number(source.Chance.Value * 100.0) + "%");
			}
			if (source.Capacity.HasValue)
			{
				list.Add($"capacity {source.Capacity.Value}");
			}
			if (source.RespawnSeconds.HasValue)
			{
				list.Add("respawn " + Number(source.RespawnSeconds.Value / 60.0) + " min");
			}
			if (source.ConfiguredMinimumAmount.HasValue && source.ConfiguredMaximumAmount.HasValue)
			{
				string text5 = ((source.ConfiguredMinimumAmount.Value == source.ConfiguredMaximumAmount.Value) ? source.ConfiguredMinimumAmount.Value.ToString(CultureInfo.InvariantCulture) : $"{source.ConfiguredMinimumAmount.Value}-{source.ConfiguredMaximumAmount.Value}");
				if (source.ConfiguredMinimumAmount.Value != source.MinimumAmount || source.ConfiguredMaximumAmount.Value != source.MaximumAmount)
				{
					list.Add("configured base " + text5 + text2);
				}
				list.Add((source.QuantitySemantics == WikiQuantitySemantics.ExactLoadedRange) ? "classification: guaranteed variable" : "classification: guaranteed fixed");
			}
			if (source.LoadedResourceRate.HasValue && Math.Abs(source.LoadedResourceRate.Value - 1.0) > 0.0001)
			{
				list.Add("loaded resource rate " + Number(source.LoadedResourceRate.Value) + "x");
			}
			if (!string.IsNullOrWhiteSpace(source.UnlockRequirement))
			{
				list.Add("requires global key " + source.UnlockRequirement);
			}
			if (source.OnePerPlayer)
			{
				list.Add("one per player");
			}
			if (!string.IsNullOrWhiteSpace(source.Method))
			{
				list.Add("method: " + source.Method);
			}
			if (source.MinimumToolTier.HasValue)
			{
				list.Add($"minimum tool tier {source.MinimumToolTier.Value}");
			}
			if (source.LevelScaled)
			{
				list.Add("quantity can scale with creature level");
			}
			if (source.WorldScaled)
			{
				list.Add("world-rate scaled");
			}
			if (variantCount > 1)
			{
				list.Add($"{variantCount} loaded prefab variants");
			}
			list.Add("certainty: " + SourceCertaintyLabel(source.Certainty));
			return string.Join(" | ", list);
		}

		private static IReadOnlyList<SourceDisplayGroup> CollapseSourceVariants(IEnumerable<WikiAcquisitionSource> sources)
		{
			return (from @group in sources.GroupBy<WikiAcquisitionSource, string>(SourceDisplayKey, StringComparer.Ordinal)
				select new SourceDisplayGroup(@group.First(), @group.Count())).ToArray();
		}

		private static string SourceDisplayKey(WikiAcquisitionSource source)
		{
			return string.Join("\u001f", source.Kind.ToString(), source.Certainty.ToString(), source.Adapter, source.SourceName, source.SourceMod ?? string.Empty, source.OutputItemId, source.OutputName, source.MinimumAmount.ToString(CultureInfo.InvariantCulture), source.MaximumAmount.ToString(CultureInfo.InvariantCulture), NullableNumber(source.Chance), source.CostItemId ?? string.Empty, source.CostItemName ?? string.Empty, source.Price?.ToString(CultureInfo.InvariantCulture) ?? string.Empty, source.UnlockRequirement ?? string.Empty, NullableNumber(source.ProductionIntervalSeconds), source.Capacity?.ToString(CultureInfo.InvariantCulture) ?? string.Empty, NullableNumber(source.RespawnSeconds), source.OnePerPlayer.ToString(), source.LevelScaled.ToString(), source.WorldScaled.ToString(), source.Method ?? string.Empty, source.MinimumToolTier?.ToString(CultureInfo.InvariantCulture) ?? string.Empty, source.QuantitySemantics.ToString(), source.ConfiguredMinimumAmount?.ToString(CultureInfo.InvariantCulture) ?? string.Empty, source.ConfiguredMaximumAmount?.ToString(CultureInfo.InvariantCulture) ?? string.Empty, NullableNumber(source.LoadedResourceRate));
		}

		private static string NullableNumber(double? value)
		{
			if (!value.HasValue)
			{
				return string.Empty;
			}
			return value.Value.ToString("R", CultureInfo.InvariantCulture);
		}

		private static WikiSourceKind? SourceKindFilter(WikiQuery query)
		{
			if (!query.Filters.TryGetValue("sourceKind", out string value))
			{
				return null;
			}
			if (!Enum.TryParse<WikiSourceKind>(value, ignoreCase: true, out var result))
			{
				return null;
			}
			return result;
		}

		private static string SourceKindLabel(WikiSourceKind kind)
		{
			return kind switch
			{
				WikiSourceKind.CreatureDrop => "Creature drop", 
				WikiSourceKind.Purchased => "Purchased", 
				WikiSourceKind.PassivelyProduced => "Passively produced", 
				WikiSourceKind.Harvested => "Harvested", 
				WikiSourceKind.MinedOrDestroyed => "Mined or destroyed", 
				_ => "Fishing", 
			};
		}

		private static string SourceCertaintyLabel(WikiSourceCertainty certainty)
		{
			return certainty switch
			{
				WikiSourceCertainty.Chance => "chance", 
				WikiSourceCertainty.Conditional => "conditional", 
				_ => "guaranteed", 
			};
		}

		private static WikiAnswer Station(WikiIndex index, WikiItem item)
		{
			IReadOnlyList<WikiRecipe> recipes = index.RecipesForOutput(item.Id);
			IReadOnlyList<WikiConversion> readOnlyList = index.ConversionsForOutput(item.Id);
			if (recipes.Count == 0 && readOnlyList.Count == 0)
			{
				return new WikiAnswer(item.DisplayName, new string[1] { "No indexed crafting or input-processing method was found." });
			}
			IEnumerable<string> lines = recipes.Select((WikiRecipe recipe, int indexValue) => (recipes.Count != 1) ? $"Recipe {indexValue + 1}: {CraftAt(recipe, 1)}" : CraftAt(recipe, 1)).Concat(readOnlyList.Select((WikiConversion conversion) => "Process at: " + conversion.StationName + " (" + ProcessLabel(conversion.Kind) + ")"));
			return new WikiAnswer("How to make " + item.DisplayName, lines);
		}

		private WikiAnswer StationQuery(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (query.EntityTexts.Count == 0)
			{
				return new WikiAnswer("Missing item or station", new string[1] { "Please provide an item or crafting-station name." });
			}
			string text = query.EntityTexts[0];
			StationResolution stationResolution = ResolveStation(index, text, allowFuzzy: false, visibility);
			if (stationResolution.Status != ResolutionStatus.NotFound)
			{
				return StationResolutionAnswer(index, stationResolution, visibility);
			}
			ResolutionResult resolutionResult = resolver.Resolve(index, text, visibility.IsVisible);
			if (resolutionResult.Status == ResolutionStatus.Resolved && resolutionResult.Item != null)
			{
				return Station(index, resolutionResult.Item);
			}
			if (resolutionResult.Status == ResolutionStatus.Ambiguous)
			{
				return ResolutionAnswer(text, resolutionResult);
			}
			StationResolution stationResolution2 = ResolveStation(index, text, allowFuzzy: true, visibility);
			if (stationResolution2.Status != ResolutionStatus.NotFound)
			{
				return StationResolutionAnswer(index, stationResolution2, visibility);
			}
			return new WikiAnswer("Item or station not found", new string[1] { "No confident item or crafting-station match for '" + text + "'." }, null, new string[1] { "Try /wiki station forge or /wiki station iron sword." });
		}

		private static WikiAnswer StationContents(WikiIndex index, string stationName, WikiVisibilitySnapshot visibility)
		{
			WikiRecipe[] array = (from @group in (from recipe in index.Recipes
					where string.Equals(recipe.StationName, stationName, StringComparison.CurrentCultureIgnoreCase)
					where visibility.IsVisible(recipe.OutputItemId)
					select recipe).GroupBy<WikiRecipe, string>((WikiRecipe recipe) => $"{recipe.OutputItemId}\u001f{recipe.StationLevelForTargetQuality(1)}", StringComparer.OrdinalIgnoreCase)
				select @group.First()).OrderBy<WikiRecipe, string>((WikiRecipe recipe) => recipe.OutputName, StringComparer.CurrentCultureIgnoreCase).ToArray();
			WikiPiece[] array2 = (from @group in index.Pieces.Where((WikiPiece piece) => string.Equals(piece.StationName, stationName, StringComparison.CurrentCultureIgnoreCase)).Where(visibility.IsVisible).GroupBy<WikiPiece, string>((WikiPiece piece) => piece.Id, StringComparer.OrdinalIgnoreCase)
				select @group.First()).OrderBy<WikiPiece, string>((WikiPiece piece) => piece.DisplayName, StringComparer.CurrentCultureIgnoreCase).ToArray();
			WikiConversion[] array3 = (from @group in (from conversion in index.Conversions
					where string.Equals(conversion.StationName, stationName, StringComparison.CurrentCultureIgnoreCase)
					where visibility.IsVisible(conversion.OutputItemId)
					select conversion).GroupBy<WikiConversion, string>((WikiConversion conversion) => conversion.Id, StringComparer.OrdinalIgnoreCase)
				select @group.First()).OrderBy<WikiConversion, string>((WikiConversion conversion) => conversion.OutputName, StringComparer.CurrentCultureIgnoreCase).ToArray();
			List<string> list = new List<string>();
			if (array.Length != 0)
			{
				list.Add("Crafting:");
				list.AddRange(array.Select((WikiRecipe recipe) => $"- {recipe.OutputName} (level {recipe.StationLevelForTargetQuality(1)})"));
			}
			if (array2.Length != 0)
			{
				list.Add("Building:");
				list.AddRange(array2.Select((WikiPiece piece) => "- " + piece.DisplayName));
			}
			if (array3.Length != 0)
			{
				list.Add("Processing:");
				list.AddRange(array3.Select((WikiConversion conversion) => "- " + ConversionSummary(conversion, visibility)));
			}
			if (list.Count == 0)
			{
				list.Add("No indexed recipe, build piece, or processing conversion uses this station.");
			}
			return new WikiAnswer($"{stationName} uses ({array.Length + array2.Length + array3.Length})", list, (array.Length == 0) ? null : new string[1] { "Crafting levels shown are the minimum for quality 1." });
		}

		private StationResolution ResolveStation(WikiIndex index, string text, bool allowFuzzy, WikiVisibilitySnapshot visibility)
		{
			bool wasQuoted;
			string query = TextNormalizer.Unquote(text, out wasQuoted);
			string normalized = TextNormalizer.Normalize(query);
			string[] source = (from name in (from recipe in index.Recipes
					where visibility.IsVisible(recipe.OutputItemId)
					select recipe.StationName).Concat<string>(from piece in index.Pieces.Where(visibility.IsVisible)
					select piece.StationName).Concat(from conversion in index.Conversions
					where visibility.IsVisible(conversion.OutputItemId)
					select conversion.StationName)
				where !string.IsNullOrWhiteSpace(name)
				select (name)).Distinct<string>(StringComparer.CurrentCultureIgnoreCase).OrderBy<string, string>((string name) => name, StringComparer.CurrentCultureIgnoreCase).ToArray();
			string[] array = source.Where((string name) => string.Equals(name, query, StringComparison.CurrentCultureIgnoreCase)).ToArray();
			if (array.Length == 0)
			{
				array = source.Where((string name) => TextNormalizer.Normalize(name) == normalized).ToArray();
			}
			if (array.Length != 0)
			{
				return new StationResolution((array.Length != 1) ? ResolutionStatus.Ambiguous : ResolutionStatus.Resolved, array, "exact station name");
			}
			if (!allowFuzzy || wasQuoted || !options.FuzzyMatchingEnabled)
			{
				return new StationResolution(ResolutionStatus.NotFound, Array.Empty<string>(), "no exact station match");
			}
			var array2 = (from name in source
				select new
				{
					Name = name,
					Score = FuzzyMatcher.Similarity(query, name)
				} into candidate
				where candidate.Score >= options.FuzzyMatchThreshold
				orderby candidate.Score descending
				select candidate).ThenBy(candidate => candidate.Name, StringComparer.CurrentCultureIgnoreCase).Take(5).ToArray();
			if (array2.Length == 0)
			{
				return new StationResolution(ResolutionStatus.NotFound, Array.Empty<string>(), "no fuzzy station match");
			}
			bool flag = array2.Length > 1 && array2[0].Score - array2[1].Score <= options.AmbiguityMargin;
			int status = (flag ? 1 : 0);
			IEnumerable<string> names;
			if (!flag)
			{
				IEnumerable<string> enumerable = new string[1] { array2[0].Name };
				names = enumerable;
			}
			else
			{
				names = array2.Select(candidate => candidate.Name);
			}
			return new StationResolution((ResolutionStatus)status, names, flag ? "station matches are within the ambiguity margin" : "fuzzy station name");
		}

		private static WikiAnswer StationResolutionAnswer(WikiIndex index, StationResolution resolution, WikiVisibilitySnapshot visibility)
		{
			if (resolution.Status == ResolutionStatus.Resolved)
			{
				return StationContents(index, resolution.Names[0], visibility);
			}
			return new WikiAnswer("Several possible stations", resolution.Names.Select((string name, int candidateIndex) => $"{candidateIndex + 1}. {name}"), null, new string[1] { "Try an exact station name, for example /wiki station \"" + resolution.Names[0] + "\"." });
		}

		private WikiAnswer Compare(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (query.EntityTexts.Count != 2)
			{
				return new WikiAnswer("Comparison", new string[1] { "Provide exactly two item names." });
			}
			ResolutionResult resolutionResult = resolver.Resolve(index, query.EntityTexts[0], visibility.IsVisible);
			if (resolutionResult.Status != ResolutionStatus.Resolved || resolutionResult.Item == null)
			{
				return ResolutionAnswer(query.EntityTexts[0], resolutionResult);
			}
			ResolutionResult resolutionResult2 = resolver.Resolve(index, query.EntityTexts[1], visibility.IsVisible);
			if (resolutionResult2.Status != ResolutionStatus.Resolved || resolutionResult2.Item == null)
			{
				return ResolutionAnswer(query.EntityTexts[1], resolutionResult2);
			}
			WikiItem item = resolutionResult.Item;
			WikiItem item2 = resolutionResult2.Item;
			int num = query.Quality ?? 1;
			int num2 = ClampQuality(item, num);
			int num3 = ClampQuality(item2, num);
			WikiQualityStats leftStats = item.StatsAt(num2);
			WikiQualityStats rightStats = item2.StatsAt(num3);
			if (query.Filters.TryGetValue("metric", out string value))
			{
				return CompareByMetric(item, item2, leftStats, rightStats, num2, num3, num, value);
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			if (item.Kind == WikiItemKind.Weapon && item2.Kind == WikiItemKind.Weapon)
			{
				if (leftStats.Damage != null && rightStats.Damage != null)
				{
					list.Add(Pair("Listed total attack damage", leftStats.Damage.ListedCombatTotal, rightStats.Damage.ListedCombatTotal, item, item2));
					foreach (DamageKind item3 in CombatDamageOrder.Where((DamageKind kind) => leftStats.Damage.HasPositive(kind) || rightStats.Damage.HasPositive(kind)))
					{
						list.Add(Pair(item3.ToString(), leftStats.Damage.Get(item3), rightStats.Damage.Get(item3), item, item2));
					}
				}
				else
				{
					list2.Add("Loaded damage data was unavailable for one or both requested qualities, so no damage ranking is shown.");
				}
				AddPair(list, "Primary attack stamina", leftStats.PrimaryAttackStamina, rightStats.PrimaryAttackStamina, item, item2);
				AddPair(list, "Secondary attack stamina", leftStats.SecondaryAttackStamina, rightStats.SecondaryAttackStamina, item, item2);
				AddPair(list, "Durability", leftStats.Durability, rightStats.Durability, item, item2);
				AddPair(list, "Block", leftStats.Block, rightStats.Block, item, item2);
				AddPair(list, "Parry bonus", item.ParryBonus, item2.ParryBonus, item, item2, "x");
				list.Add(Pair("Movement modifier %", item.MovementModifier * 100.0, item2.MovementModifier * 100.0, item, item2));
				if (options.ShowComparisonAssumptions)
				{
					list2.Add("Listed damage excludes chop/pickaxe and does not model resistances, status effects, skill scaling, attack chains, or real DPS.");
				}
			}
			else if (item.Kind == WikiItemKind.Armor && item2.Kind == WikiItemKind.Armor)
			{
				AddPair(list, "Armor", leftStats.Armor, rightStats.Armor, item, item2);
				AddPair(list, "Durability", leftStats.Durability, rightStats.Durability, item, item2);
				list.Add(Pair("Movement modifier %", item.MovementModifier * 100.0, item2.MovementModifier * 100.0, item, item2));
				list.Add(Pair("Weight", item.Weight, item2.Weight, item, item2));
			}
			else if (item.Kind == WikiItemKind.Shield && item2.Kind == WikiItemKind.Shield)
			{
				AddPair(list, "Block", leftStats.Block, rightStats.Block, item, item2);
				AddPair(list, "Durability", leftStats.Durability, rightStats.Durability, item, item2);
				AddPair(list, "Parry bonus", item.ParryBonus, item2.ParryBonus, item, item2, "x");
				list.Add(Pair("Movement modifier %", item.MovementModifier * 100.0, item2.MovementModifier * 100.0, item, item2));
				list.Add(Pair("Weight", item.Weight, item2.Weight, item, item2));
			}
			else if (item.Kind == WikiItemKind.Food && item2.Kind == WikiItemKind.Food)
			{
				AddPair(list, "Health", item.FoodHealth, item2.FoodHealth, item, item2);
				AddPair(list, "Stamina", item.FoodStamina, item2.FoodStamina, item, item2);
				AddPair(list, "Eitr", item.FoodEitr, item2.FoodEitr, item, item2);
				AddPair(list, "Duration seconds", item.FoodDurationSeconds, item2.FoodDurationSeconds, item, item2);
				AddPair(list, "Regeneration", item.FoodRegeneration, item2.FoodRegeneration, item, item2);
			}
			else
			{
				list.Add(Pair("Weight", item.Weight, item2.Weight, item, item2));
				list.Add("Category: " + item.DisplayName + " " + item.Category + " | " + item2.DisplayName + " " + item2.Category);
				list2.Add("These items do not share a supported comparison profile, so no overall ranking is given.");
			}
			list.Add($"Quality assumption: {item.DisplayName} q{num2} | {item2.DisplayName} q{num3}");
			if (num2 != num || num3 != num)
			{
				list2.Add("Requested quality was clamped independently to each item's maximum quality.");
			}
			return new WikiAnswer(item.DisplayName + " vs " + item2.DisplayName, list, list2);
		}

		private static WikiAnswer CompareByMetric(WikiItem left, WikiItem right, WikiQualityStats leftStats, WikiQualityStats rightStats, int leftQuality, int rightQuality, int requestedQuality, string metricText)
		{
			if (!ComparisonMetricCatalog.TryResolve(metricText, left, right, out ComparisonMetricDefinition metric, out string diagnostic) || metric == null)
			{
				return UnsupportedMetric(diagnostic);
			}
			if (!ComparisonMetricCatalog.TryValue(metric, left, leftStats, out var value) || !ComparisonMetricCatalog.TryValue(metric, right, rightStats, out var value2))
			{
				return new WikiAnswer(left.DisplayName + " vs " + right.DisplayName, new string[1] { metric.Name + " is unavailable or inapplicable for one or both loaded items at the requested quality." }, null, new string[1] { "Supported metrics: " + ComparisonMetricCatalog.SupportedSummary + "." });
			}
			int num = ComparisonMetricCatalog.Compare(metric, value, value2);
			string text = ((num == 0) ? ("Result: tied on " + metric.Name.ToLowerInvariant() + ".") : ("Result: " + ((num > 0) ? left.DisplayName : right.DisplayName) + " ranks higher on this selected metric by " + Number(Math.Abs(value - value2)) + metric.Suffix + "."));
			List<string> list = new List<string> { metric.Caveat };
			if (leftQuality != requestedQuality || rightQuality != requestedQuality)
			{
				list.Add("Requested quality was clamped independently to each item's maximum quality.");
			}
			return new WikiAnswer(left.DisplayName + " vs " + right.DisplayName, new string[4]
			{
				"Selected metric: " + metric.Name + " (" + metric.DirectionLabel + ").",
				Pair(metric.Name, value, value2, left, right, metric.Suffix),
				text,
				$"Quality assumption: {left.DisplayName} q{leftQuality} | {right.DisplayName} q{rightQuality}"
			}, list);
		}

		private WikiAnswer ExplainComparison(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (query.EntityTexts.Count != 2)
			{
				return new WikiAnswer("Why comparison", new string[1] { "Provide exactly two item names." });
			}
			ResolutionResult resolutionResult = resolver.Resolve(index, query.EntityTexts[0], visibility.IsVisible);
			if (resolutionResult.Status != ResolutionStatus.Resolved || resolutionResult.Item == null)
			{
				return ResolutionAnswer(query.EntityTexts[0], resolutionResult);
			}
			ResolutionResult resolutionResult2 = resolver.Resolve(index, query.EntityTexts[1], visibility.IsVisible);
			if (resolutionResult2.Status != ResolutionStatus.Resolved || resolutionResult2.Item == null)
			{
				return ResolutionAnswer(query.EntityTexts[1], resolutionResult2);
			}
			WikiItem item = resolutionResult.Item;
			WikiItem item2 = resolutionResult2.Item;
			int num = query.Quality ?? 1;
			int num2 = ClampQuality(item, num);
			int num3 = ClampQuality(item2, num);
			if (!ComparisonMetricCatalog.TryResolve(query.Filters.TryGetValue("metric", out string value) ? value : "damage", item, item2, out ComparisonMetricDefinition metric, out string diagnostic) || metric == null)
			{
				return UnsupportedMetric(diagnostic);
			}
			if (!ComparisonMetricCatalog.TryValue(metric, item, item.StatsAt(num2), out var value2) || !ComparisonMetricCatalog.TryValue(metric, item2, item2.StatsAt(num3), out var value3))
			{
				return new WikiAnswer("Comparison explanation unavailable", new string[1] { metric.Name + " is unavailable or inapplicable for one or both loaded items." });
			}
			int num4 = ComparisonMetricCatalog.Compare(metric, value2, value3);
			string text = ((num4 > 0) ? ("The loaded values support the premise: " + item.DisplayName + " ranks higher on this metric by " + Number(Math.Abs(value2 - value3)) + metric.Suffix + ".") : ((num4 >= 0) ? ("The loaded values do not support a stronger claim: both items are tied on " + metric.Name.ToLowerInvariant() + ".") : ("The loaded values do not support the premise: " + item2.DisplayName + " ranks higher on this metric by " + Number(Math.Abs(value2 - value3)) + metric.Suffix + ".")));
			List<string> list = new List<string> { metric.Caveat };
			if (num2 != num || num3 != num)
			{
				list.Add("Requested quality was clamped independently to each item's maximum quality.");
			}
			return new WikiAnswer("Why " + item.DisplayName + " versus " + item2.DisplayName, new string[5]
			{
				"Selected metric: " + metric.Name + " (" + metric.DirectionLabel + ").",
				$"{item.DisplayName} q{num2}: {Number(value2)}{metric.Suffix}",
				$"{item2.DisplayName} q{num3}: {Number(value3)}{metric.Suffix}",
				text,
				"Explanation source: deterministic loaded runtime fields only."
			}, list);
		}

		private WikiAnswer RankCategory(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (!query.Filters.TryGetValue("category", out string value) || !query.Filters.TryGetValue("metric", out string value2))
			{
				return new WikiAnswer("Category comparison", new string[1] { "Provide a supported category and explicit metric." });
			}
			WikiItem[] array = CategoryCandidates(index, value).Where(visibility.IsVisible).ToArray();
			if (array.Length == 0)
			{
				return new WikiAnswer("Unsupported comparison category", new string[1] { "No supported loaded category matched '" + value + "'." }, null, new string[1] { "Try foods, shields, armor, weapons, swords, axes, bows, spears, clubs, knives, or polearms." });
			}
			if (!ComparisonMetricCatalog.TryResolve(value2, array[0], array[0], out ComparisonMetricDefinition metric, out string diagnostic) || metric == null)
			{
				return UnsupportedMetric(diagnostic);
			}
			int requestedQuality = query.Quality ?? 1;
			var array2 = (from anon in array.Select((WikiItem item) => new
				{
					Item = item,
					Quality = ClampQuality(item, requestedQuality)
				}).Select(anon =>
				{
					double value3;
					bool available = ComparisonMetricCatalog.TryValue(metric, anon.Item, anon.Item.StatsAt(anon.Quality), out value3);
					return new
					{
						Item = anon.Item,
						Quality = anon.Quality,
						Available = available,
						Value = value3
					};
				})
				where anon.Available
				select anon).ToArray();
			if (array2.Length == 0)
			{
				return new WikiAnswer(value + " by " + metric.Name, new string[1] { "The selected metric is unavailable or inapplicable for every loaded item in this category." });
			}
			var source = (metric.HigherRanksFirst ? array2.OrderByDescending(anon => anon.Value).ThenBy(anon => anon.Item.DisplayName, StringComparer.CurrentCultureIgnoreCase) : array2.OrderBy(anon => anon.Value).ThenBy(anon => anon.Item.DisplayName, StringComparer.CurrentCultureIgnoreCase));
			int count = Math.Max(1, options.MaximumAlternativeResults);
			var array3 = source.Take(count).ToArray();
			List<string> list = new List<string>();
			list.Add($"Metric: {metric.Name}; {metric.DirectionLabel}. Showing {array3.Length} of {array2.Length} loaded items with an available value.");
			list.Add(metric.Caveat);
			List<string> list2 = list;
			if (array3.Any(anon => anon.Quality != requestedQuality))
			{
				list2.Add("Requested quality was clamped independently to each item's loaded maximum quality.");
			}
			return new WikiAnswer("Top " + value + " by " + metric.Name, array3.Select((anon, int rank) => $"{rank + 1}. {Label(anon.Item)} q{anon.Quality}: {Number(anon.Value)}{metric.Suffix}"), list2);
		}

		private static IEnumerable<WikiItem> CategoryCandidates(WikiIndex index, string categoryText)
		{
			string text = TextNormalizer.Normalize(categoryText);
			switch (text)
			{
			case "foods":
			case "food":
				return index.Items.Values.Where((WikiItem item) => item.Kind == WikiItemKind.Food);
			case "shield":
			case "shields":
				return index.Items.Values.Where((WikiItem item) => item.Kind == WikiItemKind.Shield);
			case "armor":
			case "armour":
				return index.Items.Values.Where((WikiItem item) => item.Kind == WikiItemKind.Armor);
			case "weapon":
			case "weapons":
				return index.Items.Values.Where((WikiItem item) => item.Kind == WikiItemKind.Weapon);
			default:
			{
				string category = text.TrimEnd(new char[1] { 's' });
				if (category == "mace")
				{
					category = "club";
				}
				bool flag;
				switch (category)
				{
				case "knife":
				case "spear":
				case "sword":
				case "axe":
				case "bow":
				case "club":
				case "polearm":
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (!flag)
				{
					return Array.Empty<WikiItem>();
				}
				return index.Items.Values.Where((WikiItem item) => item.Kind == WikiItemKind.Weapon && CategoryMatches(item.Category, category));
			}
			}
		}

		private WikiAnswer Stronger(WikiIndex index, WikiItem baseline, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			string value;
			bool flag = query.Filters.TryGetValue("metric", out value);
			if (!flag && baseline.Kind != WikiItemKind.Weapon)
			{
				return new WikiAnswer("Stronger than " + baseline.DisplayName, new string[1] { "Unqualified stronger-than is defined only for weapons; select a supported metric for other item profiles." });
			}
			int requestedQuality = query.Quality ?? 1;
			int num = ClampQuality(baseline, requestedQuality);
			if (!ComparisonMetricCatalog.TryResolve(flag ? value : "damage", baseline, baseline, out ComparisonMetricDefinition metric, out string diagnostic) || metric == null)
			{
				return UnsupportedMetric(diagnostic);
			}
			if (!ComparisonMetricCatalog.TryValue(metric, baseline, baseline.StatsAt(num), out var baselineValue))
			{
				return new WikiAnswer("Alternatives to " + baseline.DisplayName, new string[1] { metric.Name + " is unavailable or inapplicable for the loaded baseline item." });
			}
			var array = (from anon in (from item in index.Items.Values.Where(visibility.IsVisible)
					where !item.Id.Equals(baseline.Id, StringComparison.OrdinalIgnoreCase)
					where ComparableAlternative(baseline, item)
					select new
					{
						Item = item,
						Quality = ClampQuality(item, requestedQuality)
					}).Select(anon =>
				{
					double value2;
					bool available = ComparisonMetricCatalog.TryValue(metric, anon.Item, anon.Item.StatsAt(anon.Quality), out value2);
					return new
					{
						Item = anon.Item,
						Quality = anon.Quality,
						Available = available,
						Value = value2
					};
				})
				where anon.Available
				select new
				{
					Item = anon.Item,
					Quality = anon.Quality,
					Value = anon.Value,
					Improvement = ComparisonMetricCatalog.Improvement(metric, anon.Value, baselineValue)
				} into anon
				where anon.Improvement > 0.0
				orderby anon.Improvement
				select anon).ThenBy(anon => anon.Item.DisplayName, StringComparer.CurrentCultureIgnoreCase).Take(Math.Max(1, options.MaximumAlternativeResults)).ToArray();
			string[] lines = ((array.Length != 0) ? array.Select(anon => $"- {Label(anon.Item)} q{anon.Quality}: {Number(anon.Value)}{metric.Suffix} (improves by {Number(anon.Improvement)}{metric.Suffix})").ToArray() : new string[1] { "No comparable indexed item strictly improves on " + Number(baselineValue) + metric.Suffix + " " + metric.Name.ToLowerInvariant() + "." });
			List<string> list = new List<string>();
			list.Add(string.Format("Metric: {0} at requested quality {1}; {2}. {3}", metric.Name, requestedQuality, metric.DirectionLabel, (baseline.Kind == WikiItemKind.Weapon) ? "Weapon alternatives stay in the same category." : "Alternatives stay in the same item profile."));
			list.Add(metric.Caveat);
			List<string> list2 = list;
			if (num != requestedQuality || array.Any(anon => anon.Quality != requestedQuality))
			{
				list2.Add("Requested quality was clamped independently to loaded maximum quality.");
			}
			if (!flag && requestedQuality == 1)
			{
				list2.Add("Default stronger metric: quality-1 listed combat damage in the same weapon category.");
			}
			return new WikiAnswer("Alternatives by " + metric.Name + " for " + baseline.DisplayName, lines, list2);
		}

		private static bool ComparableAlternative(WikiItem baseline, WikiItem candidate)
		{
			if (baseline.Kind == candidate.Kind)
			{
				if (baseline.Kind == WikiItemKind.Weapon)
				{
					return string.Equals(baseline.Category, candidate.Category, StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}
			return false;
		}

		private static WikiAnswer UnsupportedMetric(string diagnostic)
		{
			return new WikiAnswer("Unsupported comparison metric", new string[1] { diagnostic }, null, new string[1] { "Try: by slash, by stamina, by block, by armor, or by weight. Supported metrics: " + ComparisonMetricCatalog.SupportedSummary + "." });
		}

		private WikiAnswer Find(WikiIndex index, WikiQuery query, WikiVisibilitySnapshot visibility)
		{
			if (!query.Filters.TryGetValue("expression", out string value) || string.IsNullOrWhiteSpace(value))
			{
				return new WikiAnswer("Find", new string[1] { "Provide a category or supported filter." });
			}
			FilterExpression parsed = FilterExpression.Parse(value);
			if (!parsed.IsSupported)
			{
				return new WikiAnswer("Unsupported filter", new string[1] { parsed.Diagnostic }, null, new string[3] { "Try: /wiki find swords", "/wiki foods above 70 health", "/wiki find weapons with frost" });
			}
			IEnumerable<WikiItem> source = index.Items.Values.Where(visibility.IsVisible);
			if (parsed.Kind.HasValue)
			{
				source = source.Where((WikiItem item) => item.Kind == parsed.Kind.Value);
			}
			string category = parsed.Category;
			if (!string.IsNullOrEmpty(category))
			{
				source = source.Where((WikiItem item) => CategoryMatches(item.Category, category));
			}
			if (parsed.Damage.HasValue)
			{
				source = source.Where((WikiItem item) => item.StatsAt(1).Damage?.HasPositive(parsed.Damage.Value) ?? false);
			}
			if (parsed.NumericField != null && parsed.NumericValue.HasValue && parsed.Operator != null)
			{
				source = source.Where((WikiItem item) => NumericFilter(GetNumeric(item, parsed.NumericField), parsed.Operator, parsed.NumericValue.Value));
			}
			WikiItem[] array = source.OrderBy<WikiItem, string>((WikiItem item) => item.DisplayName, StringComparer.CurrentCultureIgnoreCase).ToArray();
			if (array.Length == 0)
			{
				return new WikiAnswer("Find results", new string[1] { "No indexed items matched the supported filter." });
			}
			return new WikiAnswer($"Find results ({array.Length})", array.Select((WikiItem item) => (parsed.NumericField != null) ? ("- " + Label(item) + " | " + item.Category + " | " + NumericFieldLabel(parsed.NumericField, item) + " " + Number(GetNumeric(item, parsed.NumericField).Value)) : ("- " + Label(item) + " | " + item.Category)));
		}

		private WikiAnswer Diagnostics(WikiIndex index, WikiVisibilitySnapshot visibility)
		{
			WikiItem[] array = index.Items.Values.Where(visibility.IsVisible).ToArray();
			WikiPiece[] array2 = index.Pieces.Where(visibility.IsVisible).ToArray();
			IGrouping<string, WikiItem>[] array3 = (from @group in array.GroupBy<WikiItem, string>((WikiItem item) => item.DisplayName, StringComparer.CurrentCultureIgnoreCase)
				where @group.Count() > 1
				select @group).OrderBy<IGrouping<string, WikiItem>, string>((IGrouping<string, WikiItem> group) => group.Key, StringComparer.CurrentCultureIgnoreCase).ToArray();
			int num = CountDanglingEdges(index);
			int num2 = index.Recipes.Count((WikiRecipe recipe) => recipe.Requirements.Count == 0);
			int num3 = index.Conversions.Count((WikiConversion conversion) => conversion.Requirements.Count == 0);
			int num4 = array.Count((WikiItem item) => !string.IsNullOrWhiteSpace(item.SourceMod));
			List<string> list = new List<string>();
			list.Add($"Visibility: {visibility.Policy} | items {array.Length}/{index.Items.Count} | pieces {array2.Length}/{index.Pieces.Count}.");
			list.Add($"Build isolation: {index.SkippedEntries} skipped entries | {index.UnavailableStatistics} unavailable optional statistics.");
			list.Add($"Retained issue records: {index.Diagnostics.Count} | omitted after hard bound: {index.OmittedDiagnostics}.");
			list.Add(string.Format("Relationship integrity: {0} dangling item reference{1} | recipes with no listed requirements: {2} | conversions with no listed inputs: {3}.", num, (num == 1) ? string.Empty : "s", num2, num3));
			list.Add(string.Format("Localized-name ambiguity: {0} visible duplicate group{1}.", array3.Length, (array3.Length == 1) ? string.Empty : "s"));
			list.Add($"Item mod attribution: {num4}/{array.Length} visible items attributed; unattributed can mean vanilla or startup detection disabled.");
			list.Add($"Knowledge/context isolation: {visibility.EvaluationErrors} visibility evaluation errors in this query snapshot.");
			List<string> list2 = list;
			list2.AddRange(from @group in array3.Take(5)
				select $"- Duplicate name: {@group.Key} ({@group.Count()} visible item records)");
			if (array3.Length > 5)
			{
				list2.Add($"{array3.Length - 5} additional duplicate-name groups are available through paginated diagnostics in a future release; this summary is bounded to five.");
			}
			return new WikiAnswer("Diagnostics", list2, new string[1] { "Counts describe the immutable loaded index and current query visibility. Use /wiki unsupported for bounded issue details and /wiki mods for attribution groups." });
		}

		private WikiAnswer ModReport(WikiIndex index, WikiVisibilitySnapshot visibility)
		{
			WikiItem[] source = index.Items.Values.Where(visibility.IsVisible).ToArray();
			WikiAcquisitionSource[] source2 = index.Sources.Where((WikiAcquisitionSource wikiAcquisitionSource) => visibility.IsVisible(wikiAcquisitionSource.OutputItemId)).ToArray();
			var array = (from @group in source.GroupBy<WikiItem, string>((WikiItem item) => (!string.IsNullOrWhiteSpace(item.SourceMod)) ? item.SourceMod : "Unattributed (vanilla or detection disabled)", StringComparer.CurrentCultureIgnoreCase)
				select new
				{
					Name = @group.Key,
					Items = @group.Count()
				} into @group
				orderby @group.Items descending
				select @group).ThenBy(group => group.Name, StringComparer.CurrentCultureIgnoreCase).ToArray();
			Dictionary<string, int> sourceGroups = source2.Where((WikiAcquisitionSource wikiAcquisitionSource) => !string.IsNullOrWhiteSpace(wikiAcquisitionSource.SourceMod)).GroupBy<WikiAcquisitionSource, string>((WikiAcquisitionSource wikiAcquisitionSource) => wikiAcquisitionSource.SourceMod, StringComparer.CurrentCultureIgnoreCase).ToDictionary<IGrouping<string, WikiAcquisitionSource>, string, int>((IGrouping<string, WikiAcquisitionSource> group) => group.Key, (IGrouping<string, WikiAcquisitionSource> group) => group.Count(), StringComparer.CurrentCultureIgnoreCase);
			var array2 = array.Take(20).ToArray();
			int value;
			List<string> list = array2.Select(group => string.Format("- {0}: {1} item{2}{3}", group.Name, group.Items, (group.Items == 1) ? string.Empty : "s", sourceGroups.TryGetValue(group.Name, out value) ? string.Format(" | {0} direct source edge{1}", value, (value == 1) ? string.Empty : "s") : string.Empty)).ToList();
			if (array.Length == 0)
			{
				list.Add("No visible item records are available under the current policy.");
			}
			if (array.Length > array2.Length)
			{
				list.Add($"{array.Length - array2.Length} additional attribution groups were omitted by the {20}-row bound.");
			}
			if (!source.Any((WikiItem item) => !string.IsNullOrWhiteSpace(item.SourceMod)))
			{
				list.Add("No item source-mod labels are available. EnableModSourceDetection must be enabled before startup for best-effort Jotunn attribution.");
			}
			return new WikiAnswer($"Indexed mods ({array.Length} groups)", list, new string[1] { $"Visibility: {visibility.Policy}. Attribution is best effort and does not change indexed facts." }, null, isPaginated: true);
		}

		private WikiAnswer UnsupportedReport(WikiIndex index, WikiVisibilitySnapshot visibility)
		{
			IGrouping<string, WikiDiagnosticIssue>[] array = (from @group in index.Diagnostics.Where((WikiDiagnosticIssue issue) => issue.Kind == WikiDiagnosticKind.SkippedEntry).GroupBy<WikiDiagnosticIssue, string>((WikiDiagnosticIssue issue) => issue.Category, StringComparer.CurrentCultureIgnoreCase)
				orderby @group.Count() descending
				select @group).ThenBy<IGrouping<string, WikiDiagnosticIssue>, string>((IGrouping<string, WikiDiagnosticIssue> group) => group.Key, StringComparer.CurrentCultureIgnoreCase).ToArray();
			WikiDiagnosticIssue[] array2 = index.Diagnostics.Where((WikiDiagnosticIssue issue) => !visibility.IsRestricted || (issue.RelatedItemId != null && visibility.IsVisible(issue.RelatedItemId))).Take(20).ToArray();
			List<string> list = new List<string>
			{
				$"Full-index isolation totals: {index.SkippedEntries} skipped entries | {index.UnavailableStatistics} unavailable optional statistics.",
				$"Retained issue records: {index.Diagnostics.Count} | omitted after 256: {index.OmittedDiagnostics}."
			};
			if (array.Length != 0)
			{
				list.Add("Skipped categories: " + string.Join(", ", from @group in array.Take(10)
					select $"{@group.Key} {@group.Count()}") + ((array.Length > 10) ? $"; {array.Length - 10} more categories" : string.Empty) + ".");
			}
			WikiDiagnosticIssue[] array3 = array2;
			foreach (WikiDiagnosticIssue wikiDiagnosticIssue in array3)
			{
				if (wikiDiagnosticIssue.Kind == WikiDiagnosticKind.UnavailableStatistic && wikiDiagnosticIssue.RelatedItemId != null && index.Items.TryGetValue(wikiDiagnosticIssue.RelatedItemId, out WikiItem value))
				{
					list.Add("- Optional statistic '" + wikiDiagnosticIssue.Category + "' unavailable for " + Label(value) + " (" + wikiDiagnosticIssue.ReasonCode + ").");
				}
				else if (!visibility.IsRestricted)
				{
					list.Add("- Skipped " + wikiDiagnosticIssue.Category + ": " + wikiDiagnosticIssue.EntityId + " (" + wikiDiagnosticIssue.ReasonCode + ").");
				}
			}
			if (visibility.IsRestricted && index.Diagnostics.Any((WikiDiagnosticIssue issue) => issue.RelatedItemId == null))
			{
				list.Add("Unassociated skipped-prefab identifiers are not listed under a character-knowledge policy.");
			}
			if (index.Diagnostics.Count > array2.Length)
			{
				list.Add($"Issue detail output is bounded to {20} eligible records.");
			}
			list.Add("Intentionally unsupported: chance/weighted/multi-output/zero-minimum environmental tables; fish extra drops and bait probabilities; containers; locations; biome inference; random pickables; procedural loot.");
			list.Add("Intentionally unsupported: DPS, resistance-adjusted damage, attack timing, skill simulation, composite best-item scores, scene-distance station scans, inventory mutation, and progression mutation.");
			return new WikiAnswer("Unsupported and isolated content", list, new string[1] { $"Visibility: {visibility