using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Jotunn;
using Jotunn.Managers;
using Microsoft.CodeAnalysis;
using TheConcernedCat.ConcernedTeamster.Adapters;
using TheConcernedCat.ConcernedTeamster.Domain;
using TheConcernedCat.ConcernedTeamster.Domain.Authority;
using TheConcernedCat.ConcernedTeamster.Domain.Brake;
using TheConcernedCat.ConcernedTeamster.Domain.Capabilities;
using TheConcernedCat.ConcernedTeamster.Domain.Cargo;
using TheConcernedCat.ConcernedTeamster.Domain.Cartographer;
using TheConcernedCat.ConcernedTeamster.Domain.Carts;
using TheConcernedCat.ConcernedTeamster.Domain.Compatibility;
using TheConcernedCat.ConcernedTeamster.Domain.Config;
using TheConcernedCat.ConcernedTeamster.Domain.Diagnostics;
using TheConcernedCat.ConcernedTeamster.Domain.Load;
using TheConcernedCat.ConcernedTeamster.Domain.Localization;
using TheConcernedCat.ConcernedTeamster.Domain.Net;
using TheConcernedCat.ConcernedTeamster.Domain.Onboarding;
using TheConcernedCat.ConcernedTeamster.Domain.Profiles;
using TheConcernedCat.ConcernedTeamster.Domain.Risk;
using TheConcernedCat.ConcernedTeamster.Domain.RoadQuality;
using TheConcernedCat.ConcernedTeamster.Domain.Routes;
using TheConcernedCat.ConcernedTeamster.Domain.Support;
using TheConcernedCat.ConcernedTeamster.Domain.Terrain;
using TheConcernedCat.ConcernedTeamster.Domain.Trips;
using TheConcernedCat.ConcernedTeamster.Domain.Ui;
using TheConcernedCat.ConcernedTeamster.Domain.Warnings;
using TheConcernedCat.ConcernedTeamster.Ui;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[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("The Concerned Cat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2026 Eren Cansunar")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+0575bf436e7a4914371658c2e700c7cc93063d43")]
[assembly: AssemblyProduct("Concerned Teamster")]
[assembly: AssemblyTitle("TheConcernedCat.ConcernedTeamster")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Weakened/ConcernedCatMods")]
[assembly: AssemblyVersion("1.0.1.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 TheConcernedCat.ConcernedTeamster
{
	[BepInPlugin("com.theconcernedcat.valheim.concernedteamster", "Concerned Teamster", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.theconcernedcat.valheim.concernedteamster";

		public const string PluginName = "Concerned Teamster";

		public const string PluginVersion = "1.0.1";

		private bool _cartographerProbePending;

		private bool _compatibilityProbePending;

		private readonly LogTailRecorder _logTail = new LogTailRecorder();

		private void Awake()
		{
			_logTail.Attach(((BaseUnityPlugin)this).Logger);
			TeamsterSettings teamsterSettings = TeamsterSettings.Bind(((BaseUnityPlugin)this).Config);
			ApplyConfigSchemaMigrationIfNeeded(teamsterSettings);
			ApplyProfileIfChanged(teamsterSettings);
			LocalizationFiles.Initialize(((BaseUnityPlugin)this).Logger);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Concerned Teamster 1.0.1 loaded");
			LogEnvironmentBanner();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Effective config: " + $"Enabled={teamsterSettings.Enabled.Value}, " + $"DebugLogging={teamsterSettings.DebugLogging.Value}."));
			LogCartCapability(teamsterSettings);
			ArmTelemetry(teamsterSettings);
			_cartographerProbePending = teamsterSettings.Enabled.Value;
			_compatibilityProbePending = true;
		}

		private void Update()
		{
			if (_cartographerProbePending)
			{
				_cartographerProbePending = false;
				CartographerCapability.EnsureProbed(((BaseUnityPlugin)this).Logger);
			}
			if (_compatibilityProbePending)
			{
				_compatibilityProbePending = false;
				CompatibilityAdapter.EnsureProbed(((BaseUnityPlugin)this).Logger);
			}
		}

		private void ApplyConfigSchemaMigrationIfNeeded(TeamsterSettings settings)
		{
			ConfigSchemaMigration.Plan plan = ConfigSchemaMigration.Decide(settings.SchemaVersion.Value);
			if (plan.LogMessage != null)
			{
				if (plan.IsFromANewerVersion)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)plan.LogMessage);
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)plan.LogMessage);
				}
			}
			if (plan.NeedsMigration)
			{
				settings.SchemaVersion.Value = 1;
			}
		}

		private void ApplyProfileIfChanged(TeamsterSettings settings)
		{
			ConfigProfile value = settings.ActiveProfile.Value;
			ConfigProfile value2 = settings.LastAppliedProfile.Value;
			if (ProfileTransition.ShouldApply(value, value2))
			{
				ProfileValues profileValues = ConfigProfileCatalog.Resolve(value);
				settings.PanelWarningsEnabled.Value = profileValues.PanelWarningsEnabled;
				settings.HudWarningHintsEnabled.Value = profileValues.HudWarningHintsEnabled;
				settings.TripsEnabled.Value = profileValues.TripsEnabled;
				settings.RiskLookaheadPoints.Value = profileValues.RiskLookaheadPoints;
				settings.LastAppliedProfile.Value = value;
				((BaseUnityPlugin)this).Logger.LogInfo((object)($"Config profile '{value}' applied (was '{value2}'): " + $"warnings={profileValues.PanelWarningsEnabled}, HUD hint={profileValues.HudWarningHintsEnabled}, " + $"trips={profileValues.TripsEnabled}, risk lookahead={profileValues.RiskLookaheadPoints}. " + "Brake.Enabled is never changed by a profile switch — it stays opt-in."));
			}
		}

		private void ArmTelemetry(TeamsterSettings settings)
		{
			if (!settings.Enabled.Value)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Concerned Teamster is disabled by config; no cart observation runs.");
			}
			else if (CartAdapter.CapabilityEnabled)
			{
				LoadModel loadModel = LoadCalibratedModel();
				RiskModel riskModel = LoadDescentModel();
				CartTelemetryPump cartTelemetryPump = ((Component)this).gameObject.AddComponent<CartTelemetryPump>();
				TelemetrySamplerOptions telemetrySamplerOptions = cartTelemetryPump.Initialize(settings, ((BaseUnityPlugin)this).Logger, loadModel, riskModel);
				((BaseUnityPlugin)this).Logger.LogInfo((object)($"Cart telemetry sampler armed: interval {telemetrySamplerOptions.SampleIntervalSeconds:0.##} s, " + $"radius {telemetrySamplerOptions.SearchRadiusMeters:0.#} m, {telemetrySamplerOptions.MaxCartsPerTick} carts/tick, " + $"{telemetrySamplerOptions.MaxTrackedCarts} tracked max, evict after {telemetrySamplerOptions.EvictAfterSeconds:0.#} s."));
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Warnings: panel " + (settings.PanelWarningsEnabled.Value ? "on" : "off") + ", HUD hint " + (settings.HudWarningHintsEnabled.Value ? "on" : "off") + $", steep-climb caution at {settings.SteepGradeCautionPercent.Value:0.#}% " + $"(exit −{3f:0.#}%, " + $"fall hold {4.0:0.#} s)."));
				((Component)this).gameObject.AddComponent<CartStatusHudController>().Initialize(settings, ((BaseUnityPlugin)this).Logger, cartTelemetryPump, ResolveInformationalVersion(), _logTail);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Cart Status panel armed: visible Cart button at the right screen edge while in a world, " + $"UI scale {UiScaleOptions.Clamp(settings.UiScale.Value):0.##}."));
			}
		}

		private LoadModel? LoadCalibratedModel()
		{
			LoadCalibrationData loadCalibrationData = LoadCalibrationSource.TryLoadEmbedded();
			if (loadCalibrationData == null || loadCalibrationData.DataVersion <= 0)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Load calibration data missing or unreadable; load advice stays off, all telemetry keeps working.");
				return null;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)($"Load calibration v{loadCalibrationData.DataVersion} loaded: {loadCalibrationData.Rows.Count} rows " + $"({loadCalibrationData.MeasuredRowCount} measured) for game {loadCalibrationData.GameVersion}; " + ((loadCalibrationData.Errors.Count == 0) ? "no parse errors." : $"{loadCalibrationData.Errors.Count} malformed line(s) skipped.")));
			return new LoadModel(loadCalibrationData);
		}

		private RiskModel? LoadDescentModel()
		{
			DescentCalibrationData descentCalibrationData = DescentCalibrationSource.TryLoadEmbedded();
			if (descentCalibrationData == null || descentCalibrationData.DataVersion <= 0)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Descent calibration data missing or unreadable; descent risk stays Unknown, all telemetry keeps working.");
				return null;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)($"Descent calibration v{descentCalibrationData.DataVersion} loaded: {descentCalibrationData.Rows.Count} rows " + $"({descentCalibrationData.MeasuredRowCount} measured) for game {descentCalibrationData.GameVersion}; " + ((descentCalibrationData.Errors.Count == 0) ? "no parse errors." : $"{descentCalibrationData.Errors.Count} malformed line(s) skipped.")));
			return new RiskModel(descentCalibrationData);
		}

		private void LogCartCapability(TeamsterSettings settings)
		{
			GameCapabilityReport gameCapabilityReport = CartAdapter.ProbeCapability();
			if (gameCapabilityReport.Enabled)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Cart telemetry capability ENABLED: {gameCapabilityReport.VerifiedMembers.Count} game members verified.");
				if (settings.DebugLogging.Value)
				{
					((BaseUnityPlugin)this).Logger.LogDebug((object)("Verified cart members: " + string.Join(", ", gameCapabilityReport.VerifiedMembers)));
				}
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Cart telemetry capability DISABLED: missing " + string.Join(", ", gameCapabilityReport.MissingMembers) + ". A Valheim update likely changed cart internals; cart features stay off until a Concerned Teamster update, and everything else keeps working."));
			}
		}

		private void LogEnvironmentBanner()
		{
			string bepInExVersion = "unknown";
			string jotunnVersion = "unknown";
			string unityVersion = "unknown";
			try
			{
				bepInExVersion = typeof(BaseUnityPlugin).Assembly.GetName().Version?.ToString() ?? "unknown";
				jotunnVersion = typeof(Main).Assembly.GetName().Version?.ToString() ?? "unknown";
				unityVersion = Application.unityVersion;
			}
			catch
			{
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)EnvironmentBanner.Compose("ConcernedTeamster@" + ResolveInformationalVersion(), GameVersionResolver.Resolve(), unityVersion, bepInExVersion, jotunnVersion));
		}

		private static string ResolveInformationalVersion()
		{
			try
			{
				return typeof(Plugin).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion ?? "1.0.1";
			}
			catch
			{
				return "1.0.1";
			}
		}
	}
	internal sealed class TeamsterSettings
	{
		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<bool> DebugLogging { get; }

		public ConfigEntry<float> SampleIntervalSeconds { get; }

		public ConfigEntry<float> SearchRadiusMeters { get; }

		public ConfigEntry<int> MaxCartsPerTick { get; }

		public ConfigEntry<int> MaxTrackedCarts { get; }

		public ConfigEntry<KeyboardShortcut> PanelShortcut { get; }

		public ConfigEntry<bool> PanelWarningsEnabled { get; }

		public ConfigEntry<bool> HudWarningHintsEnabled { get; }

		public ConfigEntry<float> SteepGradeCautionPercent { get; }

		public ConfigEntry<int> RiskLookaheadPoints { get; }

		public ConfigEntry<bool> BrakeEnabled { get; }

		public ConfigEntry<bool> TripsEnabled { get; }

		public ConfigEntry<float> TripRecordSpacingSeconds { get; }

		public ConfigEntry<int> TripMaxSamplesPerTrip { get; }

		public ConfigEntry<int> TripMaxTripsRetained { get; }

		public ConfigEntry<float> UiScale { get; }

		public ConfigEntry<bool> OnboardingDismissed { get; }

		public ConfigEntry<ConfigProfile> ActiveProfile { get; }

		public ConfigEntry<ConfigProfile> LastAppliedProfile { get; }

		public ConfigEntry<int> SchemaVersion { get; }

		private TeamsterSettings(ConfigEntry<bool> enabled, ConfigEntry<bool> debugLogging, ConfigEntry<float> sampleIntervalSeconds, ConfigEntry<float> searchRadiusMeters, ConfigEntry<int> maxCartsPerTick, ConfigEntry<int> maxTrackedCarts, ConfigEntry<KeyboardShortcut> panelShortcut, ConfigEntry<bool> panelWarningsEnabled, ConfigEntry<bool> hudWarningHintsEnabled, ConfigEntry<float> steepGradeCautionPercent, ConfigEntry<int> riskLookaheadPoints, ConfigEntry<bool> brakeEnabled, ConfigEntry<bool> tripsEnabled, ConfigEntry<float> tripRecordSpacingSeconds, ConfigEntry<int> tripMaxSamplesPerTrip, ConfigEntry<int> tripMaxTripsRetained, ConfigEntry<float> uiScale, ConfigEntry<bool> onboardingDismissed, ConfigEntry<ConfigProfile> activeProfile, ConfigEntry<ConfigProfile> lastAppliedProfile, ConfigEntry<int> schemaVersion)
		{
			Enabled = enabled;
			DebugLogging = debugLogging;
			SampleIntervalSeconds = sampleIntervalSeconds;
			SearchRadiusMeters = searchRadiusMeters;
			MaxCartsPerTick = maxCartsPerTick;
			MaxTrackedCarts = maxTrackedCarts;
			PanelShortcut = panelShortcut;
			PanelWarningsEnabled = panelWarningsEnabled;
			HudWarningHintsEnabled = hudWarningHintsEnabled;
			SteepGradeCautionPercent = steepGradeCautionPercent;
			RiskLookaheadPoints = riskLookaheadPoints;
			BrakeEnabled = brakeEnabled;
			TripsEnabled = tripsEnabled;
			TripRecordSpacingSeconds = tripRecordSpacingSeconds;
			TripMaxSamplesPerTrip = tripMaxSamplesPerTrip;
			TripMaxTripsRetained = tripMaxTripsRetained;
			UiScale = uiScale;
			OnboardingDismissed = onboardingDismissed;
			ActiveProfile = activeProfile;
			LastAppliedProfile = lastAppliedProfile;
			SchemaVersion = schemaVersion;
		}

		public static TeamsterSettings Bind(ConfigFile config)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Expected O, but got Unknown
			return new TeamsterSettings(config.Bind<bool>("General", "Enabled", true, "Master switch for Concerned Teamster cart telemetry features. Disabling leaves carts fully vanilla; the mod never changes cart physics by default either way."), config.Bind<bool>("Diagnostics", "DebugLogging", false, "Write diagnostic messages for Teamster feature development. Never enables per-frame logging."), config.Bind<float>("Telemetry", "SampleIntervalSeconds", 0.5f, new ConfigDescription("Seconds between cart telemetry samples. Read-only observation of nearby carts; between samples the cost is one comparison per frame.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>())), config.Bind<float>("Telemetry", "SearchRadiusMeters", 30f, new ConfigDescription("Carts farther than this from you are not observed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 100f), Array.Empty<object>())), config.Bind<int>("Telemetry", "MaxCartsPerTick", 2, new ConfigDescription("Hard budget of carts examined per telemetry tick.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>())), config.Bind<int>("Telemetry", "MaxTrackedCarts", 8, new ConfigDescription("Hard cap of carts kept in the telemetry table at once.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 32), Array.Empty<object>())), config.Bind<KeyboardShortcut>("Ui", "PanelShortcut", KeyboardShortcut.Empty, "Optional keyboard accelerator that toggles the Cart Status panel. The visible Cart button is always the primary path; leave empty for no shortcut."), config.Bind<bool>("Warnings", "PanelWarningsEnabled", true, "Show load/grade warnings in the Cart Status panel."), config.Bind<bool>("Warnings", "HudWarningHintsEnabled", false, "Also show the current warning as a small HUD hint under the Cart button while pulling. Off by default: the panel is the primary surface and HUD space is precious; enable if you haul with the panel closed."), config.Bind<float>("Warnings", "SteepGradeCautionPercent", 18f, new ConfigDescription("Smoothed climbing grade (percent) that raises the steep-climb caution. Exit hysteresis and anti-flicker hold are fixed so no configuration can make warnings spam.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 60f), Array.Empty<object>())), config.Bind<int>("Risk", "LookaheadPoints", 3, new ConfigDescription("Terrain samples taken ahead of the pulled cart (4 m apart) to rate the upcoming descent. 0 disables lookahead. Each sample is one bounded ground-height read per telemetry tick.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5), Array.Empty<object>())), config.Bind<bool>("Brake", "Enabled", true, "The parking brake feature: a visible button that freezes a parked cart you control until you release it. Explicit per-use, always reversible, never saved into the world, and it releases itself on detach distance, world exit, shutdown, or any capability loss. Disable to remove the button entirely."), config.Bind<bool>("Trips", "Enabled", true, "Record hauling trips (position, grade, speed, load while you pull) into Teamster's own per-world sidecar file under BepInEx/config. Never touches Valheim saves; delete the sidecar folder to erase all history."), config.Bind<float>("Trips", "RecordSpacingSeconds", 1f, new ConfigDescription("Seconds between recorded trip samples while pulling.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 10f), Array.Empty<object>())), config.Bind<int>("Trips", "MaxSamplesPerTrip", 600, new ConfigDescription("Hard cap of samples in one trip; longer hauls split into segments.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(50, 5000), Array.Empty<object>())), config.Bind<int>("Trips", "MaxTripsRetained", 50, new ConfigDescription("Retention: how many trips each world's sidecar keeps; the oldest are pruned first.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 500), Array.Empty<object>())), config.Bind<float>("Ui", "Scale", 1f, new ConfigDescription("Uniform size of every Teamster panel, button, and font. 1.0 is the default size; takes effect the next time a panel opens (or on world enter for the always-visible Cart button), not live on an already-open panel.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.8f, 1.3f), Array.Empty<object>())), config.Bind<bool>("Onboarding", "Dismissed", false, "Set automatically once you dismiss the first-run hint pointing at the Cart button. Set back to false to see the hint again."), config.Bind<ConfigProfile>("General", "Profile", ConfigProfile.Standard, "A documented settings preset: Minimal (telemetry only, warnings/HUD hints/trips off), Standard (Teamster's normal defaults), or EverythingObservational (every read-only feature on). The parking brake stays off in every profile — enable Brake.Enabled yourself if you want it. Changing this re-applies the preset's values once, on the next load; your own edits to individual settings are never overwritten again until you change this value to something else."), config.Bind<ConfigProfile>("General", "LastAppliedProfile", ConfigProfile.Standard, "Internal bookkeeping — do not edit. Records which profile was last applied so a restart with no Profile change never re-applies it."), config.Bind<int>("Internal", "ConfigSchemaVersion", 0, "Internal bookkeeping — do not edit. Tracks which version of Teamster's config schema this file was last written by, so a future update can migrate safely."));
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Ui
{
	internal sealed class CargoManifestPanel
	{
		private const float PanelWidth = 420f;

		private const float PanelHeight = 470f;

		private const float RowHeight = 24f;

		private const int VisibleRowCount = 12;

		private const double ViewTickSeconds = 1.0;

		private readonly ManualLogSource _log;

		private readonly Func<float> _uiScale;

		private readonly CargoManifestTracker _tracker = new CargoManifestTracker();

		private bool _failed;

		private GameObject? _panel;

		private InputField? _filter;

		private Text?[] _rows = Array.Empty<Text>();

		private Text? _message;

		private Text? _overflow;

		private Text? _total;

		private Text? _freshness;

		private Button? _sortNameButton;

		private Button? _sortCountButton;

		private Button? _sortUnitButton;

		private Button? _sortLineButton;

		private CargoSortColumn _sortColumn = CargoSortColumn.LineWeight;

		private bool _sortDescending = true;

		private string _lastAppliedFilter = string.Empty;

		private CargoManifest? _lastAppliedManifest;

		private bool _viewDirty = true;

		private double _nextViewTick;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public CargoManifestPanel(ManualLogSource log, Func<float> uiScale)
		{
			_log = log;
			_uiScale = uiScale;
		}

		public void Toggle()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || Build())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						_viewDirty = true;
						_nextViewTick = 0.0;
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		public void Reset()
		{
			_tracker.Reset();
			_lastAppliedManifest = null;
			_viewDirty = true;
			Hide();
		}

		public void HandleFrame(double nowSeconds, string? selectedCartId)
		{
			if (_failed || !IsVisible)
			{
				return;
			}
			try
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					Hide();
				}
				else
				{
					if (!_viewDirty && nowSeconds < _nextViewTick)
					{
						return;
					}
					_nextViewTick = nowSeconds + 1.0;
					CargoManifest orRefresh = _tracker.GetOrRefresh(nowSeconds, (double captureTime) => CartAdapter.TryReadManifest(CartAdapter.TryFindCartById(selectedCartId), captureTime));
					string text = (((Object)(object)_filter != (Object)null) ? _filter.text : string.Empty);
					if (!_viewDirty && orRefresh == _lastAppliedManifest && string.Equals(text, _lastAppliedFilter, StringComparison.Ordinal))
					{
						if (orRefresh != null && (Object)(object)_freshness != (Object)null)
						{
							CargoManifestViewModel cargoManifestViewModel = CargoManifestPresenter.Present(orRefresh, _sortColumn, _sortDescending, text, nowSeconds, GameLocalization.LocalizeOrRaw);
							_freshness.text = cargoManifestViewModel.FreshnessLine;
						}
					}
					else
					{
						_lastAppliedManifest = orRefresh;
						_lastAppliedFilter = text;
						_viewDirty = false;
						Render(CargoManifestPresenter.Present(orRefresh, _sortColumn, _sortDescending, text, nowSeconds, GameLocalization.LocalizeOrRaw));
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Render(CargoManifestViewModel viewModel)
		{
			if ((Object)(object)_message != (Object)null)
			{
				_message.text = viewModel.Message;
			}
			int num = Math.Min(viewModel.Rows.Count, 12);
			for (int i = 0; i < _rows.Length; i++)
			{
				Text val = _rows[i];
				if (!((Object)(object)val == (Object)null))
				{
					if (i < num)
					{
						CargoRowViewModel cargoRowViewModel = viewModel.Rows[i];
						val.text = TeamsterStrings.Format("manifest.row", cargoRowViewModel.Name, cargoRowViewModel.CountText, cargoRowViewModel.UnitWeightText, cargoRowViewModel.LineWeightText);
					}
					else
					{
						val.text = string.Empty;
					}
				}
			}
			if ((Object)(object)_overflow != (Object)null)
			{
				int num2 = viewModel.Rows.Count - num;
				_overflow.text = ((num2 > 0) ? TeamsterStrings.Format("manifest.overflow", num2.ToString(CultureInfo.InvariantCulture)) : string.Empty);
			}
			if ((Object)(object)_total != (Object)null)
			{
				_total.text = viewModel.TotalLine;
			}
			if ((Object)(object)_freshness != (Object)null)
			{
				_freshness.text = viewModel.FreshnessLine;
			}
			UpdateSortButtonLabels();
		}

		private void SetSort(CargoSortColumn column)
		{
			if (_sortColumn == column)
			{
				_sortDescending = !_sortDescending;
			}
			else
			{
				_sortColumn = column;
				_sortDescending = column != CargoSortColumn.Name;
			}
			_viewDirty = true;
			UpdateSortButtonLabels();
		}

		private void UpdateSortButtonLabels()
		{
			string text = (_sortDescending ? " ▼" : " ▲");
			SetButtonLabel(_sortNameButton, TeamsterStrings.Get("manifest.colItem") + ((_sortColumn == CargoSortColumn.Name) ? text : string.Empty));
			SetButtonLabel(_sortCountButton, TeamsterStrings.Get("manifest.colCount") + ((_sortColumn == CargoSortColumn.Count) ? text : string.Empty));
			SetButtonLabel(_sortUnitButton, TeamsterStrings.Get("manifest.colUnit") + ((_sortColumn == CargoSortColumn.UnitWeight) ? text : string.Empty));
			SetButtonLabel(_sortLineButton, TeamsterStrings.Get("manifest.colLine") + ((_sortColumn == CargoSortColumn.LineWeight) ? text : string.Empty));
		}

		private static void SetButtonLabel(Button? button, string label)
		{
			if (!((Object)(object)button == (Object)null))
			{
				Text componentInChildren = ((Component)button).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = label;
				}
			}
		}

		private bool Build()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-590f, 0f), 420f, 470f, _uiScale());
			instance.CreateText(TeamsterStrings.Get("manifest.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 380f, 30f, false);
			GameObject val = instance.CreateInputField(_panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -62f), (ContentType)0, TeamsterStrings.Get("manifest.filterPlaceholder"), 15, 360f, 28f);
			_filter = val.GetComponent<InputField>();
			if ((Object)(object)_filter != (Object)null)
			{
				((UnityEvent<string>)(object)_filter.onValueChanged).AddListener((UnityAction<string>)delegate
				{
					_viewDirty = true;
				});
			}
			float num = 90f;
			float num2 = -180f + num / 2f;
			_sortNameButton = CreateSortButton(instance, num2 + 0f * num, num, delegate
			{
				SetSort(CargoSortColumn.Name);
			});
			_sortCountButton = CreateSortButton(instance, num2 + 1f * num, num, delegate
			{
				SetSort(CargoSortColumn.Count);
			});
			_sortUnitButton = CreateSortButton(instance, num2 + 2f * num, num, delegate
			{
				SetSort(CargoSortColumn.UnitWeight);
			});
			_sortLineButton = CreateSortButton(instance, num2 + 3f * num, num, delegate
			{
				SetSort(CargoSortColumn.LineWeight);
			});
			_message = CreateBodyText(instance, averiaSerifBold, body, -128f, 24f);
			_rows = (Text?[])(object)new Text[12];
			float num3 = -152f;
			for (int num4 = 0; num4 < 12; num4++)
			{
				_rows[num4] = CreateBodyText(instance, averiaSerifBold, body, num3, 24f);
				num3 -= 24f;
			}
			_overflow = CreateBodyText(instance, averiaSerifBold, body, num3, 24f);
			_total = CreateBodyText(instance, averiaSerifBold, header, num3 - 24f, 24f);
			_freshness = CreateBodyText(instance, averiaSerifBold, body, num3 - 48f, 24f);
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			UpdateSortButtonLabels();
			_panel.SetActive(false);
			return true;
		}

		private Button? CreateSortButton(GUIManager gui, float centerX, float width, Action onClick)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			Button component = gui.CreateButton(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(centerX, -98f), width - 4f, 26f).GetComponent<Button>();
			if (component != null)
			{
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
				return component;
			}
			return component;
		}

		private Text? CreateBodyText(GUIManager gui, Font font, Color color, float y, float height)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Text component = gui.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y - height / 2f), font, 15, color, true, Color.black, 380f, height, false).GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				component.alignment = (TextAnchor)0;
				component.verticalOverflow = (VerticalWrapMode)0;
				component.horizontalOverflow = (HorizontalWrapMode)1;
			}
			return component;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			try
			{
				Hide();
			}
			catch
			{
			}
			_log.LogError((object)("Cargo Manifest UI failed and was disabled for this session (telemetry keeps running): " + exception.GetType().Name + ": " + exception.Message));
		}
	}
	internal sealed class CartStatusHudController : MonoBehaviour
	{
		private const float PanelWidth = 320f;

		private const float PanelHeight = 450f;

		private const float RowHeight = 26f;

		private const float RefreshPeriodSeconds = 0.25f;

		private const int RowCount = 9;

		private TeamsterSettings? _settings;

		private ManualLogSource? _log;

		private CartTelemetryPump? _pump;

		private CargoManifestPanel? _manifestPanel;

		private RecoveryGuidancePanel? _guidancePanel;

		private TripHistoryPanel? _tripPanel;

		private RoutePickerPanel? _routePanel;

		private CompatibilityPanel? _compatPanel;

		private SupportBundlePanel? _supportPanel;

		private bool _failed;

		private GameObject? _button;

		private GameObject? _panel;

		private Text? _hudHint;

		private GameObject? _onboardingHint;

		private GameObject? _brakeButton;

		private Text? _brakeButtonText;

		private Text[] _rows = Array.Empty<Text>();

		private string? _selectedCartId;

		private double _nextRefreshTime;

		private double _nextSelectionRefreshTime;

		internal void Initialize(TeamsterSettings settings, ManualLogSource log, CartTelemetryPump? pump, string pluginVersion, LogTailRecorder logTail)
		{
			_settings = settings;
			_log = log;
			_pump = pump;
			_manifestPanel = new CargoManifestPanel(log, CurrentUiScale);
			_guidancePanel = new RecoveryGuidancePanel(log, CurrentUiScale);
			_tripPanel = new TripHistoryPanel(log, CurrentUiScale);
			_tripPanel.BindPump(pump);
			_compatPanel = new CompatibilityPanel(log, CurrentUiScale);
			_supportPanel = new SupportBundlePanel(log, CurrentUiScale, pluginVersion, settings, logTail, () => _pump?.Trips);
		}

		private float CurrentUiScale()
		{
			return UiScaleOptions.Clamp(_settings?.UiScale.Value ?? 1f);
		}

		private void Update()
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if (_failed || _settings == null)
			{
				return;
			}
			try
			{
				bool flag = CartAdapter.HasLocalPlayer();
				EnsureButton(flag);
				if (!flag)
				{
					if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
					{
						_panel.SetActive(false);
					}
					_manifestPanel?.Reset();
					_guidancePanel?.Hide();
					_tripPanel?.Hide();
					_routePanel?.Hide();
					_compatPanel?.Hide();
					_supportPanel?.Hide();
					_selectedCartId = null;
					if ((Object)(object)_hudHint != (Object)null && ((Component)_hudHint).gameObject.activeSelf)
					{
						((Component)_hudHint).gameObject.SetActive(false);
					}
					if ((Object)(object)_onboardingHint != (Object)null && _onboardingHint.activeSelf)
					{
						_onboardingHint.SetActive(false);
					}
					return;
				}
				KeyboardShortcut value = _settings.PanelShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					TogglePanel();
				}
				double unscaledTimeAsDouble = Time.unscaledTimeAsDouble;
				if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
				{
					if (Input.GetKeyDown((KeyCode)27))
					{
						_panel.SetActive(false);
					}
					else if (unscaledTimeAsDouble >= _nextRefreshTime)
					{
						_nextRefreshTime = unscaledTimeAsDouble + 0.25;
						RefreshPanel(unscaledTimeAsDouble);
					}
				}
				else if (unscaledTimeAsDouble >= _nextSelectionRefreshTime)
				{
					CargoManifestPanel manifestPanel = _manifestPanel;
					if ((manifestPanel != null && manifestPanel.IsVisible) || _settings.HudWarningHintsEnabled.Value)
					{
						_nextSelectionRefreshTime = unscaledTimeAsDouble + 1.0;
						CartStatusViewModel cartStatusViewModel = CartStatusPresenter.Present(_pump?.Telemetry, _selectedCartId, unscaledTimeAsDouble, _pump != null);
						_selectedCartId = ((cartStatusViewModel.SelectedCartId.Length > 0) ? cartStatusViewModel.SelectedCartId : null);
					}
				}
				_manifestPanel?.HandleFrame(unscaledTimeAsDouble, _selectedCartId);
				_guidancePanel?.HandleFrame(unscaledTimeAsDouble, _pump);
				_tripPanel?.HandleFrame(unscaledTimeAsDouble, _pump);
				_routePanel?.HandleFrame(unscaledTimeAsDouble);
				_compatPanel?.HandleFrame();
				_supportPanel?.HandleFrame();
				UpdateHudHint();
				UpdateOnboardingHint();
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private float? SelectedCartTotalMass()
		{
			IReadOnlyDictionary<string, CartTelemetry> readOnlyDictionary = _pump?.Telemetry;
			if (readOnlyDictionary == null || _selectedCartId == null || !readOnlyDictionary.TryGetValue(_selectedCartId, out var value) || value == null)
			{
				return null;
			}
			return value.TotalMass;
		}

		private void EnsureButton(bool inWorld)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			if ((Object)(object)_button == (Object)null)
			{
				if (!inWorld || GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
				{
					return;
				}
				_button = GUIManager.Instance.CreateButton(TeamsterStrings.Get("status.cartButton"), GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-70f, 170f), 80f, 32f);
				((UnityEvent)_button.GetComponent<Button>().onClick).AddListener(new UnityAction(TogglePanel));
				PanelStyle.ApplyScale(_button, CurrentUiScale());
				_hudHint = GUIManager.Instance.CreateText(string.Empty, GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-160f, 140f), GUIManager.Instance.AveriaSerifBold, 14, PanelStyle.HudHint, true, Color.black, 300f, 40f, false).GetComponent<Text>();
				_hudHint.alignment = (TextAnchor)5;
				((Component)_hudHint).gameObject.SetActive(false);
				PanelStyle.ApplyScale(((Component)_hudHint).gameObject, CurrentUiScale());
				_onboardingHint = GUIManager.Instance.CreateButton(TeamsterStrings.Get("onboarding.hint"), GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-150f, 225f), 280f, 44f);
				((UnityEvent)_onboardingHint.GetComponent<Button>().onClick).AddListener(new UnityAction(DismissOnboarding));
				Text componentInChildren = _onboardingHint.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.fontSize = 13;
					componentInChildren.alignment = (TextAnchor)4;
					componentInChildren.horizontalOverflow = (HorizontalWrapMode)0;
					componentInChildren.verticalOverflow = (VerticalWrapMode)0;
				}
				_onboardingHint.SetActive(false);
				PanelStyle.ApplyScale(_onboardingHint, CurrentUiScale());
			}
			if (_button.activeSelf != inWorld)
			{
				_button.SetActive(inWorld);
			}
		}

		private void TogglePanel()
		{
			try
			{
				if (!((Object)(object)_panel == (Object)null) || EnsurePanel())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						_nextRefreshTime = 0.0;
						RefreshPanel(Time.unscaledTimeAsDouble);
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private bool EnsurePanel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Expected O, but got Unknown
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Expected O, but got Unknown
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Expected O, but got Unknown
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Expected O, but got Unknown
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-190f, 0f), 320f, 450f, CurrentUiScale());
			instance.CreateText(TeamsterStrings.Get("status.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 280f, 30f, false);
			_rows = (Text[])(object)new Text[9];
			float num = -58f;
			for (int i = 0; i < _rows.Length; i++)
			{
				_rows[i] = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num - 13f), averiaSerifBold, 16, body, true, Color.black, 280f, 26f, false).GetComponent<Text>();
				_rows[i].alignment = (TextAnchor)0;
				_rows[i].verticalOverflow = (VerticalWrapMode)0;
				num -= 26f;
			}
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("status.tripsButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(90f, 62f), 110f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_tripPanel?.Toggle(_pump);
			});
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("status.compatButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-90f, 96f), 110f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_compatPanel?.Toggle();
			});
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("status.supportButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-90f, 130f), 110f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_supportPanel?.Toggle();
			});
			if (CartographerCapability.IsAvailable && _log != null)
			{
				if (_routePanel == null)
				{
					_routePanel = new RoutePickerPanel(_log, _pump?.LoadModel, SelectedCartTotalMass, CurrentUiScale);
				}
				((UnityEvent)instance.CreateButton(TeamsterStrings.Get("status.routesButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(90f, 96f), 110f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					_routePanel?.Toggle();
				});
			}
			_brakeButton = instance.CreateButton(TeamsterStrings.Get("status.engageBrake"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-70f, 62f), 150f, 30f);
			_brakeButtonText = _brakeButton.GetComponentInChildren<Text>();
			((UnityEvent)_brakeButton.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_pump?.Brake?.RequestToggle(_selectedCartId);
				RefreshPanel(Time.unscaledTimeAsDouble);
			});
			_brakeButton.SetActive(false);
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("status.manifestButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-102f, 28f), 96f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_manifestPanel?.Toggle();
			});
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("status.guidanceButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 28f), 96f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_guidancePanel?.Toggle();
			});
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(102f, 28f), 96f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_panel.SetActive(false);
			});
			_panel.SetActive(false);
			return true;
		}

		private void RefreshPanel(double nowSeconds)
		{
			CartStatusViewModel cartStatusViewModel = CartStatusPresenter.Present(_pump?.Telemetry, _selectedCartId, nowSeconds, _pump != null);
			_selectedCartId = ((cartStatusViewModel.SelectedCartId.Length > 0) ? cartStatusViewModel.SelectedCartId : null);
			if (_rows.Length != 9 || (Object)(object)_rows[0] == (Object)null)
			{
				return;
			}
			_rows[0].text = cartStatusViewModel.SourceLine;
			_rows[1].text = cartStatusViewModel.MassLine;
			_rows[2].text = cartStatusViewModel.BreakdownLine;
			_rows[3].text = cartStatusViewModel.GradeLine;
			_rows[4].text = cartStatusViewModel.SurfaceLine;
			_rows[5].text = cartStatusViewModel.PullLine;
			_rows[6].text = cartStatusViewModel.FreshnessLine;
			string text = string.Empty;
			if (_pump != null && _settings != null && _settings.PanelWarningsEnabled.Value && cartStatusViewModel.SelectedCartId.Length > 0)
			{
				CartWarning cartWarning = _pump.TryGetWarning(cartStatusViewModel.SelectedCartId);
				if (cartWarning != null)
				{
					text = cartWarning.ComposeLine();
				}
			}
			_rows[7].text = text;
			string text2 = string.Empty;
			CartDiagnostic cartDiagnostic = _pump?.LatestDiagnostic;
			if (cartDiagnostic != null && cartStatusViewModel.SelectedCartId.Length > 0 && _pump.LatestDescentRisk?.CartId == cartStatusViewModel.SelectedCartId)
			{
				text2 = cartDiagnostic.ComposeLine();
			}
			_rows[8].text = text2;
			RefreshBrakeButton(cartStatusViewModel.SelectedCartId);
		}

		private void RefreshBrakeButton(string selectedCartId)
		{
			if ((Object)(object)_brakeButton == (Object)null)
			{
				return;
			}
			BrakeService brakeService = _pump?.Brake;
			bool flag = false;
			string text = TeamsterStrings.Get("status.engageBrake");
			if (brakeService != null && selectedCartId.Length > 0)
			{
				if (brakeService.EngagedCartId == selectedCartId)
				{
					flag = true;
					text = TeamsterStrings.Get("status.releaseBrake");
				}
				else if (!brakeService.IsEngaged)
				{
					BrakeFacts brakeFacts = CartBrakeAdapter.ReadFacts(selectedCartId);
					flag = brakeFacts.CartExists && brakeFacts.IsLocalAuthority && !brakeFacts.IsAttached && brakeFacts.DistanceMeters <= 5f;
				}
			}
			if (_brakeButton.activeSelf != flag)
			{
				_brakeButton.SetActive(flag);
			}
			if (flag && (Object)(object)_brakeButtonText != (Object)null && _brakeButtonText.text != text)
			{
				_brakeButtonText.text = text;
			}
		}

		private void UpdateHudHint()
		{
			if ((Object)(object)_hudHint == (Object)null)
			{
				return;
			}
			string text = string.Empty;
			if (_settings != null && _settings.HudWarningHintsEnabled.Value && _pump != null && _selectedCartId != null)
			{
				IReadOnlyDictionary<string, CartTelemetry> telemetry = _pump.Telemetry;
				if (telemetry != null && telemetry.TryGetValue(_selectedCartId, out var value) && value.IsPulledByLocalPlayer)
				{
					CartWarning cartWarning = _pump.TryGetWarning(_selectedCartId);
					if (cartWarning != null)
					{
						text = cartWarning.ComposeLine();
					}
				}
			}
			bool flag = text.Length > 0;
			if (((Component)_hudHint).gameObject.activeSelf != flag)
			{
				((Component)_hudHint).gameObject.SetActive(flag);
			}
			if (flag && _hudHint.text != text)
			{
				_hudHint.text = text;
			}
		}

		private void UpdateOnboardingHint()
		{
			if (!((Object)(object)_onboardingHint == (Object)null) && _settings != null)
			{
				GameObject panel = _panel;
				bool num = panel != null && panel.activeSelf;
				IReadOnlyDictionary<string, CartTelemetry> readOnlyDictionary = _pump?.Telemetry;
				OnboardingVisibility onboardingVisibility = OnboardingPresenter.Evaluate(isNearCart: readOnlyDictionary != null && readOnlyDictionary.Count > 0, dismissedForever: _settings.OnboardingDismissed.Value);
				bool flag = !num && onboardingVisibility == OnboardingVisibility.Visible;
				if (_onboardingHint.activeSelf != flag)
				{
					_onboardingHint.SetActive(flag);
				}
			}
		}

		private void DismissOnboarding()
		{
			if (_settings != null)
			{
				_settings.OnboardingDismissed.Value = true;
			}
			if ((Object)(object)_onboardingHint != (Object)null)
			{
				_onboardingHint.SetActive(false);
			}
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			try
			{
				if ((Object)(object)_panel != (Object)null)
				{
					_panel.SetActive(false);
				}
				if ((Object)(object)_button != (Object)null)
				{
					_button.SetActive(false);
				}
				if ((Object)(object)_hudHint != (Object)null)
				{
					((Component)_hudHint).gameObject.SetActive(false);
				}
				if ((Object)(object)_onboardingHint != (Object)null)
				{
					_onboardingHint.SetActive(false);
				}
				_manifestPanel?.Hide();
				_guidancePanel?.Hide();
				_tripPanel?.Hide();
				_routePanel?.Hide();
				_compatPanel?.Hide();
				_supportPanel?.Hide();
			}
			catch
			{
			}
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogError((object)("Cart Status UI failed and was disabled for this session (telemetry keeps running): " + exception.GetType().Name + ": " + exception.Message));
			}
		}
	}
	internal sealed class CompatibilityPanel
	{
		private const float PanelWidth = 380f;

		private const float PanelHeight = 360f;

		private const float RowHeight = 26f;

		private const int MaxLines = 8;

		private readonly ManualLogSource _log;

		private readonly Func<float> _uiScale;

		private bool _failed;

		private GameObject? _panel;

		private Text[] _lines = Array.Empty<Text>();

		private Text? _overflow;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public CompatibilityPanel(ManualLogSource log, Func<float> uiScale)
		{
			_log = log;
			_uiScale = uiScale;
		}

		public void Toggle()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || EnsurePanel())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						Render();
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		public void HandleFrame()
		{
			if (_failed || !IsVisible)
			{
				return;
			}
			try
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					Hide();
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Render()
		{
			IReadOnlyList<ModDetectionResult> results = CompatibilityAdapter.Results;
			if (results == null)
			{
				_lines[0].text = TeamsterStrings.Get("compat.notYetChecked");
				for (int i = 1; i < _lines.Length; i++)
				{
					_lines[i].text = string.Empty;
				}
				if ((Object)(object)_overflow != (Object)null)
				{
					_overflow.text = string.Empty;
				}
				return;
			}
			IReadOnlyList<string> readOnlyList = CompatibilityStatusPresenter.ComposeDetectedLines(results);
			if (readOnlyList.Count == 0)
			{
				_lines[0].text = CompatibilityStatusPresenter.ComposeNoneDetectedLine();
				for (int j = 1; j < _lines.Length; j++)
				{
					_lines[j].text = string.Empty;
				}
				if ((Object)(object)_overflow != (Object)null)
				{
					_overflow.text = string.Empty;
				}
				return;
			}
			int num = Math.Min(readOnlyList.Count, _lines.Length);
			for (int k = 0; k < _lines.Length; k++)
			{
				_lines[k].text = ((k < num) ? readOnlyList[k] : string.Empty);
			}
			if ((Object)(object)_overflow != (Object)null)
			{
				int num2 = readOnlyList.Count - num;
				_overflow.text = ((num2 > 0) ? TeamsterStrings.Format("compat.overflow", num2.ToString(CultureInfo.InvariantCulture)) : string.Empty);
			}
		}

		private bool EnsurePanel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 120f), 380f, 360f, _uiScale());
			instance.CreateText(TeamsterStrings.Get("compat.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 340f, 30f, false);
			_lines = (Text[])(object)new Text[8];
			float num = -66f;
			for (int i = 0; i < 8; i++)
			{
				_lines[i] = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num - 13f), averiaSerifBold, 14, body, true, Color.black, 340f, 26f, false).GetComponent<Text>();
				_lines[i].alignment = (TextAnchor)0;
				_lines[i].verticalOverflow = (VerticalWrapMode)0;
				_lines[i].horizontalOverflow = (HorizontalWrapMode)1;
				num -= 26f;
			}
			_overflow = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num - 13f), averiaSerifBold, 13, body, true, Color.black, 340f, 26f, false).GetComponent<Text>();
			_overflow.alignment = (TextAnchor)0;
			_overflow.horizontalOverflow = (HorizontalWrapMode)1;
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			_panel.SetActive(false);
			return true;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			try
			{
				Hide();
			}
			catch
			{
			}
			_log.LogError((object)("Compatibility panel UI failed and was disabled for this session: " + exception.GetType().Name + ": " + exception.Message));
		}
	}
	internal static class PanelStyle
	{
		public static Color Header => ToColor(PanelPalette.Header);

		public static Color Body => ToColor(PanelPalette.Body);

		public static Color HudHint => ToColor(PanelPalette.HudHint);

		public static void ApplyScale(GameObject gameObject, float scale)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			gameObject.transform.localScale = new Vector3(scale, scale, scale);
		}

		public static GameObject CreateScaledWoodpanel(GUIManager gui, Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, float width, float height, float scale)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = gui.CreateWoodpanel(parent, anchorMin, anchorMax, position, width, height, true);
			ApplyScale(obj, scale);
			return obj;
		}

		private static Color ToColor((float R, float G, float B) rgb)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return new Color(rgb.R, rgb.G, rgb.B, 1f);
		}
	}
	internal sealed class RecoveryGuidancePanel
	{
		private const float PanelWidth = 380f;

		private const float PanelHeight = 360f;

		private const float RowHeight = 34f;

		private const int StepRowCount = 6;

		private const double RefreshPeriodSeconds = 1.0;

		private readonly ManualLogSource _log;

		private readonly Func<float> _uiScale;

		private bool _failed;

		private GameObject? _panel;

		private Text? _title;

		private Text?[] _steps = Array.Empty<Text>();

		private double _nextRefreshTime;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public RecoveryGuidancePanel(ManualLogSource log, Func<float> uiScale)
		{
			_log = log;
			_uiScale = uiScale;
		}

		public void Toggle()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || Build())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						_nextRefreshTime = 0.0;
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		public void HandleFrame(double nowSeconds, CartTelemetryPump? pump)
		{
			if (_failed || !IsVisible)
			{
				return;
			}
			try
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					Hide();
				}
				else
				{
					if (nowSeconds < _nextRefreshTime)
					{
						return;
					}
					_nextRefreshTime = nowSeconds + 1.0;
					CartTelemetry telemetry = null;
					string text = pump?.LatestDescentRisk?.CartId;
					if (text != null)
					{
						IReadOnlyDictionary<string, CartTelemetry> readOnlyDictionary = pump?.Telemetry;
						if (readOnlyDictionary != null && readOnlyDictionary.TryGetValue(text, out var value))
						{
							telemetry = value;
						}
					}
					RecoveryGuidanceViewModel viewModel = RecoveryGuidancePresenter.Present(pump?.LatestDiagnostic, telemetry, pump?.LoadModel, pump?.Brake != null);
					Render(viewModel);
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Render(RecoveryGuidanceViewModel viewModel)
		{
			if ((Object)(object)_title != (Object)null)
			{
				_title.text = viewModel.Title;
			}
			for (int i = 0; i < _steps.Length; i++)
			{
				Text val = _steps[i];
				if (!((Object)(object)val == (Object)null))
				{
					val.text = ((i < viewModel.Steps.Count) ? ((i + 1).ToString(CultureInfo.InvariantCulture) + ". " + viewModel.Steps[i]) : string.Empty);
				}
			}
		}

		private bool Build()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-570f, -120f), 380f, 360f, _uiScale());
			instance.CreateText(TeamsterStrings.Get("recovery.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 340f, 30f, false);
			_title = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -66f), averiaSerifBold, 15, header, true, Color.black, 340f, 40f, false).GetComponent<Text>();
			if ((Object)(object)_title != (Object)null)
			{
				_title.alignment = (TextAnchor)0;
				_title.verticalOverflow = (VerticalWrapMode)0;
			}
			_steps = (Text?[])(object)new Text[6];
			float num = -104f;
			for (int i = 0; i < 6; i++)
			{
				Text component = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num - 17f), averiaSerifBold, 14, body, true, Color.black, 340f, 34f, false).GetComponent<Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.alignment = (TextAnchor)0;
					component.verticalOverflow = (VerticalWrapMode)0;
				}
				_steps[i] = component;
				num -= 34f;
			}
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			_panel.SetActive(false);
			return true;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			try
			{
				Hide();
			}
			catch
			{
			}
			_log.LogError((object)("Recovery Guidance UI failed and was disabled for this session (telemetry keeps running): " + exception.GetType().Name + ": " + exception.Message));
		}
	}
	internal sealed class RoutePickerPanel
	{
		private const float PanelWidth = 380f;

		private const float PanelHeight = 570f;

		private const float RowHeight = 26f;

		private const int RowCount = 11;

		private const double RefreshPeriodSeconds = 1.0;

		private const int ProfileSamplesPerFrame = 24;

		private readonly ManualLogSource _log;

		private readonly LoadModel? _loadModel;

		private readonly Func<float?> _cartMassProvider;

		private readonly Func<float> _uiScale;

		private readonly RouteProfileCache _profileCache = new RouteProfileCache();

		private readonly RouteReportPanel _reportPanel;

		private string _selectedRouteName = "";

		private RouteProfiler? _profiler;

		private Guid? _profileRouteId;

		private ulong _profileFingerprint;

		private RouteProfile? _shownProfile;

		private RouteLoadBottleneck.Result? _shownBottleneck;

		private Text[] _profileLines = Array.Empty<Text>();

		private bool _failed;

		private GameObject? _panel;

		private Text? _statusLine;

		private Text? _overflowLine;

		private GameObject[] _rowButtons = Array.Empty<GameObject>();

		private Text[] _rowTexts = Array.Empty<Text>();

		private readonly Guid?[] _rowRouteIds = new Guid?[11];

		private Guid? _selectedRouteId;

		private long _lastChangeStamp = long.MinValue;

		private double _nextRefreshTime;

		internal Guid? SelectedRouteId => _selectedRouteId;

		internal bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		internal RoutePickerPanel(ManualLogSource log, LoadModel? loadModel, Func<float?> cartMassProvider, Func<float> uiScale)
		{
			_log = log;
			_loadModel = loadModel;
			_cartMassProvider = cartMassProvider;
			_uiScale = uiScale;
			_reportPanel = new RouteReportPanel(log, uiScale);
		}

		internal void Toggle()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || EnsurePanel())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						ForceRefresh();
					}
					else
					{
						_reportPanel.Hide();
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		internal void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
			_selectedRouteId = null;
			_lastChangeStamp = long.MinValue;
			_profiler?.Cancel();
			_profiler = null;
			_profileRouteId = null;
			_shownProfile = null;
			_shownBottleneck = null;
			_selectedRouteName = "";
			_profileCache.Clear();
			_reportPanel.Hide();
		}

		internal void HandleFrame(double nowSeconds)
		{
			if (_failed || !IsVisible)
			{
				return;
			}
			try
			{
				if (nowSeconds >= _nextRefreshTime)
				{
					_nextRefreshTime = nowSeconds + 1.0;
					long changeStamp;
					bool flag = CartographerCapability.TryReadRouteChangeStamp(out changeStamp);
					if (!flag || changeStamp != _lastChangeStamp)
					{
						_lastChangeStamp = (flag ? changeStamp : long.MinValue);
						Refresh();
					}
					else
					{
						RecomputeBottleneck();
						RenderProfileLines();
					}
				}
				AdvanceProfiling();
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void ForceRefresh()
		{
			_nextRefreshTime = 0.0;
			_lastChangeStamp = long.MinValue;
			Refresh();
		}

		private void Refresh()
		{
			IReadOnlyList<CartographerRouteSnapshot> routes;
			bool flag = CartographerCapability.TryReadRoutes(out routes);
			RoutePickerPresenter.ViewModel viewModel = RoutePickerPresenter.Present(flag, flag ? routes : null, _selectedRouteId);
			_selectedRouteId = viewModel.EffectiveSelectedId;
			object route;
			if (flag)
			{
				Guid? selectedRouteId = _selectedRouteId;
				if (selectedRouteId.HasValue)
				{
					route = FindRoute(routeId: selectedRouteId.GetValueOrDefault(), routes: routes);
					goto IL_0051;
				}
			}
			route = null;
			goto IL_0051;
			IL_0051:
			SyncProfileTarget((CartographerRouteSnapshot?)route);
			RecomputeBottleneck();
			if ((Object)(object)_statusLine == (Object)null || _rowTexts.Length != 11)
			{
				return;
			}
			_statusLine.text = viewModel.StatusLine;
			int num = Math.Min(11, viewModel.Rows.Count);
			for (int i = 0; i < 11; i++)
			{
				bool flag2 = i < num;
				RoutePickerPresenter.Row row = (flag2 ? viewModel.Rows[i] : null);
				_rowRouteIds[i] = ((row != null && row.Eligible) ? new Guid?(row.RouteId) : ((Guid?)null));
				_rowTexts[i].text = row?.Text ?? string.Empty;
				if (_rowButtons[i].activeSelf != flag2)
				{
					_rowButtons[i].SetActive(flag2);
				}
			}
			int num2 = viewModel.Rows.Count - num;
			if ((Object)(object)_overflowLine != (Object)null)
			{
				_overflowLine.text = ((num2 > 0) ? TeamsterStrings.Format("routes.overflow", num2.ToString(CultureInfo.InvariantCulture)) : string.Empty);
			}
			RenderProfileLines();
		}

		private static CartographerRouteSnapshot? FindRoute(IReadOnlyList<CartographerRouteSnapshot> routes, Guid routeId)
		{
			for (int i = 0; i < routes.Count; i++)
			{
				if (routes[i].Id == routeId)
				{
					return routes[i];
				}
			}
			return null;
		}

		private void SyncProfileTarget(CartographerRouteSnapshot? route)
		{
			if (route == null)
			{
				_profiler?.Cancel();
				_profiler = null;
				_profileRouteId = null;
				_shownProfile = null;
				_shownBottleneck = null;
				_selectedRouteName = "";
				return;
			}
			_selectedRouteName = route.Name;
			ulong num = RouteGeometry.Fingerprint(route.Points);
			Guid? profileRouteId = _profileRouteId;
			Guid id = route.Id;
			if (!profileRouteId.HasValue || !(profileRouteId.GetValueOrDefault() == id) || _profileFingerprint != num || (_shownProfile == null && _profiler == null))
			{
				_profiler?.Cancel();
				_profiler = null;
				_profileRouteId = route.Id;
				_profileFingerprint = num;
				_shownProfile = null;
				_shownBottleneck = null;
				if (_profileCache.TryGet(route.Id, num, out RouteProfile profile))
				{
					_shownProfile = profile;
				}
				else
				{
					_profiler = new RouteProfiler(route.Points, TerrainAdapter.TrySamplePoint);
				}
			}
		}

		private void AdvanceProfiling()
		{
			if (_profiler == null)
			{
				return;
			}
			_profiler.Advance(24);
			if (_profiler.IsComplete)
			{
				RouteProfile routeProfile = _profiler.TryBuildProfile();
				_profiler = null;
				if (routeProfile != null)
				{
					Guid? profileRouteId = _profileRouteId;
					if (profileRouteId.HasValue)
					{
						Guid valueOrDefault = profileRouteId.GetValueOrDefault();
						_profileCache.Store(valueOrDefault, _profileFingerprint, routeProfile);
						_shownProfile = routeProfile;
						RecomputeBottleneck();
					}
				}
			}
			RenderProfileLines();
		}

		private void RecomputeBottleneck()
		{
			_shownBottleneck = ((_loadModel != null && _shownProfile != null) ? RouteLoadBottleneck.Evaluate(_shownProfile, _loadModel, _cartMassProvider(), CompatibilityAdapter.CartMassAdviceReliable) : null);
		}

		private void RenderProfileLines()
		{
			if (_profileLines.Length == 5 && !((Object)(object)_profileLines[0] == (Object)null))
			{
				Guid? selectedRouteId = _selectedRouteId;
				IReadOnlyList<string> readOnlyList = RouteProfilePresenter.Present(selectedRouteId.HasValue, _profiler != null, _profiler?.PositionsProbed ?? 0, _profiler?.PositionCount ?? 0, _shownProfile, _shownBottleneck);
				for (int i = 0; i < _profileLines.Length; i++)
				{
					_profileLines[i].text = readOnlyList[i];
				}
				if (_reportPanel.IsVisible)
				{
					_reportPanel.Render(BuildReportViewModel());
				}
			}
		}

		private RouteReportPresenter.ViewModel BuildReportViewModel()
		{
			return RouteReportPresenter.Present(_selectedRouteName, _shownProfile, _loadModel, _cartMassProvider(), CompatibilityAdapter.CartMassAdviceReliable);
		}

		private void SelectRow(int index)
		{
			try
			{
				Guid? selectedRouteId = _rowRouteIds[index];
				if (selectedRouteId.HasValue)
				{
					_selectedRouteId = selectedRouteId;
					ForceRefresh();
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private bool EnsurePanel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Expected O, but got Unknown
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Expected O, but got Unknown
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 380f, 570f, _uiScale());
			instance.CreateText(TeamsterStrings.Get("routes.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 340f, 30f, false);
			_statusLine = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -56f), averiaSerifBold, 15, body, true, Color.black, 340f, 24f, false).GetComponent<Text>();
			_statusLine.alignment = (TextAnchor)0;
			_rowButtons = (GameObject[])(object)new GameObject[11];
			_rowTexts = (Text[])(object)new Text[11];
			float num = -86f;
			for (int i = 0; i < 11; i++)
			{
				int captured = i;
				GameObject val = instance.CreateButton(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num - 13f), 340f, 24f);
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					SelectRow(captured);
				});
				_rowButtons[i] = val;
				_rowTexts[i] = val.GetComponentInChildren<Text>();
				_rowTexts[i].fontSize = 14;
				_rowTexts[i].alignment = (TextAnchor)3;
				val.SetActive(false);
				num -= 26f;
			}
			_overflowLine = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 48f), averiaSerifBold, 13, body, true, Color.black, 340f, 22f, false).GetComponent<Text>();
			_profileLines = (Text[])(object)new Text[5];
			float num2 = -388f;
			for (int num3 = 0; num3 < _profileLines.Length; num3++)
			{
				_profileLines[num3] = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num2 - 10f), averiaSerifBold, 13, body, true, Color.black, 340f, 20f, false).GetComponent<Text>();
				_profileLines[num3].alignment = (TextAnchor)0;
				_profileLines[num3].verticalOverflow = (VerticalWrapMode)0;
				num2 -= 21f;
			}
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("routes.clearButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-120f, 30f), 100f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_selectedRouteId = null;
				ForceRefresh();
			});
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("routes.reportButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 30f), 100f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_reportPanel.Toggle(BuildReportViewModel());
			});
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(120f, 30f), 100f, 30f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_panel.SetActive(false);
				_reportPanel.Hide();
			});
			_panel.SetActive(false);
			return true;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			_selectedRouteId = null;
			_profiler?.Cancel();
			_profiler = null;
			_profileRouteId = null;
			_shownProfile = null;
			_shownBottleneck = null;
			_selectedRouteName = "";
			_profileCache.Clear();
			_reportPanel.Hide();
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			_log.LogError((object)("Route picker disabled for this session after a UI exception; everything else keeps working: " + exception));
		}
	}
	internal sealed class RouteReportPanel
	{
		private const float PanelWidth = 460f;

		private const float PanelHeight = 500f;

		private const float LineHeight = 21f;

		internal const int MaxLines = 18;

		private readonly ManualLogSource _log;

		private readonly Func<float> _uiScale;

		private bool _failed;

		private GameObject? _panel;

		private Text? _title;

		private Text[] _lines = Array.Empty<Text>();

		internal bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		internal RouteReportPanel(ManualLogSource log, Func<float> uiScale)
		{
			_log = log;
			_uiScale = uiScale;
		}

		internal void Toggle(RouteReportPresenter.ViewModel viewModel)
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || EnsurePanel())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						Render(viewModel);
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		internal void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		internal void Render(RouteReportPresenter.ViewModel viewModel)
		{
			if (_failed || !IsVisible || (Object)(object)_title == (Object)null || _lines.Length != 18)
			{
				return;
			}
			try
			{
				_title.text = viewModel.Title;
				for (int i = 0; i < 18; i++)
				{
					_lines[i].text = ((i < viewModel.Lines.Count) ? viewModel.Lines[i] : string.Empty);
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private bool EnsurePanel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(120f, 0f), 460f, 500f, _uiScale());
			_title = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 18, header, true, Color.black, 420f, 30f, false).GetComponent<Text>();
			_lines = (Text[])(object)new Text[18];
			float num = -56f;
			for (int i = 0; i < 18; i++)
			{
				_lines[i] = instance.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num - 10.5f), averiaSerifBold, 14, body, true, Color.black, 420f, 21f, false).GetComponent<Text>();
				_lines[i].alignment = (TextAnchor)0;
				_lines[i].verticalOverflow = (VerticalWrapMode)0;
				num -= 21f;
			}
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_panel.SetActive(false);
			});
			_panel.SetActive(false);
			return true;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			_log.LogError((object)("Route report disabled for this session after a UI exception; everything else keeps working: " + exception));
		}
	}
	internal sealed class SupportBundlePanel
	{
		private const float PanelWidth = 420f;

		private const float PanelHeight = 320f;

		private readonly ManualLogSource _log;

		private readonly Func<float> _uiScale;

		private readonly string _pluginVersion;

		private readonly TeamsterSettings _settings;

		private readonly LogTailRecorder _logTail;

		private readonly Func<TripRecordingService?> _tripsProvider;

		private bool _failed;

		private GameObject? _panel;

		private Text? _statusText;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public SupportBundlePanel(ManualLogSource log, Func<float> uiScale, string pluginVersion, TeamsterSettings settings, LogTailRecorder logTail, Func<TripRecordingService?> tripsProvider)
		{
			_log = log;
			_uiScale = uiScale;
			_pluginVersion = pluginVersion;
			_settings = settings;
			_logTail = logTail;
			_tripsProvider = tripsProvider;
		}

		public void Toggle()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || EnsurePanel())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag && (Object)(object)_statusText != (Object)null)
					{
						_statusText.text = TeamsterStrings.Get("support.readyToExport");
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		public void HandleFrame()
		{
			if (_failed || !IsVisible)
			{
				return;
			}
			try
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					Hide();
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void HandleExportClicked()
		{
			if (_failed || (Object)(object)_statusText == (Object)null)
			{
				return;
			}
			try
			{
				var (flag, text, text2) = SupportBundleExporter.Export(_pluginVersion, _settings, _tripsProvider(), _logTail, DateTime.UtcNow);
				_statusText.text = (flag ? TeamsterStrings.Format("support.exported", text) : TeamsterStrings.Format("support.exportFailed", text2 ?? TeamsterStrings.Get("support.unknownError")));
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void HandleReportBugClicked()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				Application.OpenURL("https://github.com/Weakened/ConcernedCatMods/issues");
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private bool EnsurePanel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Expected O, but got Unknown
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 120f), 420f, 320f, _uiScale());
			instance.CreateText(TeamsterStrings.Get("support.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 380f, 30f, false);
			instance.CreateText(TeamsterStrings.Get("support.explainer"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -66f), averiaSerifBold, 13, body, true, Color.black, 380f, 60f, false);
			_statusText = instance.CreateText(TeamsterStrings.Get("support.readyToExport"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -128f), averiaSerifBold, 13, body, true, Color.black, 380f, 40f, false).GetComponent<Text>();
			_statusText.alignment = (TextAnchor)0;
			_statusText.horizontalOverflow = (HorizontalWrapMode)0;
			instance.CreateText(TeamsterStrings.Get("support.feedbackExplainer"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -172f), averiaSerifBold, 13, body, true, Color.black, 380f, 70f, false);
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("support.reportBugButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 64f), 150f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(HandleReportBugClicked));
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("support.exportButton"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-60f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(HandleExportClicked));
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(60f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			_panel.SetActive(false);
			return true;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			try
			{
				Hide();
			}
			catch
			{
			}
			_log.LogError((object)("Support Bundle panel UI failed and was disabled for this session: " + exception.GetType().Name + ": " + exception.Message));
		}
	}
	internal sealed class TripHistoryPanel
	{
		private const float PanelWidth = 470f;

		private const float PanelHeight = 760f;

		private const float RowHeight = 26f;

		private const int VisibleRowCount = 10;

		private const double ConfirmWindowSeconds = 3.0;

		private readonly ManualLogSource _log;

		private readonly Func<float> _uiScale;

		private bool _failed;

		private GameObject? _panel;

		private Text?[] _rowTexts = Array.Empty<Text>();

		private Button?[] _rowSelectA = Array.Empty<Button>();

		private Button?[] _rowSelectB = Array.Empty<Button>();

		private Button?[] _rowDelete = Array.Empty<Button>();

		private Text? _overflow;

		private Text? _message;

		private Text? _compareHeaderA;

		private Text? _compareHeaderB;

		private Text?[] _compareLines = Array.Empty<Text>();

		private IReadOnlyList<Trip> _trips = Array.Empty<Trip>();

		private RoadQualityIndex _segments = new RoadQualityIndex();

		private List<TripSummary> _summaries = new List<TripSummary>();

		private InputField? _massInput;

		private Text?[] _bottleneckLines = Array.Empty<Text>();

		private Text? _bottleneckHeader;

		private TripHistoryPresenter.SortColumn _sortColumn;

		private bool _sortDescending = true;

		private int? _selectedAId;

		private int? _selectedBId;

		private int[] _visibleTripIds = Array.Empty<int>();

		private int? _pendingDeleteId;

		private double _pendingDeleteUntil;

		private CartTelemetryPump? _pumpForButtons;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public TripHistoryPanel(ManualLogSource log, Func<float> uiScale)
		{
			_log = log;
			_uiScale = uiScale;
		}

		public void Toggle(CartTelemetryPump? pump)
		{
			if (_failed)
			{
				return;
			}
			try
			{
				if (!((Object)(object)_panel == (Object)null) || Build())
				{
					bool flag = !_panel.activeSelf;
					_panel.SetActive(flag);
					if (flag)
					{
						Reload(pump);
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		public void HandleFrame(double nowSeconds, CartTelemetryPump? pump)
		{
			if (_failed || !IsVisible)
			{
				return;
			}
			try
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					Hide();
					return;
				}
				int? pendingDeleteId = _pendingDeleteId;
				if (pendingDeleteId.HasValue && nowSeconds > _pendingDeleteUntil)
				{
					_pendingDeleteId = null;
					Render();
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Reload(CartTelemetryPump? pump)
		{
			(IReadOnlyList<Trip>, RoadQualityIndex, long) tuple = pump?.Trips?.LoadWorldData() ?? (Array.Empty<Trip>(), new RoadQualityIndex(), 0L);
			_trips = tuple.Item1;
			_segments = tuple.Item2;
			_summaries = new List<TripSummary>(_trips.Count);
			foreach (Trip trip in _trips)
			{
				_summaries.Add(TripSummarizer.Summarize(trip));
			}
			int? selectedAId = _selectedAId;
			if (selectedAId.HasValue)
			{
				int valueOrDefault = selectedAId.GetValueOrDefault();
				if (FindTrip(valueOrDefault) == null)
				{
					_selectedAId = null;
				}
			}
			selectedAId = _selectedBId;
			if (selectedAId.HasValue)
			{
				int valueOrDefault2 = selectedAId.GetValueOrDefault();
				if (FindTrip(valueOrDefault2) == null)
				{
					_selectedBId = null;
				}
			}
			_pendingDeleteId = null;
			Render();
		}

		private Trip? FindTrip(int tripId)
		{
			foreach (Trip trip in _trips)
			{
				if (trip.Id == tripId)
				{
					return trip;
				}
			}
			return null;
		}

		private void Render()
		{
			TripHistoryPresenter.ViewModel viewModel = TripHistoryPresenter.Present(_summaries, _sortColumn, _sortDescending, _selectedAId, _selectedBId);
			if ((Object)(object)_message != (Object)null)
			{
				_message.text = (viewModel.Empty ? viewModel.Message : string.Empty);
			}
			int num = Math.Min(viewModel.Rows.Count, 10);
			_visibleTripIds = new int[num];
			for (int i = 0; i < _rowTexts.Length; i++)
			{
				bool flag = i < num;
				if ((Object)(object)_rowTexts[i] != (Object)null)
				{
					_rowTexts[i].text = (flag ? viewModel.Rows[i].Text : string.Empty);
				}
				if (flag)
				{
					_visibleTripIds[i] = viewModel.Rows[i].TripId;
				}
				SetRowButtonsActive(i, flag);
				if (flag && (Object)(object)_rowDelete[i] != (Object)null)
				{
					SetButtonLabel(_rowDelete[i], TeamsterStrings.Get((_pendingDeleteId == viewModel.Rows[i].TripId) ? "trips.deleteConfirm" : "trips.deleteButton"));
				}
			}
			if ((Object)(object)_overflow != (Object)null)
			{
				int num2 = viewModel.Rows.Count - num;
				_overflow.text = ((num2 > 0) ? TeamsterStrings.Format("trips.overflow", num2.ToString(CultureInfo.InvariantCulture)) : string.Empty);
			}
			RenderBottlenecks(null);
			int? selectedAId = _selectedAId;
			object tripA;
			if (selectedAId.HasValue)
			{
				int valueOrDefault = selectedAId.GetValueOrDefault();
				tripA = FindTrip(valueOrDefault);
			}
			else
			{
				tripA = null;
			}
			selectedAId = _selectedBId;
			object tripB;
			if (selectedAId.HasValue)
			{
				int valueOrDefault2 = selectedAId.GetValueOrDefault();
				tripB = FindTrip(valueOrDefault2);
			}
			else
			{
				tripB = null;
			}
			TripComparisonPresenter.ViewModel viewModel2 = TripComparisonPresenter.Present((Trip?)tripA, (Trip?)tripB);
			if ((Object)(object)_compareHeaderA != (Object)null)
			{
				_compareHeaderA.text = (viewModel2.HasComparison ? viewModel2.HeaderA : viewModel2.Message);
			}
			if ((Object)(object)_compareHeaderB != (Object)null)
			{
				_compareHeaderB.text = (viewModel2.HasComparison ? viewModel2.HeaderB : string.Empty);
			}
			for (int j = 0; j < _compareLines.Length; j++)
			{
				if ((Object)(object)_compareLines[j] != (Object)null)
				{
					_compareLines[j].text = ((viewModel2.HasComparison && j < viewModel2.BucketLines.Count) ? viewModel2.BucketLines[j] : string.Empty);
				}
			}
		}

		private static void SetButtonLabel(Button? button, string label)
		{
			if (!((Object)(object)button == (Object)null))
			{
				Text componentInChildren = ((Component)button).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null && componentInChildren.text != label)
				{
					componentInChildren.text = label;
				}
			}
		}

		private void SetRowButtonsActive(int index, bool active)
		{
			Button val = _rowSelectA[index];
			if (val != null && ((Component)val).gameObject.activeSelf != active)
			{
				((Component)val).gameObject.SetActive(active);
			}
			Button val2 = _rowSelectB[index];
			if (val2 != null && ((Component)val2).gameObject.activeSelf != active)
			{
				((Component)val2).gameObject.SetActive(active);
			}
			Button val3 = _rowDelete[index];
			if (val3 != null && ((Component)val3).gameObject.activeSelf != active)
			{
				((Component)val3).gameObject.SetActive(active);
			}
		}

		private void OnSelect(int rowIndex, bool asA, CartTelemetryPump? pump)
		{
			if (rowIndex < _visibleTripIds.Length)
			{
				int num = _visibleTripIds[rowIndex];
				if (asA)
				{
					_selectedAId = ((_selectedAId == num) ? ((int?)null) : new int?(num));
				}
				else
				{
					_selectedBId = ((_selectedBId == num) ? ((int?)null) : new int?(num));
				}
				Render();
			}
		}

		private void OnDelete(int rowIndex, CartTelemetryPump? pump)
		{
			if (rowIndex >= _visibleTripIds.Length)
			{
				return;
			}
			int num = _visibleTripIds[rowIndex];
			if (_pendingDeleteId != num)
			{
				_pendingDeleteId = num;
				_pendingDeleteUntil = Time.unscaledTimeAsDouble + 3.0;
				Render();
				return;
			}
			_pendingDeleteId = null;
			if (pump != null && pump.Trips?.DeleteTrip(num) == true)
			{
				_log.LogInfo((object)("Trip #" + num + " deleted from this world's sidecar."));
			}
			Reload(pump);
		}

		private void RenderBottlenecks(object? pumpUnused)
		{
			int? selectedAId = _selectedAId;
			object trip;
			if (selectedAId.HasValue)
			{
				int valueOrDefault = selectedAId.GetValueOrDefault();
				trip = FindTrip(valueOrDefault);
			}
			else
			{
				trip = null;
			}
			RouteBottleneckPresenter.ViewModel viewModel = RouteBottleneckPresenter.Present((Trip?)trip, _segments, _pumpForButtons?.LoadModel, ((Object)(object)_massInput != (Object)null) ? _massInput.text : null, CompatibilityAdapter.CartMassAdviceReliable);
			if ((Object)(object)_bottleneckHeader != (Object)null)
			{
				_bottleneckHeader.text = (viewModel.Available ? viewModel.Message : viewModel.Message);
			}
			for (int i = 0; i < _bottleneckLines.Length; i++)
			{
				if ((Object)(object)_bottleneckLines[i] != (Object)null)
				{
					_bottleneckLines[i].text = ((viewModel.Available && i < viewModel.Lines.Count) ? viewModel.Lines[i] : string.Empty);
				}
			}
		}

		private void SetSort(TripHistoryPresenter.SortColumn column)
		{
			if (_sortColumn == column)
			{
				_sortDescending = !_sortDescending;
			}
			else
			{
				_sortColumn = column;
				_sortDescending = true;
			}
			Render();
		}

		public void BindPump(CartTelemetryPump? pump)
		{
			_pumpForButtons = pump;
		}

		private bool Build()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Expected O, but got Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Expected O, but got Unknown
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color header = PanelStyle.Header;
			Color body = PanelStyle.Body;
			_panel = PanelStyle.CreateScaledWoodpanel(instance, GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 470f, 760f, _uiScale());
			instance.CreateText(TeamsterStrings.Get("trips.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, header, true, Color.black, 430f, 30f, false);
			(string, TripHistoryPresenter.SortColumn)[] array = new(string, TripHistoryPresenter.SortColumn)[5]
			{
				(TeamsterStrings.Get("trips.colDate"), TripHistoryPresenter.SortColumn.StartTime),
				(TeamsterStrings.Get("trips.colTime"), TripHistoryPresenter.SortColumn.Duration),
				(TeamsterStrings.Get("trips.colDist"), TripHistoryPresenter.SortColumn.Distance),
				(TeamsterStrings.Get("trips.colLoad"), TripHistoryPresenter.SortColumn.Load),
				(TeamsterStrings.Get("trips.colGrade"), TripHistoryPresenter.SortColumn.WorstGrade)
			};
			float num = 410f / (float)array.Length;
			float num2 = -205f + num / 2f;
			for (int i = 0; i < array.Length; i++)
			{
				TripHistoryPresenter.SortColumn column = array[i].Item2;
				((UnityEvent)instance.CreateButton(array[i].Item1, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(num2 + (float)i * num, -62f), num - 4f, 26f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					SetSort(column);
				});
			}
			_message = CreateText(instance, averiaSerifBold, body, 0f, -96f, 430f, 26f);
			_rowTexts = (Text?[])(object)new Text[10];
			_rowSelectA = (Button?[])(object)new Button[10];
			_rowSelectB = (Button?[])(object)new Button[10];
			_rowDelete = (Button?[])(object)new Button[10];
			float num3 = -96f;
			float num4 = -209f;
			for (int num5 = 0; num5 < 10; num5++)
			{
				int rowIndex = num5;
				_rowSelectA[num5] = CreateRowButton(instance, TeamsterStrings.Get("trips.selectA"), num4, num3, delegate
				{
					OnSelect(rowIndex, asA: true, _pumpForButtons);
				});
				_rowSelectB[num5] = CreateRowButton(instance, TeamsterStrings.Get("trips.selectB"), num4 + 30f, num3, delegate
				{
					OnSelect(rowIndex, asA: false, _pumpForButtons);
				});
				_rowDelete[num5] = CreateRowButton(instance, TeamsterStrings.Get("trips.deleteButton"), num4 + 60f, num3, delegate
				{
					OnDelete(rowIndex, _pumpForButtons);
				});
				_rowTexts[num5] = CreateText(instance, averiaSerifBold, body, 55f, num3, 320f, 26f);
				num3 -= 26f;
			}
			_overflow = CreateText(instance, averiaSerifBold, body, 0f, num3, 430f, 26f);
			num3 -= 32f;
			_compareHeaderA = CreateText(instance, averiaSerifBold, header, 0f, num3, 430f, 26f);
			num3 -= 26f;
			_compareHeaderB = CreateText(instance, averiaSerifBold, header, 0f, num3, 430f, 26f);
			num3 -= 26f;
			_compareLines = (Text?[])(object)new Text[5];
			for (int num6 = 0; num6 < _compareLines.Length; num6++)
			{
				_compareLines[num6] = CreateText(instance, averiaSerifBold, body, 0f, num3, 430f, 26f);
				num3 -= 26f;
			}
			num3 -= 6f;
			GameObject val = instance.CreateInputField(_panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-130f, num3 - 14f), (ContentType)0, TeamsterStrings.Get("trips.massPlaceholder"), 14, 150f, 26f);
			_massInput = val.GetComponent<InputField>();
			if ((Object)(object)_massInput != (Object)null)
			{
				((UnityEvent<string>)(object)_massInput.onValueChanged).AddListener((UnityAction<string>)delegate
				{
					RenderBottlenecks(null);
				});
			}
			_bottleneckHeader = CreateText(instance, averiaSerifBold, header, 90f, num3, 250f, 26f);
			num3 -= 30f;
			_bottleneckLines = (Text?[])(object)new Text[3];
			for (int num7 = 0; num7 < _bottleneckLines.Length; num7++)
			{
				_bottleneckLines[num7] = CreateText(instance, averiaSerifBold, body, 0f, num3, 430f, 26f);
				num3 -= 26f;
			}
			((UnityEvent)instance.CreateButton(TeamsterStrings.Get("ui.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 26f), 110f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			_panel.SetActive(false);
			return true;
		}

		private Button? CreateRowButton(GUIManager gui, string label, float x, float y, Action onClick)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			GameObject obj = gui.CreateButton(label, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(x, y - 13f), 26f, 22f);
			Button component = obj.GetComponent<Button>();
			if (component != null)
			{
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
			obj.SetActive(false);
			return component;
		}

		private Text? CreateText(GUIManager gui, Font font, Color color, float xOffset, float y, float width, float height)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Text component = gui.CreateText(string.Empty, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(xOffset, y - height / 2f), font, 14, color, true, Color.black, width, height, false).GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				component.alignment = (TextAnchor)0;
				component.verticalOverflow = (VerticalWrapMode)0;
				component.horizontalOverflow = (HorizontalWrapMode)1;
			}
			return component;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			try
			{
				Hide();
			}
			catch
			{
			}
			_log.LogError((object)("Trip History UI failed and was disabled for this session (recording keeps running): " + exception.GetType().Name + ": " + exception.Message));
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain
{
	public static class EnvironmentBanner
	{
		public const string Unknown = "unknown";

		public static string Compose(string? releaseIdentity, string? valheimVersion, string? unityVersion, string? bepInExVersion, string? jotunnVersion)
		{
			return "Release " + Normalize(releaseIdentity) + " | Valheim " + Normalize(valheimVersion) + " | Unity " + Normalize(unityVersion) + " | BepInEx " + Normalize(bepInExVersion) + " | Jotunn " + Normalize(jotunnVersion);
		}

		public static string Normalize(string? label)
		{
			if (string.IsNullOrWhiteSpace(label))
			{
				return "unknown";
			}
			string text = label.Replace("\r\n", " ").Replace('\r', ' ').Replace('\n', ' ')
				.Trim();
			if (text.Length != 0)
			{
				return text;
			}
			return "unknown";
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Warnings
{
	public sealed class CartWarning
	{
		public string CartId { get; }

		public WarningLevel Level { get; }

		public string Situation { get; }

		public string Action { get; }

		public CartWarning(string cartId, WarningLevel level, string situation, string action)
		{
			CartId = cartId;
			Level = level;
			Situation = situation;
			Action = action;
		}

		public string ComposeLine()
		{
			if (Level == WarningLevel.None)
			{
				return string.Empty;
			}
			string text = TeamsterStrings.Get((Level == WarningLevel.Danger) ? "warn.cueDanger" : "warn.cueCaution");
			return TeamsterStrings.Format("warn.line", text, Situation, Action);
		}
	}
	public sealed class CartWarningTracker
	{
		private sealed class CartState
		{
			public WarningLevel Level;

			public CartWarning? Warning;

			public double LowerSinceSeconds = double.NaN;

			public bool SteepCauseActive;

			public double LastUpdateSeconds;
		}

		private readonly LoadModel? _loadModel;

		private readonly Dictionary<string, CartState> _stateByCartId = new Dictionary<string, CartState>();

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

		public int EvaluationCount { get; private set; }

		public CartWarningTracker(LoadModel? loadModel)
		{
			_loadModel = loadModel;
		}

		public CartWarning? TryGet(string cartId)
		{
			if (!_stateByCartId.TryGetValue(cartId, out CartState value))
			{
				return null;
			}
			return value.Warning;
		}

		public CartWarning? Update(CartTelemetry telemetry, WarningOptions options)
		{
			EvaluationCount++;
			if (!_stateByCartId.TryGetValue(telemetry.CartId, out CartState value))
			{
				value = new CartState();
				_stateByCartId[telemetry.CartId] = value;
			}
			double num = (value.LastUpdateSeconds = telemetry.SampleTimeSeconds);
			var (warningLevel, cartWarning) = EvaluateTarget(telemetry, options, value);
			if (warningLevel > value.Level)
			{
				value.Level = warningLevel;
				value.Warning = cartWarning;
				value.LowerSinceSeconds = double.NaN;
			}
			else if (warningLevel < value.Level)
			{
				if (double.IsNaN(value.LowerSinceSeconds))
				{
					value.LowerSinceSeconds = num;
				}
				if (num - value.LowerSinceSeconds >= 4.0)
				{
					value.Level = warningLevel;
					value.Warning = cartWarning;
					value.LowerSinceSeconds = double.NaN;
				}
			}
			else
			{
				if (cartWarning != null)
				{
					value.Warning = cartWarning;
				}
				value.LowerSinceSeconds = double.NaN;
			}
			return value.Warning;
		}

		public void Sweep(double nowSeconds, double evictAfterSeconds)
		{
			_staleKeyBuffer.Clear();
			foreach (KeyValuePair<string, CartState> item in _stateByCartId)
			{
				if (nowSeconds - item.Value.LastUpdateSeconds > evictAfterSeconds)
				{
					_staleKeyBuffer.Add(item.Key);
				}
			}
			for (int i = 0; i < _staleKeyBuffer.Count; i++)
			{
				_stateByCartId.Remove(_staleKeyBuffer[i]);
			}
			_staleKeyBuffer.Clear();
		}

		public void Reset()
		{
			_stateByCartId.Clear();
			_staleKeyBuffer.Clear();
		}

		private (WarningLevel, CartWarning?) EvaluateTarget(CartTelemetry telemetry, WarningOptions options, CartState state)
		{
			if (!telemetry.GradeAvailable || telemetry.SmoothedGradePercent <= 0f)
			{
				state.SteepCauseActive = false;
				return (WarningLevel.None, null);
			}
			float smoothedGradePercent = telemetry.SmoothedGradePercent;
			string text = smoothedGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "%";
			string text2 = telemetry.TotalMass.ToString("F0", CultureInfo.InvariantCulture);
			if (_loadModel != null)
			{
				LoadVerdict loadVerdict = _loadModel.Query(smoothedGradePercent, telemetry.TotalMass);
				if (loadVerdict.Climbability == Climbability.No)
				{
					state.SteepCauseActive = false;
					return (WarningLevel.Danger, new CartWarning(telemetry.CartId, WarningLevel.Danger, TeamsterStrings.Format("warn.impossibleSituation", text, text2, loadVerdict.Explanation), TeamsterStrings.Get("warn.impossibleAction")));
				}
				if (loadVerdict.Climbability == Climbability.Marginal)
				{
					state.SteepCauseActive = false;
					return (WarningLevel.Caution, new CartWarning(telemetry.CartId, WarningLevel.Caution, TeamsterStrings.Format("warn.marginalSituation", text, text2, loadVerdict.Explanation), TeamsterStrings.Get("warn.marginalAction")));
				}
				if (loadVerdict.Climbability == Climbability.Yes)
				{
					state.SteepCauseActive = false;
					return (WarningLevel.None, null);
				}
			}
			float steepGradeCautionPercent = options.SteepGradeCautionPercent;
			float num = steepGradeCautionPercent - 3f;
			if (state.SteepCauseActive = (state.SteepCauseActive ? (smoothedGradePercent > num) : (smoothedGradePercent >= steepGradeCautionPercent)))
			{
				return (WarningLevel.Caution, new CartWarning(telemetry.CartId, WarningLevel.Caution, TeamsterStrings.Format("warn.steepSituation", text, text2), TeamsterStrings.Get("warn.steepAction")));
			}
			return (WarningLevel.None, null);
		}
	}
	public enum WarningLevel
	{
		None,
		Caution,
		Danger
	}
	public sealed class WarningOptions
	{
		public const float DefaultSteepGradeCautionPercent = 18f;

		public const float MinSteepGradeCautionPercent = 5f;

		public const float MaxSteepGradeCautionPercent = 60f;

		public const float ExitBandPercent = 3f;

		public const double FallHoldSeconds = 4.0;

		public float SteepGradeCautionPercent { get; }

		public bool PanelWarningsEnabled { get; }

		public bool HudHintsEnabled { get; }

		private WarningOptions(float steepGradeCautionPercent, bool panelWarningsEnabled, bool hudHintsEnabled)
		{
			SteepGradeCautionPercent = steepGradeCautionPercent;
			PanelWarningsEnabled = panelWarningsEnabled;
			HudHintsEnabled = hudHintsEnabled;
		}

		public static WarningOptions CreateClamped(float steepGradeCautionPercent, bool panelWarningsEnabled, bool hudHintsEnabled)
		{
			return new WarningOptions((float.IsNaN(steepGradeCautionPercent) || float.IsInfinity(steepGradeCautionPercent)) ? 18f : Math.Min(60f, Math.Max(5f, steepGradeCautionPercent)), panelWarningsEnabled, hudHintsEnabled);
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Ui
{
	public static class CargoManifestPresenter
	{
		private readonly struct DisplayEntry
		{
			public CargoEntry Entry { get; }

			public string Name { get; }

			public int CanonicalIndex { get; }

			public DisplayEntry(CargoEntry entry, string name, int canonicalIndex)
			{
				Entry = entry;
				Name = name;
				CanonicalIndex = canonicalIndex;
			}
		}

		public const double StaleAfterSeconds = 3.0;

		public static CargoManifestViewModel Present(CargoManifest? manifest, CargoSortColumn sortColumn, bool sortDescending, string? filterText, double nowSeconds, Func<string, string>? localizeName)
		{
			if (manifest == null)
			{
				return new CargoManifestViewModel(CargoManifestState.NoManifest, TeamsterStrings.Get("manifest.noContainer"), Array.Empty<CargoRowViewModel>(), string.Empty, string.Empty);
			}
			string totalLine = ComposeTotalLine(manifest);
			double num = nowSeconds - manifest.CaptureTimeSeconds;
			if (num < 0.0)
			{
				num = 0.0;
			}
			bool flag = num > 3.0;
			string freshnessLine = TeamsterStrings.Format(flag ? "manifest.capturedStale" : "manifest.captured", num.ToString("F1", CultureInfo.InvariantCulture));
			if (manifest.Entries.Count == 0)
			{
				return new CargoManifestViewModel(CargoManifestState.Empty, TeamsterStrings.Get("manifest.empty"), Array.Empty<CargoRowViewModel>(), totalLine, freshnessLine);
			}
			List<DisplayEntry> list = BuildDisplayEntries(manifest, localizeName);
			string filter = filterText?.Trim() ?? string.Empty;
			if (filter.Length > 0)
			{
				list.RemoveAll((DisplayEntry entry) => entry.Name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) < 0);
				if (list.Count == 0)
				{
					return new CargoManifestViewModel(CargoManifestState.NoMatch, TeamsterStrings.Format("manifest.noMatch", filter), Array.Empty<CargoRowViewModel>(), totalLine, freshnessLine);
				}
			}
			SortEntries(list, sortColumn, sortDescending);
			CargoRowViewModel[] array = new CargoRowViewModel[list.Count];
			for (int num2 = 0; num2 < list.Count; num2++)
			{
				DisplayEntry displayEntry = list[num2];
				array[num2] = new CargoRowViewModel(displayEntry.Name, displayEntry.Entry.Count.ToString(CultureInfo.InvariantCulture), displayEntry.Entry.WeightKnown ? displayEntry.Entry.UnitWeight.ToString("F1", CultureInfo.InvariantCulture) : "?", displayEntry.Entry.WeightKnown ? displayEntry.Entry.LineWeight.ToString("F1", CultureInfo.InvariantCulture) : "?");
			}
			return new CargoManifestViewModel(flag ? CargoManifestState.Stale : CargoManifestState.Live, string.Empty, array, totalLine, freshnessLine);
		}

		private static List<DisplayEntry> BuildDisplayEntries(CargoManifest manifest, Func<string, string>? localizeName)
		{
			List<DisplayEntry> list = new List<DisplayEntry>(manifest.Entries.Count);
			for (int i = 0; i < manifest.Entries.Count; i++)
			{
				CargoEntry cargoEntry = manifest.Entries[i];
				string text = cargoEntry.EffectiveDisplayName;
				if (localizeName != null)
				{
					try
					{
						string text2 = localizeName(text);
						if (!string.IsNullOrEmpty(text2))
						{
							text = text2;
						}
					}
					catch
					{
					}
				}
				list.Add(new DisplayEntry(cargoEntry, text, i));
			}
			return list;
		}

		private static void SortEntries(List<DisplayEntry> entries, CargoSortColumn column, bool descending)
		{
			entries.Sort(delegate(DisplayEntry left, DisplayEntry right)
			{
				if (left.Entry.WeightKnown != right.Entry.WeightKnown)
				{
					if (!left.Entry.WeightKnown)
					{
						return 1;
					}
					return -1;
				}
				int num = column switch
				{
					CargoSortColumn.Name => string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase), 
					CargoSortColumn.Count => left.Entry.Count.CompareTo(right.Entry.Count), 
					CargoSortColumn.UnitWeight => left.Entry.UnitWeight.CompareTo(right.Entry.UnitWeight), 
					_ => left.Entry.LineWeight.CompareTo(right.Entry.LineWeight), 
				};
				if (descending)
				{
					num = -num;
				}
				return (num != 0) ? num : left.CanonicalIndex.CompareTo(right.CanonicalIndex);
			});
		}

		private static string ComposeTotalLine(CargoManifest manifest)
		{
			string text = manifest.TotalKnownWeight.ToString("F1", CultureInfo.InvariantCulture);
			string text2 = manifest.TotalItemCount.ToString(CultureInfo.InvariantCulture);
			if (manifest.HasUnknownWeights)
			{
				return TeamsterStrings.Format("manifest.totalLineWithUnknown", text, manifest.UnknownWeightEntryCount.ToString(CultureInfo.InvariantCulture), text2);
			}
			return TeamsterStrings.Format("manifest.totalLine", text, text2);
		}
	}
	public enum CargoManifestState
	{
		NoManifest,
		Empty,
		NoMatch,
		Live,
		Stale
	}
	public sealed class CargoManifestViewModel
	{
		public CargoManifestState State { get; }

		public string Message { get; }

		public IReadOnlyList<CargoRowViewModel> Rows { get; }

		public string TotalLine { get; }

		public string FreshnessLine { get; }

		public CargoManifestViewModel(CargoManifestState state, string message, IReadOnlyList<CargoRowViewModel> rows, string totalLine, string freshnessLine)
		{
			State = state;
			Message = message;
			Rows = rows;
			TotalLine = totalLine;
			FreshnessLine = freshnessLine;
		}
	}
	public sealed class CargoRowViewModel
	{
		public string Name { get; }

		public string CountText { get; }

		public string UnitWeightText { get; }

		public string LineWeightText { get; }

		public CargoRowViewModel(string name, string countText, string unitWeightText, string lineWeightText)
		{
			Name = name;
			CountText = countText;
			UnitWeightText = unitWeightText;
			LineWeightText = lineWeightText;
		}
	}
	public static class CartStatusPresenter
	{
		public const double StaleAfterSeconds = 1.5;

		public static CartStatusViewModel Present(IReadOnlyDictionary<string, CartTelemetry>? telemetryByCartId, string? previouslySelectedCartId, double nowSeconds, bool telemetryActive)
		{
			if (!telemetryActive)
			{
				return Message(CartStatusState.TelemetryOff, TeamsterStrings.Get("status.telemetryOff"));
			}
			if (telemetryByCartId == null || telemetryByCartId.Count == 0)
			{
				return Message(CartStatusState.NoCart, TeamsterStrings.Get("status.noCart"));
			}
			CartTelemetry cartTelemetry = Select(telemetryByCartId, previouslySelectedCartId);
			double num = nowSeconds - cartTelemetry.SampleTimeSeconds;
			if (num < 0.0)
			{
				num = 0.0;
			}
			bool flag = num > 1.5;
			return new CartStatusViewModel(flag ? CartStatusState.Stale : CartStatusState.Live, TeamsterStrings.Get(cartTelemetry.IsPulledByLocalPlayer ? "status.pullingThisCart" : "status.nearbyCart"), TeamsterStrings.Format("status.totalMass", cartTelemetry.TotalMass.ToString("F1", CultureInfo.InvariantCulture)), ComposeBreakdown(cartTelemetry), ComposeGrade(cartTelemetry), TeamsterStrings.Format("status.surface", DescribeSurface(cartTelemetry.Surface)), ComposePull(cartTelemetry), TeamsterStrings.Format(flag ? "status.stale" : "status.updated", num.ToString("F1", CultureInfo.InvariantCulture)), cartTelemetry.CartId);
		}

		private static CartTelemetry Select(IReadOnlyDictionary<string, CartTelemetry> telemetryByCartId, string? previouslySelectedCartId)
		{
			CartTelemetry cartTelemetry = null;
			CartTelemetry cartTelemetry2 = null;
			foreach (KeyValuePair<string, CartTelemetry> item in telemetryByCartId)
			{
				CartTelemetry value = item.Value;
				if (value.IsPulledByLocalPlayer && (cartTelemetry == null || string.CompareOrdinal(value.CartId, cartTelemetry.CartId) < 0))
				{
					cartTelemetry = value;
				}
				if (cartTelemetry2 == null || string.CompareOrdinal(value.CartId, cartTelemetry2.CartId) < 0)
				{
					cartTelemetry2 = value;
				}
			}
			if (cartTelemetry != null)
			{
				return cartTelemetry;
			}
			if (previouslySelectedCartId != null && telemetryByCartId.TryGetValue(previouslySelectedCartId, out CartTelemetry value2))
			{
				return value2;
			}
			return cartTelemetry2;
		}

		private static CartStatusViewModel Message(CartStatusState state, string message)
		{
			return new CartStatusViewModel(state, message, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty);
		}

		private static string ComposeBreakdown(CartTelemetry telemetry)
		{
			string text = telemetry.BaseMass.ToString("F1", CultureInfo.InvariantCulture);
			if (!telemetry.CargoDataAvailable)
			{
				return TeamsterStrings.Format("status.breakdownCargoUnknown", text);
			}
			string text2 = telemetry.CargoWeight.ToString("F1", CultureInfo.InvariantCulture);
			if (telemetry.ItemWeightMassFactor != 1f)
			{
				return TeamsterStrings.Format("status.breakdownScaled", text, text2, telemetry.ItemWeightMassFactor.ToString("F2", CultureInfo.InvariantCulture));
			}
			return TeamsterStrings.Format("status.breakdown", text, text2);
		}

		private static string ComposeGrade(CartTelemetry telemetry)
		{
			if (!telemetry.GradeAvailable)
			{
				return TeamsterStrings.Get("status.gradeUnavailable");
			}
			string text = TeamsterStrings.Get(telemetry.GradeDirection switch
			{
				GradeDirection.Climbing => "status.gradeWordClimbing", 
				GradeDirection.Descending => "status.gradeWordDescending", 
				_ => "status.gradeWordLevel", 
			});
			return TeamsterStrings.Format("status.grade", telemetry.SmoothedGradePercent.ToString("F1", CultureInfo.InvariantCulture), text);
		}

		private static string ComposePull(CartTelemetry telemetry)
		{
			if (telemetry.IsPulledByLocalPlayer)
			{
				return TeamsterStrings.Get("status.pulledByYou");
			}
			return TeamsterStrings.Get(telemetry.IsAttached ? "status.attachedOtherPuller" : "status.notAttached");
		}

		private static string DescribeSurface(TerrainSurfaceKind surface)
		{
			return TeamsterStrings.Get(surface switch
			{
				TerrainSurfaceKind.Untouched => "status.surfaceUntouched", 
				TerrainSurfaceKind.Dirt => "status.surfaceDirt", 
				TerrainSurfaceKind.Cultivated => "status.surfaceCultivated", 
				TerrainSurfaceKind.Paved => "status.surfacePaved", 
				_ => "status.surfaceUnknown", 
			});
		}
	}
	public enum CartStatusState
	{
		TelemetryOff,
		NoCart,
		Live,
		Stale
	}
	public sealed class CartStatusViewModel
	{
		public CartStatusState State { get; }

		public string SourceLine { get; }

		public string MassLine { get; }

		public string BreakdownLine { get; }

		public string GradeLine { get; }

		public string SurfaceLine { get; }

		public string PullLine { get; }

		public string FreshnessLine { get; }

		public string SelectedCartId { get; }

		public CartStatusViewModel(CartStatusState state, string sourceLine, string massLine, string breakdownLine, string gradeLine, string surfaceLine, string pullLine, string freshnessLine, string selectedCartId)
		{
			State = state;
			SourceLine = sourceLine;
			MassLine = massLine;
			BreakdownLine = breakdownLine;
			GradeLine = gradeLine;
			SurfaceLine = surfaceLine;
			PullLine = pullLine;
			FreshnessLine = freshnessLine;
			SelectedCartId = selectedCartId;
		}
	}
	public static class ContrastRatio
	{
		public const double AaNormalTextMinimum = 4.5;

		public static double Compute((float R, float G, float B) colorOne, (float R, float G, float B) colorTwo)
		{
			double val = RelativeLuminance(colorOne);
			double val2 = RelativeLuminance(colorTwo);
			double num = Math.Max(val, val2);
			double num2 = Math.Min(val, val2);
			return (num + 0.05) / (num2 + 0.05);
		}

		private static double RelativeLuminance((float R, float G, float B) color)
		{
			return 0.2126 * Linearize(color.R) + 0.7152 * Linearize(color.G) + 0.0722 * Linearize(color.B);
		}

		private static double Linearize(float channel)
		{
			double num = Math.Min(1.0, Math.Max(0.0, channel));
			if (!(num <= 0.03928))
			{
				return Math.Pow((num + 0.055) / 1.055, 2.4);
			}
			return num / 12.92;
		}
	}
	public static class PanelPalette
	{
		public static readonly (float R, float G, float B) Header = (R: 0.9f, G: 0.8f, B: 0.6f);

		public static readonly (float R, float G, float B) Body = (R: 0.85f, G: 0.85f, B: 0.82f);

		public static readonly (float R, float G, float B) HudHint = (R: 1f, G: 0.85f, B: 0.5f);

		public static readonly (float R, float G, float B) ApproximateWoodBackground = (R: 0.3f, G: 0.24f, B: 0.17f);
	}
	public static class RecoveryGuidancePresenter
	{
		public const float BrakeRelevantGradePercent = 5f;

		public static RecoveryGuidanceViewModel Present(CartDiagnostic? diagnostic, CartTelemetry? telemetry, LoadModel? loadModel, bool brakeFeatureEnabled, IReadOnlyList<CoopParticipant>? participants = null)
		{
			if (diagnostic == null || diagnostic.Diagnosis == CartDiagnosis.None || telemetry == null)
			{
				return new RecoveryGuidanceViewModel(hasGuidance: false, TeamsterStrings.Get("recovery.noDiagnosis"), Array.Empty<string>());
			}
			List<string> list = new List<string>();
			float num = (telemetry.GradeAvailable ? telemetry.SmoothedGradePercent : 0f);
			bool flag = brakeFeatureEnabled && telemetry.GradeAvailable && Math.Abs(num) >= 5f;
			string title;
			switch (diagnostic.Diagnosis)
			{
			case CartDiagnosis.ImpossibleLoad:
			case CartDiagnosis.MarginalLoad:
				title = TeamsterStrings.Get((diagnostic.Diagnosis == CartDiagnosis.ImpossibleLoad) ? "recovery.titleOverloaded" : "recovery.titleMarginal");
				if (flag)
				{
					list.Add(TeamsterStrings.Get("recovery.stepBrakeHold"));
				}
				AddUnloadStep(list, telemetry, loadModel, num);
				list.Add(TeamsterStrings.Get("recovery.stepRetryClimb"));
				list.Add(TeamsterStrings.Get("recovery.stepRouteAround"));
				break;
			case CartDiagnosis.SteepClimb:
				title = TeamsterStrings.Get("recovery.titleSteep");
				list.Add(TeamsterStrings.Get("recovery.stepBackDown"));
				if (flag)
				{
					list.Add(TeamsterStrings.Get("recovery.stepBrakeScout"));
				}
				list.Add(TeamsterStrings.Get("recovery.stepShallowerLine"));
				list.Add(TeamsterStrings.Get("recovery.stepSwitchback"));
				list.Add(TeamsterStrings.Get("recovery.stepSecondTrip"));
				break;
			case CartDiagnosis.Obstruction:
				title = TeamsterStrings.Get("recovery.titleObstruction");
				list.Add(TeamsterStrings.Get("recovery.stepCheckWheels"));
				list.Add(TeamsterStrings.Get("recovery.stepBackUpAngle"));
				list.Add(TeamsterStrings.Get("recovery.stepHoe"));
				list.Add(TeamsterStrings.Get("recovery.stepWheelHole"));
				break;
			case CartDiagnosis.LoadAdviceUnavailable:
				title = TeamsterStrings.Get("recovery.titleLoadAdviceUnavailable");
				list.Add(TeamsterStrings.Get("compat.alteredPhysicsSituation"));
				list.Add(TeamsterStrings.Get("compat.alteredPhysicsAction"));
				if (flag)
				{
					list.Add(TeamsterStrings.Get("recovery.stepBrakeHold"));
				}
				list.Add(TeamsterStrings.Get("recovery.stepRouteAround"));
				break;
			default:
				title = TeamsterStrings.Get("recovery.titleUnclear");
				list.Add(TeamsterStrings.Get("recovery.stepReattach"));
				list.Add(TeamsterStrings.Get("recovery.stepDifferentLine"));
				list.Add(TeamsterStrings.Get("recovery.stepCheckCaught"));
				if (flag)
				{
					list.Add(TeamsterStrings.Get("recovery.stepBrakeInvestigate"));
				}
				list.Add(TeamsterStrings.Get("recovery.stepUnloadSome"));
				break;
			}
			if (participants != null && participants.Count > 0)
			{
				string text = CooperativeEffortClassifier.Summarize(participants);
				if (text.Length > 0)
				{
					CooperativeEffortClassifier.EffortTally effortTally = CooperativeEffortClassifier.Tally(participants);
					list.Insert(0, TeamsterStrings.Format("recovery.crewNow", text));
					if (effortTally.Helping > 1 && (diagnostic.Diagnosis == CartDiagnosis.ImpossibleLoad || diagnostic.Diagnosis == CartDiagnosis.SteepClimb))
					{
						list.Insert(1, TeamsterStrings.Get("recovery.extraHands"));
					}
				}
			}
			return new RecoveryGuidanceViewModel(hasGuidance: true, title, list);
		}

		private static void AddUnloadStep(List<string> steps, CartTelemetry telemetry, LoadModel? loadModel, float grade)
		{
			LoadRecommendation loadRecommendation = ((!telemetry.GradeAvailable) ? null : loadModel?.RecommendedMaxMass(grade));
			if (loadRecommendation == null)
			{
				steps.Add(TeamsterStrings.Get("recovery.unloadNothingProven"));
				return;
			}
			float num = telemetry.TotalMass - loadRecommendation.TotalMass;
			if (num > 0f)
			{
				steps.Add(TeamsterStrings.Format("recovery.unloadAtLeast", num.ToString("F0", CultureInfo.InvariantCulture), loadRecommendation.TotalMass.ToString("F0", CultureInfo.InvariantCulture), LoadText.BasisWord(loadRecommendation.Basis)));
			}
			else
			{
				steps.Add(TeamsterStrings.Format("recovery.unloadAlreadyUnder", telemetry.TotalMass.ToString("F0", CultureInfo.InvariantCulture), loadRecommendation.TotalMass.ToString("F0", CultureInfo.InvariantCulture)));
			}
		}
	}
	public sealed class RecoveryGuidanceViewModel
	{
		public bool HasGuidance { get; }

		public string Title { get; }

		public IReadOnlyList<string> Steps { get; }

		public RecoveryGuidanceViewModel(bool hasGuidance, string title, IReadOnlyList<string> steps)
		{
			HasGuidance = hasGuidance;
			Title = title;
			Steps = steps;
		}
	}
	public static class RouteBottleneckPresenter
	{
		public sealed class ViewModel
		{
			public bool Available { get; }

			public string Message { get; }

			public IReadOnlyList<string> Lines { get; }

			public ViewModel(bool available, string message, IReadOnlyList<string> lines)
			{
				Available = available;
				Message = message;
				Lines = lines;
			}
		}

		public static ViewModel Present(Trip? trip, RoadQualityIndex? segments, LoadModel? loadModel, string? hypotheticalMassText, bool massAdviceReliable = true)
		{
			if (trip == null)
			{
				return new ViewModel(available: false, TeamsterStrings.Get("bottleneck.selectTripA"), Array.Empty<string>());
			}
			if (!TryParseMass(hypotheticalMassText, out float mass, out string problem))
			{
				return new ViewModel(available: false, problem, Array.Empty<string>());
			}
			int count = trip.Samples.Count;
			float[] array = new float[count];
			float num = 0f;
			for (int i = 1; i < count; i++)
			{
				TripSample tripSample = trip.Samples[i - 1];
				TripSample tripSample2 = trip.Samples[i];
				float num2 = tripSample2.PositionX - tripSample.PositionX;
				float num3 = tripSample2.PositionZ - tripSample.PositionZ;
				num = (array[i] = num + (float)Math.Sqrt(num2 * num2 + num3 * num3));
			}
			List<string> lines = new List<string>(3)
			{
				DescribeWorstGrade(trip, array, num),
				DescribeWorstQuality(trip, segments, array, num),
				DescribeLoadBinding(trip, loadModel, mass, array, num, massAdviceReliable)
			};
			return new ViewModel(available: true, TeamsterStrings.Format("bottleneck.header", trip.Id.ToString(CultureInfo.InvariantCulture), mass.ToString("F0", CultureInfo.InvariantCulture)), lines);
		}

		private static bool TryParseMass(string? text, out float mass, out string problem)
		{
			problem = string.Empty;
			mass = 0f;
			string text2 = text?.Trim() ?? string.Empty;
			if (text2.Length == 0)
			{
				problem = TeamsterStrings.Get("bottleneck.enterMass");
				return false;
			}
			if (!float.TryParse(text2, NumberStyles.Float, CultureInfo.InvariantCulture, out mass) || float.IsNaN(mass) || float.IsInfinity(mass) || mass <= 0f)
			{
				problem = TeamsterStrings.Format("bottleneck.badMass", text2);
				return false;
			}
			return true;
		}

		private static string DescribeWorstGrade(Trip trip, float[] cumulative, float total)
		{
			int num = -1;
			float num2 = 0f;
			for (int i = 0; i < trip.Samples.Count; i++)
			{
				float gradePercent = trip.Samples[i].GradePercent;
				if (!float.IsNaN(gradePercent) && (num < 0 || Math.Abs(gradePercent) > num2))
				{
					num2 = Math.Abs(gradePercent);
					num = i;
				}
			}
			if (num < 0)
			{
				return TeamsterStrings.Get("bottleneck.noGradeData");
			}
			return TeamsterStrings.Format("bottleneck.gradeConstraint", trip.Samples[num].GradePercent.ToString("F1", CultureInfo.InvariantCulture), Locate(cumulative, num, total));
		}

		private static string DescribeWorstQuality(Trip trip, RoadQualityIndex? segments, float[] cumulative, float total)
		{
			if (segments == null || segments.Segments.Count == 0)
			{
				return TeamsterStrings.Get("bottleneck.noScoredSegments");
			}
			float num = float.NaN;
			int num2 = -1;
			RoadSegmentKey roadSegmentKey = default(RoadSegmentKey);
			HashSet<RoadSegmentKey> hashSet = new HashSet<RoadSegmentKey>();
			for (int i = 0; i < trip.Samples.Count; i++)
			{
				TripSample tripSample = trip.Samples[i];
				RoadSegmentKey roadSegmentKey2 = RoadSegmentKey.FromPosition(tripSample.PositionX, tripSample.PositionZ);
				if (hashSet.Add(roadSegmentKey2) && segments.Segments.TryGetValue(roadSegmentKey2, out RoadSegmentStats value) && !float.IsNaN(value.RoughnessGradeJitter) && (float.IsNaN(num) || value.RoughnessGradeJitter > num))
				{
					num = value.RoughnessGradeJitter;
					num2 = i;
					roadSegmentKey = roadSegmentKey2;
				}
			}
			if (num2 < 0)
			{
				return TeamsterStrings.Get("bottleneck.noRoughness");
			}
			return TeamsterStrings.Format("bottleneck.qualityConstraint", num.ToString("F1", CultureInfo.InvariantCulture), Locate(cumulative, num2, total), roadSegmentKey.CellX.ToString(CultureInfo.InvariantCulture), roadSegmentKey.CellZ.ToString(CultureInfo.InvariantCulture));
		}

		private static string DescribeLoadBinding(Trip trip, LoadModel? loadModel, float mass, float[] cumulative, float total, bool massAdviceReliable)
		{
			if (loadModel == null)
			{
				return TeamsterStrings.Get("bottleneck.noCalibration");
			}
			if (!massAdviceReliable)
			{
				return TeamsterStrings.Get("compat.loadAdviceUnavailableLine");
			}
			int num = 0;
			int num2 = 0;
			int num3 = -1;
			LoadVerdict loadVerdict = null;
			int num4 = -1;
			LoadVerdict loadVerdict2 = null;
			for (int i = 0; i < trip.Samples.Count; i++)
			{
				float gradePercent = trip.Samples[i].GradePercent;
				if (float.IsNaN(gradePercent) || gradePercent <= 0f)
				{
					continue;
				}
				num++;
				LoadVerdict loadVerdict3 = loadModel.Query(gradePercent, mass);
				switch (loadVerdict3.Climbability)
				{
				case Climbability.No:
					if (num3 < 0)
					{
						num3 = i;
						loadVerdict = loadVerdict3;
					}
					break;
				case Climbability.Marginal:
					if (num4 < 0)
					{
						num4 = i;
						loadVerdict2 = loadVerdict3;
					}
					break;
				case Climbability.Unknown:
					num2++;
					break;
				}
			}
			if (num == 0)
			{
				return TeamsterStrings.Format("bottleneck.neverClimbs", mass.ToString("F0", CultureInfo.InvariantCulture));
			}
			if (num3 >= 0)
			{
				return TeamsterStrings.Format("bottleneck.binds", mass.ToString("F0", CultureInfo.InvariantCulture), Locate(cumulative, num3, total), loadVerdict.Explanation);
			}
			if (num4 >= 0)
			{
				return TeamsterStrings.Format("bottleneck.marginal", Locate(cumulative, num4, total), loadVerdict2.Explanation);
			}
			if (num2 > 0)
			{
				return TeamsterStrings.Format("bottleneck.uncalibratedPoints", num2.ToString(CultureInfo.InvariantCulture), num.ToString(CultureInfo.InvariantCulture));
			}
			return TeamsterStrings.Format("bottleneck.allProven", mass.ToString("F0", CultureInfo.InvariantCulture));
		}

		private static string Locate(float[] cumulative, int index, float total)
		{
			float num = cumulative[index];
			string text = TeamsterStrings.Format("unit.meters", num.ToString("F0", CultureInfo.InvariantCulture));
			if (total <= 0f)
			{
				return text;
			}
			float num2 = num / total * 100f;
			return TeamsterStrings.Format("bottleneck.locate", text, num2.ToString("F0", CultureInfo.InvariantCulture));
		}
	}
	public static class RoutePickerPresenter
	{
		public sealed class Row
		{
			public Guid RouteId { get; }

			public string Text { get; }

			public bool Eligible { get; }

			public Row(Guid routeId, string text, bool eligible)
			{
				RouteId = routeId;
				Text = text;
				Eligible = eligible;
			}
		}

		public sealed class ViewModel
		{
			public string StatusLine { get; }

			public IReadOnlyList<Row> Rows { get; }

			public Guid? EffectiveSelectedId { get; }

			public bool SelectionLost { get; }

			public ViewModel(string statusLine, IReadOnlyList<Row> rows, Guid? effectiveSelectedId, bool selectionLost)
			{
				StatusLine = statusLine;
				Rows = rows;
				EffectiveSelectedId = effectiveSelectedId;
				SelectionLost = selectionLost;
			}
		}

		public const int MinimumEligiblePoints = 2;

		public static ViewModel Present(bool readable, IReadOnlyList<CartographerRouteSnapshot>? routes, Guid? selectedId)
		{
			if (!readable || routes == null)
			{
				return new ViewModel(TeamsterStrings.Get((!selectedId.HasValue) ? "routes.unreadable" : "routes.unreadableCleared"), Array.Empty<Row>(), null, selectedId.HasValue);
			}
			List<CartographerRouteSnapshot> list = new List<CartographerRouteSnapshot>(routes.Count);
			foreach (CartographerRouteSnapshot route in routes)
			{
				if (route != null && !route.Archived)
				{
					list.Add(route);
				}
			}
			if (list.Count == 0)
			{
				return new ViewModel(TeamsterStrings.Get((!selectedId.HasValue) ? "routes.none" : "routes.lostSelection"), Array.Empty<Row>(), null, selectedId.HasValue);
			}
			list.Sort(delegate(CartographerRouteSnapshot left, CartographerRouteSnapshot right)
			{
				int num3 = string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase);
				return (num3 == 0) ? left.Id.CompareTo(right.Id) : num3;
			});
			Guid? effectiveSelectedId = null;
			string text = null;
			Row[] array = new Row[list.Count];
			for (int num = 0; num < list.Count; num++)
			{
				CartographerRouteSnapshot cartographerRouteSnapshot = list[num];
				bool flag = cartographerRouteSnapshot.Points.Count >= 2;
				int num2;
				if (flag && selectedId.HasValue)
				{
					num2 = ((cartographerRouteSnapshot.Id == selectedId.Value) ? 1 : 0);
					if (num2 != 0)
					{
						effectiveSelectedId = cartographerRouteSnapshot.Id;
						text = DisplayName(cartographerRouteSnapshot);
					}
				}
				else
				{
					num2 = 0;
				}
				string text2 = ((num2 != 0) ? (TeamsterStrings.Get("routes.selectedMarker") + " ") : "      ") + DisplayName(cartographerRouteSnapshot) + (flag ? ("  " + TeamsterStrings.Format("routes.rowGeometry", HorizontalLengthMeters(cartographerRouteSnapshot.Points).ToString("F0", CultureInfo.InvariantCulture), cartographerRouteSnapshot.Points.Count.ToString(CultureInfo.InvariantCulture))) : ("  " + TeamsterStrings.Get("routes.noGeometry")));
				array[num] = new Row(cartographerRouteSnapshot.Id, text2, flag);
			}
			bool flag2 = selectedId.HasValue && !effectiveSelectedId.HasValue;
			return new ViewModel(flag2 ? TeamsterStrings.Get("routes.lostSelection") : ((!effectiveSelectedId.HasValue) ? TeamsterStrings.Get("routes.pick") : TeamsterStrings.Format("routes.selected", text ?? "")), array, effectiveSelectedId, flag2);
		}

		public static float HorizontalLengthMeters(IReadOnlyList<CartographerRoutePoint> points)
		{
			float num = 0f;
			for (int i = 1; i < points.Count; i++)
			{
				float num2 = points[i].X - points[i - 1].X;
				float num3 = points[i].Z - points[i - 1].Z;
				num += (float)Math.Sqrt(num2 * num2 + num3 * num3);
			}
			return num;
		}

		private static string DisplayName(CartographerRouteSnapshot route)
		{
			if (route.Name.Length <= 0)
			{
				return TeamsterStrings.Get("routes.unnamed");
			}
			return route.Name;
		}
	}
	public static class RouteProfilePresenter
	{
		public const int LineCount = 5;

		private static readonly string[] BandLabels = new string[5] { "<3%", "3-8%", "8-15%", "15-25%", "25%+" };

		public static IReadOnlyList<string> Present(bool hasSelection, bool profiling, int positionsProbed, int positionCount, RouteProfile? profile, RouteLoadBottleneck.Result? bottleneck)
		{
			string[] array = new string[5];
			for (int i = 0; i < 5; i++)
			{
				array[i] = string.Empty;
			}
			if (!hasSelection)
			{
				return array;
			}
			if (profiling || profile == null)
			{
				array[0] = TeamsterStrings.Format("profile.profiling", positionsProbed.ToString(CultureInfo.InvariantCulture), positionCount.ToString(CultureInfo.InvariantCulture));
				return array;
			}
			array[0] = ((profile.UnsampledMeters > 0.05f) ? TeamsterStrings.Format("profile.summaryUnsampled", Meters(profile.TotalDistanceMeters), Meters(profile.SampledMeters), Meters(profile.UnsampledMeters)) : TeamsterStrings.Format("profile.summary", Meters(profile.TotalDistanceMeters), Meters(profile.SampledMeters)));
			array[1] = SurfaceLine(profile);
			array[2] = WorstLine(profile);
			array[3] = BandLine(profile);
			array[4] = BottleneckLine(bottleneck);
			return array;
		}

		private static string SurfaceLine(RouteProfile profile)
		{
			if (profile.SampledMeters <= 0f)
			{
				return TeamsterStrings.Get("profile.surfacesNoneSampled");
			}
			List<string> list = new List<string>(5);
			TerrainSurfaceKind[] array = new TerrainSurfaceKind[4]
			{
				TerrainSurfaceKind.Paved,
				TerrainSurfaceKind.Dirt,
				TerrainSurfaceKind.Cultivated,
				TerrainSurfaceKind.Untouched
			};
			foreach (TerrainSurfaceKind terrainSurfaceKind in array)
			{
				if (profile.SurfaceMeters.TryGetValue(terrainSurfaceKind, out var value) && value > 0f)
				{
					list.Add(SurfaceWord(terrainSurfaceKind) + " " + Percent(value, profile.SampledMeters));
				}
			}
			if (profile.SurfaceUnknownMeters > 0f)
			{
				list.Add(TeamsterStrings.Get("profile.surfaceUnknown") + " " + Percent(profile.SurfaceUnknownMeters, profile.SampledMeters));
			}
			return TeamsterStrings.Format("profile.surfaces", (list.Count == 0) ? TeamsterStrings.Get("profile.surfacesNoneClassified") : string.Join(", ", list));
		}

		private static string SurfaceWord(TerrainSurfaceKind kind)
		{
			return TeamsterStrings.Get(kind switch
			{
				TerrainSurfaceKind.Paved => "profile.surfacePaved", 
				TerrainSurfaceKind.Dirt => "profile.surfaceDirt", 
				TerrainSurfaceKind.Cultivated => "profile.surfaceCultivated", 
				_ => "profile.surfaceUntouched", 
			});
		}

		private static string WorstLine(RouteProfile profile)
		{
			if (float.IsNaN(profile.MaxAbsGradePercent) || profile.WorstSegments.Count == 0)
			{
				return TeamsterStrings.Get("profile.gradesNoData");
			}
			RouteProfileSegment routeProfileSegment = profile.WorstSegments[0];
			return TeamsterStrings.Format((routeProfileSegment.GradePercent >= 0f) ? "profile.worstClimb" : "profile.worstDescent", routeProfileSegment.GradePercent.ToString("+0.0;-0.0", CultureInfo.InvariantCulture), Meters(routeProfileSegment.StartMeters));
		}

		private static string BandLine(RouteProfile profile)
		{
			float num = 0f;
			for (int i = 0; i < profile.GradeBandMeters.Count; i++)
			{
				num += profile.GradeBandMeters[i];
			}
			if (num <= 0f)
			{
				return string.Empty;
			}
			List<string> list = new List<string>(5);
			for (int j = 0; j < profile.GradeBandMeters.Count; j++)
			{
				float num2 = profile.GradeBandMeters[j];
				if (num2 > 0f)
				{
					list.Add(BandLabels[j] + " " + Percent(num2, num));
				}
			}
			return TeamsterStrings.Format("profile.gradeMix", string.Join(", ", list));
		}

		private static string BottleneckLine(RouteLoadBottleneck.Result? bottleneck)
		{
			if (bottleneck == null)
			{
				return TeamsterStrings.Get("profile.loadNoModel");
			}
			if (!bottleneck.HasGradeData)
			{
				return TeamsterStrings.Get("profile.loadNoGrade");
			}
			if (!bottleneck.MassAdviceReliable)
			{
				return TeamsterStrings.Get("compat.loadAdviceUnavailableLine");
			}
			string text = bottleneck.BottleneckGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "%";
			string text2 = ((bottleneck.ProvenMaxMass == null) ? TeamsterStrings.Format("profile.loadNoProven", text) : TeamsterStrings.Format("profile.loadProven", bottleneck.ProvenMaxMass.TotalMass.ToString("F0", CultureInfo.InvariantCulture), text, LoadText.BasisWord(bottleneck.ProvenMaxMass.Basis)));
			if (bottleneck.Verdict == null)
			{
				return TeamsterStrings.Format("profile.loadCheck", text2);
			}
			return TeamsterStrings.Format("profile.loadCheckWithVerdict", text2, bottleneck.QueriedMass.ToString("F0", CultureInfo.InvariantCulture), VerdictWord(bottleneck.Verdict));
		}

		private static string VerdictWord(LoadVerdict verdict)
		{
			return TeamsterStrings.Get(verdict.Climbability switch
			{
				Climbability.Yes => "verdict.ok", 
				Climbability.Marginal => "verdict.marginal", 
				Climbability.No => "verdict.tooHeavy", 
				_ => "verdict.unknown", 
			});
		}

		private static string Meters(float value)
		{
			return TeamsterStrings.Format("unit.meters", value.ToString("F0", CultureInfo.InvariantCulture));
		}

		private static string Percent(float part, float whole)
		{
			return (part / whole * 100f).ToString("F0", CultureInfo.InvariantCulture) + "%";
		}
	}
	public static class RouteReportPresenter
	{
		public sealed class ViewModel
		{
			public string Title { get; }

			public bool HasProfile { get; }

			public IReadOnlyList<string> Lines { get; }

			public ViewModel(string title, bool hasProfile, IReadOnlyList<string> lines)
			{
				Title = title;
				HasProfile = hasProfile;
				Lines = lines;
			}
		}

		public const float ProblemGradePercent = 15f;

		public static ViewModel Present(string routeName, RouteProfile? profile, LoadModel? model, float? cartTotalMass, bool massAdviceReliable = true)
		{
			string title = TeamsterStrings.Format("report.title", (routeName.Length > 0) ? routeName : TeamsterStrings.Get("routes.unnamed"));
			if (profile == null)
			{
				return new ViewModel(title, hasProfile: false, new string[1] { TeamsterStrings.Get("report.needProfile") });
			}
			List<string> list = new List<string>(20);
			list.Add((profile.UnsampledMeters > 0.05f) ? TeamsterStrings.Format("report.summaryUnsampled", Meters(profile.TotalDistanceMeters), Meters(profile.SampledMeters), Meters(profile.UnsampledMeters)) : TeamsterStrings.Format("report.summary", Meters(profile.TotalDistanceMeters), Meters(profile.SampledMeters)));
			list.Add(GradeMixLine(profile));
			int num = 0;
			foreach (RouteProfileSegment worstSegment in profile.WorstSegments)
			{
				if (!(Math.Abs(worstSegment.GradePercent) < 15f))
				{
					num++;
					bool flag = worstSegment.GradePercent >= 0f;
					list.Add(TeamsterStrings.Format(flag ? "report.steepClimbSection" : "report.steepDescentSection", num.ToString(CultureInfo.InvariantCulture), worstSegment.GradePercent.ToString("+0.0;-0.0", CultureInfo.InvariantCulture), Meters(worstSegment.StartMeters), Meters(worstSegment.LengthMeters)));
					string text = SectionAdvice(worstSegment, flag, model, cartTotalMass, massAdviceReliable);
					if (text != null)
					{
						list.Add("   " + text);
					}
				}
			}
			foreach (RouteProfileSegment unsampledSpan in profile.UnsampledSpans)
			{
				num++;
				list.Add(TeamsterStrings.Format("report.gapSection", num.ToString(CultureInfo.InvariantCulture), Meters(unsampledSpan.LengthMeters), Meters(unsampledSpan.StartMeters)));
			}
			if (num == 0)
			{
				list.Add(TeamsterStrings.Format("report.noProblems", 15f.ToString("F0", CultureInfo.InvariantCulture)));
			}
			if (model == null)
			{
				list.Add(TeamsterStrings.Get("report.loadUnavailableNoModel"));
			}
			else
			{
				RouteLoadBottleneck.Result result = RouteLoadBottleneck.Evaluate(profile, model, cartTotalMass, massAdviceReliable);
				if (!result.HasGradeData)
				{
					list.Add(TeamsterStrings.Get("report.loadUnavailableNoGrade"));
				}
				else if (!result.MassAdviceReliable)
				{
					list.Add(TeamsterStrings.Get("compat.loadAdviceUnavailableLine"));
				}
				else
				{
					string text2 = result.BottleneckGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "%";
					list.Add((result.ProvenMaxMass == null) ? TeamsterStrings.Format("report.bottleneckNoProven", text2) : TeamsterStrings.Format("report.bottleneckKeepUnder", text2, result.ProvenMaxMass.TotalMass.ToString("F0", CultureInfo.InvariantCulture), LoadText.BasisWord(result.ProvenMaxMass.Basis)));
					if (result.Verdict != null)
					{
						list.Add(TeamsterStrings.Format("report.yourCart", result.QueriedMass.ToString("F0", CultureInfo.InvariantCulture), VerdictWord(result.Verdict.Climbability), result.Verdict.Explanation));
					}
				}
			}
			return new ViewModel(title, hasProfile: true, list);
		}

		private static string? SectionAdvice(RouteProfileSegment segment, bool climb, LoadModel? model, float? cartTotalMass, bool massAdviceReliable)
		{
			if (model == null || !massAdviceReliable)
			{
				return null;
			}
			float gradePercent = Math.Abs(segment.GradePercent);
			if (cartTotalMass.HasValue)
			{
				LoadVerdict loadVerdict = model.Query(gradePercent, cartTotalMass.Value);
				if (loadVerdict.Climbability != Climbability.Unknown)
				{
					return TeamsterStrings.Format(climb ? "report.adviceVerdictHere" : "report.adviceVerdictReturn", VerdictWord(loadVerdict.Climbability), loadVerdict.Explanation);
				}
			}
			LoadRecommendation loadRecommendation = model.RecommendedMaxMass(gradePercent);
			if (loadRecommendation != null)
			{
				return TeamsterStrings.Format(climb ? "report.adviceProvenHere" : "report.adviceProvenReturn", loadRecommendation.TotalMass.ToString("F0", CultureInfo.InvariantCulture), LoadText.BasisWord(loadRecommendation.Basis));
			}
			return null;
		}

		private static string GradeMixLine(RouteProfile profile)
		{
			float num = 0f;
			for (int i = 0; i < profile.GradeBandMeters.Count; i++)
			{
				num += profile.GradeBandMeters[i];
			}
			if (num <= 0f)
			{
				return TeamsterStrings.Get("report.gradeMixNoData");
			}
			string text = (float.IsNaN(profile.MaxAbsGradePercent) ? "?" : (profile.MaxAbsGradePercent.ToString("F1", CultureInfo.InvariantCulture) + "%"));
			float num2 = profile.GradeBandMeters[3] + profile.GradeBandMeters[4];
			if (!(num2 > 0f))
			{
				return TeamsterStrings.Format("report.gradeMixNoSteep", text);
			}
			return TeamsterStrings.Format("report.gradeMixSteep", text, Meters(num2));
		}

		private static string VerdictWord(Climbability climbability)
		{
			return TeamsterStrings.Get(climbability switch
			{
				Climbability.Yes => "verdict.ok", 
				Climbability.Marginal => "verdict.marginal", 
				Climbability.No => "verdict.tooHeavy", 
				_ => "verdict.unknown", 
			});
		}

		private static string Meters(float value)
		{
			return TeamsterStrings.Format("unit.meters", value.ToString("F0", CultureInfo.InvariantCulture));
		}
	}
	public static class TripComparisonPresenter
	{
		public sealed class ViewModel
		{
			public bool HasComparison { get; }

			public string Message { get; }

			public string HeaderA { get; }

			public string HeaderB { get; }

			public IReadOnlyList<string> BucketLines { get; }

			public ViewModel(bool hasComparison, string message, string headerA, string headerB, IReadOnlyList<string> bucketLines)
			{
				HasComparison = hasComparison;
				Message = message;
				HeaderA = headerA;
				HeaderB = headerB;
				BucketLines = bucketLines;
			}
		}

		public const int BucketCount = 5;

		public static ViewModel Present(Trip? tripA, Trip? tripB)
		{
			if (tripA == null && tripB == null)
			{
				return new ViewModel(hasComparison: false, TeamsterStrings.Get("compare.selectTwo"), string.Empty, string.Empty, Array.Empty<string>());
			}
			if (tripA == null || tripB == null)
			{
				return new ViewModel(hasComparison: false, TeamsterStrings.Get((tripA == null) ? "compare.selectSecondVsB" : "compare.selectSecondVsA"), string.Empty, string.Empty, Array.Empty<string>());
			}
			TripSummary summary = TripSummarizer.Summarize(tripA);
			TripSummary summary2 = TripSummarizer.Summarize(tripB);
			float[] array = BucketMeanAbsGrades(tripA);
			float[] array2 = BucketMeanAbsGrades(tripB);
			float[] array3 = BucketMeanSpeeds(tripA);
			float[] array4 = BucketMeanSpeeds(tripB);
			string[] array5 = new string[5];
			for (int i = 0; i < 5; i++)
			{
				int num = i * 100 / 5;
				int num2 = (i + 1) * 100 / 5;
				array5[i] = TeamsterStrings.Format("compare.bucketLine", num.ToString(CultureInfo.InvariantCulture), num2.ToString(CultureInfo.InvariantCulture), FormatGrade(array[i]), FormatSpeed(array3[i]), FormatGrade(array2[i]), FormatSpeed(array4[i]));
			}
			return new ViewModel(hasComparison: true, string.Empty, TeamsterStrings.Format("compare.headerA", tripA.Id.ToString(CultureInfo.InvariantCulture), Describe(summary)), TeamsterStrings.Format("compare.headerB", tripB.Id.ToString(CultureInfo.InvariantCulture), Describe(summary2)), array5);
		}

		public static float[] BucketMeanAbsGrades(Trip trip)
		{
			return BucketAggregate(trip, (TripSample sample) => (!float.IsNaN(sample.GradePercent)) ? Math.Abs(sample.GradePercent) : float.NaN);
		}

		public static float[] BucketMeanSpeeds(Trip trip)
		{
			return BucketAggregate(trip, (TripSample sample) => sample.SpeedMetersPerSecond);
		}

		private static float[] BucketAggregate(Trip trip, Func<TripSample, float> selector)
		{
			float[] array = new float[5];
			int[] array2 = new int[5];
			float num = 0f;
			float[] array3 = new float[trip.Samples.Count];
			for (int i = 1; i < trip.Samples.Count; i++)
			{
				TripSample tripSample = trip.Samples[i - 1];
				TripSample tripSample2 = trip.Samples[i];
				float num2 = tripSample2.PositionX - tripSample.PositionX;
				float num3 = tripSample2.PositionZ - tripSample.PositionZ;
				num = (array3[i] = num + (float)Math.Sqrt(num2 * num2 + num3 * num3));
			}
			for (int j = 0; j < trip.Samples.Count; j++)
			{
				float num4 = selector(trip.Samples[j]);
				if (!float.IsNaN(num4))
				{
					float num5 = ((num > 0f) ? (array3[j] / num) : 0f);
					int num6 = Math.Min(4, (int)(num5 * 5f));
					array[num6] += num4;
					array2[num6]++;
				}
			}
			float[] array4 = new float[5];
			for (int k = 0; k < 5; k++)
			{
				array4[k] = ((array2[k] > 0) ? (array[k] / (float)array2[k]) : float.NaN);
			}
			return array4;
		}

		private static string Describe(TripSummary summary)
		{
			return TeamsterStrings.Format("compare.summary", summary.DistanceMeters.ToString("F0", CultureInfo.InvariantCulture), summary.MeanMass.ToString("F0", CultureInfo.InvariantCulture), float.IsNaN(summary.WorstAbsGradePercent) ? "?" : (summary.WorstAbsGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "%"));
		}

		private static string FormatGrade(float value)
		{
			if (!float.IsNaN(value))
			{
				return value.ToString("F1", CultureInfo.InvariantCulture) + "%";
			}
			return "—";
		}

		private static string FormatSpeed(float value)
		{
			if (!float.IsNaN(value))
			{
				return TeamsterStrings.Format("unit.metersPerSecond", value.ToString("F1", CultureInfo.InvariantCulture));
			}
			return "—";
		}
	}
	public static class TripHistoryPresenter
	{
		public enum SortColumn
		{
			StartTime,
			Duration,
			Distance,
			Load,
			WorstGrade
		}

		public sealed class Row
		{
			public int TripId { get; }

			public string Text { get; }

			public Row(int tripId, string text)
			{
				TripId = tripId;
				Text = text;
			}
		}

		public sealed class ViewModel
		{
			public bool Empty { get; }

			public string Message { get; }

			public IReadOnlyList<Row> Rows { get; }

			public ViewModel(bool empty, string message, IReadOnlyList<Row> rows)
			{
				Empty = empty;
				Message = message;
				Rows = rows;
			}
		}

		public static ViewModel Present(IReadOnlyList<TripSummary> summaries, SortColumn sortColumn, bool descending, int? selectedAId, int? selectedBId)
		{
			if (summaries.Count == 0)
			{
				return new ViewModel(empty: true, TeamsterStrings.Get("trips.empty"), Array.Empty<Row>());
			}
			List<TripSummary> list = new List<TripSummary>(summaries);
			list.Sort(delegate(TripSummary left, TripSummary right)
			{
				int num2 = sortColumn switch
				{
					SortColumn.StartTime => left.StartTimeSeconds.CompareTo(right.StartTimeSeconds), 
					SortColumn.Duration => left.DurationSeconds.CompareTo(right.DurationSeconds), 
					SortColumn.Distance => left.DistanceMeters.CompareTo(right.DistanceMeters), 
					SortColumn.Load => left.MeanMass.CompareTo(right.MeanMass), 
					_ => CompareWithNaNLast(left.WorstAbsGradePercent, right.WorstAbsGradePercent), 
				};
				if (descending)
				{
					num2 = -num2;
				}
				return (num2 == 0) ? left.TripId.CompareTo(right.TripId) : num2;
			});
			Row[] array = new Row[list.Count];
			for (int num = 0; num < list.Count; num++)
			{
				TripSummary tripSummary = list[num];
				string text = ((tripSummary.TripId == selectedAId) ? (TeamsterStrings.Get("trips.markerA") + " ") : ((tripSummary.TripId == selectedBId) ? (TeamsterStrings.Get("trips.markerB") + " ") : "    "));
				array[num] = new Row(tripSummary.TripId, text + Format(tripSummary));
			}
			return new ViewModel(empty: false, string.Empty, array);
		}

		private static int CompareWithNaNLast(float left, float right)
		{
			bool flag = float.IsNaN(left);
			bool flag2 = float.IsNaN(right);
			if (flag != flag2)
			{
				if (!flag)
				{
					return 1;
				}
				return -1;
			}
			if (!flag)
			{
				return left.CompareTo(right);
			}
			return 0;
		}

		private static string Format(TripSummary summary)
		{
			return TeamsterStrings.Format("trips.row", summary.TripId.ToString(CultureInfo.InvariantCulture), FormatDuration(summary.DurationSeconds), summary.DistanceMeters.ToString("F0", CultureInfo.InvariantCulture), summary.MeanMass.ToString("F0", CultureInfo.InvariantCulture), float.IsNaN(summary.WorstAbsGradePercent) ? "?" : (summary.WorstAbsGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "%"), float.IsNaN(summary.MeanSpeedMetersPerSecond) ? "?" : TeamsterStrings.Format("unit.metersPerSecond", summary.MeanSpeedMetersPerSecond.ToString("F1", CultureInfo.InvariantCulture)));
		}

		private static string FormatDuration(double seconds)
		{
			int num = (int)Math.Round(seconds);
			int num2 = num / 60;
			int num3 = num % 60;
			return num2.ToString(CultureInfo.InvariantCulture) + ":" + num3.ToString("D2", CultureInfo.InvariantCulture);
		}
	}
	public static class UiScaleOptions
	{
		public const float DefaultScale = 1f;

		public const float MinScale = 0.8f;

		public const float MaxScale = 1.3f;

		public static float Clamp(float scale)
		{
			if (float.IsNaN(scale) || float.IsInfinity(scale))
			{
				return 1f;
			}
			return Math.Min(1.3f, Math.Max(0.8f, scale));
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Ui.Navigation
{
	public readonly struct FocusItem
	{
		public string Id { get; }

		public string Label { get; }

		public bool IsButton { get; }

		public FocusItem(string id, string label, bool isButton)
		{
			Id = id;
			Label = label;
			IsButton = isButton;
		}
	}
	public sealed class FocusRing
	{
		private readonly IReadOnlyList<FocusItem> _items;

		public int Count => _items.Count;

		public int CurrentIndex { get; private set; }

		public bool HasFocus
		{
			get
			{
				if (CurrentIndex >= 0)
				{
					return CurrentIndex < _items.Count;
				}
				return false;
			}
		}

		public FocusItem Current
		{
			get
			{
				if (!HasFocus)
				{
					return default(FocusItem);
				}
				return _items[CurrentIndex];
			}
		}

		public FocusRing(IReadOnlyList<FocusItem> items)
		{
			_items = items ?? Array.Empty<FocusItem>();
			CurrentIndex = ((_items.Count <= 0) ? (-1) : 0);
		}

		public FocusItem Next()
		{
			if (_items.Count == 0)
			{
				return default(FocusItem);
			}
			CurrentIndex = (CurrentIndex + 1) % _items.Count;
			return _items[CurrentIndex];
		}

		public FocusItem Previous()
		{
			if (_items.Count == 0)
			{
				return default(FocusItem);
			}
			CurrentIndex = (CurrentIndex - 1 + _items.Count) % _items.Count;
			return _items[CurrentIndex];
		}

		public bool FocusById(string id)
		{
			for (int i = 0; i < _items.Count; i++)
			{
				if (string.Equals(_items[i].Id, id, StringComparison.Ordinal))
				{
					CurrentIndex = i;
					return true;
				}
			}
			return false;
		}

		public void Reset()
		{
			CurrentIndex = ((_items.Count <= 0) ? (-1) : 0);
		}
	}
	public static class NavigationCatalog
	{
		public const string CartStatusPanel = "cart-status";

		public const string CargoManifestPanel = "cargo-manifest";

		public const string TripHistoryPanel = "trip-history";

		public const string RecoveryGuidancePanel = "recovery-guidance";

		public const string RoutePickerPanel = "route-picker";

		public const string RouteReportPanel = "route-report";

		public const string SupportBundlePanel = "support-bundle";

		private static readonly IReadOnlyDictionary<string, IReadOnlyList<FocusItem>> Panels = new Dictionary<string, IReadOnlyList<FocusItem>>
		{
			["cart-status"] = new FocusItem[8]
			{
				new FocusItem("status.trips", TeamsterStrings.Get("nav.trips"), isButton: true),
				new FocusItem("status.routes", TeamsterStrings.Get("nav.routes"), isButton: true),
				new FocusItem("status.brake", TeamsterStrings.Get("nav.brake"), isButton: true),
				new FocusItem("status.manifest", TeamsterStrings.Get("nav.manifest"), isButton: true),
				new FocusItem("status.guidance", TeamsterStrings.Get("nav.guidance"), isButton: true),
				new FocusItem("status.compat", TeamsterStrings.Get("nav.compat"), isButton: true),
				new FocusItem("status.support", TeamsterStrings.Get("nav.support"), isButton: true),
				new FocusItem("status.close", TeamsterStrings.Get("nav.close"), isButton: true)
			},
			["cargo-manifest"] = new FocusItem[3]
			{
				new FocusItem("manifest.sort", TeamsterStrings.Get("nav.sortColumn"), isButton: true),
				new FocusItem("manifest.filter", TeamsterStrings.Get("nav.filter"), isButton: false),
				new FocusItem("manifest.close", TeamsterStrings.Get("nav.close"), isButton: true)
			},
			["trip-history"] = new FocusItem[6]
			{
				new FocusItem("trips.sort", TeamsterStrings.Get("nav.sortColumn"), isButton: true),
				new FocusItem("trips.mass", TeamsterStrings.Get("nav.hypotheticalMass"), isButton: false),
				new FocusItem("trips.selectA", TeamsterStrings.Get("nav.selectA"), isButton: true),
				new FocusItem("trips.selectB", TeamsterStrings.Get("nav.selectB"), isButton: true),
				new FocusItem("trips.delete", TeamsterStrings.Get("nav.delete"), isButton: true),
				new FocusItem("trips.close", TeamsterStrings.Get("nav.close"), isButton: true)
			},
			["recovery-guidance"] = new FocusItem[1]
			{
				new FocusItem("guidance.close", TeamsterStrings.Get("nav.close"), isButton: true)
			},
			["route-picker"] = new FocusItem[4]
			{
				new FocusItem("routes.list", TeamsterStrings.Get("nav.routeList"), isButton: true),
				new FocusItem("routes.clear", TeamsterStrings.Get("nav.clear"), isButton: true),
				new FocusItem("routes.report", TeamsterStrings.Get("nav.report"), isButton: true),
				new FocusItem("routes.close", TeamsterStrings.Get("nav.close"), isButton: true)
			},
			["route-report"] = new FocusItem[1]
			{
				new FocusItem("report.close", TeamsterStrings.Get("nav.close"), isButton: true)
			},
			["support-bundle"] = new FocusItem[3]
			{
				new FocusItem("support.reportbug", TeamsterStrings.Get("nav.reportBug"), isButton: true),
				new FocusItem("support.export", TeamsterStrings.Get("nav.export"), isButton: true),
				new FocusItem("support.close", TeamsterStrings.Get("nav.close"), isButton: true)
			}
		};

		public static IEnumerable<string> PanelIds => Panels.Keys;

		public static bool TryGetOrder(string panelId, out IReadOnlyList<FocusItem> items)
		{
			return Panels.TryGetValue(panelId, out items);
		}

		public static FocusRing RingFor(string panelId)
		{
			if (!TryGetOrder(panelId, out IReadOnlyList<FocusItem> items))
			{
				return new FocusRing(Array.Empty<FocusItem>());
			}
			return new FocusRing(items);
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Trips
{
	public sealed class RecoveryEvent
	{
		public string Reason { get; }

		public string SidecarFileName { get; }

		public string Message { get; }

		public RecoveryEvent(string reason, string sidecarFileName, string message)
		{
			Reason = reason;
			SidecarFileName = sidecarFileName;
			Message = message;
		}
	}
	public static class SidecarFileStore
	{
		public const int MaxBackupGenerationsPerReason = 3;

		public static string? TryRead(string path, out string? error)
		{
			error = null;
			try
			{
				return File.Exists(path) ? File.ReadAllText(path) : null;
			}
			catch (Exception ex)
			{
				error = ex.GetType().Name + ": " + ex.Message;
				return null;
			}
		}

		public static bool TryWriteAtomic(string path, string content, out string? error)
		{
			error = null;
			string text = path + ".tmp";
			try
			{
				string directoryName = Path.GetDirectoryName(path);
				if (!string.IsNullOrEmpty(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				File.WriteAllText(text, content);
				if (File.Exists(path))
				{
					File.Replace(text, path, null);
				}
				else
				{
					File.Move(text, path);
				}
				return true;
			}
			catch (Exception ex)
			{
				error = ex.GetType().Name + ": " + ex.Message;
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch
				{
				}
				return false;
			}
		}

		public static bool TryBackup(string path, string reason, out string? error)
		{
			error = null;
			try
			{
				if (!File.Exists(path))
				{
					return true;
				}
				string path2 = BackupPath(path, reason, 3);
				if (File.Exists(path2))
				{
					File.Delete(path2);
				}
				for (int num = 2; num >= 1; num--)
				{
					string text = BackupPath(path, reason, num);
					if (File.Exists(text))
					{
						File.Move(text, BackupPath(path, reason, num + 1));
					}
				}
				File.Copy(path, BackupPath(path, reason, 1), overwrite: true);
				return true;
			}
			catch (Exception ex)
			{
				error = ex.GetType().Name + ": " + ex.Message;
				return false;
			}
		}

		private static string BackupPath(string path, string reason, int generation)
		{
			return path + ".bak-" + reason + "-" + generation.ToString(CultureInfo.InvariantCulture);
		}
	}
	public sealed class Trip
	{
		public int Id { get; }

		public string CartId { get; }

		public IReadOnlyList<TripSample> Samples { get; }

		public double StartTimeSeconds
		{
			get
			{
				if (Samples.Count <= 0)
				{
					return 0.0;
				}
				return Samples[0].TimeSeconds;
			}
		}

		public double EndTimeSeconds
		{
			get
			{
				if (Samples.Count <= 0)
				{
					return 0.0;
				}
				return Samples[Samples.Count - 1].TimeSeconds;
			}
		}

		public Trip(int id, string cartId, IReadOnlyList<TripSample> samples)
		{
			Id = id;
			CartId = cartId;
			Samples = samples;
		}
	}
	public static class TripPersistPlan
	{
		public sealed class Plan
		{
			public string? BackupReason { get; }

			public string? LogWarning { get; }

			public string? LogInfo { get; }

			public Plan(string? backupReason, string? logWarning, string? logInfo)
			{
				BackupReason = backupReason;
				LogWarning = logWarning;
				LogInfo = logInfo;
			}
		}

		public static Plan Decide(TripSidecar.ParseResult existing)
		{
			if (existing.Refused)
			{
				return new Plan("refused", "Trip sidecar was refused (" + string.Join("; ", existing.Errors) + "); backing it up and starting fresh.", null);
			}
			if (existing.Errors.Count > 0)
			{
				return new Plan("malformed", "Trip sidecar had " + existing.Errors.Count + " malformed line(s); valid trips were kept and the original was backed up.", null);
			}
			if (existing.NeedsMigration)
			{
				return new Plan("migrate-v1", null, "Trip sidecar migrated from format v1: segment scores recomputed from " + existing.Trips.Count + " stored trip(s); original backed up.");
			}
			return new Plan(null, null, null);
		}

		public static bool ShouldDiscardPendingRetry(int pendingCount, long pendingWorldUid, long currentWorldUid)
		{
			if (pendingCount > 0)
			{
				return pendingWorldUid != currentWorldUid;
			}
			return false;
		}

		public static List<Trip> CombineForRetry(IReadOnlyList<Trip> pending, IReadOnlyList<Trip> newTrips)
		{
			if (pending.Count == 0)
			{
				return new List<Trip>(newTrips);
			}
			List<Trip> list = new List<Trip>(pending.Count + newTrips.Count);
			list.AddRange(pending);
			list.AddRange(newTrips);
			return list;
		}

		public static List<Trip> BoundForRetry(List<Trip> trips, int maxRetained)
		{
			int num = trips.Count - maxRetained;
			if (num > 0)
			{
				trips.RemoveRange(0, num);
			}
			return trips;
		}
	}
	public sealed class TripRecorder
	{
		private readonly TripRecorderOptions _options;

		private readonly List<TripSample> _current = new List<TripSample>();

		private readonly List<Trip> _finished = new List<Trip>();

		private string? _currentCartId;

		private double _lastRecordTime = double.NegativeInfinity;

		private double _pendingEndSince = double.NaN;

		public bool IsRecording => _currentCartId != null;

		public int CurrentSampleCount => _current.Count;

		public TripRecorder(TripRecorderOptions options)
		{
			_options = options;
		}

		public void FeedPulled(CartTelemetry telemetry)
		{
			if (_currentCartId != null && _currentCartId != telemetry.CartId)
			{
				Finalize();
			}
			if (_currentCartId == null)
			{
				_currentCartId = telemetry.CartId;
				_current.Clear();
				_lastRecordTime = double.NegativeInfinity;
			}
			_pendingEndSince = double.NaN;
			if (!(telemetry.SampleTimeSeconds - _lastRecordTime < (double)_options.RecordSpacingSeconds))
			{
				_lastRecordTime = telemetry.SampleTimeSeconds;
				_current.Add(new TripSample(telemetry.SampleTimeSeconds, telemetry.PositionX, telemetry.PositionZ, telemetry.GradeAvailable ? telemetry.SmoothedGradePercent : float.NaN, telemetry.VelocityAvailable ? telemetry.SpeedMetersPerSecond : float.NaN, telemetry.TotalMass));
				if (_current.Count >= _options.MaxSamplesPerTrip)
				{
					string currentCartId = _currentCartId;
					Finalize();
					_currentCartId = currentCartId;
					_lastRecordTime = double.NegativeInfinity;
				}
			}
		}

		public void NotifyNotPulled(double nowSeconds)
		{
			if (_currentCartId != null)
			{
				if (double.IsNaN(_pendingEndSince))
				{
					_pendingEndSince = nowSeconds;
				}
				else if (nowSeconds - _pendingEndSince >= 3.0)
				{
					Finalize();
				}
			}
		}

		public IReadOnlyList<Trip> DrainOnReset()
		{
			Finalize();
			return DrainFinishedTrips();
		}

		public IReadOnlyList<Trip> DrainFinishedTrips()
		{
			if (_finished.Count == 0)
			{
				return Array.Empty<Trip>();
			}
			Trip[] result = _finished.ToArray();
			_finished.Clear();
			return result;
		}

		private void Finalize()
		{
			if (_currentCartId != null && _current.Count >= 5)
			{
				_finished.Add(new Trip(0, _currentCartId, _current.ToArray()));
			}
			_currentCartId = null;
			_current.Clear();
			_pendingEndSince = double.NaN;
			_lastRecordTime = double.NegativeInfinity;
		}
	}
	public sealed class TripRecorderOptions
	{
		public const float DefaultRecordSpacingSeconds = 1f;

		public const float MinRecordSpacingSeconds = 0.25f;

		public const float MaxRecordSpacingSeconds = 10f;

		public const int DefaultMaxSamplesPerTrip = 600;

		public const int MinMaxSamplesPerTrip = 50;

		public const int MaxMaxSamplesPerTrip = 5000;

		public const int DefaultMaxTripsRetained = 50;

		public const int MinMaxTripsRetained = 5;

		public const int MaxMaxTripsRetained = 500;

		public const int MinSamplesToKeep = 5;

		public const double EndDebounceSeconds = 3.0;

		public float RecordSpacingSeconds { get; }

		public int MaxSamplesPerTrip { get; }

		public int MaxTripsRetained { get; }

		private TripRecorderOptions(float recordSpacingSeconds, int maxSamplesPerTrip, int maxTripsRetained)
		{
			RecordSpacingSeconds = recordSpacingSeconds;
			MaxSamplesPerTrip = maxSamplesPerTrip;
			MaxTripsRetained = maxTripsRetained;
		}

		public static TripRecorderOptions CreateClamped(float recordSpacingSeconds, int maxSamplesPerTrip, int maxTripsRetained)
		{
			return new TripRecorderOptions((float.IsNaN(recordSpacingSeconds) || float.IsInfinity(recordSpacingSeconds)) ? 1f : Math.Min(10f, Math.Max(0.25f, recordSpacingSeconds)), Math.Min(5000, Math.Max(50, maxSamplesPerTrip)), Math.Min(500, Math.Max(5, maxTripsRetained)));
		}

		public static TripRecorderOptions CreateDefault()
		{
			return CreateClamped(1f, 600, 50);
		}
	}
	public readonly struct TripSample
	{
		public double TimeSeconds { get; }

		public float PositionX { get; }

		public float PositionZ { get; }

		public float GradePercent { get; }

		public float SpeedMetersPerSecond { get; }

		public float TotalMass { get; }

		public TripSample(double timeSeconds, float positionX, float positionZ, float gradePercent, float speedMetersPerSecond, float totalMass)
		{
			TimeSeconds = timeSeconds;
			PositionX = positionX;
			PositionZ = positionZ;
			GradePercent = gradePercent;
			SpeedMetersPerSecond = speedMetersPerSecond;
			TotalMass = totalMass;
		}
	}
	public static class TripSidecar
	{
		public sealed class ParseResult
		{
			public IReadOnlyList<Trip> Trips { get; }

			public RoadQualityIndex Segments { get; }

			public IReadOnlyList<string> Errors { get; }

			public bool Refused { get; }

			public bool NeedsMigration { get; }

			public ParseResult(IReadOnlyList<Trip> trips, RoadQualityIndex segments, IReadOnlyList<string> errors, bool refused, bool needsMigration)
			{
				Trips = trips;
				Segments = segments;
				Errors = errors;
				Refused = refused;
				NeedsMigration = needsMigration;
			}
		}

		public const int FormatVersion = 2;

		public static string Compose(IReadOnlyList<Trip> trips, long worldUid, string pluginVersion, RoadQualityIndex? segments = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("# Concerned Teamster trip sidecar\n");
			stringBuilder.Append("format-version: ").Append(2.ToString(CultureInfo.InvariantCulture)).Append('\n');
			stringBuilder.Append("world-uid: ").Append(worldUid.ToString(CultureInfo.InvariantCulture)).Append('\n');
			stringBuilder.Append("plugin-version: ").Append(pluginVersion).Append('\n');
			if (segments != null)
			{
				List<RoadSegmentKey> list = new List<RoadSegmentKey>(segments.Segments.Keys);
				list.Sort((RoadSegmentKey left, RoadSegmentKey right) => (left.CellX == right.CellX) ? left.CellZ.CompareTo(right.CellZ) : left.CellX.CompareTo(right.CellX));
				foreach (RoadSegmentKey item in list)
				{
					RoadSegmentStats roadSegmentStats = segments.Segments[item];
					stringBuilder.Append("seg: ").Append(item.CellX.ToString(CultureInfo.InvariantCulture)).Append(" | ")
						.Append(item.CellZ.ToString(CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.SampleCount.ToString(CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.PairCount.ToString(CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.SumAbsGradeDelta.ToString("F3", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.GradeCount.ToString(CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.SumGrade.ToString("F3", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.MaxAbsGrade.ToString("F3", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.LevelCount.ToString(CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(roadSegmentStats.SumLevelSpeed.ToString("F3", CultureInfo.InvariantCulture))
						.Append('\n');
				}
			}
			for (int num = 0; num < trips.Count; num++)
			{
				Trip trip = trips[num];
				stringBuilder.Append("trip: ").Append((num + 1).ToString(CultureInfo.InvariantCulture)).Append(" | ")
					.Append(trip.CartId)
					.Append('\n');
				foreach (TripSample sample in trip.Samples)
				{
					stringBuilder.Append("s: ").Append(sample.TimeSeconds.ToString("F2", CultureInfo.InvariantCulture)).Append(" | ")
						.Append(sample.PositionX.ToString("F1", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(sample.PositionZ.ToString("F1", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(float.IsNaN(sample.GradePercent) ? "-" : sample.GradePercent.ToString("F1", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(float.IsNaN(sample.SpeedMetersPerSecond) ? "-" : sample.SpeedMetersPerSecond.ToString("F2", CultureInfo.InvariantCulture))
						.Append(" | ")
						.Append(sample.TotalMass.ToString("F1", CultureInfo.InvariantCulture))
						.Append('\n');
				}
				stringBuilder.Append("end-trip\n");
			}
			return stringBuilder.ToString();
		}

		public static ParseResult Parse(string? text, long expectedWorldUid)
		{
			List<Trip> list = new List<Trip>();
			List<string> list2 = new List<string>();
			RoadQualityIndex segments = new RoadQualityIndex();
			if (string.IsNullOrEmpty(text))
			{
				return new ParseResult(list, segments, list2, refused: false, needsMigration: false);
			}
			int result = -1;
			long result2 = 0L;
			string cartId = null;
			List<TripSample> list3 = null;
			string[] array = text.Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].TrimEnd(new char[1] { '\r' }).Trim();
				if (text2.Length == 0 || text2.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (text2.StartsWith("format-version:", StringComparison.Ordinal))
				{
					int.TryParse(text2.Substring(15).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
					if (result != 2 && result != 1)
					{
						list2.Add($"unsupported format-version {result}; file left untouched");
						return new ParseResult(Array.Empty<Trip>(), segments, list2, refused: true, needsMigration: false);
					}
				}
				else if (text2.StartsWith("world-uid:", StringComparison.Ordinal))
				{
					long.TryParse(text2.Substring(10).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out result2);
					if (result2 != expectedWorldUid)
					{
						list2.Add($"world-uid {result2} does not match this world ({expectedWorldUid}); file refused");
						return new ParseResult(Array.Empty<Trip>(), segments, list2, refused: true, needsMigration: false);
					}
				}
				else if (text2.StartsWith("seg:", StringComparison.Ordinal))
				{
					ParseSegment(text2.Substring(4), i + 1, segments, list2);
				}
				else
				{
					if (text2.StartsWith("plugin-version:", StringComparison.Ordinal))
					{
						continue;
					}
					if (text2.StartsWith("trip:", StringComparison.Ordinal))
					{
						if (list3 != null)
						{
							list2.Add($"line {i + 1}: trip started before previous ended; previous kept");
							FinishTrip(list, cartId, list3);
						}
						string[] array2 = text2.Substring(5).Split(new char[1] { '|' });
						cartId = ((array2.Length > 1) ? array2[1].Trim() : string.Empty);
						list3 = new List<TripSample>();
					}
					else if (text2.StartsWith("s:", StringComparison.Ordinal))
					{
						if (list3 == null)
						{
							list2.Add($"line {i + 1}: sample outside a trip; skipped");
							continue;
						}
						TripSample? tripSample = ParseSample(text2.Substring(2), i + 1, list2);
						if (tripSample.HasValue)
						{
							list3.Add(tripSample.Value);
						}
					}
					else if (text2.StartsWith("end-trip", StringComparison.Ordinal))
					{
						if (list3 == null)
						{
							list2.Add($"line {i + 1}: end-trip without a trip; skipped");
							continue;
						}
						FinishTrip(list, cartId, list3);
						cartId = null;
						list3 = null;
					}
					else
					{
						list2.Add($"line {i + 1}: unrecognized line; skipped");
					}
				}
			}
			if (list3 != null)
			{
				list2.Add("file ended inside a trip; partial trip kept");
				FinishTrip(list, cartId, list3);
			}
			if (result < 0 && list.Count > 0)
			{
				list2.Add("missing format-version header");
			}
			return new ParseResult(list, segments, list2, refused: false, result == 1);
		}

		private static void ParseSegment(string body, int lineNumber, RoadQualityIndex segments, List<string> errors)
		{
			string[] array = body.Split(new char[1] { '|' });
			if (array.Length < 10)
			{
				errors.Add($"line {lineNumber}: segment needs 10 fields; skipped");
				return;
			}
			if (!int.TryParse(array[0].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(array[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || !int.TryParse(array[2].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || !int.TryParse(array[3].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4) || !float.TryParse(array[4].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result5) || !int.TryParse(array[5].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result6) || !float.TryParse(array[6].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result7) || !float.TryParse(array[7].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result8) || !int.TryParse(array[8].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result9) || !float.TryParse(array[9].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result10))
			{
				errors.Add($"line {lineNumber}: malformed segment; skipped");
				return;
			}
			RoadSegmentStats roadSegmentStats = new RoadSegmentStats();
			roadSegmentStats.Restore(result3, result4, result5, result6, result7, result8, result9, result10);
			segments.RestoreSegment(new RoadSegmentKey(result, result2), roadSegmentStats);
		}

		public static string MergeAndCompose(ParseResult existing, IReadOnlyList<Trip> newTrips, int maxTrips, long worldUid, string pluginVersion)
		{
			RoadQualityIndex roadQualityIndex = (existing.NeedsMigration ? RoadQualityIndex.ComputeFromTrips(existing.Trips) : existing.Segments);
			foreach (Trip newTrip in newTrips)
			{
				roadQualityIndex.AddTrip(newTrip);
			}
			List<Trip> list = new List<Trip>(existing.Trips);
			list.AddRange(newTrips);
			return Compose(Prune(list, maxTrips), worldUid, pluginVersion, roadQualityIndex);
		}

		public static IReadOnlyList<Trip> Prune(IReadOnlyList<Trip> trips, int maxTrips)
		{
			int num = Math.Min(trips.Count, Math.Max(0, maxTrips));
			List<Trip> list = new List<Trip>(num);
			for (int i = trips.Count - num; i < trips.Count; i++)
			{
				Trip trip = trips[i];
				list.Add(new Trip(list.Count + 1, trip.CartId, trip.Samples));
			}
			return list;
		}

		private static void FinishTrip(List<Trip> trips, string? cartId, List<TripSample> samples)
		{
			if (samples.Count > 0)
			{
				trips.Add(new Trip(trips.Count + 1, cartId ?? string.Empty, samples.ToArray()));
			}
		}

		private static TripSample? ParseSample(string body, int lineNumber, List<string> errors)
		{
			string[] array = body.Split(new char[1] { '|' });
			if (array.Length < 6)
			{
				errors.Add($"line {lineNumber}: sample needs 6 fields; skipped");
				return null;
			}
			if (!double.TryParse(array[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !float.TryParse(array[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || !float.TryParse(array[2].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) || !TryParseOptionalFloat(array[3], out var value) || !TryParseOptionalFloat(array[4], out var value2) || !float.TryParse(array[5].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
			{
				errors.Add($"line {lineNumber}: malformed sample; skipped");
				return null;
			}
			return new TripSample(result, result2, result3, value, value2, result4);
		}

		private static bool TryParseOptionalFloat(string text, out float value)
		{
			string text2 = text.Trim();
			if (text2 == "-")
			{
				value = float.NaN;
				return true;
			}
			return float.TryParse(text2, NumberStyles.Float, CultureInfo.InvariantCulture, out value);
		}
	}
	public static class TripSummarizer
	{
		public static TripSummary Summarize(Trip trip)
		{
			float num = 0f;
			float num2 = 0f;
			float num3 = float.NaN;
			float num4 = 0f;
			int num5 = 0;
			for (int i = 0; i < trip.Samples.Count; i++)
			{
				TripSample tripSample = trip.Samples[i];
				num2 += tripSample.TotalMass;
				if (i > 0)
				{
					TripSample tripSample2 = trip.Samples[i - 1];
					float num6 = tripSample.PositionX - tripSample2.PositionX;
					float num7 = tripSample.PositionZ - tripSample2.PositionZ;
					num += (float)Math.Sqrt(num6 * num6 + num7 * num7);
				}
				if (!float.IsNaN(tripSample.GradePercent))
				{
					float num8 = Math.Abs(tripSample.GradePercent);
					if (float.IsNaN(num3) || num8 > num3)
					{
						num3 = num8;
					}
				}
				if (!float.IsNaN(tripSample.SpeedMetersPerSecond))
				{
					num4 += tripSample.SpeedMetersPerSecond;
					num5++;
				}
			}
			int count = trip.Samples.Count;
			return new TripSummary(trip.Id, trip.CartId, trip.StartTimeSeconds, trip.EndTimeSeconds - trip.StartTimeSeconds, num, (count > 0) ? (num2 / (float)count) : 0f, num3, (num5 > 0) ? (num4 / (float)num5) : float.NaN);
		}
	}
	public sealed class TripSummary
	{
		public int TripId { get; }

		public string CartId { get; }

		public double StartTimeSeconds { get; }

		public double DurationSeconds { get; }

		public float DistanceMeters { get; }

		public float MeanMass { get; }

		public float WorstAbsGradePercent { get; }

		public float MeanSpeedMetersPerSecond { get; }

		public TripSummary(int tripId, string cartId, double startTimeSeconds, double durationSeconds, float distanceMeters, float meanMass, float worstAbsGradePercent, float meanSpeedMetersPerSecond)
		{
			TripId = tripId;
			CartId = cartId;
			StartTimeSeconds = startTimeSeconds;
			DurationSeconds = durationSeconds;
			DistanceMeters = distanceMeters;
			MeanMass = meanMass;
			WorstAbsGradePercent = worstAbsGradePercent;
			MeanSpeedMetersPerSecond = meanSpeedMetersPerSecond;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Terrain
{
	public enum GradeDirection
	{
		Level,
		Climbing,
		Descending
	}
	public static class GradeMath
	{
		public const float SmoothingAlpha = 0.35f;

		public const float DirectionEnterThresholdPercent = 4f;

		public const float DirectionExitThresholdPercent = 2f;

		public static float ComputeInstantGradePercent(float heightAhead, float heightBehind, float runMeters)
		{
			if (float.IsNaN(heightAhead) || float.IsInfinity(heightAhead) || float.IsNaN(heightBehind) || float.IsInfinity(heightBehind) || float.IsNaN(runMeters) || float.IsInfinity(runMeters) || runMeters <= 0f)
			{
				return float.NaN;
			}
			return (heightAhead - heightBehind) / runMeters * 100f;
		}

		public static float Smooth(float previousSmoothedPercent, float instantGradePercent)
		{
			if (float.IsNaN(instantGradePercent))
			{
				return previousSmoothedPercent;
			}
			if (float.IsNaN(previousSmoothedPercent))
			{
				return instantGradePercent;
			}
			return previousSmoothedPercent + 0.35f * (instantGradePercent - previousSmoothedPercent);
		}

		public static GradeDirection ClassifyDirection(float smoothedGradePercent, GradeDirection previousDirection)
		{
			if (float.IsNaN(smoothedGradePercent))
			{
				return previousDirection;
			}
			float num = Math.Abs(smoothedGradePercent);
			bool flag = smoothedGradePercent > 0f;
			switch (previousDirection)
			{
			case GradeDirection.Climbing:
				if (smoothedGradePercent >= 2f)
				{
					return GradeDirection.Climbing;
				}
				break;
			case GradeDirection.Descending:
				if (smoothedGradePercent <= -2f)
				{
					return GradeDirection.Descending;
				}
				break;
			}
			if (num >= 4f)
			{
				if (!flag)
				{
					return GradeDirection.Descending;
				}
				return GradeDirection.Climbing;
			}
			return GradeDirection.Level;
		}
	}
	public static class TerrainPaint
	{
		public const float DefaultThreshold = 0.4f;

		public static TerrainSurfaceKind Classify(float red, float green, float blue, float threshold)
		{
			if (float.IsNaN(red) || float.IsNaN(green) || float.IsNaN(blue))
			{
				return TerrainSurfaceKind.Unavailable;
			}
			float num = red;
			TerrainSurfaceKind result = TerrainSurfaceKind.Dirt;
			if (green > num)
			{
				num = green;
				result = TerrainSurfaceKind.Cultivated;
			}
			if (blue > num)
			{
				num = blue;
				result = TerrainSurfaceKind.Paved;
			}
			if (num < threshold)
			{
				return TerrainSurfaceKind.Untouched;
			}
			int num2 = 0;
			if (red == num)
			{
				num2++;
			}
			if (green == num)
			{
				num2++;
			}
			if (blue == num)
			{
				num2++;
			}
			if (num2 <= 1)
			{
				return result;
			}
			return TerrainSurfaceKind.Untouched;
		}
	}
	public enum TerrainSurfaceKind
	{
		Unavailable,
		Untouched,
		Dirt,
		Cultivated,
		Paved
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Support
{
	public static class FeedbackLinks
	{
		public const string IssuesUrl = "https://github.com/Weakened/ConcernedCatMods/issues";
	}
	public static class SupportBundleComposer
	{
		public sealed class SidecarSummary
		{
			public string FileName { get; }

			public long KilobyteSize { get; }

			public int TripCount { get; }

			public int MalformedRowCount { get; }

			public SidecarSummary(string fileName, long kilobyteSize, int tripCount, int malformedRowCount)
			{
				FileName = fileName;
				KilobyteSize = kilobyteSize;
				TripCount = tripCount;
				MalformedRowCount = malformedRowCount;
			}
		}

		public const string Header = "# Concerned Teamster support bundle (sanitized: no world identifiers beyond a masked number, no player names, no full paths)";

		public static List<string> Compose(DateTime generatedUtc, string pluginVersion, string effectiveConfigSummary, IReadOnlyList<string> compatibilityLines, IReadOnlyList<SidecarSummary> sidecars, int backupFileCount, IReadOnlyList<RecoveryEvent> recoveryEvents, IReadOnlyList<string> recentLogLines)
		{
			List<string> list = new List<string>
			{
				"# Concerned Teamster support bundle (sanitized: no world identifiers beyond a masked number, no player names, no full paths)",
				Scrub("generated-utc: " + generatedUtc.ToString("yyyy-MM-dd HH:mm:ss") + "Z"),
				Scrub("plugin-version: " + pluginVersion),
				Scrub("config: " + effectiveConfigSummary),
				"",
				"## Compatibility"
			};
			if (compatibilityLines.Count == 0)
			{
				list.Add(Scrub("(not yet probed)"));
			}
			else
			{
				foreach (string compatibilityLine in compatibilityLines)
				{
					list.Add(Scrub(compatibilityLine));
				}
			}
			list.Add("");
			list.Add("## Sidecars (" + backupFileCount + " backup file(s) across all reasons)");
			if (sidecars.Count == 0)
			{
				list.Add(Scrub("(none found)"));
			}
			else
			{
				foreach (SidecarSummary sidecar in sidecars)
				{
					list.Add(Scrub(sidecar.FileName + ": " + sidecar.KilobyteSize + " KB, " + sidecar.TripCount + " trip(s), " + sidecar.MalformedRowCount + " malformed row(s)"));
				}
			}
			list.Add("");
			list.Add("## Recovery events this session");
			if (recoveryEvents.Count == 0)
			{
				list.Add(Scrub("(none)"));
			}
			else
			{
				foreach (RecoveryEvent recoveryEvent in recoveryEvents)
				{
					list.Add(Scrub(recoveryEvent.SidecarFileName + " [" + recoveryEvent.Reason + "]: " + recoveryEvent.Message));
				}
			}
			list.Add("");
			list.Add("## Recent log lines (this mod only, newest last)");
			if (recentLogLines.Count == 0)
			{
				list.Add(Scrub("(none captured)"));
			}
			else
			{
				foreach (string recentLogLine in recentLogLines)
				{
					list.Add(Scrub(recentLogLine));
				}
			}
			return list;
		}

		private static string Scrub(string line)
		{
			return SupportBundleSanitizer.Sanitize(line);
		}
	}
	public static class SupportBundleSanitizer
	{
		public const int MaxLineLength = 2000;

		private static readonly Regex Urls = new Regex("\\b(?:https?|wss?|ftp)://\\S+", RegexOptions.Compiled);

		private static readonly Regex CoordinatePairs = new Regex("\\(\\s*-?\\d+(?:\\.\\d+)?\\s*,\\s*-?\\d+(?:\\.\\d+)?(?:\\s*,\\s*-?\\d+(?:\\.\\d+)?)?\\s*\\)", RegexOptions.Compiled);

		private static readonly Regex WindowsPath = new Regex("[A-Za-z]:[\\\\/](?:[^\\\\/\\r\\n:*?\"<>|\\s]+[\\\\/])*[^\\\\/\\r\\n:*?\"<>|\\s]*", RegexOptions.Compiled);

		private static readonly Regex UnixPath = new Regex("(?<![\\w.<])/(?:[^/\\s]+/)+[^/\\s]*", RegexOptions.Compiled);

		private static readonly Regex UsersFragment = new Regex("\\bUsers[\\\\/][^\\\\/\\s]+", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly Regex SaveFileNames = new Regex("[^\\\\/\\s\"']+\\.(db|fwl|fch)(\\.old|\\.bak)?\\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly Regex Ipv4 = new Regex("\\b\\d{1,3}(?:\\.\\d{1,3}){3}(?::\\d{1,5})?\\b", RegexOptions.Compiled);

		private static readonly Regex HexBlob = new Regex("\\b[A-Fa-f0-9]{32,}\\b", RegexOptions.Compiled);

		private static readonly Regex TokenBlob = new Regex("[A-Za-z0-9+/=_\\-]{40,}", RegexOptions.Compiled);

		private static readonly Regex LongDigits = new Regex("\\d{7,}", RegexOptions.Compiled);

		public static string Sanitize(string? line)
		{
			if (string.IsNullOrEmpty(line))
			{
				return "";
			}
			string input = line;
			input = Urls.Replace(input, "<url>");
			input = CoordinatePairs.Replace(input, "(<pos>)");
			input = WindowsPath.Replace(input, "<path>");
			input = UnixPath.Replace(input, "<path>");
			input = UsersFragment.Replace(input, "Users/<user>");
			input = SaveFileNames.Replace(input, "<save>.$1");
			input = Ipv4.Replace(input, "<ip>");
			input = HexBlob.Replace(input, "<hex>");
			input = TokenBlob.Replace(input, "<token>");
			input = LongDigits.Replace(input, "<n>");
			if (input.Length > 2000)
			{
				input = input.Substring(0, 2000) + "…[truncated]";
			}
			return input;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Routes
{
	public static class RouteGeometry
	{
		public static ulong Fingerprint(IReadOnlyList<CartographerRoutePoint> points)
		{
			ulong hash = 14695981039346656037uL;
			hash = Mix(hash, (uint)points.Count, 1099511628211uL);
			for (int i = 0; i < points.Count; i++)
			{
				CartographerRoutePoint cartographerRoutePoint = points[i];
				hash = Mix(hash, (uint)cartographerRoutePoint.X.GetHashCode(), 1099511628211uL);
				hash = Mix(hash, (uint)cartographerRoutePoint.Y.GetHashCode(), 1099511628211uL);
				hash = Mix(hash, (uint)cartographerRoutePoint.Z.GetHashCode(), 1099511628211uL);
			}
			return hash;
		}

		private static ulong Mix(ulong hash, uint value, ulong prime)
		{
			for (int i = 0; i < 32; i += 8)
			{
				hash ^= (byte)(value >> i);
				hash *= prime;
			}
			return hash;
		}
	}
	public static class RouteLoadBottleneck
	{
		public sealed class Result
		{
			public bool HasGradeData { get; }

			public float BottleneckGradePercent { get; }

			public LoadRecommendation? ProvenMaxMass { get; }

			public LoadVerdict? Verdict { get; }

			public float QueriedMass { get; }

			public bool MassAdviceReliable { get; }

			public Result(bool hasGradeData, float bottleneckGradePercent, LoadRecommendation? provenMaxMass, LoadVerdict? verdict, float queriedMass, bool massAdviceReliable = true)
			{
				HasGradeData = hasGradeData;
				BottleneckGradePercent = bottleneckGradePercent;
				ProvenMaxMass = provenMaxMass;
				Verdict = verdict;
				QueriedMass = queriedMass;
				MassAdviceReliable = massAdviceReliable;
			}
		}

		public static Result Evaluate(RouteProfile profile, LoadModel model, float? chosenTotalMass, bool massAdviceReliable = true)
		{
			if (float.IsNaN(profile.MaxAbsGradePercent))
			{
				return new Result(hasGradeData: false, float.NaN, null, null, float.NaN, massAdviceReliable);
			}
			float maxAbsGradePercent = profile.MaxAbsGradePercent;
			if (!massAdviceReliable)
			{
				return new Result(hasGradeData: true, maxAbsGradePercent, null, null, chosenTotalMass ?? float.NaN, massAdviceReliable: false);
			}
			LoadRecommendation provenMaxMass = model.RecommendedMaxMass(maxAbsGradePercent);
			LoadVerdict verdict = (chosenTotalMass.HasValue ? model.Query(maxAbsGradePercent, chosenTotalMass.Value) : null);
			return new Result(hasGradeData: true, maxAbsGradePercent, provenMaxMass, verdict, chosenTotalMass ?? float.NaN);
		}
	}
	public readonly struct RouteProfileSegment
	{
		public float StartMeters { get; }

		public float LengthMeters { get; }

		public float GradePercent { get; }

		public RouteProfileSegment(float startMeters, float lengthMeters, float gradePercent)
		{
			StartMeters = startMeters;
			LengthMeters = lengthMeters;
			GradePercent = gradePercent;
		}
	}
	public sealed class RouteProfile
	{
		public static readonly float[] GradeBandUpperBoundsPercent = new float[4] { 3f, 8f, 15f, 25f };

		public const int GradeBandCount = 5;

		public float TotalDistanceMeters { get; }

		public float SampledMeters { get; }

		public float UnsampledMeters { get; }

		public IReadOnlyDictionary<TerrainSurfaceKind, float> SurfaceMeters { get; }

		public float SurfaceUnknownMeters { get; }

		public IReadOnlyList<float> GradeBandMeters { get; }

		public float WorstUphillGradePercent { get; }

		public float WorstDownhillGradePercent { get; }

		public float MaxAbsGradePercent { get; }

		public IReadOnlyList<RouteProfileSegment> WorstSegments { get; }

		public IReadOnlyList<RouteProfileSegment> UnsampledSpans { get; }

		public float SampleSpacingMeters { get; }

		public int PositionCount { get; }

		public int SampledPositionCount { get; }

		public RouteProfile(float totalDistanceMeters, float sampledMeters, float unsampledMeters, IReadOnlyDictionary<TerrainSurfaceKind, float> surfaceMeters, float surfaceUnknownMeters, IReadOnlyList<float> gradeBandMeters, float worstUphillGradePercent, float worstDownhillGradePercent, float maxAbsGradePercent, IReadOnlyList<RouteProfileSegment> worstSegments, IReadOnlyList<RouteProfileSegment> unsampledSpans, float sampleSpacingMeters, int positionCount, int sampledPositionCount)
		{
			TotalDistanceMeters = totalDistanceMeters;
			SampledMeters = sampledMeters;
			UnsampledMeters = unsampledMeters;
			SurfaceMeters = surfaceMeters;
			SurfaceUnknownMeters = surfaceUnknownMeters;
			GradeBandMeters = gradeBandMeters;
			WorstUphillGradePercent = worstUphillGradePercent;
			WorstDownhillGradePercent = worstDownhillGradePercent;
			MaxAbsGradePercent = maxAbsGradePercent;
			WorstSegments = worstSegments;
			UnsampledSpans = unsampledSpans;
			SampleSpacingMeters = sampleSpacingMeters;
			PositionCount = positionCount;
			SampledPositionCount = sampledPositionCount;
		}
	}
	public sealed class RouteProfileCache
	{
		public const int MaxEntries = 64;

		private readonly Dictionary<Guid, KeyValuePair<ulong, RouteProfile>> _entries = new Dictionary<Guid, KeyValuePair<ulong, RouteProfile>>();

		public int Count => _entries.Count;

		public bool TryGet(Guid routeId, ulong fingerprint, out RouteProfile? profile)
		{
			if (_entries.TryGetValue(routeId, out KeyValuePair<ulong, RouteProfile> value) && value.Key == fingerprint)
			{
				profile = value.Value;
				return true;
			}
			profile = null;
			return false;
		}

		public void Store(Guid routeId, ulong fingerprint, RouteProfile profile)
		{
			if (!_entries.ContainsKey(routeId) && _entries.Count >= 64)
			{
				_entries.Clear();
			}
			_entries[routeId] = new KeyValuePair<ulong, RouteProfile>(fingerprint, profile);
		}

		public void Clear()
		{
			_entries.Clear();
		}
	}
	public delegate bool RouteSampleProbe(float x, float z, out float height, out TerrainSurfaceKind surface);
	public sealed class RouteProfiler
	{
		public const float DefaultSampleSpacingMeters = 4f;

		public const int MaxSamplePositions = 4096;

		private const int WorstSegmentCount = 3;

		private readonly RouteSampleProbe _probe;

		private readonly float[] _vertexX;

		private readonly float[] _vertexZ;

		private readonly float[] _vertexT;

		private readonly float[] _positionT;

		private readonly bool[] _sampled;

		private readonly float[] _heights;

		private readonly TerrainSurfaceKind[] _surfaces;

		private int _nextIndex;

		private int _segmentCursor;

		private bool _cancelled;

		public float TotalDistanceMeters { get; }

		public float SampleSpacingMeters { get; }

		public int PositionCount => _positionT.Length;

		public int PositionsProbed => _nextIndex;

		public bool IsCancelled => _cancelled;

		public bool IsComplete
		{
			get
			{
				if (!_cancelled)
				{
					return _nextIndex >= _positionT.Length;
				}
				return false;
			}
		}

		public int TotalSamplesConsumed { get; private set; }

		public int LastAdvanceSampleCount { get; private set; }

		public RouteProfiler(IReadOnlyList<CartographerRoutePoint> points, RouteSampleProbe probe, float sampleSpacingMeters = 4f)
		{
			_probe = probe;
			if (sampleSpacingMeters <= 0f || float.IsNaN(sampleSpacingMeters))
			{
				sampleSpacingMeters = 4f;
			}
			int num = points?.Count ?? 0;
			_vertexX = new float[num];
			_vertexZ = new float[num];
			_vertexT = new float[num];
			float num2 = 0f;
			for (int i = 0; i < num; i++)
			{
				CartographerRoutePoint cartographerRoutePoint = points[i];
				_vertexX[i] = cartographerRoutePoint.X;
				_vertexZ[i] = cartographerRoutePoint.Z;
				if (i > 0)
				{
					float num3 = cartographerRoutePoint.X - _vertexX[i - 1];
					float num4 = cartographerRoutePoint.Z - _vertexZ[i - 1];
					num2 += (float)Math.Sqrt(num3 * num3 + num4 * num4);
				}
				_vertexT[i] = num2;
			}
			TotalDistanceMeters = num2;
			if (num < 2 || !(num2 > 0f) || float.IsInfinity(num2))
			{
				_positionT = Array.Empty<float>();
				_sampled = Array.Empty<bool>();
				_heights = Array.Empty<float>();
				_surfaces = Array.Empty<TerrainSurfaceKind>();
				SampleSpacingMeters = sampleSpacingMeters;
				return;
			}
			int num5 = (int)Math.Floor(num2 / sampleSpacingMeters);
			if (num5 + 2 > 4096)
			{
				sampleSpacingMeters = num2 / 4095f;
				num5 = 4094;
			}
			SampleSpacingMeters = sampleSpacingMeters;
			List<float> list = new List<float>(num5 + 2);
			for (int j = 0; j <= num5; j++)
			{
				list.Add((float)j * sampleSpacingMeters);
			}
			if (list.Count == 1 || num2 - list[list.Count - 1] > 0.5f)
			{
				list.Add(num2);
			}
			else
			{
				list[list.Count - 1] = num2;
			}
			_positionT = list.ToArray();
			_sampled = new bool[_positionT.Length];
			_heights = new float[_positionT.Length];
			_surfaces = new TerrainSurfaceKind[_positionT.Length];
		}

		public int Advance(int maxSamples)
		{
			LastAdvanceSampleCount = 0;
			if (_cancelled || maxSamples <= 0)
			{
				return 0;
			}
			int i;
			for (i = 0; i < maxSamples; i++)
			{
				if (_nextIndex >= _positionT.Length)
				{
					break;
				}
				int nextIndex = _nextIndex;
				PositionAt(_positionT[nextIndex], out var x, out var z);
				bool flag;
				float height;
				TerrainSurfaceKind surface;
				try
				{
					flag = _probe(x, z, out height, out surface);
				}
				catch
				{
					flag = false;
					height = float.NaN;
					surface = TerrainSurfaceKind.Unavailable;
				}
				_sampled[nextIndex] = flag;
				_heights[nextIndex] = (flag ? height : float.NaN);
				_surfaces[nextIndex] = (flag ? surface : TerrainSurfaceKind.Unavailable);
				_nextIndex++;
			}
			LastAdvanceSampleCount = i;
			TotalSamplesConsumed += i;
			return i;
		}

		public void Cancel()
		{
			_cancelled = true;
		}

		public RouteProfile? TryBuildProfile()
		{
			if (!IsComplete)
			{
				return null;
			}
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			Dictionary<TerrainSurfaceKind, float> dictionary = new Dictionary<TerrainSurfaceKind, float>();
			float[] array = new float[5];
			float num4 = float.NaN;
			float num5 = float.NaN;
			float num6 = float.NaN;
			List<RouteProfileSegment> list = new List<RouteProfileSegment>(4);
			List<RouteProfileSegment> list2 = new List<RouteProfileSegment>(4);
			float gapStart = float.NaN;
			float gapLength = 0f;
			int num7 = 0;
			for (int i = 0; i < _positionT.Length; i++)
			{
				if (_sampled[i])
				{
					num7++;
				}
			}
			for (int j = 1; j < _positionT.Length; j++)
			{
				float num8 = _positionT[j] - _positionT[j - 1];
				if (num8 <= 0f)
				{
					continue;
				}
				if (!_sampled[j - 1] || !_sampled[j])
				{
					num2 += num8;
					if (float.IsNaN(gapStart))
					{
						gapStart = _positionT[j - 1];
					}
					gapLength += num8;
					continue;
				}
				CloseGap(list2, ref gapStart, ref gapLength);
				num += num8;
				float num9 = (_heights[j] - _heights[j - 1]) / num8 * 100f;
				TerrainSurfaceKind terrainSurfaceKind = _surfaces[j - 1];
				if (terrainSurfaceKind == TerrainSurfaceKind.Unavailable)
				{
					num3 += num8;
				}
				else
				{
					dictionary.TryGetValue(terrainSurfaceKind, out var value);
					dictionary[terrainSurfaceKind] = value + num8;
				}
				float num10 = Math.Abs(num9);
				array[BandIndex(num10)] += num8;
				if (num9 > 0f && (float.IsNaN(num4) || num9 > num4))
				{
					num4 = num9;
				}
				if (num9 < 0f && (float.IsNaN(num5) || num9 < num5))
				{
					num5 = num9;
				}
				if (float.IsNaN(num6) || num10 > num6)
				{
					num6 = num10;
				}
				InsertWorst(list, new RouteProfileSegment(_positionT[j - 1], num8, num9));
			}
			CloseGap(list2, ref gapStart, ref gapLength);
			return new RouteProfile(TotalDistanceMeters, num, num2, dictionary, num3, array, num4, num5, num6, list, list2, SampleSpacingMeters, _positionT.Length, num7);
		}

		private static int BandIndex(float absGradePercent)
		{
			float[] gradeBandUpperBoundsPercent = RouteProfile.GradeBandUpperBoundsPercent;
			for (int i = 0; i < gradeBandUpperBoundsPercent.Length; i++)
			{
				if (absGradePercent < gradeBandUpperBoundsPercent[i])
				{
					return i;
				}
			}
			return gradeBandUpperBoundsPercent.Length;
		}

		private static void CloseGap(List<RouteProfileSegment> gaps, ref float gapStart, ref float gapLength)
		{
			if (float.IsNaN(gapStart) || gapLength <= 0f)
			{
				gapStart = float.NaN;
				gapLength = 0f;
				return;
			}
			RouteProfileSegment item = new RouteProfileSegment(gapStart, gapLength, float.NaN);
			gapStart = float.NaN;
			gapLength = 0f;
			int num = gaps.Count;
			for (int i = 0; i < gaps.Count; i++)
			{
				if (item.LengthMeters > gaps[i].LengthMeters)
				{
					num = i;
					break;
				}
			}
			if (num < 3)
			{
				gaps.Insert(num, item);
				if (gaps.Count > 3)
				{
					gaps.RemoveAt(gaps.Count - 1);
				}
			}
		}

		private static void InsertWorst(List<RouteProfileSegment> worst, RouteProfileSegment candidate)
		{
			float num = Math.Abs(candidate.GradePercent);
			int num2 = worst.Count;
			for (int i = 0; i < worst.Count; i++)
			{
				if (num > Math.Abs(worst[i].GradePercent))
				{
					num2 = i;
					break;
				}
			}
			if (num2 < 3)
			{
				worst.Insert(num2, candidate);
				if (worst.Count > 3)
				{
					worst.RemoveAt(worst.Count - 1);
				}
			}
		}

		private void PositionAt(float t, out float x, out float z)
		{
			while (_segmentCursor < _vertexT.Length - 2 && _vertexT[_segmentCursor + 1] < t)
			{
				_segmentCursor++;
			}
			float num = _vertexT[_segmentCursor];
			float num2 = _vertexT[_segmentCursor + 1] - num;
			float num3 = ((num2 > 0f) ? Math.Min(1f, Math.Max(0f, (t - num) / num2)) : 0f);
			x = _vertexX[_segmentCursor] + (_vertexX[_segmentCursor + 1] - _vertexX[_segmentCursor]) * num3;
			z = _vertexZ[_segmentCursor] + (_vertexZ[_segmentCursor + 1] - _vertexZ[_segmentCursor]) * num3;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.RoadQuality
{
	public sealed class RoadQualityIndex
	{
		private readonly Dictionary<RoadSegmentKey, RoadSegmentStats> _segments = new Dictionary<RoadSegmentKey, RoadSegmentStats>();

		public IReadOnlyDictionary<RoadSegmentKey, RoadSegmentStats> Segments => _segments;

		public int LastAddTouchedSegments { get; private set; }

		public void AddTrip(Trip trip)
		{
			HashSet<RoadSegmentKey> hashSet = new HashSet<RoadSegmentKey>();
			float? num = null;
			RoadSegmentKey roadSegmentKey = default(RoadSegmentKey);
			bool flag = false;
			foreach (TripSample sample in trip.Samples)
			{
				RoadSegmentKey roadSegmentKey2 = RoadSegmentKey.FromPosition(sample.PositionX, sample.PositionZ);
				if (!_segments.TryGetValue(roadSegmentKey2, out RoadSegmentStats value))
				{
					value = new RoadSegmentStats();
					_segments[roadSegmentKey2] = value;
				}
				float? previousGradePercent = ((flag && roadSegmentKey.Equals(roadSegmentKey2)) ? num : ((float?)null));
				value.AddSample(sample.GradePercent, sample.SpeedMetersPerSecond, previousGradePercent);
				hashSet.Add(roadSegmentKey2);
				num = sample.GradePercent;
				roadSegmentKey = roadSegmentKey2;
				flag = true;
			}
			LastAddTouchedSegments = hashSet.Count;
		}

		public void RestoreSegment(RoadSegmentKey key, RoadSegmentStats stats)
		{
			_segments[key] = stats;
		}

		public void Clear()
		{
			_segments.Clear();
			LastAddTouchedSegments = 0;
		}

		public static RoadQualityIndex ComputeFromTrips(IReadOnlyList<Trip> trips)
		{
			RoadQualityIndex roadQualityIndex = new RoadQualityIndex();
			foreach (Trip trip in trips)
			{
				roadQualityIndex.AddTrip(trip);
			}
			return roadQualityIndex;
		}
	}
	public readonly struct RoadSegmentKey : IEquatable<RoadSegmentKey>
	{
		public const float SegmentSizeMeters = 8f;

		public int CellX { get; }

		public int CellZ { get; }

		public RoadSegmentKey(int cellX, int cellZ)
		{
			CellX = cellX;
			CellZ = cellZ;
		}

		public static RoadSegmentKey FromPosition(float x, float z)
		{
			return new RoadSegmentKey((int)Math.Floor(x / 8f), (int)Math.Floor(z / 8f));
		}

		public bool Equals(RoadSegmentKey other)
		{
			if (CellX == other.CellX)
			{
				return CellZ == other.CellZ;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (CellX * 397) ^ CellZ;
		}
	}
	public sealed class RoadSegmentStats
	{
		public const float LevelGradeMaxPercent = 3f;

		public int SampleCount { get; private set; }

		public int PairCount { get; private set; }

		public float SumAbsGradeDelta { get; private set; }

		public int GradeCount { get; private set; }

		public float SumGrade { get; private set; }

		public float MaxAbsGrade { get; private set; }

		public int LevelCount { get; private set; }

		public float SumLevelSpeed { get; private set; }

		public float RoughnessGradeJitter
		{
			get
			{
				if (PairCount <= 0)
				{
					return float.NaN;
				}
				return SumAbsGradeDelta / (float)PairCount;
			}
		}

		public float MeanGradePercent
		{
			get
			{
				if (GradeCount <= 0)
				{
					return float.NaN;
				}
				return SumGrade / (float)GradeCount;
			}
		}

		public float DragProxySpeed
		{
			get
			{
				if (LevelCount <= 0)
				{
					return float.NaN;
				}
				return SumLevelSpeed / (float)LevelCount;
			}
		}

		public void AddSample(float gradePercent, float speedMetersPerSecond, float? previousGradePercent)
		{
			SampleCount++;
			if (float.IsNaN(gradePercent))
			{
				return;
			}
			GradeCount++;
			SumGrade += gradePercent;
			float num = Math.Abs(gradePercent);
			if (num > MaxAbsGrade)
			{
				MaxAbsGrade = num;
			}
			if (previousGradePercent.HasValue)
			{
				float valueOrDefault = previousGradePercent.GetValueOrDefault();
				if (!float.IsNaN(valueOrDefault))
				{
					PairCount++;
					SumAbsGradeDelta += Math.Abs(gradePercent - valueOrDefault);
				}
			}
			if (num < 3f && !float.IsNaN(speedMetersPerSecond))
			{
				LevelCount++;
				SumLevelSpeed += speedMetersPerSecond;
			}
		}

		public void Restore(int sampleCount, int pairCount, float sumAbsGradeDelta, int gradeCount, float sumGrade, float maxAbsGrade, int levelCount, float sumLevelSpeed)
		{
			SampleCount = sampleCount;
			PairCount = pairCount;
			SumAbsGradeDelta = sumAbsGradeDelta;
			GradeCount = gradeCount;
			SumGrade = sumGrade;
			MaxAbsGrade = maxAbsGrade;
			LevelCount = levelCount;
			SumLevelSpeed = sumLevelSpeed;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Risk
{
	public sealed class DescentCalibrationData
	{
		public int DataVersion { get; }

		public string GameVersion { get; }

		public string Protocol { get; }

		public string Generated { get; }

		public IReadOnlyList<DescentCalibrationRow> Rows { get; }

		public IReadOnlyList<string> Errors { get; }

		public int MeasuredRowCount
		{
			get
			{
				int num = 0;
				foreach (DescentCalibrationRow row in Rows)
				{
					if (row.Basis == CalibrationBasis.Measured)
					{
						num++;
					}
				}
				return num;
			}
		}

		private DescentCalibrationData(int dataVersion, string gameVersion, string protocol, string generated, IReadOnlyList<DescentCalibrationRow> rows, IReadOnlyList<string> errors)
		{
			DataVersion = dataVersion;
			GameVersion = gameVersion;
			Protocol = protocol;
			Generated = generated;
			Rows = rows;
			Errors = errors;
		}

		public static DescentCalibrationData Parse(string? text)
		{
			List<DescentCalibrationRow> list = new List<DescentCalibrationRow>();
			List<string> list2 = new List<string>();
			int result = 0;
			string gameVersion = string.Empty;
			string protocol = string.Empty;
			string generated = string.Empty;
			if (text == null)
			{
				list2.Add("calibration text is null");
				return new DescentCalibrationData(0, gameVersion, protocol, generated, list, list2);
			}
			string[] array = text.Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].TrimEnd(new char[1] { '\r' }).Trim();
				if (text2.Length == 0 || text2.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (text2.StartsWith("row:", StringComparison.Ordinal))
				{
					DescentCalibrationRow descentCalibrationRow = ParseRow(text2.Substring(4), i + 1, list2);
					if (descentCalibrationRow != null)
					{
						list.Add(descentCalibrationRow);
					}
					continue;
				}
				int num = text2.IndexOf(':');
				if (num <= 0)
				{
					list2.Add($"line {i + 1}: not a header or row");
					continue;
				}
				string text3 = text2.Substring(0, num).Trim();
				string text4 = text2.Substring(num + 1).Trim();
				switch (text3)
				{
				case "data-version":
					if (!int.TryParse(text4, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
					{
						list2.Add($"line {i + 1}: bad data-version");
					}
					break;
				case "game-version":
					gameVersion = text4;
					break;
				case "protocol":
					protocol = text4;
					break;
				case "generated":
					generated = text4;
					break;
				}
			}
			if (result <= 0)
			{
				list2.Add("missing or invalid data-version header");
			}
			return new DescentCalibrationData(result, gameVersion, protocol, generated, list, list2);
		}

		private static DescentCalibrationRow? ParseRow(string body, int lineNumber, List<string> errors)
		{
			string[] array = body.Split(new char[1] { '|' });
			if (array.Length < 5)
			{
				errors.Add($"line {lineNumber}: row needs grade | mass | speed | outcome | basis");
				return null;
			}
			if (!TryParseFinite(array[0], out var value) || value < 0f)
			{
				errors.Add($"line {lineNumber}: bad down-grade");
				return null;
			}
			if (!TryParseFinite(array[1], out var value2) || value2 <= 0f)
			{
				errors.Add($"line {lineNumber}: bad mass");
				return null;
			}
			if (!TryParseFinite(array[2], out var value3) || value3 < 0f)
			{
				errors.Add($"line {lineNumber}: bad speed");
				return null;
			}
			if (!Enum.TryParse<DescentOutcome>(array[3].Trim(), ignoreCase: false, out var result))
			{
				errors.Add($"line {lineNumber}: unknown outcome '{array[3].Trim()}'");
				return null;
			}
			if (!Enum.TryParse<CalibrationBasis>(array[4].Trim(), ignoreCase: false, out var result2))
			{
				errors.Add($"line {lineNumber}: unknown basis '{array[4].Trim()}'");
				return null;
			}
			string note = ((array.Length > 5) ? array[5].Trim() : string.Empty);
			return new DescentCalibrationRow(value, value2, value3, result, result2, note);
		}

		private static bool TryParseFinite(string text, out float value)
		{
			if (float.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out value) && !float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public sealed class DescentCalibrationRow
	{
		public float DownGradePercent { get; }

		public float TotalMass { get; }

		public float EntrySpeedMetersPerSecond { get; }

		public DescentOutcome Outcome { get; }

		public CalibrationBasis Basis { get; }

		public string Note { get; }

		public DescentCalibrationRow(float downGradePercent, float totalMass, float entrySpeedMetersPerSecond, DescentOutcome outcome, CalibrationBasis basis, string note)
		{
			DownGradePercent = downGradePercent;
			TotalMass = totalMass;
			EntrySpeedMetersPerSecond = entrySpeedMetersPerSecond;
			Outcome = outcome;
			Basis = basis;
			Note = note;
		}
	}
	public static class DescentCalibrationSource
	{
		public const string ResourceName = "CT.Data.CartDescentCalibration";

		public static DescentCalibrationData? TryLoadEmbedded()
		{
			try
			{
				using Stream stream = typeof(DescentCalibrationSource).Assembly.GetManifestResourceStream("CT.Data.CartDescentCalibration");
				if (stream == null)
				{
					return null;
				}
				using StreamReader streamReader = new StreamReader(stream);
				return DescentCalibrationData.Parse(streamReader.ReadToEnd());
			}
			catch
			{
				return null;
			}
		}
	}
	public enum DescentOutcome
	{
		Held,
		Dragged,
		Runaway,
		JointBreak
	}
	public static class DescentRiskEvaluator
	{
		public static RiskVerdict EvaluateCurrent(RiskModel? model, CartTelemetry telemetry)
		{
			if (!telemetry.GradeAvailable)
			{
				return new RiskVerdict(RiskLevel.Unknown, null, "grade unavailable");
			}
			if (telemetry.SmoothedGradePercent >= 0f)
			{
				return new RiskVerdict(RiskLevel.Safe, null, "not descending");
			}
			if (model == null)
			{
				return new RiskVerdict(RiskLevel.Unknown, null, "no descent calibration data");
			}
			float speedMetersPerSecond = (telemetry.VelocityAvailable ? telemetry.SpeedMetersPerSecond : 0f);
			return model.Query(0f - telemetry.SmoothedGradePercent, telemetry.TotalMass, speedMetersPerSecond);
		}

		public static RiskVerdict? EvaluateLookahead(RiskModel? model, CartTelemetry telemetry, bool lookaheadAvailable, float worstAheadDownGradePercent)
		{
			if (!lookaheadAvailable)
			{
				return null;
			}
			if (worstAheadDownGradePercent <= 0f)
			{
				return new RiskVerdict(RiskLevel.Safe, null, "no descent ahead in the lookahead window");
			}
			if (model == null)
			{
				return new RiskVerdict(RiskLevel.Unknown, null, "no descent calibration data");
			}
			float speedMetersPerSecond = (telemetry.VelocityAvailable ? telemetry.SpeedMetersPerSecond : 0f);
			return model.Query(worstAheadDownGradePercent, telemetry.TotalMass, speedMetersPerSecond);
		}
	}
	public sealed class DescentRiskInfo
	{
		public string CartId { get; }

		public RiskVerdict Current { get; }

		public bool LookaheadAvailable { get; }

		public float WorstAheadDownGradePercent { get; }

		public RiskVerdict? Lookahead { get; }

		public double SampleTimeSeconds { get; }

		public DescentRiskInfo(string cartId, RiskVerdict current, bool lookaheadAvailable, float worstAheadDownGradePercent, RiskVerdict? lookahead, double sampleTimeSeconds)
		{
			CartId = cartId;
			Current = current;
			LookaheadAvailable = lookaheadAvailable;
			WorstAheadDownGradePercent = worstAheadDownGradePercent;
			Lookahead = lookahead;
			SampleTimeSeconds = sampleTimeSeconds;
		}

		public string Describe()
		{
			string text = ((LookaheadAvailable && Lookahead != null) ? (Lookahead.Level.ToString() + " (worst ahead " + WorstAheadDownGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "% down)") : "unavailable");
			return "descent risk: here " + Current.Level.ToString() + ", ahead " + text;
		}
	}
	public sealed class LookaheadOptions
	{
		public const int DefaultPoints = 3;

		public const int MinPoints = 0;

		public const int MaxPoints = 5;

		public const float SpacingMeters = 4f;

		public int Points { get; }

		public float[] OffsetsMeters { get; }

		public int MaxHeightQueriesPerEvaluation
		{
			get
			{
				if (Points != 0)
				{
					return Points + 1;
				}
				return 0;
			}
		}

		private LookaheadOptions(int points)
		{
			Points = points;
			float[] array = new float[points];
			for (int i = 0; i < points; i++)
			{
				array[i] = 4f * (float)(i + 1);
			}
			OffsetsMeters = array;
		}

		public static LookaheadOptions CreateClamped(int points)
		{
			return new LookaheadOptions(Math.Min(5, Math.Max(0, points)));
		}
	}
	public enum RiskLevel
	{
		Safe,
		Unknown,
		Caution,
		Danger
	}
	public sealed class RiskModel
	{
		private readonly DescentCalibrationData _data;

		public RiskModel(DescentCalibrationData data)
		{
			_data = data;
		}

		public RiskVerdict Query(float downGradePercent, float totalMass, float speedMetersPerSecond)
		{
			if (float.IsNaN(downGradePercent) || float.IsInfinity(downGradePercent) || downGradePercent < 0f || float.IsNaN(totalMass) || float.IsInfinity(totalMass) || totalMass <= 0f || float.IsNaN(speedMetersPerSecond) || float.IsInfinity(speedMetersPerSecond) || speedMetersPerSecond < 0f)
			{
				return new RiskVerdict(RiskLevel.Unknown, null, "invalid downgrade, mass, or speed");
			}
			DescentCalibrationRow descentCalibrationRow = null;
			DescentCalibrationRow descentCalibrationRow2 = null;
			DescentCalibrationRow descentCalibrationRow3 = null;
			foreach (DescentCalibrationRow row in _data.Rows)
			{
				bool flag = row.DownGradePercent >= downGradePercent && row.TotalMass >= totalMass && row.EntrySpeedMetersPerSecond >= speedMetersPerSecond;
				bool flag2 = row.DownGradePercent <= downGradePercent && row.TotalMass <= totalMass && row.EntrySpeedMetersPerSecond <= speedMetersPerSecond;
				switch (row.Outcome)
				{
				case DescentOutcome.Held:
					if (flag)
					{
						descentCalibrationRow = Stronger(descentCalibrationRow, row);
					}
					continue;
				case DescentOutcome.Dragged:
					if (flag2)
					{
						descentCalibrationRow2 = Stronger(descentCalibrationRow2, row);
					}
					continue;
				case DescentOutcome.Runaway:
					if (!flag2)
					{
						continue;
					}
					break;
				case DescentOutcome.JointBreak:
					if (!flag2)
					{
						continue;
					}
					break;
				default:
					continue;
				}
				descentCalibrationRow3 = Stronger(descentCalibrationRow3, row);
			}
			if (descentCalibrationRow != null && (descentCalibrationRow3 != null || descentCalibrationRow2 != null))
			{
				return new RiskVerdict(RiskLevel.Unknown, null, "contradictory calibration rows cover this descent; re-run the protocol");
			}
			if (descentCalibrationRow3 != null)
			{
				return new RiskVerdict(RiskLevel.Danger, descentCalibrationRow3.Basis, Describe("ran away at", descentCalibrationRow3));
			}
			if (descentCalibrationRow2 != null)
			{
				return new RiskVerdict(RiskLevel.Caution, descentCalibrationRow2.Basis, Describe("was dragged at", descentCalibrationRow2));
			}
			if (descentCalibrationRow != null)
			{
				return new RiskVerdict(RiskLevel.Safe, descentCalibrationRow.Basis, Describe("stayed controlled at", descentCalibrationRow));
			}
			return new RiskVerdict(RiskLevel.Unknown, null, "outside calibrated coverage — no descent row answers this downgrade, mass, and speed");
		}

		private static DescentCalibrationRow Stronger(DescentCalibrationRow? current, DescentCalibrationRow candidate)
		{
			if (current != null && candidate.Basis <= current.Basis)
			{
				return current;
			}
			return candidate;
		}

		private static string Describe(string verb, DescentCalibrationRow row)
		{
			return "a " + row.Basis.ToString() + " row " + verb + " " + row.DownGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "% down with mass " + row.TotalMass.ToString("F0", CultureInfo.InvariantCulture) + " at " + row.EntrySpeedMetersPerSecond.ToString("F1", CultureInfo.InvariantCulture) + " m/s";
		}
	}
	public sealed class RiskVerdict
	{
		public RiskLevel Level { get; }

		public CalibrationBasis? Basis { get; }

		public string Explanation { get; }

		public RiskVerdict(RiskLevel level, CalibrationBasis? basis, string explanation)
		{
			Level = level;
			Basis = basis;
			Explanation = explanation;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Profiles
{
	public enum ConfigProfile
	{
		Minimal,
		Standard,
		EverythingObservational
	}
	public static class ConfigProfileCatalog
	{
		public static ProfileValues Resolve(ConfigProfile profile)
		{
			return profile switch
			{
				ConfigProfile.Minimal => new ProfileValues(panelWarningsEnabled: false, hudWarningHintsEnabled: false, tripsEnabled: false, brakeEnabled: false, 0), 
				ConfigProfile.EverythingObservational => new ProfileValues(panelWarningsEnabled: true, hudWarningHintsEnabled: true, tripsEnabled: true, brakeEnabled: false, 5), 
				_ => new ProfileValues(panelWarningsEnabled: true, hudWarningHintsEnabled: false, tripsEnabled: true, brakeEnabled: false, 3), 
			};
		}
	}
	public static class ProfileTransition
	{
		public static bool ShouldApply(ConfigProfile active, ConfigProfile lastApplied)
		{
			return active != lastApplied;
		}
	}
	public sealed class ProfileValues
	{
		public bool PanelWarningsEnabled { get; }

		public bool HudWarningHintsEnabled { get; }

		public bool TripsEnabled { get; }

		public bool BrakeEnabled { get; }

		public int RiskLookaheadPoints { get; }

		public ProfileValues(bool panelWarningsEnabled, bool hudWarningHintsEnabled, bool tripsEnabled, bool brakeEnabled, int riskLookaheadPoints)
		{
			PanelWarningsEnabled = panelWarningsEnabled;
			HudWarningHintsEnabled = hudWarningHintsEnabled;
			TripsEnabled = tripsEnabled;
			BrakeEnabled = brakeEnabled;
			RiskLookaheadPoints = riskLookaheadPoints;
		}

		public bool ValueEquals(ProfileValues other)
		{
			if (PanelWarningsEnabled == other.PanelWarningsEnabled && HudWarningHintsEnabled == other.HudWarningHintsEnabled && TripsEnabled == other.TripsEnabled && BrakeEnabled == other.BrakeEnabled)
			{
				return RiskLookaheadPoints == other.RiskLookaheadPoints;
			}
			return false;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Onboarding
{
	public static class OnboardingPresenter
	{
		public static OnboardingVisibility Evaluate(bool dismissedForever, bool isNearCart)
		{
			if (dismissedForever)
			{
				return OnboardingVisibility.Hidden;
			}
			if (!isNearCart)
			{
				return OnboardingVisibility.Hidden;
			}
			return OnboardingVisibility.Visible;
		}
	}
	public enum OnboardingVisibility
	{
		Hidden,
		Visible
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Net
{
	public static class NetworkInputGuard
	{
		public readonly struct Sanitized
		{
			public float Value { get; }

			public bool Adjusted { get; }

			public Sanitized(float value, bool adjusted)
			{
				Value = value;
				Adjusted = adjusted;
			}
		}

		public const float MaxMass = 10000000f;

		public const float MaxMassFactor = 10000f;

		public const float MaxSpeed = 10000f;

		public const float MaxGradePercent = 10000f;

		public static Sanitized NonNegative(float raw, float cap)
		{
			if (float.IsNaN(raw) || float.IsInfinity(raw))
			{
				return new Sanitized(0f, adjusted: true);
			}
			if (raw < 0f)
			{
				return new Sanitized(0f, adjusted: true);
			}
			if (raw > cap)
			{
				return new Sanitized(cap, adjusted: true);
			}
			return new Sanitized(raw, adjusted: false);
		}

		public static Sanitized Signed(float raw, float cap)
		{
			if (float.IsNaN(raw) || float.IsInfinity(raw))
			{
				return new Sanitized(0f, adjusted: true);
			}
			if (raw > cap)
			{
				return new Sanitized(cap, adjusted: true);
			}
			if (raw < 0f - cap)
			{
				return new Sanitized(0f - cap, adjusted: true);
			}
			return new Sanitized(raw, adjusted: false);
		}

		public static Sanitized Mass(float raw)
		{
			return NonNegative(raw, 10000000f);
		}

		public static Sanitized MassFactor(float raw)
		{
			return NonNegative(raw, 10000f);
		}

		public static Sanitized Speed(float raw)
		{
			return Signed(raw, 10000f);
		}

		public static Sanitized Grade(float raw)
		{
			return Signed(raw, 10000f);
		}

		public static string Label(string? raw, int maxLength = 32)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return string.Empty;
			}
			string text = raw.Trim();
			int num = Math.Min(text.Length, maxLength);
			char[] array = new char[num];
			for (int i = 0; i < num; i++)
			{
				char c = text[i];
				array[i] = (char.IsControl(c) ? ' ' : c);
			}
			return new string(array);
		}
	}
	public sealed class OncePerKeyGate
	{
		public const int DefaultCapacity = 512;

		private readonly HashSet<string> _seen = new HashSet<string>();

		private readonly int _capacity;

		public int Count => _seen.Count;

		public OncePerKeyGate(int capacity = 512)
		{
			_capacity = ((capacity < 1) ? 1 : capacity);
		}

		public bool ShouldLog(string key)
		{
			if (_seen.Contains(key))
			{
				return false;
			}
			if (_seen.Count >= _capacity)
			{
				return false;
			}
			_seen.Add(key);
			return true;
		}

		public void Reset()
		{
			_seen.Clear();
		}
	}
	public static class RemoteStalenessPolicy
	{
		public const double DefaultStaleAfterSeconds = 5.0;

		public static bool IsStale(double sampledAt, double now, double staleAfterSeconds = 5.0)
		{
			double num = now - sampledAt;
			if (double.IsNaN(num) || double.IsInfinity(num))
			{
				return true;
			}
			if (num <= 0.0)
			{
				return false;
			}
			return num >= staleAfterSeconds;
		}

		public static bool IsStaleForRemote(bool isLocalAuthority, double sampledAt, double now, double staleAfterSeconds = 5.0)
		{
			if (!isLocalAuthority)
			{
				return IsStale(sampledAt, now, staleAfterSeconds);
			}
			return false;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Localization
{
	public static class TeamsterStrings
	{
		public const string TemplateHeader = "# ConcernedTeamster strings v1 — key<TAB>translation (missing keys fall back to English)";

		private static readonly Dictionary<string, string> English = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["routes.pick"] = "Pick a route to profile.",
			["routes.selected"] = "Selected: {0}",
			["routes.lostSelection"] = "Selected route is no longer available in Cartographer — pick another.",
			["routes.none"] = "No routes in this world yet — draw one in Cartographer.",
			["routes.unreadable"] = "Cartographer routes are not readable right now.",
			["routes.unreadableCleared"] = "Cartographer routes are not readable right now — selection cleared.",
			["routes.unnamed"] = "(unnamed route)",
			["routes.noGeometry"] = "(no usable geometry)",
			["report.title"] = "Route report: {0}",
			["report.needProfile"] = "Select a route and let it finish profiling first.",
			["report.noProblems"] = "No problem sections: every sampled grade stays under {0}% and nothing went unsampled.",
			["report.loadUnavailableNoModel"] = "Load advice unavailable: no calibration data loaded.",
			["report.loadUnavailableNoGrade"] = "Load advice unavailable: no sampled grade data yet.",
			["ui.close"] = "Close",
			["onboarding.hint"] = "New here? Click Cart below to see your mass, grade, and warnings. (Tap this to dismiss)",
			["compat.title"] = "Compatibility",
			["compat.noneDetected"] = "No known compatibility concerns detected.",
			["compat.notYetChecked"] = "Compatibility check has not run yet.",
			["compat.line"] = "{0} {1} ({2}): {3}",
			["compat.versionUnknown"] = "unknown version",
			["compat.policyCoexist"] = "coexisting",
			["compat.policyAdapt"] = "adapted",
			["compat.policyWarn"] = "caution",
			["compat.overflow"] = "… {0} more detected — open the log for the full list",
			["compat.alteredPhysicsSituation"] = "A detected mod changes cart mass or physics.",
			["compat.alteredPhysicsAction"] = "Load advice is unavailable — see the Compat panel for details.",
			["compat.loadAdviceUnavailableLine"] = "Load advice unavailable — a detected mod changes cart mass or physics (see the Compat panel).",
			["compat.betterCartsDescription"] = "Quick attach/detach and multiplayer push convenience — but reduces cart mass by default, so Teamster's load advice is shown as unavailable while it's detected.",
			["compat.itemStacksDescription"] = "Reduces every item's weight by a default 90% and increases stack sizes — cargo weight is affected too, so Teamster's load advice is shown as unavailable while it's detected.",
			["compat.valheimPlusDescription"] = "A large, configurable overhaul. Its own optional Wagon section is off by default (cart mass then matches vanilla exactly) but can be enabled to change cart base mass and cargo-to-mass scaling — if you've turned that section on, Teamster's readings may no longer match; check your valheim_plus.cfg [Wagon] settings.",
			["support.title"] = "Support Bundle",
			["support.explainer"] = "Exports a sanitized diagnostic file (versions, config, compatibility, sidecar summaries, recent log lines) to share when reporting a problem. No world names, player names, or full file paths are included.",
			["support.readyToExport"] = "Ready to export.",
			["support.exportButton"] = "Export",
			["support.exported"] = "Exported to: {0}",
			["support.exportFailed"] = "Export failed: {0}",
			["support.unknownError"] = "unknown error",
			["support.feedbackExplainer"] = "To report a problem, open a GitHub issue and attach the bundle above. Never attach a world save file, a screenshot showing another player's name, or anything else you consider private.",
			["support.reportBugButton"] = "Report a Bug",
			["status.title"] = "Cart Status",
			["status.cartButton"] = "Cart",
			["status.tripsButton"] = "Trips",
			["status.routesButton"] = "Routes",
			["status.manifestButton"] = "Manifest",
			["status.guidanceButton"] = "Guidance",
			["status.compatButton"] = "Compat",
			["status.supportButton"] = "Support",
			["status.engageBrake"] = "Engage brake",
			["status.releaseBrake"] = "Release brake",
			["status.telemetryOff"] = "Cart telemetry is unavailable — see the log for details.",
			["status.noCart"] = "No cart nearby.",
			["status.pullingThisCart"] = "Pulling this cart",
			["status.nearbyCart"] = "Nearby cart",
			["status.totalMass"] = "Total mass: {0}",
			["status.breakdownCargoUnknown"] = "Base {0} + cargo unknown",
			["status.breakdown"] = "Base {0} + cargo {1}",
			["status.breakdownScaled"] = "Base {0} + cargo {1} × {2}",
			["status.gradeUnavailable"] = "Grade: unavailable",
			["status.grade"] = "Grade: {0}% {1}",
			["status.gradeWordClimbing"] = "climbing",
			["status.gradeWordDescending"] = "descending",
			["status.gradeWordLevel"] = "level",
			["status.surface"] = "Surface: {0}",
			["status.surfaceUntouched"] = "untouched ground",
			["status.surfaceDirt"] = "dirt path",
			["status.surfaceCultivated"] = "cultivated soil",
			["status.surfacePaved"] = "paved road",
			["status.surfaceUnknown"] = "unknown",
			["status.pulledByYou"] = "Pulled by you",
			["status.attachedOtherPuller"] = "Attached to another puller",
			["status.notAttached"] = "Not attached",
			["status.stale"] = "STALE — last update {0} s ago",
			["status.updated"] = "Updated {0} s ago",
			["manifest.title"] = "Cargo Manifest",
			["manifest.filterPlaceholder"] = "filter items…",
			["manifest.colItem"] = "Item",
			["manifest.colCount"] = "Count",
			["manifest.colUnit"] = "Unit",
			["manifest.colLine"] = "Line",
			["manifest.noContainer"] = "No cart container available.",
			["manifest.empty"] = "Cart is empty.",
			["manifest.noMatch"] = "No items match \"{0}\".",
			["manifest.totalLine"] = "Total weight: {0} · {1} items",
			["manifest.totalLineWithUnknown"] = "Total weight: {0} (+{1} unknown) · {2} items",
			["manifest.captured"] = "Captured {0} s ago",
			["manifest.capturedStale"] = "STALE — captured {0} s ago",
			["manifest.row"] = "{0}   ×{1}   unit {2}   line {3}",
			["manifest.overflow"] = "… {0} more — sort or filter to narrow",
			["manifest.unknownItem"] = "unknown item",
			["manifest.unreadableSlot"] = "unreadable-slot-{0}",
			["load.invalidQuery"] = "invalid grade or mass",
			["load.contradictory"] = "contradictory calibration rows cover this query; re-run the protocol",
			["load.outsideCoverage"] = "outside calibrated coverage — no row answers this grade and mass",
			["load.rowDescribe"] = "a {0} row {1} {2}% with mass {3}",
			["load.verbFailedAt"] = "failed at",
			["load.verbClimbedAt"] = "climbed at",
			["load.verbMarginalAt"] = "was marginal at",
			["load.basisPrior"] = "Prior",
			["load.basisDerivedConstant"] = "DerivedConstant",
			["load.basisMeasured"] = "Measured",
			["warn.cueDanger"] = "[!!] DANGER",
			["warn.cueCaution"] = "[!] CAUTION",
			["warn.line"] = "{0} — {1} {2}",
			["warn.impossibleSituation"] = "This load cannot climb this grade ({0}, mass {1}; {2}).",
			["warn.impossibleAction"] = "Lighten the load or find a shallower path.",
			["warn.marginalSituation"] = "This climb is marginal ({0}, mass {1}; {2}).",
			["warn.marginalAction"] = "Expect stalls — consider dropping some cargo.",
			["warn.steepSituation"] = "Steep climb ahead ({0}) with cart mass {1}.",
			["warn.steepAction"] = "Check your load before committing; calibration has no verdict here.",
			["diag.line"] = "[?] STUCK — {0}: {1} {2}",
			["diag.labelImpossibleLoad"] = "overloaded for this grade",
			["diag.labelMarginalLoad"] = "load is marginal here",
			["diag.labelSteepClimb"] = "steep climb",
			["diag.labelObstruction"] = "obstruction or grounded chassis",
			["diag.labelUnclear"] = "cause unclear",
			["diag.labelLoadAdviceUnavailable"] = "load advice unavailable",
			["diag.noTerrainEvidence"] = "pulling with no movement and no terrain data.",
			["diag.noTerrainAction"] = "Look for obstacles around the wheels.",
			["diag.descentEvidence"] = "not moving on a {0} descent — stalls there are unusual.",
			["diag.descentAction"] = "Check for obstacles or a grounded chassis.",
			["diag.mildGradeEvidence"] = "near-level ground ({0}) does not explain a stall.",
			["diag.mildGradeAction"] = "Look for rocks, stumps, or a terrain lip at the wheels; back up and re-approach.",
			["diag.verdictEvidence"] = "{0}.",
			["diag.impossibleAction"] = "Lighten the load or find a shallower path.",
			["diag.marginalAction"] = "Drop some cargo and try again.",
			["diag.provenYetStuckEvidence"] = "this load is proven to climb {0} ({1}), yet the cart is not moving.",
			["diag.provenYetStuckAction"] = "Something blocks the cart — check the wheels and the ground line.",
			["diag.steepClimbEvidence"] = "a {0} climb with no calibration verdict.",
			["diag.steepClimbAction"] = "Try a shallower route, or lighten the load and retry.",
			["diag.unclearClimbEvidence"] = "a {0} climb; calibration has no verdict and the grade alone is not conclusive.",
			["diag.unclearClimbAction"] = "Check for obstacles first, then try with less cargo.",
			["diag.loadAdviceUnavailableEvidence"] = "a {0} climb, but a detected mod changes cart mass or physics — the load model's verdict cannot be trusted right now.",
			["coop.helpingCount"] = "{0} helping",
			["coop.hinderingCount"] = "{0} hindering",
			["coop.unclearCount"] = "{0} unclear",
			["coop.nameList"] = "({0})",
			["coop.you"] = "you",
			["coop.teammate"] = "a teammate",
			["coop.crewLine"] = "Crew: {0}.",
			["coop.evenWithHelp"] = "Even with help, {0}",
			["coop.nobodyHelping"] = "Nobody is helping the cart along.",
			["recovery.title"] = "Recovery Guidance",
			["recovery.noDiagnosis"] = "No active diagnosis — guidance appears here when your cart is stuck.",
			["recovery.crewNow"] = "Crew right now: {0}.",
			["recovery.extraHands"] = "Extra hands will not beat this — the fix is less weight or a shallower line, not more pushing.",
			["recovery.titleOverloaded"] = "Overloaded for this grade — the load must come down",
			["recovery.titleMarginal"] = "Marginal load — a lighter cart makes this climb",
			["recovery.titleSteep"] = "Steep, uncalibrated climb",
			["recovery.titleObstruction"] = "Something is physically blocking the cart",
			["recovery.titleUnclear"] = "Cause unclear — safe general steps",
			["recovery.titleLoadAdviceUnavailable"] = "Load advice unavailable under altered physics",
			["recovery.stepBrakeHold"] = "Detach, then hold the cart with the parking brake while you work.",
			["recovery.stepRetryClimb"] = "Retry the climb straight uphill at a steady pace.",
			["recovery.stepRouteAround"] = "If it still stalls, route around: a longer, shallower path beats a stuck cart.",
			["recovery.stepBackDown"] = "Back the cart down to level ground first.",
			["recovery.stepBrakeScout"] = "Use the parking brake to hold it while you scout.",
			["recovery.stepShallowerLine"] = "Look for a shallower line — even a few degrees less grade helps more than pushing harder.",
			["recovery.stepSwitchback"] = "Cut the slope diagonally (switchback) instead of attacking it straight on.",
			["recovery.stepSecondTrip"] = "Unloading part of the cargo for a second trip is slower but certain.",
			["recovery.stepCheckWheels"] = "Walk around the cart and check each wheel for rocks, stumps, or a terrain lip.",
			["recovery.stepBackUpAngle"] = "Back up two or three meters and approach again at a slight angle.",
			["recovery.stepHoe"] = "A hoe can level the offending lip — the vanilla tool is the intended fix.",
			["recovery.stepWheelHole"] = "If a wheel dropped into a hole, pull backward out of it rather than forward through it.",
			["recovery.stepReattach"] = "Detach and re-attach the cart to reset the pull joint.",
			["recovery.stepDifferentLine"] = "Back up a few meters and try a slightly different line.",
			["recovery.stepCheckCaught"] = "Check the wheels and the ground line for anything the cart could be caught on.",
			["recovery.stepBrakeInvestigate"] = "On a slope, hold the cart with the parking brake while you investigate.",
			["recovery.stepUnloadSome"] = "If nothing helps, unload some cargo — a lighter cart forgives more.",
			["recovery.unloadNothingProven"] = "No load is proven to climb this grade yet — unload as much as you can carry, or pick a shallower path.",
			["recovery.unloadAtLeast"] = "Unload at least {0} weight (down to total mass {1}, the heaviest load a {2} row proved at this grade).",
			["recovery.unloadAlreadyUnder"] = "Your mass ({0}) is already at or under the proven {1} for this grade — the load is probably not the blocker; check for obstructions.",
			["unit.meters"] = "{0} m",
			["unit.metersPerSecond"] = "{0} m/s",
			["verdict.ok"] = "OK",
			["verdict.marginal"] = "MARGINAL",
			["verdict.tooHeavy"] = "TOO HEAVY",
			["verdict.unknown"] = "UNKNOWN",
			["trips.title"] = "Trip History",
			["trips.empty"] = "No trips recorded in this world yet — pull a cart!",
			["trips.markerA"] = "[A]",
			["trips.markerB"] = "[B]",
			["trips.row"] = "#{0}  {1}  {2} m  mass {3}  worst {4}  avg {5}",
			["trips.colDate"] = "Date",
			["trips.colTime"] = "Time",
			["trips.colDist"] = "Dist",
			["trips.colLoad"] = "Load",
			["trips.colGrade"] = "Grade",
			["trips.selectA"] = "A",
			["trips.selectB"] = "B",
			["trips.deleteButton"] = "X",
			["trips.deleteConfirm"] = "Sure?",
			["trips.overflow"] = "… {0} more — sort to bring them up",
			["trips.massPlaceholder"] = "test mass…",
			["compare.selectTwo"] = "Select two trips ([A] and [B]) to compare their profiles.",
			["compare.selectSecondVsA"] = "Select a second trip to compare against [A].",
			["compare.selectSecondVsB"] = "Select a second trip to compare against [B].",
			["compare.headerA"] = "A #{0}: {1}",
			["compare.headerB"] = "B #{0}: {1}",
			["compare.summary"] = "{0} m, mass {1}, worst {2}",
			["compare.bucketLine"] = "{0}–{1}%:  A {2} @ {3}   |   B {4} @ {5}",
			["bottleneck.selectTripA"] = "Select trip [A] to analyze its bottlenecks.",
			["bottleneck.enterMass"] = "Enter a cargo total mass to test (for example 220).",
			["bottleneck.badMass"] = "\"{0}\" is not a usable mass — enter a positive number.",
			["bottleneck.header"] = "Bottlenecks for trip #{0} at mass {1}:",
			["bottleneck.noGradeData"] = "Grade: no grade data on this trip.",
			["bottleneck.gradeConstraint"] = "Grade constraint: steepest point is {0}% at {1}.",
			["bottleneck.noScoredSegments"] = "Quality: no scored segments yet for this world.",
			["bottleneck.noRoughness"] = "Quality: crossed segments have no roughness scores yet.",
			["bottleneck.qualityConstraint"] = "Quality constraint: roughest crossed segment (jitter {0}%) enters at {1} (cell {2},{3}).",
			["bottleneck.noCalibration"] = "Load: no calibration data — cannot test a load against this route.",
			["bottleneck.neverClimbs"] = "Load: this route never climbs — mass {0} is not grade-limited here.",
			["bottleneck.binds"] = "Load constraint BINDS: mass {0} is proven to fail at {1} ({2}). Lighten below the proven limit or reroute.",
			["bottleneck.marginal"] = "Load constraint is marginal at {0} ({1}).",
			["bottleneck.uncalibratedPoints"] = "Load: no proven blocker, but {0} of {1} climb points are uncalibrated — run the protocol to firm this up.",
			["bottleneck.allProven"] = "Load: every climb point is proven passable at mass {0}.",
			["bottleneck.locate"] = "{0} ({1}% of the route)",
			["profile.profiling"] = "Profiling route… {0}/{1} samples",
			["profile.summary"] = "Route {0}: sampled {1}",
			["profile.summaryUnsampled"] = "Route {0}: sampled {1}, UNSAMPLED {2} (unloaded terrain)",
			["profile.surfacesNoneSampled"] = "Surfaces: none sampled",
			["profile.surfaces"] = "Surfaces: {0}",
			["profile.surfacesNoneClassified"] = "none classified",
			["profile.surfacePaved"] = "paved",
			["profile.surfaceDirt"] = "dirt",
			["profile.surfaceCultivated"] = "cultivated",
			["profile.surfaceUntouched"] = "untouched",
			["profile.surfaceUnknown"] = "unknown",
			["profile.gradesNoData"] = "Grades: no sampled grade data",
			["profile.worstClimb"] = "Worst climb {0}% at {1} from start",
			["profile.worstDescent"] = "Worst descent {0}% at {1} from start",
			["profile.gradeMix"] = "Grade mix: {0}",
			["profile.loadNoModel"] = "Load check: no load model available",
			["profile.loadNoGrade"] = "Load check: no grade data yet",
			["profile.loadNoProven"] = "no proven load at {0}",
			["profile.loadProven"] = "proven {0} mass at {1} ({2})",
			["profile.loadCheck"] = "Load check: {0}",
			["profile.loadCheckWithVerdict"] = "Load check: {0} · your cart ({1}): {2}",
			["report.summary"] = "Distance {0} — sampled {1}",
			["report.summaryUnsampled"] = "Distance {0} — sampled {1}, UNSAMPLED {2}",
			["report.gradeMixNoData"] = "Grades: no sampled grade data.",
			["report.gradeMixSteep"] = "Steepest sampled grade {0}; {1} of the route is 15% or steeper.",
			["report.gradeMixNoSteep"] = "Steepest sampled grade {0}; no sampled stretch reaches 15%.",
			["report.steepClimbSection"] = "{0}. Steep climb {1}% at {2}, {3} long",
			["report.steepDescentSection"] = "{0}. Steep descent {1}% at {2}, {3} long",
			["report.gapSection"] = "{0}. Unprofiled {1} starting at {2} — nothing was measured there",
			["report.adviceVerdictHere"] = "Here: your cart is {0} — {1}.",
			["report.adviceVerdictReturn"] = "As the return climb: your cart is {0} — {1}.",
			["report.adviceProvenHere"] = "Here: keep total mass at or under {0} ({1} calibration).",
			["report.adviceProvenReturn"] = "As the return climb: keep total mass at or under {0} ({1} calibration).",
			["report.bottleneckNoProven"] = "Bottleneck {0}: no proven safe load — outside calibrated coverage.",
			["report.bottleneckKeepUnder"] = "Bottleneck {0}: keep total mass at or under {1} ({2} calibration).",
			["report.yourCart"] = "Your cart ({0} mass): {1} — {2}.",
			["routes.title"] = "Cartographer Routes",
			["routes.clearButton"] = "Clear",
			["routes.reportButton"] = "Report",
			["routes.selectedMarker"] = "[SEL]",
			["routes.rowGeometry"] = "{0} m  ({1} pts)",
			["routes.overflow"] = "… +{0} more (rename in Cartographer to sort forward)",
			["nav.trips"] = "Trips",
			["nav.routes"] = "Routes",
			["nav.brake"] = "Engage/Release brake",
			["nav.manifest"] = "Manifest",
			["nav.guidance"] = "Guidance",
			["nav.compat"] = "Compatibility",
			["nav.support"] = "Support Bundle",
			["nav.close"] = "Close",
			["nav.sortColumn"] = "Sort column",
			["nav.filter"] = "Filter",
			["nav.hypotheticalMass"] = "Hypothetical mass",
			["nav.selectA"] = "Select A",
			["nav.selectB"] = "Select B",
			["nav.delete"] = "Delete",
			["nav.export"] = "Export bundle",
			["nav.routeList"] = "Route list",
			["nav.clear"] = "Clear",
			["nav.report"] = "Report",
			["nav.reportBug"] = "Report a Bug"
		};

		private static Dictionary<string, string> _overrides = new Dictionary<string, string>(StringComparer.Ordinal);

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

		private static readonly Regex PlaceholderPattern = new Regex("\\{(\\d+)\\}", RegexOptions.Compiled);

		public static IReadOnlyDictionary<string, string> Defaults => English;

		public static Action<string>? MissingKeyReporter { get; set; }

		public static bool HasKey(string key)
		{
			return English.ContainsKey(key);
		}

		public static void LoadOverrides(Dictionary<string, string> overrides)
		{
			_overrides = overrides ?? new Dictionary<string, string>(StringComparer.Ordinal);
		}

		public static string Get(string key, out bool known)
		{
			known = English.ContainsKey(key);
			if (!known)
			{
				Action<string> missingKeyReporter = MissingKeyReporter;
				if (missingKeyReporter != null && ShouldReportMissing(key))
				{
					try
					{
						missingKeyReporter(key);
					}
					catch
					{
					}
				}
			}
			if (_overrides.TryGetValue(key, out string value) && !string.IsNullOrEmpty(value))
			{
				return value;
			}
			if (!known)
			{
				return key;
			}
			return English[key];
		}

		public static string Get(string key)
		{
			bool known;
			return Get(key, out known);
		}

		public static string Format(string key, params object[] arguments)
		{
			bool known;
			string format = Get(key, out known);
			try
			{
				return string.Format(CultureInfo.InvariantCulture, format, arguments);
			}
			catch (FormatException)
			{
				string value;
				return English.TryGetValue(key, out value) ? string.Format(CultureInfo.InvariantCulture, value, arguments) : key;
			}
		}

		public static bool ShouldReportMissing(string key)
		{
			return _missingReported.Add(key);
		}

		public static SortedSet<int> PlaceholderIndices(string value)
		{
			SortedSet<int> sortedSet = new SortedSet<int>();
			foreach (Match item in PlaceholderPattern.Matches(value ?? string.Empty))
			{
				if (int.TryParse(item.Groups[1].Value, out var result))
				{
					sortedSet.Add(result);
				}
			}
			return sortedSet;
		}

		public static IEnumerable<string> TranslatorTemplate()
		{
			yield return "# ConcernedTeamster strings v1 — key<TAB>translation (missing keys fall back to English)";
			foreach (KeyValuePair<string, string> item in English)
			{
				yield return item.Key + "\t" + Escape(item.Value);
			}
		}

		public static Dictionary<string, string> ParseOverrides(IEnumerable<string> lines, out int skippedRows)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			skippedRows = 0;
			foreach (string item in lines ?? Array.Empty<string>())
			{
				string text = item.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				int num = text.IndexOf('\t');
				if (num <= 0 || num == text.Length - 1)
				{
					skippedRows++;
					continue;
				}
				string key = text.Substring(0, num);
				if (!English.TryGetValue(key, out string value))
				{
					skippedRows++;
					continue;
				}
				string value2 = Unescape(text.Substring(num + 1));
				if (!PlaceholderIndices(value2).SetEquals(PlaceholderIndices(value)))
				{
					skippedRows++;
				}
				else
				{
					dictionary[key] = value2;
				}
			}
			return dictionary;
		}

		private static string Escape(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				switch (c)
				{
				case '%':
					stringBuilder.Append("%25");
					break;
				case '\t':
					stringBuilder.Append("%09");
					break;
				case '\n':
					stringBuilder.Append("%0A");
					break;
				case '\r':
					stringBuilder.Append("%0D");
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			return stringBuilder.ToString();
		}

		private static string Unescape(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			for (int i = 0; i < value.Length; i++)
			{
				if (value[i] == '%' && i + 2 < value.Length)
				{
					char? c = value.Substring(i, 3) switch
					{
						"%25" => '%', 
						"%09" => '\t', 
						"%0A" => '\n', 
						"%0D" => '\r', 
						_ => null, 
					};
					if (c.HasValue)
					{
						char valueOrDefault = c.GetValueOrDefault();
						stringBuilder.Append(valueOrDefault);
						i += 2;
						continue;
					}
				}
				stringBuilder.Append(value[i]);
			}
			return stringBuilder.ToString();
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Load
{
	public enum CalibrationBasis
	{
		Prior,
		DerivedConstant,
		Measured
	}
	public enum CalibrationOutcome
	{
		Climbs,
		Marginal,
		Stalls,
		JointBreak
	}
	public sealed class CalibrationRow
	{
		public float GradePercent { get; }

		public float TotalMass { get; }

		public CalibrationOutcome Outcome { get; }

		public CalibrationBasis Basis { get; }

		public string Note { get; }

		public CalibrationRow(float gradePercent, float totalMass, CalibrationOutcome outcome, CalibrationBasis basis, string note)
		{
			GradePercent = gradePercent;
			TotalMass = totalMass;
			Outcome = outcome;
			Basis = basis;
			Note = note;
		}
	}
	public enum Climbability
	{
		No,
		Unknown,
		Marginal,
		Yes
	}
	public sealed class LoadCalibrationData
	{
		public int DataVersion { get; }

		public string GameVersion { get; }

		public string Protocol { get; }

		public string Generated { get; }

		public IReadOnlyList<CalibrationRow> Rows { get; }

		public IReadOnlyList<string> Errors { get; }

		public int MeasuredRowCount
		{
			get
			{
				int num = 0;
				foreach (CalibrationRow row in Rows)
				{
					if (row.Basis == CalibrationBasis.Measured)
					{
						num++;
					}
				}
				return num;
			}
		}

		private LoadCalibrationData(int dataVersion, string gameVersion, string protocol, string generated, IReadOnlyList<CalibrationRow> rows, IReadOnlyList<string> errors)
		{
			DataVersion = dataVersion;
			GameVersion = gameVersion;
			Protocol = protocol;
			Generated = generated;
			Rows = rows;
			Errors = errors;
		}

		public static LoadCalibrationData Parse(string? text)
		{
			List<CalibrationRow> list = new List<CalibrationRow>();
			List<string> list2 = new List<string>();
			int result = 0;
			string gameVersion = string.Empty;
			string protocol = string.Empty;
			string generated = string.Empty;
			if (text == null)
			{
				list2.Add("calibration text is null");
				return new LoadCalibrationData(0, gameVersion, protocol, generated, list, list2);
			}
			string[] array = text.Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].TrimEnd(new char[1] { '\r' }).Trim();
				if (text2.Length == 0 || text2.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (text2.StartsWith("row:", StringComparison.Ordinal))
				{
					CalibrationRow calibrationRow = ParseRow(text2.Substring(4), i + 1, list2);
					if (calibrationRow != null)
					{
						list.Add(calibrationRow);
					}
					continue;
				}
				int num = text2.IndexOf(':');
				if (num <= 0)
				{
					list2.Add($"line {i + 1}: not a header or row");
					continue;
				}
				string text3 = text2.Substring(0, num).Trim();
				string text4 = text2.Substring(num + 1).Trim();
				switch (text3)
				{
				case "data-version":
					if (!int.TryParse(text4, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
					{
						list2.Add($"line {i + 1}: bad data-version");
					}
					break;
				case "game-version":
					gameVersion = text4;
					break;
				case "protocol":
					protocol = text4;
					break;
				case "generated":
					generated = text4;
					break;
				}
			}
			if (result <= 0)
			{
				list2.Add("missing or invalid data-version header");
			}
			return new LoadCalibrationData(result, gameVersion, protocol, generated, list, list2);
		}

		private static CalibrationRow? ParseRow(string body, int lineNumber, List<string> errors)
		{
			string[] array = body.Split(new char[1] { '|' });
			if (array.Length < 4)
			{
				errors.Add($"line {lineNumber}: row needs grade | mass | outcome | basis");
				return null;
			}
			if (!float.TryParse(array[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || float.IsNaN(result) || float.IsInfinity(result))
			{
				errors.Add($"line {lineNumber}: bad grade");
				return null;
			}
			if (!float.TryParse(array[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || float.IsNaN(result2) || float.IsInfinity(result2) || result2 <= 0f)
			{
				errors.Add($"line {lineNumber}: bad mass");
				return null;
			}
			if (!Enum.TryParse<CalibrationOutcome>(array[2].Trim(), ignoreCase: false, out var result3))
			{
				errors.Add($"line {lineNumber}: unknown outcome '{array[2].Trim()}'");
				return null;
			}
			if (!Enum.TryParse<CalibrationBasis>(array[3].Trim(), ignoreCase: false, out var result4))
			{
				errors.Add($"line {lineNumber}: unknown basis '{array[3].Trim()}'");
				return null;
			}
			string note = ((array.Length > 4) ? array[4].Trim() : string.Empty);
			return new CalibrationRow(result, result2, result3, result4, note);
		}
	}
	public static class LoadCalibrationSource
	{
		public const string ResourceName = "CT.Data.CartLoadCalibration";

		public static LoadCalibrationData? TryLoadEmbedded()
		{
			try
			{
				using Stream stream = typeof(LoadCalibrationSource).Assembly.GetManifestResourceStream("CT.Data.CartLoadCalibration");
				if (stream == null)
				{
					return null;
				}
				using StreamReader streamReader = new StreamReader(stream);
				return LoadCalibrationData.Parse(streamReader.ReadToEnd());
			}
			catch
			{
				return null;
			}
		}
	}
	public sealed class LoadModel
	{
		private readonly LoadCalibrationData _data;

		public LoadModel(LoadCalibrationData data)
		{
			_data = data;
		}

		public LoadVerdict Query(float gradePercent, float totalMass)
		{
			if (float.IsNaN(gradePercent) || float.IsInfinity(gradePercent) || float.IsNaN(totalMass) || float.IsInfinity(totalMass) || totalMass <= 0f)
			{
				return new LoadVerdict(Climbability.Unknown, null, TeamsterStrings.Get("load.invalidQuery"));
			}
			CalibrationRow calibrationRow = null;
			CalibrationRow calibrationRow2 = null;
			CalibrationRow calibrationRow3 = null;
			foreach (CalibrationRow row in _data.Rows)
			{
				bool flag = row.GradePercent >= gradePercent && row.TotalMass >= totalMass;
				bool flag2 = row.GradePercent <= gradePercent && row.TotalMass <= totalMass;
				switch (row.Outcome)
				{
				case CalibrationOutcome.Climbs:
					if (flag)
					{
						calibrationRow = Stronger(calibrationRow, row);
					}
					continue;
				case CalibrationOutcome.Marginal:
					if (flag)
					{
						calibrationRow2 = Stronger(calibrationRow2, row);
					}
					continue;
				case CalibrationOutcome.Stalls:
					if (!flag2)
					{
						continue;
					}
					break;
				case CalibrationOutcome.JointBreak:
					if (!flag2)
					{
						continue;
					}
					break;
				default:
					continue;
				}
				calibrationRow3 = Stronger(calibrationRow3, row);
			}
			if (calibrationRow != null && calibrationRow3 != null)
			{
				return new LoadVerdict(Climbability.Unknown, null, TeamsterStrings.Get("load.contradictory"));
			}
			if (calibrationRow3 != null)
			{
				return new LoadVerdict(Climbability.No, calibrationRow3.Basis, Describe("load.verbFailedAt", calibrationRow3));
			}
			if (calibrationRow != null)
			{
				return new LoadVerdict(Climbability.Yes, calibrationRow.Basis, Describe("load.verbClimbedAt", calibrationRow));
			}
			if (calibrationRow2 != null)
			{
				return new LoadVerdict(Climbability.Marginal, calibrationRow2.Basis, Describe("load.verbMarginalAt", calibrationRow2));
			}
			return new LoadVerdict(Climbability.Unknown, null, TeamsterStrings.Get("load.outsideCoverage"));
		}

		public LoadRecommendation? RecommendedMaxMass(float gradePercent)
		{
			if (float.IsNaN(gradePercent) || float.IsInfinity(gradePercent))
			{
				return null;
			}
			CalibrationRow calibrationRow = null;
			foreach (CalibrationRow row in _data.Rows)
			{
				if (row.Outcome == CalibrationOutcome.Climbs && !(row.GradePercent < gradePercent) && (calibrationRow == null || row.TotalMass > calibrationRow.TotalMass || (row.TotalMass == calibrationRow.TotalMass && row.Basis > calibrationRow.Basis)))
				{
					calibrationRow = row;
				}
			}
			if (calibrationRow != null)
			{
				return new LoadRecommendation(calibrationRow.TotalMass, calibrationRow.Basis);
			}
			return null;
		}

		private static CalibrationRow Stronger(CalibrationRow? current, CalibrationRow candidate)
		{
			if (current != null && candidate.Basis <= current.Basis)
			{
				return current;
			}
			return candidate;
		}

		private static string Describe(string verbKey, CalibrationRow row)
		{
			return TeamsterStrings.Format("load.rowDescribe", LoadText.BasisWord(row.Basis), TeamsterStrings.Get(verbKey), row.GradePercent.ToString("F0", CultureInfo.InvariantCulture), row.TotalMass.ToString("F0", CultureInfo.InvariantCulture));
		}
	}
	public sealed class LoadRecommendation
	{
		public float TotalMass { get; }

		public CalibrationBasis Basis { get; }

		public LoadRecommendation(float totalMass, CalibrationBasis basis)
		{
			TotalMass = totalMass;
			Basis = basis;
		}
	}
	public static class LoadText
	{
		public static string BasisWord(CalibrationBasis basis)
		{
			return TeamsterStrings.Get(basis switch
			{
				CalibrationBasis.Measured => "load.basisMeasured", 
				CalibrationBasis.DerivedConstant => "load.basisDerivedConstant", 
				_ => "load.basisPrior", 
			});
		}
	}
	public sealed class LoadVerdict
	{
		public Climbability Climbability { get; }

		public CalibrationBasis? Basis { get; }

		public string Explanation { get; }

		public LoadVerdict(Climbability climbability, CalibrationBasis? basis, string explanation)
		{
			Climbability = climbability;
			Basis = basis;
			Explanation = explanation;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Input
{
	public readonly struct AcceleratorBinding
	{
		public string ActionId { get; }

		public string Chord { get; }

		public bool IsBound => Chord.Length > 0;

		public AcceleratorBinding(string actionId, string chord)
		{
			ActionId = actionId ?? string.Empty;
			Chord = Normalize(chord);
		}

		public static string Normalize(string? chord)
		{
			if (string.IsNullOrWhiteSpace(chord))
			{
				return string.Empty;
			}
			string[] array = chord.Split(new char[1] { '+' });
			List<string> list = new List<string>(array.Length);
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string text = array2[i].Trim().ToLowerInvariant();
				if (text.Length > 0 && !list.Contains(text))
				{
					list.Add(text);
				}
			}
			list.Sort(StringComparer.Ordinal);
			return string.Join("+", list);
		}
	}
	public static class BindingConflictChecker
	{
		public sealed class ExternalConflict
		{
			public string ActionId { get; }

			public string Chord { get; }

			public string ReservedLabel { get; }

			public ExternalConflict(string actionId, string chord, string reservedLabel)
			{
				ActionId = actionId;
				Chord = chord;
				ReservedLabel = reservedLabel;
			}
		}

		public sealed class InternalConflict
		{
			public string Chord { get; }

			public IReadOnlyList<string> ActionIds { get; }

			public InternalConflict(string chord, IReadOnlyList<string> actionIds)
			{
				Chord = chord;
				ActionIds = actionIds;
			}
		}

		public static IReadOnlyDictionary<string, string> BuildReserved(IEnumerable<KeyValuePair<string, string>> chordLabelPairs)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (KeyValuePair<string, string> chordLabelPair in chordLabelPairs)
			{
				string text = AcceleratorBinding.Normalize(chordLabelPair.Key);
				if (text.Length > 0 && !dictionary.ContainsKey(text))
				{
					dictionary[text] = chordLabelPair.Value;
				}
			}
			return dictionary;
		}

		public static IReadOnlyList<ExternalConflict> FindExternalConflicts(IEnumerable<AcceleratorBinding> bindings, IReadOnlyDictionary<string, string> reserved)
		{
			List<ExternalConflict> list = new List<ExternalConflict>();
			foreach (AcceleratorBinding binding in bindings)
			{
				if (binding.IsBound && reserved.TryGetValue(binding.Chord, out string value))
				{
					list.Add(new ExternalConflict(binding.ActionId, binding.Chord, value));
				}
			}
			return list;
		}

		public static IReadOnlyList<InternalConflict> FindInternalConflicts(IEnumerable<AcceleratorBinding> bindings)
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>();
			List<string> list = new List<string>();
			foreach (AcceleratorBinding binding in bindings)
			{
				if (binding.IsBound)
				{
					if (!dictionary.TryGetValue(binding.Chord, out var value))
					{
						value = new List<string>();
						dictionary[binding.Chord] = value;
						list.Add(binding.Chord);
					}
					value.Add(binding.ActionId);
				}
			}
			List<InternalConflict> list2 = new List<InternalConflict>();
			foreach (string item in list)
			{
				if (dictionary[item].Count > 1)
				{
					list2.Add(new InternalConflict(item, dictionary[item]));
				}
			}
			return list2;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Diagnostics
{
	public enum CartDiagnosis
	{
		None,
		ImpossibleLoad,
		MarginalLoad,
		SteepClimb,
		Obstruction,
		Unclear,
		LoadAdviceUnavailable
	}
	public sealed class CartDiagnostic
	{
		public static readonly CartDiagnostic None = new CartDiagnostic(CartDiagnosis.None, string.Empty, string.Empty);

		public CartDiagnosis Diagnosis { get; }

		public string Evidence { get; }

		public string Action { get; }

		public CartDiagnostic(CartDiagnosis diagnosis, string evidence, string action)
		{
			Diagnosis = diagnosis;
			Evidence = evidence;
			Action = action;
		}

		public string ComposeLine()
		{
			if (Diagnosis == CartDiagnosis.None)
			{
				return string.Empty;
			}
			string text = TeamsterStrings.Get(Diagnosis switch
			{
				CartDiagnosis.ImpossibleLoad => "diag.labelImpossibleLoad", 
				CartDiagnosis.MarginalLoad => "diag.labelMarginalLoad", 
				CartDiagnosis.SteepClimb => "diag.labelSteepClimb", 
				CartDiagnosis.Obstruction => "diag.labelObstruction", 
				CartDiagnosis.LoadAdviceUnavailable => "diag.labelLoadAdviceUnavailable", 
				_ => "diag.labelUnclear", 
			});
			return TeamsterStrings.Format("diag.line", text, Evidence, Action);
		}
	}
	public enum CoopEffort
	{
		Idle,
		Helping,
		Hindering,
		Unclear
	}
	public static class CooperativeEffortClassifier
	{
		public readonly struct EffortTally
		{
			public int Helping { get; }

			public int Hindering { get; }

			public int Idle { get; }

			public int Unclear { get; }

			public int Contributors => Helping + Hindering;

			public EffortTally(int helping, int hindering, int idle, int unclear)
			{
				Helping = helping;
				Hindering = hindering;
				Idle = idle;
				Unclear = unclear;
			}
		}

		public const float MeaningfulAlignment = 0.15f;

		public static CoopEffort Classify(in CoopParticipant participant)
		{
			if (participant.IsAttached)
			{
				return CoopEffort.Helping;
			}
			if (!participant.InContact)
			{
				return CoopEffort.Idle;
			}
			float motionAlignment = participant.MotionAlignment;
			if (float.IsNaN(motionAlignment))
			{
				return CoopEffort.Unclear;
			}
			if (motionAlignment > 0.15f)
			{
				return CoopEffort.Helping;
			}
			if (motionAlignment < -0.15f)
			{
				return CoopEffort.Hindering;
			}
			return CoopEffort.Idle;
		}

		public static EffortTally Tally(IReadOnlyList<CoopParticipant> participants)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			for (int i = 0; i < participants.Count; i++)
			{
				switch (Classify(participants[i]))
				{
				case CoopEffort.Helping:
					num++;
					break;
				case CoopEffort.Hindering:
					num2++;
					break;
				case CoopEffort.Unclear:
					num4++;
					break;
				default:
					num3++;
					break;
				}
			}
			return new EffortTally(num, num2, num3, num4);
		}

		public static string Summarize(IReadOnlyList<CoopParticipant> participants)
		{
			EffortTally effortTally = Tally(participants);
			if (effortTally.Contributors == 0 && effortTally.Unclear == 0)
			{
				return string.Empty;
			}
			List<string> list = new List<string>(3);
			if (effortTally.Helping > 0)
			{
				list.Add(TeamsterStrings.Format("coop.helpingCount", effortTally.Helping.ToString(CultureInfo.InvariantCulture)) + NameList(participants, CoopEffort.Helping));
			}
			if (effortTally.Hindering > 0)
			{
				list.Add(TeamsterStrings.Format("coop.hinderingCount", effortTally.Hindering.ToString(CultureInfo.InvariantCulture)) + NameList(participants, CoopEffort.Hindering));
			}
			if (effortTally.Unclear > 0)
			{
				list.Add(TeamsterStrings.Format("coop.unclearCount", effortTally.Unclear.ToString(CultureInfo.InvariantCulture)));
			}
			return string.Join(", ", list);
		}

		public static string ExplainStuck(IReadOnlyList<CoopParticipant> participants, CartDiagnostic diagnosis)
		{
			string text = Summarize(participants);
			string text2 = diagnosis.ComposeLine();
			if (text.Length == 0)
			{
				return text2;
			}
			EffortTally effortTally = Tally(participants);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(TeamsterStrings.Format("coop.crewLine", text));
			if (text2.Length > 0)
			{
				stringBuilder.Append(' ');
				if (effortTally.Helping > 1 && (diagnosis.Diagnosis == CartDiagnosis.ImpossibleLoad || diagnosis.Diagnosis == CartDiagnosis.SteepClimb))
				{
					stringBuilder.Append(TeamsterStrings.Format("coop.evenWithHelp", text2));
				}
				else
				{
					stringBuilder.Append(text2);
				}
			}
			else if (effortTally.Hindering > 0 && effortTally.Helping == 0)
			{
				stringBuilder.Append(' ').Append(TeamsterStrings.Get("coop.nobodyHelping"));
			}
			return stringBuilder.ToString();
		}

		private static string NameList(IReadOnlyList<CoopParticipant> participants, CoopEffort effort)
		{
			List<string> list = new List<string>(2);
			for (int i = 0; i < participants.Count; i++)
			{
				if (list.Count >= 2)
				{
					break;
				}
				CoopParticipant participant = participants[i];
				if (Classify(in participant) == effort)
				{
					string text = NetworkInputGuard.Label(participant.DisplayName);
					list.Add((text.Length > 0) ? text : TeamsterStrings.Get(participant.IsLocalPlayer ? "coop.you" : "coop.teammate"));
				}
			}
			if (list.Count <= 0)
			{
				return string.Empty;
			}
			return " " + TeamsterStrings.Format("coop.nameList", string.Join(", ", list));
		}
	}
	public readonly struct CoopParticipant
	{
		public string DisplayName { get; }

		public bool IsLocalPlayer { get; }

		public bool IsAttached { get; }

		public bool InContact { get; }

		public float MotionAlignment { get; }

		public CoopParticipant(string displayName, bool isLocalPlayer, bool isAttached, bool inContact, float motionAlignment)
		{
			DisplayName = displayName ?? string.Empty;
			IsLocalPlayer = isLocalPlayer;
			IsAttached = isAttached;
			InContact = inContact;
			MotionAlignment = motionAlignment;
		}
	}
	public sealed class StuckDetector
	{
		public const float StuckSpeedThresholdMetersPerSecond = 0.3f;

		public const double StuckAfterSeconds = 2.5;

		public const float ObstructionMaxGradePercent = 8f;

		public const float SteepClimbMinPercent = 15f;

		private readonly LoadModel? _loadModel;

		private string? _watchedCartId;

		private double _lowSpeedSinceSeconds = double.NaN;

		public StuckDetector(LoadModel? loadModel)
		{
			_loadModel = loadModel;
		}

		public CartDiagnostic Update(CartTelemetry telemetry, bool massAdviceReliable = true)
		{
			if (!telemetry.IsPulledByLocalPlayer || !telemetry.VelocityAvailable)
			{
				Reset();
				return CartDiagnostic.None;
			}
			if (_watchedCartId != telemetry.CartId)
			{
				_watchedCartId = telemetry.CartId;
				_lowSpeedSinceSeconds = double.NaN;
			}
			if (telemetry.SpeedMetersPerSecond >= 0.3f)
			{
				_lowSpeedSinceSeconds = double.NaN;
				return CartDiagnostic.None;
			}
			if (double.IsNaN(_lowSpeedSinceSeconds))
			{
				_lowSpeedSinceSeconds = telemetry.SampleTimeSeconds;
			}
			if (telemetry.SampleTimeSeconds - _lowSpeedSinceSeconds < 2.5)
			{
				return CartDiagnostic.None;
			}
			return Classify(telemetry, massAdviceReliable);
		}

		public void Reset()
		{
			_watchedCartId = null;
			_lowSpeedSinceSeconds = double.NaN;
		}

		private CartDiagnostic Classify(CartTelemetry telemetry, bool massAdviceReliable)
		{
			if (!telemetry.GradeAvailable)
			{
				return new CartDiagnostic(CartDiagnosis.Unclear, TeamsterStrings.Get("diag.noTerrainEvidence"), TeamsterStrings.Get("diag.noTerrainAction"));
			}
			float smoothedGradePercent = telemetry.SmoothedGradePercent;
			string text = smoothedGradePercent.ToString("F0", CultureInfo.InvariantCulture) + "%";
			if (smoothedGradePercent <= -8f)
			{
				return new CartDiagnostic(CartDiagnosis.Unclear, TeamsterStrings.Format("diag.descentEvidence", text), TeamsterStrings.Get("diag.descentAction"));
			}
			if (smoothedGradePercent < 8f)
			{
				return new CartDiagnostic(CartDiagnosis.Obstruction, TeamsterStrings.Format("diag.mildGradeEvidence", text), TeamsterStrings.Get("diag.mildGradeAction"));
			}
			if (!massAdviceReliable)
			{
				return new CartDiagnostic(CartDiagnosis.LoadAdviceUnavailable, TeamsterStrings.Format("diag.loadAdviceUnavailableEvidence", text), TeamsterStrings.Get("compat.alteredPhysicsAction"));
			}
			if (_loadModel != null)
			{
				LoadVerdict loadVerdict = _loadModel.Query(smoothedGradePercent, telemetry.TotalMass);
				switch (loadVerdict.Climbability)
				{
				case Climbability.No:
					return new CartDiagnostic(CartDiagnosis.ImpossibleLoad, TeamsterStrings.Format("diag.verdictEvidence", loadVerdict.Explanation), TeamsterStrings.Get("diag.impossibleAction"));
				case Climbability.Marginal:
					return new CartDiagnostic(CartDiagnosis.MarginalLoad, TeamsterStrings.Format("diag.verdictEvidence", loadVerdict.Explanation), TeamsterStrings.Get("diag.marginalAction"));
				case Climbability.Yes:
					return new CartDiagnostic(CartDiagnosis.Obstruction, TeamsterStrings.Format("diag.provenYetStuckEvidence", text, loadVerdict.Explanation), TeamsterStrings.Get("diag.provenYetStuckAction"));
				}
			}
			if (smoothedGradePercent >= 15f)
			{
				return new CartDiagnostic(CartDiagnosis.SteepClimb, TeamsterStrings.Format("diag.steepClimbEvidence", text), TeamsterStrings.Get("diag.steepClimbAction"));
			}
			return new CartDiagnostic(CartDiagnosis.Unclear, TeamsterStrings.Format("diag.unclearClimbEvidence", text), TeamsterStrings.Get("diag.unclearClimbAction"));
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Config
{
	public static class ConfigSchemaMigration
	{
		public sealed class Plan
		{
			public bool NeedsMigration { get; }

			public bool IsFromANewerVersion { get; }

			public string? LogMessage { get; }

			public Plan(bool needsMigration, bool isFromANewerVersion, string? logMessage)
			{
				NeedsMigration = needsMigration;
				IsFromANewerVersion = isFromANewerVersion;
				LogMessage = logMessage;
			}
		}

		public static Plan Decide(int storedVersion)
		{
			if (storedVersion > 1)
			{
				return new Plan(needsMigration: false, isFromANewerVersion: true, "Config schema version " + storedVersion + " is newer than this build understands (current: " + 1 + "); settings are left exactly as found. This usually means the mod was downgraded after a newer version wrote this config file.");
			}
			return storedVersion switch
			{
				1 => new Plan(needsMigration: false, isFromANewerVersion: false, null), 
				0 => new Plan(needsMigration: true, isFromANewerVersion: false, "Config schema versioning introduced at version " + 1 + "; no existing setting value changed."), 
				_ => new Plan(needsMigration: true, isFromANewerVersion: false, "Config schema migrated from version " + storedVersion + " to " + 1 + "."), 
			};
		}
	}
	public static class ConfigSchemaVersion
	{
		public const int PreVersioning = 0;

		public const int Current = 1;
	}
	public static class TeamsterDefaults
	{
		public const bool Enabled = true;

		public const bool DebugLogging = false;

		public const bool PanelWarningsEnabled = true;

		public const bool HudWarningHintsEnabled = false;

		public const bool BrakeEnabled = true;

		public const bool TripsEnabled = true;

		public const bool OnboardingDismissed = false;

		public const ConfigProfile DefaultProfile = ConfigProfile.Standard;
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Compatibility
{
	public static class CompatibilityAdvisoryGate
	{
		public static bool CartMassAdviceReliable(IReadOnlyList<ModDetectionResult> results)
		{
			return !results.Any((ModDetectionResult result) => result.Found && result.Probe.AffectedAspect == CompatibilityAffectedAspect.CartMassOrPhysics);
		}
	}
	public enum CompatibilityAffectedAspect
	{
		None,
		CartMassOrPhysics
	}
	public static class CompatibilityKnownMods
	{
		public static readonly IReadOnlyList<KnownModProbe> Registry = new KnownModProbe[3]
		{
			new KnownModProbe("TastyChickenLegs.BetterCarts", "BetterCarts", CompatibilityPolicy.Adapt, CompatibilityAffectedAspect.CartMassOrPhysics, TeamsterStrings.Get("compat.betterCartsDescription")),
			new KnownModProbe("net.mtnewton.itemstacks", "ItemStacks", CompatibilityPolicy.Adapt, CompatibilityAffectedAspect.CartMassOrPhysics, TeamsterStrings.Get("compat.itemStacksDescription")),
			new KnownModProbe("org.bepinex.plugins.valheim_plus", "ValheimPlus", CompatibilityPolicy.Warn, CompatibilityAffectedAspect.None, TeamsterStrings.Get("compat.valheimPlusDescription"))
		};
	}
	public enum CompatibilityPolicy
	{
		Coexist,
		Adapt,
		Warn
	}
	public static class CompatibilityRegistry
	{
		public static IReadOnlyList<ModDetectionResult> Evaluate(IReadOnlyList<KnownModProbe> registry, Func<string, (bool Found, string? Version)> lookup)
		{
			List<ModDetectionResult> list = new List<ModDetectionResult>(registry.Count);
			foreach (KnownModProbe item in registry)
			{
				bool found = false;
				string detectedVersion = null;
				try
				{
					(found, detectedVersion) = lookup(item.Guid);
				}
				catch
				{
				}
				list.Add(new ModDetectionResult(item, found, detectedVersion));
			}
			return list;
		}
	}
	public static class CompatibilityStatusPresenter
	{
		public static IReadOnlyList<string> ComposeDetectedLines(IReadOnlyList<ModDetectionResult> results)
		{
			return (from result in results
				where result.Found
				select TeamsterStrings.Format("compat.line", result.Probe.DisplayName, VersionText(result.DetectedVersion), PolicyWord(result.Probe.Policy), result.Probe.Description)).ToList();
		}

		public static string ComposeNoneDetectedLine()
		{
			return TeamsterStrings.Get("compat.noneDetected");
		}

		private static string VersionText(string? detectedVersion)
		{
			if (!string.IsNullOrEmpty(detectedVersion))
			{
				return "v" + detectedVersion;
			}
			return TeamsterStrings.Get("compat.versionUnknown");
		}

		private static string PolicyWord(CompatibilityPolicy policy)
		{
			return policy switch
			{
				CompatibilityPolicy.Coexist => TeamsterStrings.Get("compat.policyCoexist"), 
				CompatibilityPolicy.Adapt => TeamsterStrings.Get("compat.policyAdapt"), 
				CompatibilityPolicy.Warn => TeamsterStrings.Get("compat.policyWarn"), 
				_ => throw new ArgumentOutOfRangeException("policy", policy, "Unhandled CompatibilityPolicy value — add a wording case above."), 
			};
		}
	}
	public sealed class KnownModProbe
	{
		public string Guid { get; }

		public string DisplayName { get; }

		public CompatibilityPolicy Policy { get; }

		public CompatibilityAffectedAspect AffectedAspect { get; }

		public string Description { get; }

		public KnownModProbe(string guid, string displayName, CompatibilityPolicy policy, CompatibilityAffectedAspect affectedAspect, string description)
		{
			Guid = guid;
			DisplayName = displayName;
			Policy = policy;
			AffectedAspect = affectedAspect;
			Description = description;
		}
	}
	public sealed class ModDetectionResult
	{
		public KnownModProbe Probe { get; }

		public bool Found { get; }

		public string? DetectedVersion { get; }

		public ModDetectionResult(KnownModProbe probe, bool found, string? detectedVersion)
		{
			Probe = probe;
			Found = found;
			DetectedVersion = (found ? detectedVersion : null);
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Carts
{
	public sealed class CartSnapshot
	{
		public string CartId { get; }

		public float BaseMass { get; }

		public float CargoWeight { get; }

		public bool CargoDataAvailable { get; }

		public float ItemWeightMassFactor { get; }

		public float TotalMass { get; }

		public bool IsAttached { get; }

		public bool IsPulledByLocalPlayer { get; }

		private CartSnapshot(string cartId, float baseMass, float cargoWeight, bool cargoDataAvailable, float itemWeightMassFactor, float totalMass, bool isAttached, bool isPulledByLocalPlayer)
		{
			CartId = cartId;
			BaseMass = baseMass;
			CargoWeight = cargoWeight;
			CargoDataAvailable = cargoDataAvailable;
			ItemWeightMassFactor = itemWeightMassFactor;
			TotalMass = totalMass;
			IsAttached = isAttached;
			IsPulledByLocalPlayer = isPulledByLocalPlayer;
		}

		public static CartSnapshot Create(string? cartId, float baseMass, float cargoWeight, bool cargoDataAvailable, float itemWeightMassFactor, bool isAttached, bool isPulledByLocalPlayer)
		{
			float value = NetworkInputGuard.Mass(baseMass).Value;
			float value2 = NetworkInputGuard.MassFactor(itemWeightMassFactor).Value;
			float value3 = NetworkInputGuard.Mass(cargoWeight).Value;
			float num = (cargoDataAvailable ? value3 : 0f);
			return new CartSnapshot(cartId ?? string.Empty, value, num, cargoDataAvailable, value2, value + num * value2, isAttached, isPulledByLocalPlayer);
		}
	}
	public sealed class CartTelemetry
	{
		public string CartId { get; }

		public float BaseMass { get; }

		public float CargoWeight { get; }

		public bool CargoDataAvailable { get; }

		public float ItemWeightMassFactor { get; }

		public float TotalMass { get; }

		public bool IsAttached { get; }

		public bool IsPulledByLocalPlayer { get; }

		public bool VelocityAvailable { get; }

		public float SpeedMetersPerSecond { get; }

		public float VerticalSpeedMetersPerSecond { get; }

		public bool GradeAvailable { get; }

		public float InstantGradePercent { get; }

		public float SmoothedGradePercent { get; }

		public GradeDirection GradeDirection { get; }

		public TerrainSurfaceKind Surface { get; }

		public double SampleTimeSeconds { get; }

		public float PositionX { get; }

		public float PositionZ { get; }

		private CartTelemetry(string cartId, float baseMass, float cargoWeight, bool cargoDataAvailable, float itemWeightMassFactor, float totalMass, bool isAttached, bool isPulledByLocalPlayer, bool velocityAvailable, float speedMetersPerSecond, float verticalSpeedMetersPerSecond, bool gradeAvailable, float instantGradePercent, float smoothedGradePercent, GradeDirection gradeDirection, TerrainSurfaceKind surface, double sampleTimeSeconds, float positionX, float positionZ)
		{
			CartId = cartId;
			BaseMass = baseMass;
			CargoWeight = cargoWeight;
			CargoDataAvailable = cargoDataAvailable;
			ItemWeightMassFactor = itemWeightMassFactor;
			TotalMass = totalMass;
			IsAttached = isAttached;
			IsPulledByLocalPlayer = isPulledByLocalPlayer;
			VelocityAvailable = velocityAvailable;
			SpeedMetersPerSecond = speedMetersPerSecond;
			VerticalSpeedMetersPerSecond = verticalSpeedMetersPerSecond;
			GradeAvailable = gradeAvailable;
			InstantGradePercent = instantGradePercent;
			SmoothedGradePercent = smoothedGradePercent;
			GradeDirection = gradeDirection;
			Surface = surface;
			SampleTimeSeconds = sampleTimeSeconds;
			PositionX = positionX;
			PositionZ = positionZ;
		}

		public static CartTelemetry Create(CartSnapshot snapshot, bool velocityAvailable, float speedMetersPerSecond, float verticalSpeedMetersPerSecond, bool gradeAvailable, float instantGradePercent, float smoothedGradePercent, GradeDirection gradeDirection, TerrainSurfaceKind surface, double sampleTimeSeconds, float positionX = 0f, float positionZ = 0f)
		{
			return new CartTelemetry(snapshot.CartId, snapshot.BaseMass, snapshot.CargoWeight, snapshot.CargoDataAvailable, snapshot.ItemWeightMassFactor, snapshot.TotalMass, snapshot.IsAttached, snapshot.IsPulledByLocalPlayer, velocityAvailable, velocityAvailable ? speedMetersPerSecond : 0f, velocityAvailable ? verticalSpeedMetersPerSecond : 0f, gradeAvailable, gradeAvailable ? instantGradePercent : 0f, gradeAvailable ? smoothedGradePercent : 0f, gradeAvailable ? gradeDirection : GradeDirection.Level, surface, sampleTimeSeconds, positionX, positionZ);
		}
	}
	public sealed class TelemetrySampler
	{
		private readonly TelemetrySamplerOptions _options;

		private readonly Action<List<object>, TelemetrySamplerOptions> _collectNearbyCarts;

		private readonly Func<object, double, IReadOnlyDictionary<string, CartTelemetry>, CartTelemetry?> _sampleCart;

		private readonly List<object> _cartBuffer = new List<object>();

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

		private readonly Dictionary<string, CartTelemetry> _telemetryByCartId = new Dictionary<string, CartTelemetry>();

		private double _nextDueTimeSeconds;

		private int _rotation;

		public TelemetrySamplerOptions Options => _options;

		public IReadOnlyDictionary<string, CartTelemetry> TelemetryByCartId => _telemetryByCartId;

		public int TrackedCartCount => _telemetryByCartId.Count;

		public int SampledOnLastDueTick { get; private set; }

		public TelemetrySampler(TelemetrySamplerOptions options, Action<List<object>, TelemetrySamplerOptions> collectNearbyCarts, Func<object, double, IReadOnlyDictionary<string, CartTelemetry>, CartTelemetry?> sampleCart)
		{
			_options = options;
			_collectNearbyCarts = collectNearbyCarts;
			_sampleCart = sampleCart;
		}

		public bool Tick(double nowSeconds)
		{
			if (nowSeconds < _nextDueTimeSeconds)
			{
				return false;
			}
			_nextDueTimeSeconds = nowSeconds + (double)_options.SampleIntervalSeconds;
			_cartBuffer.Clear();
			_collectNearbyCarts(_cartBuffer, _options);
			int count = _cartBuffer.Count;
			int num = 0;
			int num2 = 0;
			if (count > 0)
			{
				int num3 = _rotation % count;
				_rotation = (_rotation + 1) & 0x7FFFFFFF;
				for (int i = 0; i < count; i++)
				{
					if (num >= _options.MaxCartsPerTick)
					{
						break;
					}
					object arg = _cartBuffer[(num3 + i) % count];
					num++;
					CartTelemetry cartTelemetry = _sampleCart(arg, nowSeconds, _telemetryByCartId);
					if (cartTelemetry != null && (_telemetryByCartId.ContainsKey(cartTelemetry.CartId) || _telemetryByCartId.Count < _options.MaxTrackedCarts))
					{
						_telemetryByCartId[cartTelemetry.CartId] = cartTelemetry;
						num2++;
					}
				}
			}
			SampledOnLastDueTick = num2;
			EvictStale(nowSeconds);
			_cartBuffer.Clear();
			return true;
		}

		public void Reset()
		{
			_telemetryByCartId.Clear();
			_cartBuffer.Clear();
			_staleKeyBuffer.Clear();
			_nextDueTimeSeconds = 0.0;
			_rotation = 0;
			SampledOnLastDueTick = 0;
		}

		private void EvictStale(double nowSeconds)
		{
			_staleKeyBuffer.Clear();
			foreach (KeyValuePair<string, CartTelemetry> item in _telemetryByCartId)
			{
				if (nowSeconds - item.Value.SampleTimeSeconds > _options.EvictAfterSeconds)
				{
					_staleKeyBuffer.Add(item.Key);
				}
			}
			for (int i = 0; i < _staleKeyBuffer.Count; i++)
			{
				_telemetryByCartId.Remove(_staleKeyBuffer[i]);
			}
			_staleKeyBuffer.Clear();
		}
	}
	public sealed class TelemetrySamplerOptions
	{
		public const float DefaultSampleIntervalSeconds = 0.5f;

		public const float MinSampleIntervalSeconds = 0.1f;

		public const float MaxSampleIntervalSeconds = 10f;

		public const float DefaultSearchRadiusMeters = 30f;

		public const float MinSearchRadiusMeters = 5f;

		public const float MaxSearchRadiusMeters = 100f;

		public const int DefaultMaxCartsPerTick = 2;

		public const int MinMaxCartsPerTick = 1;

		public const int MaxMaxCartsPerTick = 8;

		public const int DefaultMaxTrackedCarts = 8;

		public const int MinMaxTrackedCarts = 1;

		public const int MaxMaxTrackedCarts = 32;

		public float SampleIntervalSeconds { get; }

		public float SearchRadiusMeters { get; }

		public int MaxCartsPerTick { get; }

		public int MaxTrackedCarts { get; }

		public double EvictAfterSeconds => Math.Max(2.0, (double)SampleIntervalSeconds * 3.0);

		private TelemetrySamplerOptions(float sampleIntervalSeconds, float searchRadiusMeters, int maxCartsPerTick, int maxTrackedCarts)
		{
			SampleIntervalSeconds = sampleIntervalSeconds;
			SearchRadiusMeters = searchRadiusMeters;
			MaxCartsPerTick = maxCartsPerTick;
			MaxTrackedCarts = maxTrackedCarts;
		}

		public static TelemetrySamplerOptions CreateClamped(float sampleIntervalSeconds, float searchRadiusMeters, int maxCartsPerTick, int maxTrackedCarts)
		{
			return new TelemetrySamplerOptions(ClampFloat(sampleIntervalSeconds, 0.1f, 10f, 0.5f), ClampFloat(searchRadiusMeters, 5f, 100f, 30f), ClampInt(maxCartsPerTick, 1, 8), ClampInt(maxTrackedCarts, 1, 32));
		}

		public static TelemetrySamplerOptions CreateDefault()
		{
			return CreateClamped(0.5f, 30f, 2, 8);
		}

		private static float ClampFloat(float value, float min, float max, float fallback)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return fallback;
			}
			return Math.Min(max, Math.Max(min, value));
		}

		private static int ClampInt(int value, int min, int max)
		{
			return Math.Min(max, Math.Max(min, value));
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Cartographer
{
	public enum CartographerAvailability
	{
		Available = 1,
		Absent,
		VersionTooLow,
		ProbeFailed
	}
	public sealed class CartographerCapabilityReport
	{
		public CartographerAvailability Availability { get; }

		public string DetectedVersion { get; }

		public string Detail { get; }

		public int VerifiedMemberCount { get; }

		public bool IsAvailable => Availability == CartographerAvailability.Available;

		public string LogLine => Availability switch
		{
			CartographerAvailability.Available => "Cartographer integration AVAILABLE: Concerned Cartographer " + $"{DetectedVersion} detected, {VerifiedMemberCount} contract members verified. " + "Route features can appear once a world is loaded.", 
			CartographerAvailability.Absent => "Cartographer integration hidden: Concerned Cartographer is not installed. Concerned Teamster runs fully standalone.", 
			CartographerAvailability.VersionTooLow => "Cartographer integration hidden: Concerned Cartographer " + $"{DetectedVersion} is below the supported floor {CartographerContract.FloorVersion}; " + "update Concerned Cartographer to enable route features.", 
			_ => "Cartographer integration hidden: Concerned Cartographer " + DetectedVersion + " was detected but its route surface did not verify (" + Detail + "). A Concerned Teamster update is likely needed; everything else keeps working.", 
		};

		private CartographerCapabilityReport(CartographerAvailability availability, string detectedVersion, string detail, int verifiedMemberCount)
		{
			Availability = availability;
			DetectedVersion = detectedVersion;
			Detail = detail;
			VerifiedMemberCount = verifiedMemberCount;
		}

		public static CartographerCapabilityReport Available(string detectedVersion, int verifiedMemberCount)
		{
			return new CartographerCapabilityReport(CartographerAvailability.Available, detectedVersion, "", verifiedMemberCount);
		}

		public static CartographerCapabilityReport Absent()
		{
			return new CartographerCapabilityReport(CartographerAvailability.Absent, "unknown", "not installed", 0);
		}

		public static CartographerCapabilityReport VersionTooLow(string detectedVersion)
		{
			return new CartographerCapabilityReport(CartographerAvailability.VersionTooLow, detectedVersion, $"below floor {CartographerContract.FloorVersion}", 0);
		}

		public static CartographerCapabilityReport ProbeFailed(string detectedVersion, string detail)
		{
			return new CartographerCapabilityReport(CartographerAvailability.ProbeFailed, detectedVersion, detail, 0);
		}
	}
	public static class CartographerContract
	{
		public const string PluginGuid = "com.theconcernedcat.valheim.concernedcartographer";

		public const string ProductName = "Concerned Cartographer";

		public static readonly Version FloorVersion = new Version(0, 10, 0);

		public const string PluginLabel = "CartographerPlugin";

		public const string RuntimeLabel = "CartographerRuntime";

		public const string StoreLabel = "RouteStore";

		public const string RouteLabel = "AtlasRoute";

		public const string IdLabel = "AtlasId";

		public const string PointLabel = "RoadPoint";

		public const string RuntimeField = "_runtime";

		public const string RouteStoreField = "_routeStore";

		public const string LivingProperty = "Living";

		public const string ChangeStampProperty = "ChangeStamp";

		public const string RouteIdProperty = "Id";

		public const string RouteNameProperty = "Name";

		public const string RouteArchivedProperty = "Archived";

		public const string RoutePointsProperty = "Points";

		public const string IdValueProperty = "Value";

		public const string PointXProperty = "X";

		public const string PointYProperty = "Y";

		public const string PointZProperty = "Z";

		private const BindingFlags InstanceMembers = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public static IReadOnlyList<GameMemberRequirement> BuildRequirements(Type? pluginType)
		{
			List<GameMemberRequirement> obj = new List<GameMemberRequirement>(12)
			{
				new GameMemberRequirement("CartographerPlugin", pluginType, "_runtime", GameMemberKind.InstanceField)
			};
			Type type = ResolveFieldType(pluginType, "_runtime");
			obj.Add(new GameMemberRequirement("CartographerRuntime", type, "_routeStore", GameMemberKind.InstanceField));
			Type type2 = ResolveFieldType(type, "_routeStore");
			obj.Add(new GameMemberRequirement("RouteStore", type2, "Living", GameMemberKind.InstanceProperty));
			obj.Add(new GameMemberRequirement("RouteStore", type2, "ChangeStamp", GameMemberKind.InstanceProperty, typeof(long)));
			Type type3 = ResolveElementType(ResolvePropertyType(type2, "Living"));
			obj.Add(new GameMemberRequirement("AtlasRoute", type3, "Id", GameMemberKind.InstanceProperty));
			obj.Add(new GameMemberRequirement("AtlasRoute", type3, "Name", GameMemberKind.InstanceProperty, typeof(string)));
			obj.Add(new GameMemberRequirement("AtlasRoute", type3, "Archived", GameMemberKind.InstanceProperty, typeof(bool)));
			obj.Add(new GameMemberRequirement("AtlasRoute", type3, "Points", GameMemberKind.InstanceProperty));
			Type ownerType = ResolvePropertyType(type3, "Id");
			obj.Add(new GameMemberRequirement("AtlasId", ownerType, "Value", GameMemberKind.InstanceProperty, typeof(Guid)));
			Type ownerType2 = ResolveElementType(ResolvePropertyType(type3, "Points"));
			obj.Add(new GameMemberRequirement("RoadPoint", ownerType2, "X", GameMemberKind.InstanceProperty, typeof(float)));
			obj.Add(new GameMemberRequirement("RoadPoint", ownerType2, "Y", GameMemberKind.InstanceProperty, typeof(float)));
			obj.Add(new GameMemberRequirement("RoadPoint", ownerType2, "Z", GameMemberKind.InstanceProperty, typeof(float)));
			return obj;
		}

		private static Type? ResolveFieldType(Type? owner, string fieldName)
		{
			try
			{
				return owner?.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.FieldType;
			}
			catch
			{
				return null;
			}
		}

		private static Type? ResolvePropertyType(Type? owner, string propertyName)
		{
			try
			{
				return owner?.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.PropertyType;
			}
			catch
			{
				return null;
			}
		}

		private static Type? ResolveElementType(Type? enumerableType)
		{
			try
			{
				if ((object)enumerableType == null)
				{
					return null;
				}
				if (enumerableType.IsGenericType && enumerableType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
				{
					return enumerableType.GetGenericArguments()[0];
				}
				Type[] interfaces = enumerableType.GetInterfaces();
				foreach (Type type in interfaces)
				{
					if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
					{
						return type.GetGenericArguments()[0];
					}
				}
				return null;
			}
			catch
			{
				return null;
			}
		}
	}
	public static class CartographerGate
	{
		public static CartographerCapabilityReport Evaluate(Func<CartographerLookup>? lookup)
		{
			if (lookup == null)
			{
				return CartographerCapabilityReport.ProbeFailed("unknown", "no plugin lookup supplied");
			}
			CartographerLookup cartographerLookup;
			try
			{
				cartographerLookup = lookup();
			}
			catch (Exception ex)
			{
				return CartographerCapabilityReport.ProbeFailed("unknown", "plugin lookup threw " + ex.GetType().Name);
			}
			if (cartographerLookup == null)
			{
				return CartographerCapabilityReport.ProbeFailed("unknown", "plugin lookup returned nothing");
			}
			if (!cartographerLookup.Found)
			{
				return CartographerCapabilityReport.Absent();
			}
			string detectedVersion = cartographerLookup.Version?.ToString() ?? "unknown";
			if ((object)cartographerLookup.Version == null || cartographerLookup.Version < CartographerContract.FloorVersion)
			{
				return CartographerCapabilityReport.VersionTooLow(detectedVersion);
			}
			if (cartographerLookup.Instance == null)
			{
				return CartographerCapabilityReport.ProbeFailed(detectedVersion, "plugin instance is not available");
			}
			IReadOnlyList<GameMemberRequirement> requirements;
			try
			{
				requirements = CartographerContract.BuildRequirements(cartographerLookup.Instance.GetType());
			}
			catch (Exception ex2)
			{
				return CartographerCapabilityReport.ProbeFailed(detectedVersion, "contract resolution threw " + ex2.GetType().Name);
			}
			GameCapabilityReport gameCapabilityReport = GameMemberProbe.Probe(requirements);
			if (!gameCapabilityReport.Enabled)
			{
				return CartographerCapabilityReport.ProbeFailed(detectedVersion, "missing " + string.Join(", ", gameCapabilityReport.MissingMembers));
			}
			return CartographerCapabilityReport.Available(detectedVersion, gameCapabilityReport.VerifiedMembers.Count);
		}
	}
	public sealed class CartographerLookup
	{
		public bool Found { get; }

		public Version? Version { get; }

		public object? Instance { get; }

		private CartographerLookup(bool found, Version? version, object? instance)
		{
			Found = found;
			Version = version;
			Instance = instance;
		}

		public static CartographerLookup NotFound()
		{
			return new CartographerLookup(found: false, null, null);
		}

		public static CartographerLookup Detected(Version? version, object? instance)
		{
			return new CartographerLookup(found: true, version, instance);
		}
	}
	public readonly struct CartographerRoutePoint
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public CartographerRoutePoint(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public override string ToString()
		{
			return string.Format(CultureInfo.InvariantCulture, "({0:0.##}, {1:0.##}, {2:0.##})", X, Y, Z);
		}
	}
	public static class CartographerRouteReader
	{
		private const BindingFlags InstanceMembers = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public static bool TryReadRoutes(object? pluginInstance, out IReadOnlyList<CartographerRouteSnapshot> routes)
		{
			routes = Array.Empty<CartographerRouteSnapshot>();
			try
			{
				if (!TryResolveStore(pluginInstance, out object store))
				{
					return false;
				}
				if (!(GetPropertyValue(store, "Living") is IEnumerable enumerable))
				{
					return false;
				}
				List<CartographerRouteSnapshot> list = new List<CartographerRouteSnapshot>();
				foreach (object item in enumerable)
				{
					if (item != null && TryReadRoute(item, out CartographerRouteSnapshot snapshot))
					{
						list.Add(snapshot);
					}
				}
				routes = list;
				return true;
			}
			catch
			{
				routes = Array.Empty<CartographerRouteSnapshot>();
				return false;
			}
		}

		public static bool TryReadChangeStamp(object? pluginInstance, out long changeStamp)
		{
			changeStamp = 0L;
			try
			{
				if (!TryResolveStore(pluginInstance, out object store))
				{
					return false;
				}
				if (!(GetPropertyValue(store, "ChangeStamp") is long num))
				{
					return false;
				}
				changeStamp = num;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryResolveStore(object? pluginInstance, out object store)
		{
			store = null;
			if (pluginInstance == null)
			{
				return false;
			}
			object fieldValue = GetFieldValue(pluginInstance, "_runtime");
			if (fieldValue == null)
			{
				return false;
			}
			object fieldValue2 = GetFieldValue(fieldValue, "_routeStore");
			if (fieldValue2 == null)
			{
				return false;
			}
			store = fieldValue2;
			return true;
		}

		private static bool TryReadRoute(object routeObject, out CartographerRouteSnapshot? snapshot)
		{
			snapshot = null;
			try
			{
				object propertyValue = GetPropertyValue(routeObject, "Id");
				if (propertyValue == null || !(GetPropertyValue(propertyValue, "Value") is Guid id))
				{
					return false;
				}
				string name = (GetPropertyValue(routeObject, "Name") as string) ?? "";
				if (!(GetPropertyValue(routeObject, "Archived") is bool archived))
				{
					return false;
				}
				if (!(GetPropertyValue(routeObject, "Points") is IEnumerable enumerable))
				{
					return false;
				}
				List<CartographerRoutePoint> list = new List<CartographerRoutePoint>();
				foreach (object item in enumerable)
				{
					if (item == null || !(GetPropertyValue(item, "X") is float x) || !(GetPropertyValue(item, "Y") is float y) || !(GetPropertyValue(item, "Z") is float z))
					{
						return false;
					}
					list.Add(new CartographerRoutePoint(x, y, z));
				}
				snapshot = new CartographerRouteSnapshot(id, name, archived, list);
				return true;
			}
			catch
			{
				snapshot = null;
				return false;
			}
		}

		private static object? GetFieldValue(object owner, string fieldName)
		{
			return owner.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(owner);
		}

		private static object? GetPropertyValue(object owner, string propertyName)
		{
			return owner.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(owner);
		}
	}
	public sealed class CartographerRouteSnapshot
	{
		public Guid Id { get; }

		public string Name { get; }

		public bool Archived { get; }

		public IReadOnlyList<CartographerRoutePoint> Points { get; }

		public CartographerRouteSnapshot(Guid id, string name, bool archived, IReadOnlyList<CartographerRoutePoint> points)
		{
			Id = id;
			Name = name;
			Archived = archived;
			Points = points;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Cargo
{
	public sealed class CargoEntry
	{
		public string ItemId { get; }

		public string DisplayNameToken { get; }

		public int Count { get; }

		public float UnitWeight { get; }

		public float LineWeight { get; }

		public bool WeightKnown { get; }

		public string EffectiveDisplayName
		{
			get
			{
				if (DisplayNameToken.Length > 0)
				{
					return DisplayNameToken;
				}
				if (ItemId.Length <= 0)
				{
					return TeamsterStrings.Get("manifest.unknownItem");
				}
				return ItemId;
			}
		}

		private CargoEntry(string itemId, string displayNameToken, int count, float unitWeight, float lineWeight, bool weightKnown)
		{
			ItemId = itemId;
			DisplayNameToken = displayNameToken;
			Count = count;
			UnitWeight = unitWeight;
			LineWeight = lineWeight;
			WeightKnown = weightKnown;
		}

		public static CargoEntry Create(string? itemId, string? displayNameToken, int count, float unitWeight, float lineWeight, bool weightKnown)
		{
			return new CargoEntry(itemId ?? string.Empty, displayNameToken ?? string.Empty, count, weightKnown ? unitWeight : 0f, weightKnown ? lineWeight : 0f, weightKnown);
		}

		public static CargoEntry CreateUnreadable(int slotIndex)
		{
			return new CargoEntry(TeamsterStrings.Format("manifest.unreadableSlot", slotIndex.ToString(CultureInfo.InvariantCulture)), string.Empty, 0, 0f, 0f, weightKnown: false);
		}
	}
	public sealed class CargoManifest
	{
		private static readonly CargoEntry[] NoEntries = Array.Empty<CargoEntry>();

		public IReadOnlyList<CargoEntry> Entries { get; }

		public float TotalKnownWeight { get; }

		public int TotalItemCount { get; }

		public int UnknownWeightEntryCount { get; }

		public bool HasUnknownWeights => UnknownWeightEntryCount > 0;

		public double CaptureTimeSeconds { get; }

		private CargoManifest(CargoEntry[] entries, float totalKnownWeight, int totalItemCount, int unknownWeightEntryCount, double captureTimeSeconds)
		{
			Entries = entries;
			TotalKnownWeight = totalKnownWeight;
			TotalItemCount = totalItemCount;
			UnknownWeightEntryCount = unknownWeightEntryCount;
			CaptureTimeSeconds = captureTimeSeconds;
		}

		public static CargoManifest Create(IEnumerable<CargoEntry> entries, double captureTimeSeconds)
		{
			List<CargoEntry> list = new List<CargoEntry>(entries ?? NoEntries);
			list.Sort(CompareEntries);
			float num = 0f;
			int num2 = 0;
			int num3 = 0;
			foreach (CargoEntry item in list)
			{
				num2 += item.Count;
				if (item.WeightKnown)
				{
					num += item.LineWeight;
				}
				else
				{
					num3++;
				}
			}
			return new CargoManifest(list.ToArray(), num, num2, num3, captureTimeSeconds);
		}

		public static CargoManifest CreateEmpty(double captureTimeSeconds)
		{
			return new CargoManifest(NoEntries, 0f, 0, 0, captureTimeSeconds);
		}

		private static int CompareEntries(CargoEntry left, CargoEntry right)
		{
			if (left.WeightKnown != right.WeightKnown)
			{
				if (!left.WeightKnown)
				{
					return 1;
				}
				return -1;
			}
			int num = right.LineWeight.CompareTo(left.LineWeight);
			if (num != 0)
			{
				return num;
			}
			int num2 = string.CompareOrdinal(left.EffectiveDisplayName, right.EffectiveDisplayName);
			if (num2 != 0)
			{
				return num2;
			}
			return string.CompareOrdinal(left.ItemId, right.ItemId);
		}
	}
	public sealed class CargoManifestTracker
	{
		public const double MinRefreshSpacingSeconds = 1.0;

		private readonly double _refreshSpacingSeconds;

		private CargoManifest? _current;

		private double _nextRefreshTime;

		public CargoManifest? Current => _current;

		public CargoManifestTracker(double refreshSpacingSeconds = 1.0)
		{
			_refreshSpacingSeconds = Math.Max(1.0, refreshSpacingSeconds);
		}

		public CargoManifest? GetOrRefresh(double nowSeconds, Func<double, CargoManifest?> readManifest)
		{
			if (nowSeconds >= _nextRefreshTime)
			{
				_nextRefreshTime = nowSeconds + _refreshSpacingSeconds;
				_current = readManifest(nowSeconds);
			}
			return _current;
		}

		public void Reset()
		{
			_current = null;
			_nextRefreshTime = 0.0;
		}
	}
	public enum CargoSortColumn
	{
		Name,
		Count,
		UnitWeight,
		LineWeight
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Capabilities
{
	public sealed class GameCapabilityReport
	{
		public bool Enabled => MissingMembers.Count == 0;

		public IReadOnlyList<string> VerifiedMembers { get; }

		public IReadOnlyList<string> MissingMembers { get; }

		public GameCapabilityReport(IReadOnlyList<string> verifiedMembers, IReadOnlyList<string> missingMembers)
		{
			VerifiedMembers = verifiedMembers;
			MissingMembers = missingMembers;
		}
	}
	public enum GameMemberKind
	{
		InstanceField,
		StaticField,
		InstanceMethod,
		StaticMethod,
		InstanceProperty,
		StaticProperty
	}
	public static class GameMemberProbe
	{
		public static GameCapabilityReport Probe(IReadOnlyList<GameMemberRequirement> requirements)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			try
			{
				foreach (GameMemberRequirement requirement in requirements)
				{
					string displayName = requirement.DisplayName;
					try
					{
						string text = ProbeOne(requirement);
						if (text == null)
						{
							list.Add(displayName);
						}
						else
						{
							list2.Add(displayName + " (" + text + ")");
						}
					}
					catch (Exception ex)
					{
						list2.Add(displayName + " (probe error: " + ex.GetType().Name + ")");
					}
				}
			}
			catch (Exception ex2)
			{
				list2.Add("capability probe failed (" + ex2.GetType().Name + ")");
			}
			return new GameCapabilityReport(list, list2);
		}

		private static string? ProbeOne(GameMemberRequirement requirement)
		{
			if (string.IsNullOrWhiteSpace(requirement.MemberName))
			{
				return "empty member name";
			}
			if ((object)requirement.OwnerType == null)
			{
				return "type not found";
			}
			switch (requirement.Kind)
			{
			case GameMemberKind.InstanceField:
			case GameMemberKind.StaticField:
			{
				BindingFlags bindingAttr3 = (BindingFlags)(0x30 | ((requirement.Kind == GameMemberKind.StaticField) ? 72 : 4));
				FieldInfo field = requirement.OwnerType.GetField(requirement.MemberName, bindingAttr3);
				if ((object)field == null)
				{
					return "field not found";
				}
				if ((object)requirement.ExpectedType != null && field.FieldType != requirement.ExpectedType)
				{
					return "field type is " + field.FieldType.Name + ", expected " + requirement.ExpectedType.Name;
				}
				return null;
			}
			case GameMemberKind.InstanceMethod:
			case GameMemberKind.StaticMethod:
			{
				Type[] array;
				if (requirement.ParameterTypes == null)
				{
					array = Type.EmptyTypes;
				}
				else
				{
					array = new Type[requirement.ParameterTypes.Count];
					for (int i = 0; i < requirement.ParameterTypes.Count; i++)
					{
						Type type = requirement.ParameterTypes[i];
						if ((object)type == null)
						{
							return $"parameter {i} type not found";
						}
						array[i] = type;
					}
				}
				BindingFlags bindingAttr2 = (BindingFlags)(0x30 | ((requirement.Kind == GameMemberKind.StaticMethod) ? 72 : 4));
				MethodInfo method = requirement.OwnerType.GetMethod(requirement.MemberName, bindingAttr2, null, array, null);
				if ((object)method == null)
				{
					return "method not found";
				}
				if ((object)requirement.ExpectedType != null && method.ReturnType != requirement.ExpectedType)
				{
					return "return type is " + method.ReturnType.Name + ", expected " + requirement.ExpectedType.Name;
				}
				return null;
			}
			case GameMemberKind.InstanceProperty:
			case GameMemberKind.StaticProperty:
			{
				BindingFlags bindingAttr = (BindingFlags)(0x30 | ((requirement.Kind == GameMemberKind.StaticProperty) ? 72 : 4));
				PropertyInfo property = requirement.OwnerType.GetProperty(requirement.MemberName, bindingAttr);
				if ((object)property == null)
				{
					return "property not found";
				}
				if ((object)property.GetMethod == null)
				{
					return "property has no getter";
				}
				if ((object)requirement.ExpectedType != null && property.PropertyType != requirement.ExpectedType)
				{
					return "property type is " + property.PropertyType.Name + ", expected " + requirement.ExpectedType.Name;
				}
				return null;
			}
			default:
				return $"unsupported member kind {requirement.Kind}";
			}
		}
	}
	public sealed class GameMemberRequirement
	{
		public string OwnerLabel { get; }

		public Type? OwnerType { get; }

		public string MemberName { get; }

		public GameMemberKind Kind { get; }

		public Type? ExpectedType { get; }

		public IReadOnlyList<Type?>? ParameterTypes { get; }

		public string DisplayName => OwnerLabel + "." + MemberName;

		public GameMemberRequirement(string ownerLabel, Type? ownerType, string memberName, GameMemberKind kind, Type? expectedType = null, IReadOnlyList<Type?>? parameterTypes = null)
		{
			OwnerLabel = ownerLabel;
			OwnerType = ownerType;
			MemberName = memberName;
			Kind = kind;
			ExpectedType = expectedType;
			ParameterTypes = parameterTypes;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Brake
{
	public enum BrakeAction
	{
		None,
		Engage,
		Release
	}
	public readonly struct BrakeFacts
	{
		public bool CapabilityOk { get; }

		public bool InWorld { get; }

		public bool CartExists { get; }

		public bool IsLocalAuthority { get; }

		public CartAuthority Authority
		{
			get
			{
				if (!IsLocalAuthority)
				{
					return CartAuthority.Unknown;
				}
				return CartAuthority.Local;
			}
		}

		public bool IsAttached { get; }

		public float DistanceMeters { get; }

		public static BrakeFacts Unavailable => new BrakeFacts(capabilityOk: false, inWorld: false, cartExists: false, isLocalAuthority: false, isAttached: false, float.MaxValue);

		public BrakeFacts(bool capabilityOk, bool inWorld, bool cartExists, bool isLocalAuthority, bool isAttached, float distanceMeters)
		{
			CapabilityOk = capabilityOk;
			InWorld = inWorld;
			CartExists = cartExists;
			IsLocalAuthority = isLocalAuthority;
			IsAttached = isAttached;
			DistanceMeters = distanceMeters;
		}
	}
	public sealed class BrakeLifecycle
	{
		public const float EngageMaxDistanceMeters = 5f;

		public const float AutoReleaseDistanceMeters = 12f;

		public string? EngagedCartId { get; private set; }

		public bool IsEngaged => EngagedCartId != null;

		public BrakeAction EvaluateToggle(string cartId, BrakeFacts facts, out string reason)
		{
			if (EngagedCartId != null)
			{
				if (EngagedCartId == cartId)
				{
					reason = "released by player";
					return BrakeAction.Release;
				}
				reason = "another cart is already braked; release it first";
				return BrakeAction.None;
			}
			if (!facts.CapabilityOk)
			{
				reason = "cart capability is unavailable";
				return BrakeAction.None;
			}
			if (!facts.InWorld)
			{
				reason = "no local player";
				return BrakeAction.None;
			}
			if (!facts.CartExists)
			{
				reason = "cart no longer exists";
				return BrakeAction.None;
			}
			if (!CartAuthorityPolicy.MayMutate(TeamsterFeature.ParkingBrake, facts.Authority))
			{
				reason = "this client does not control the cart";
				return BrakeAction.None;
			}
			if (facts.IsAttached)
			{
				reason = "cart is being pulled; detach first";
				return BrakeAction.None;
			}
			if (facts.DistanceMeters > 5f)
			{
				reason = "too far from the cart";
				return BrakeAction.None;
			}
			reason = "engaged by player";
			return BrakeAction.Engage;
		}

		public BrakeAction EvaluateTick(BrakeFacts facts, out string reason)
		{
			if (EngagedCartId == null)
			{
				reason = string.Empty;
				return BrakeAction.None;
			}
			if (!facts.InWorld)
			{
				reason = "left the world";
				return BrakeAction.Release;
			}
			if (!facts.CapabilityOk)
			{
				reason = "cart capability lost";
				return BrakeAction.Release;
			}
			if (!facts.CartExists)
			{
				reason = "cart no longer exists";
				return BrakeAction.Release;
			}
			if (!CartAuthorityPolicy.MayMutate(TeamsterFeature.ParkingBrake, facts.Authority))
			{
				reason = "cart authority moved to another client";
				return BrakeAction.Release;
			}
			if (facts.IsAttached)
			{
				reason = "cart was grabbed";
				return BrakeAction.Release;
			}
			if (facts.DistanceMeters > 12f)
			{
				reason = "player left the cart behind";
				return BrakeAction.Release;
			}
			reason = string.Empty;
			return BrakeAction.None;
		}

		public void MarkEngaged(string cartId)
		{
			EngagedCartId = cartId;
		}

		public void MarkReleased()
		{
			EngagedCartId = null;
		}
	}
}
namespace TheConcernedCat.ConcernedTeamster.Domain.Authority
{
	public enum CartAuthority
	{
		Unknown,
		Local,
		Remote
	}
	public static class CartAuthorityResolver
	{
		public static CartAuthority Resolve(bool capabilityOk, bool viewValid, bool isOwner)
		{
			if (!capabilityOk || !viewValid)
			{
				return CartAuthority.Unknown;
			}
			if (!isOwner)
			{
				return CartAuthority.Remote;
			}
			return CartAuthority.Local;
		}
	}
	public static class CartAuthorityPolicy
	{
		private sealed class Entry
		{
			public FeatureClass FeatureClass { get; }

			public bool LabelWhenRemote { get; }

			public Entry(FeatureClass featureClass, bool labelWhenRemote)
			{
				FeatureClass = featureClass;
				LabelWhenRemote = labelWhenRemote;
			}
		}

		private static readonly IReadOnlyDictionary<TeamsterFeature, Entry> Matrix = new Dictionary<TeamsterFeature, Entry>
		{
			[TeamsterFeature.CartTelemetry] = new Entry(FeatureClass.Observation, labelWhenRemote: true),
			[TeamsterFeature.CartStatusPanel] = new Entry(FeatureClass.Observation, labelWhenRemote: true),
			[TeamsterFeature.CargoManifest] = new Entry(FeatureClass.Observation, labelWhenRemote: true),
			[TeamsterFeature.LoadWarnings] = new Entry(FeatureClass.Observation, labelWhenRemote: true),
			[TeamsterFeature.DescentRisk] = new Entry(FeatureClass.Observation, labelWhenRemote: true),
			[TeamsterFeature.RecoveryGuidance] = new Entry(FeatureClass.Observation, labelWhenRemote: false),
			[TeamsterFeature.TripRecording] = new Entry(FeatureClass.Observation, labelWhenRemote: false),
			[TeamsterFeature.RouteProfiling] = new Entry(FeatureClass.Observation, labelWhenRemote: false),
			[TeamsterFeature.ParkingBrake] = new Entry(FeatureClass.Mutation, labelWhenRemote: false)
		};

		public static IEnumerable<TeamsterFeature> AllFeatures => Matrix.Keys;

		public static FeatureClass ClassOf(TeamsterFeature feature)
		{
			return Matrix[feature].FeatureClass;
		}

		public static bool IsMutation(TeamsterFeature feature)
		{
			return Matrix[feature].FeatureClass == FeatureClass.Mutation;
		}

		public static bool MayMutate(TeamsterFeature feature, CartAuthority authority)
		{
			if (Matrix[feature].FeatureClass == FeatureClass.Mutation)
			{
				return authority == CartAuthority.Local;
			}
			return false;
		}

		public static bool RequiresRemoteLabel(TeamsterFeature feature, CartAuthority authority)
		{
			if (Matrix[feature].FeatureClass == FeatureClass.Observation && Matrix[feature].LabelWhenRemote)
			{
				return authority != CartAuthority.Local;
			}
			return false;
		}
	}
	public enum TeamsterFeature
	{
		CartTelemetry,
		CartStatusPanel,
		CargoManifest,
		LoadWarnings,
		DescentRisk,
		RecoveryGuidance,
		TripRecording,
		RouteProfiling,
		ParkingBrake
	}
	public enum FeatureClass
	{
		Observation,
		Mutation
	}
}
namespace TheConcernedCat.ConcernedTeamster.Adapters
{
	internal sealed class BrakeService
	{
		private readonly BrakeLifecycle _lifecycle = new BrakeLifecycle();

		private readonly ManualLogSource _log;

		private int _capturedConstraints;

		public bool IsEngaged => _lifecycle.IsEngaged;

		public string? EngagedCartId => _lifecycle.EngagedCartId;

		public BrakeService(ManualLogSource log)
		{
			_log = log;
		}

		public void RequestToggle(string? cartId)
		{
			if (cartId != null)
			{
				BrakeFacts facts = CartBrakeAdapter.ReadFacts(cartId);
				string reason;
				BrakeAction action = _lifecycle.EvaluateToggle(cartId, facts, out reason);
				Apply(action, cartId, reason);
			}
		}

		public void Tick()
		{
			if (_lifecycle.IsEngaged)
			{
				BrakeFacts facts = CartBrakeAdapter.ReadFacts(_lifecycle.EngagedCartId);
				if (_lifecycle.EvaluateTick(facts, out string reason) == BrakeAction.Release)
				{
					Apply(BrakeAction.Release, _lifecycle.EngagedCartId, reason);
				}
			}
		}

		public void ReleaseNow(string reason)
		{
			if (_lifecycle.IsEngaged)
			{
				Apply(BrakeAction.Release, _lifecycle.EngagedCartId, reason);
			}
		}

		private void Apply(BrakeAction action, string cartId, string reason)
		{
			switch (action)
			{
			case BrakeAction.Engage:
			{
				if (CartBrakeAdapter.TryEngage(cartId, out var captured))
				{
					_capturedConstraints = captured;
					_lifecycle.MarkEngaged(cartId);
					_log.LogInfo((object)("Parking brake ENGAGED on cart " + cartId + " (" + reason + ")."));
				}
				else
				{
					_log.LogWarning((object)("Parking brake could not engage on cart " + cartId + "; nothing was changed."));
				}
				break;
			}
			case BrakeAction.Release:
			{
				bool flag = CartBrakeAdapter.TryRelease(cartId, _capturedConstraints);
				_lifecycle.MarkReleased();
				_log.LogInfo((object)("Parking brake RELEASED on cart " + cartId + " (" + reason + ")" + (flag ? "." : "; the cart no longer exists, nothing to restore.")));
				break;
			}
			}
		}
	}
	public static class CartAdapter
	{
		private static GameCapabilityReport? _capability;

		private static readonly List<float> DistanceBuffer = new List<float>();

		public static bool CapabilityEnabled
		{
			get
			{
				if (_capability != null)
				{
					return _capability.Enabled;
				}
				return false;
			}
		}

		public static GameCapabilityReport ProbeCapability()
		{
			return _capability = BuildReport();
		}

		private static GameCapabilityReport BuildReport()
		{
			try
			{
				List<string> list = new List<string>();
				Type type = ResolveGameType("Vagon", list);
				Type type2 = ResolveGameType("Container", list);
				Type type3 = ResolveGameType("Inventory", list);
				Type ownerType = ResolveGameType("ZNetView", list);
				Type type4 = ResolveGameType("ZDO", list);
				Type expectedType = ResolveGameType("ZDOID", list);
				Type type5 = ResolveGameType("Player", list);
				Type type6 = ResolveGameType("Character", list);
				if (list.Count > 0)
				{
					return new GameCapabilityReport(Array.Empty<string>(), list);
				}
				Type expectedType2 = typeof(List<>).MakeGenericType(type);
				Type ownerType2 = ResolveNamedType("UnityEngine.Rigidbody, UnityEngine.PhysicsModule", "UnityEngine.Rigidbody", list);
				Type type7 = ResolveNamedType("UnityEngine.Vector3, UnityEngine.CoreModule", "UnityEngine.Vector3", list);
				Type type8 = ResolveGameType("Heightmap", list);
				Type expectedType3 = ResolveNamedType("UnityEngine.Transform, UnityEngine.CoreModule", "UnityEngine.Transform", list);
				Type expectedType4 = ResolveNamedType("UnityEngine.Color, UnityEngine.CoreModule", "UnityEngine.Color", list);
				Type type9 = ResolveGameType("ItemDrop+ItemData", list);
				Type type10 = ResolveGameType("ItemDrop+ItemData+SharedData", list);
				Type expectedType5 = ResolveNamedType("UnityEngine.GameObject, UnityEngine.CoreModule", "UnityEngine.GameObject", list);
				Type type11 = ResolveGameType("ZNet", list);
				if (list.Count > 0)
				{
					return new GameCapabilityReport(Array.Empty<string>(), list);
				}
				Type expectedType6 = typeof(List<>).MakeGenericType(type9);
				List<GameMemberRequirement> list2 = new List<GameMemberRequirement>();
				list2.Add(new GameMemberRequirement("Vagon", type, "m_baseMass", GameMemberKind.InstanceField, typeof(float)));
				list2.Add(new GameMemberRequirement("Vagon", type, "m_itemWeightMassFactor", GameMemberKind.InstanceField, typeof(float)));
				list2.Add(new GameMemberRequirement("Vagon", type, "m_container", GameMemberKind.InstanceField, type2));
				list2.Add(new GameMemberRequirement("Vagon", type, "IsAttached", GameMemberKind.InstanceMethod, typeof(bool)));
				list2.Add(new GameMemberRequirement("Vagon", type, "IsAttached", GameMemberKind.InstanceMethod, typeof(bool), new Type[1] { type6 }));
				list2.Add(new GameMemberRequirement("Container", type2, "GetInventory", GameMemberKind.InstanceMethod, type3));
				list2.Add(new GameMemberRequirement("Inventory", type3, "GetTotalWeight", GameMemberKind.InstanceMethod, typeof(float)));
				list2.Add(new GameMemberRequirement("ZNetView", ownerType, "IsValid", GameMemberKind.InstanceMethod, typeof(bool)));
				list2.Add(new GameMemberRequirement("ZNetView", ownerType, "GetZDO", GameMemberKind.InstanceMethod, type4));
				list2.Add(new GameMemberRequirement("ZDO", type4, "m_uid", GameMemberKind.InstanceField, expectedType));
				list2.Add(new GameMemberRequirement("Player", type5, "m_localPlayer", GameMemberKind.StaticField, type5));
				list2.Add(new GameMemberRequirement("Vagon", type, "m_instances", GameMemberKind.StaticField, expectedType2));
				list2.Add(new GameMemberRequirement("Rigidbody", ownerType2, "linearVelocity", GameMemberKind.InstanceProperty, type7));
				list2.Add(new GameMemberRequirement("Vagon", type, "m_attachPoint", GameMemberKind.InstanceField, expectedType3));
				list2.Add(new GameMemberRequirement("Heightmap", type8, "GetHeight", GameMemberKind.StaticMethod, typeof(bool), new Type[2]
				{
					type7,
					typeof(float).MakeByRefType()
				}));
				list2.Add(new GameMemberRequirement("Heightmap", type8, "FindHeightmap", GameMemberKind.StaticMethod, type8, new Type[1] { type7 }));
				list2.Add(new GameMemberRequirement("Heightmap", type8, "WorldToVertex", GameMemberKind.InstanceMethod, typeof(void), new Type[3]
				{
					type7,
					typeof(int).MakeByRefType(),
					typeof(int).MakeByRefType()
				}));
				list2.Add(new GameMemberRequirement("Heightmap", type8, "GetPaintMask", GameMemberKind.InstanceMethod, expectedType4, new Type[2]
				{
					typeof(int),
					typeof(int)
				}));
				list2.Add(new GameMemberRequirement("Inventory", type3, "GetAllItems", GameMemberKind.InstanceMethod, expectedType6));
				list2.Add(new GameMemberRequirement("ItemData", type9, "m_stack", GameMemberKind.InstanceField, typeof(int)));
				list2.Add(new GameMemberRequirement("ItemData", type9, "m_shared", GameMemberKind.InstanceField, type10));
				list2.Add(new GameMemberRequirement("ItemData", type9, "m_dropPrefab", GameMemberKind.InstanceField, expectedType5));
				list2.Add(new GameMemberRequirement("ItemData", type9, "GetWeight", GameMemberKind.InstanceMethod, typeof(float), new Type[1] { typeof(int) }));
				list2.Add(new GameMemberRequirement("ItemData", type9, "GetNonStackedWeight", GameMemberKind.InstanceMethod, typeof(float)));
				list2.Add(new GameMemberRequirement("SharedData", type10, "m_name", GameMemberKind.InstanceField, typeof(string)));
				list2.Add(new GameMemberRequirement("ZNetView", ownerType, "IsOwner", GameMemberKind.InstanceMethod, typeof(bool)));
				list2.Add(new GameMemberRequirement("Rigidbody", ownerType2, "constraints", GameMemberKind.InstanceProperty, ResolveNamedType("UnityEngine.RigidbodyConstraints, UnityEngine.PhysicsModule", "UnityEngine.RigidbodyConstraints", list)));
				list2.Add(new GameMemberRequirement("ZNet", type11, "instance", GameMemberKind.StaticProperty, type11));
				list2.Add(new GameMemberRequirement("ZNet", type11, "GetWorldUID", GameMemberKind.InstanceMethod, typeof(long)));
				List<GameMemberRequirement> requirements = list2;
				if (list.Count > 0)
				{
					return new GameCapabilityReport(Array.Empty<string>(), list);
				}
				return GameMemberProbe.Probe(requirements);
			}
			catch (Exception ex)
			{
				return new GameCapabilityReport(Array.Empty<string>(), new string[1] { "capability probe failed (" + ex.GetType().Name + ")" });
			}
		}

		private static Type? ResolveGameType(string typeName, List<string> missingTypes)
		{
			return ResolveNamedType(typeName + ", assembly_valheim", typeName, missingTypes);
		}

		private static Type? ResolveNamedType(string assemblyQualifiedName, string label, List<string> missingTypes)
		{
			Type type = null;
			try
			{
				type = Type.GetType(assemblyQualifiedName, throwOnError: false);
			}
			catch
			{
			}
			if ((object)type == null)
			{
				missingTypes.Add(label + " (type not found)");
			}
			return type;
		}

		public static CartSnapshot? TryCreateSnapshot(object? cartComponent)
		{
			if (cartComponent == null || !CapabilityEnabled)
			{
				return null;
			}
			try
			{
				return CreateSnapshotCore(cartComponent);
			}
			catch
			{
				return null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static CartSnapshot? CreateSnapshotCore(object cartComponent)
		{
			Vagon val = (Vagon)((cartComponent is Vagon) ? cartComponent : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			ZNetView component = ((Component)val).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return null;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return null;
			}
			string? cartId = ((object)Unsafe.As<ZDOID, ZDOID>(ref zDO.m_uid)/*cast due to .constrained prefix*/).ToString();
			float baseMass = val.m_baseMass;
			float itemWeightMassFactor = val.m_itemWeightMassFactor;
			float cargoWeight = 0f;
			bool cargoDataAvailable = false;
			Container container = val.m_container;
			if ((Object)(object)container != (Object)null)
			{
				Inventory inventory = container.GetInventory();
				if (inventory != null)
				{
					cargoWeight = inventory.GetTotalWeight();
					cargoDataAvailable = true;
				}
			}
			bool isAttached = val.IsAttached();
			bool isPulledByLocalPlayer = false;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				isPulledByLocalPlayer = val.IsAttached((Character)(object)localPlayer);
			}
			return CartSnapshot.Create(cartId, baseMass, cargoWeight, cargoDataAvailable, itemWeightMassFactor, isAttached, isPulledByLocalPlayer);
		}

		public static CartTelemetry? TrySampleCart(object? cartComponent, double sampleTimeSeconds, IReadOnlyDictionary<string, CartTelemetry> previousByCartId)
		{
			if (cartComponent == null || !CapabilityEnabled)
			{
				return null;
			}
			try
			{
				CartSnapshot cartSnapshot = CreateSnapshotCore(cartComponent);
				if (cartSnapshot == null)
				{
					return null;
				}
				float speedMetersPerSecond;
				float verticalSpeedMetersPerSecond;
				bool velocityAvailable = TryReadVelocityCore(cartComponent, out speedMetersPerSecond, out verticalSpeedMetersPerSecond);
				TryReadPositionCore(cartComponent, out var positionX, out var positionZ);
				TerrainAdapter.GroundReading groundReading = TerrainAdapter.TryReadGround(cartComponent);
				float previousSmoothedPercent = float.NaN;
				GradeDirection previousDirection = GradeDirection.Level;
				if (previousByCartId != null && previousByCartId.TryGetValue(cartSnapshot.CartId, out CartTelemetry value) && value.GradeAvailable)
				{
					previousSmoothedPercent = value.SmoothedGradePercent;
					previousDirection = value.GradeDirection;
				}
				float smoothedGradePercent = GradeMath.Smooth(previousSmoothedPercent, groundReading.InstantGradePercent);
				GradeDirection gradeDirection = GradeMath.ClassifyDirection(smoothedGradePercent, previousDirection);
				return CartTelemetry.Create(cartSnapshot, velocityAvailable, speedMetersPerSecond, verticalSpeedMetersPerSecond, groundReading.GradeAvailable, groundReading.InstantGradePercent, smoothedGradePercent, gradeDirection, groundReading.Surface, sampleTimeSeconds, positionX, positionZ);
			}
			catch
			{
				return null;
			}
		}

		public static void CollectNearbyCarts(List<object> buffer, TelemetrySamplerOptions options)
		{
			if (!CapabilityEnabled)
			{
				return;
			}
			try
			{
				CollectNearbyCartsCore(buffer, options);
			}
			catch
			{
			}
		}

		public static bool HasLocalPlayer()
		{
			if (!CapabilityEnabled)
			{
				return false;
			}
			try
			{
				return HasLocalPlayerCore();
			}
			catch
			{
				return false;
			}
		}

		public static CargoManifest? TryReadManifest(object? cartComponent, double captureTimeSeconds)
		{
			if (cartComponent == null || !CapabilityEnabled)
			{
				return null;
			}
			try
			{
				return ReadManifestCore(cartComponent, captureTimeSeconds);
			}
			catch
			{
				return null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static CargoManifest? ReadManifestCore(object cartComponent, double captureTimeSeconds)
		{
			Vagon val = (Vagon)((cartComponent is Vagon) ? cartComponent : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Container container = val.m_container;
			if ((Object)(object)container == (Object)null)
			{
				return null;
			}
			Inventory inventory = container.GetInventory();
			if (inventory == null)
			{
				return null;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			if (allItems == null || allItems.Count == 0)
			{
				return CargoManifest.CreateEmpty(captureTimeSeconds);
			}
			List<CargoEntry> list = new List<CargoEntry>(allItems.Count);
			for (int i = 0; i < allItems.Count; i++)
			{
				ItemData val2 = allItems[i];
				if (val2 != null)
				{
					try
					{
						string text = val2.m_shared?.m_name;
						string text2 = (((Object)(object)val2.m_dropPrefab != (Object)null) ? ((Object)val2.m_dropPrefab).name : null);
						list.Add(CargoEntry.Create(text2 ?? text, text, val2.m_stack, val2.GetNonStackedWeight(), val2.GetWeight(-1), weightKnown: true));
					}
					catch
					{
						list.Add(CargoEntry.CreateUnreadable(i));
					}
				}
			}
			return CargoManifest.Create(list, captureTimeSeconds);
		}

		public static object? TryFindCartById(string? cartId)
		{
			if (string.IsNullOrEmpty(cartId) || !CapabilityEnabled)
			{
				return null;
			}
			try
			{
				return FindCartByIdCore(cartId);
			}
			catch
			{
				return null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static object? FindCartByIdCore(string cartId)
		{
			List<Vagon> instances = Vagon.m_instances;
			if (instances == null)
			{
				return null;
			}
			for (int i = 0; i < instances.Count; i++)
			{
				Vagon val = instances[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				ZNetView component = ((Component)val).GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && component.IsValid())
				{
					ZDO zDO = component.GetZDO();
					if (zDO != null && ((object)Unsafe.As<ZDOID, ZDOID>(ref zDO.m_uid)/*cast due to .constrained prefix*/).ToString() == cartId)
					{
						return val;
					}
				}
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void TryReadPositionCore(object cartComponent, out float positionX, out float positionZ)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			positionX = 0f;
			positionZ = 0f;
			Vagon val = (Vagon)((cartComponent is Vagon) ? cartComponent : null);
			if (!((Object)(object)val == (Object)null))
			{
				Vector3 position = ((Component)val).transform.position;
				positionX = position.x;
				positionZ = position.z;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool HasLocalPlayerCore()
		{
			return (Object)(object)Player.m_localPlayer != (Object)null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool TryReadVelocityCore(object cartComponent, out float speedMetersPerSecond, out float verticalSpeedMetersPerSecond)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			speedMetersPerSecond = 0f;
			verticalSpeedMetersPerSecond = 0f;
			Vagon val = (Vagon)((cartComponent is Vagon) ? cartComponent : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			Vector3 linearVelocity = component.linearVelocity;
			speedMetersPerSecond = ((Vector3)(ref linearVelocity)).magnitude;
			verticalSpeedMetersPerSecond = linearVelocity.y;
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void CollectNearbyCartsCore(List<object> buffer, TelemetrySamplerOptions options)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			List<Vagon> instances = Vagon.m_instances;
			if (instances == null)
			{
				return;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			float num = options.SearchRadiusMeters * options.SearchRadiusMeters;
			int maxTrackedCarts = options.MaxTrackedCarts;
			DistanceBuffer.Clear();
			for (int i = 0; i < instances.Count; i++)
			{
				Vagon val = instances[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Vector3 val2 = ((Component)val).transform.position - position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude > num)
				{
					continue;
				}
				int num2 = buffer.Count;
				while (num2 > 0 && DistanceBuffer[num2 - 1] > sqrMagnitude)
				{
					num2--;
				}
				if (num2 < maxTrackedCarts)
				{
					buffer.Insert(num2, val);
					DistanceBuffer.Insert(num2, sqrMagnitude);
					if (buffer.Count > maxTrackedCarts)
					{
						buffer.RemoveAt(buffer.Count - 1);
						DistanceBuffer.RemoveAt(DistanceBuffer.Count - 1);
					}
				}
			}
			DistanceBuffer.Clear();
		}
	}
	public static class CartBrakeAdapter
	{
		public static BrakeFacts ReadFacts(string? cartId)
		{
			if (!CartAdapter.CapabilityEnabled)
			{
				return BrakeFacts.Unavailable;
			}
			try
			{
				return ReadFactsCore(cartId);
			}
			catch
			{
				return BrakeFacts.Unavailable;
			}
		}

		public static bool TryEngage(string cartId, out int captured)
		{
			captured = 0;
			if (!CartAdapter.CapabilityEnabled)
			{
				return false;
			}
			try
			{
				return EngageCore(cartId, out captured);
			}
			catch
			{
				return false;
			}
		}

		public static bool TryRelease(string cartId, int captured)
		{
			if (!CartAdapter.CapabilityEnabled)
			{
				return false;
			}
			try
			{
				return ReleaseCore(cartId, captured);
			}
			catch
			{
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static BrakeFacts ReadFactsCore(string? cartId)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)Player.m_localPlayer != (Object)null;
			if (cartId == null || !flag)
			{
				return new BrakeFacts(capabilityOk: true, flag, cartExists: false, isLocalAuthority: false, isAttached: false, float.MaxValue);
			}
			object? obj = CartAdapter.TryFindCartById(cartId);
			Vagon val = (Vagon)((obj is Vagon) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return new BrakeFacts(capabilityOk: true, flag, cartExists: false, isLocalAuthority: false, isAttached: false, float.MaxValue);
			}
			ZNetView component = ((Component)val).GetComponent<ZNetView>();
			bool isLocalAuthority = (Object)(object)component != (Object)null && component.IsValid() && component.IsOwner();
			bool isAttached = val.IsAttached();
			float distanceMeters = Vector3.Distance(((Component)val).transform.position, ((Component)Player.m_localPlayer).transform.position);
			return new BrakeFacts(capabilityOk: true, flag, cartExists: true, isLocalAuthority, isAttached, distanceMeters);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool EngageCore(string cartId, out int captured)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected I4, but got Unknown
			captured = 0;
			object? obj = CartAdapter.TryFindCartById(cartId);
			Vagon val = (Vagon)((obj is Vagon) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			captured = (int)component.constraints;
			component.constraints = (RigidbodyConstraints)126;
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool ReleaseCore(string cartId, int captured)
		{
			object? obj = CartAdapter.TryFindCartById(cartId);
			Vagon val = (Vagon)((obj is Vagon) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			component.constraints = (RigidbodyConstraints)captured;
			component.WakeUp();
			return true;
		}
	}
	public static class CartographerCapability
	{
		private static CartographerCapabilityReport? _report;

		private static object? _pluginInstance;

		public static CartographerCapabilityReport? Report => _report;

		public static bool IsAvailable => _report?.IsAvailable ?? false;

		public static CartographerCapabilityReport EnsureProbed(ManualLogSource logger)
		{
			if (_report != null)
			{
				return _report;
			}
			_report = CartographerGate.Evaluate(Lookup);
			logger.LogInfo((object)_report.LogLine);
			return _report;
		}

		public static bool TryReadRoutes(out IReadOnlyList<CartographerRouteSnapshot> routes)
		{
			if (!IsAvailable)
			{
				routes = Array.Empty<CartographerRouteSnapshot>();
				return false;
			}
			return CartographerRouteReader.TryReadRoutes(_pluginInstance, out routes);
		}

		public static bool TryReadRouteChangeStamp(out long changeStamp)
		{
			if (!IsAvailable)
			{
				changeStamp = 0L;
				return false;
			}
			return CartographerRouteReader.TryReadChangeStamp(_pluginInstance, out changeStamp);
		}

		private static CartographerLookup Lookup()
		{
			if (!Chainloader.PluginInfos.TryGetValue("com.theconcernedcat.valheim.concernedcartographer", out var value) || value == null)
			{
				return CartographerLookup.NotFound();
			}
			BepInPlugin metadata = value.Metadata;
			Version version = ((metadata != null) ? metadata.Version : null);
			_pluginInstance = value.Instance;
			return CartographerLookup.Detected(version, value.Instance);
		}
	}
	internal sealed class CartTelemetryPump : MonoBehaviour
	{
		private const double DebugSummaryPeriodSeconds = 5.0;

		private TelemetrySampler? _sampler;

		private TeamsterSettings? _settings;

		private ManualLogSource? _log;

		private CartWarningTracker? _warnings;

		private WarningOptions? _warningOptions;

		private RiskModel? _riskModel;

		private LookaheadOptions? _lookaheadOptions;

		private bool _resetWhileNoLocalPlayer;

		private double _nextDebugSummaryTime;

		private bool _failed;

		private StuckDetector? _stuckDetector;

		private TripRecordingService? _trips;

		private long _lastKnownWorldUid;

		public DescentRiskInfo? LatestDescentRisk { get; private set; }

		public BrakeService? Brake { get; private set; }

		public TripRecordingService? Trips => _trips;

		public LoadModel? LoadModel { get; private set; }

		public CartDiagnostic? LatestDiagnostic { get; private set; }

		public IReadOnlyDictionary<string, CartTelemetry>? Telemetry => _sampler?.TelemetryByCartId;

		public WarningOptions? WarningOptions => _warningOptions;

		public CartWarning? TryGetWarning(string? cartId)
		{
			if (cartId == null)
			{
				return null;
			}
			if (!CompatibilityAdapter.CartMassAdviceReliable)
			{
				return new CartWarning(cartId, WarningLevel.Caution, TeamsterStrings.Get("compat.alteredPhysicsSituation"), TeamsterStrings.Get("compat.alteredPhysicsAction"));
			}
			return _warnings?.TryGet(cartId);
		}

		internal TelemetrySamplerOptions Initialize(TeamsterSettings settings, ManualLogSource log, LoadModel? loadModel, RiskModel? riskModel)
		{
			_settings = settings;
			_log = log;
			TelemetrySamplerOptions telemetrySamplerOptions = TelemetrySamplerOptions.CreateClamped(settings.SampleIntervalSeconds.Value, settings.SearchRadiusMeters.Value, settings.MaxCartsPerTick.Value, settings.MaxTrackedCarts.Value);
			_sampler = new TelemetrySampler(telemetrySamplerOptions, CartAdapter.CollectNearbyCarts, CartAdapter.TrySampleCart);
			_warnings = new CartWarningTracker(loadModel);
			_warningOptions = TheConcernedCat.ConcernedTeamster.Domain.Warnings.WarningOptions.CreateClamped(settings.SteepGradeCautionPercent.Value, settings.PanelWarningsEnabled.Value, settings.HudWarningHintsEnabled.Value);
			_riskModel = riskModel;
			_lookaheadOptions = LookaheadOptions.CreateClamped(settings.RiskLookaheadPoints.Value);
			Brake = (settings.BrakeEnabled.Value ? new BrakeService(log) : null);
			_stuckDetector = new StuckDetector(loadModel);
			LoadModel = loadModel;
			_trips = (settings.TripsEnabled.Value ? new TripRecordingService(TripRecorderOptions.CreateClamped(settings.TripRecordSpacingSeconds.Value, settings.TripMaxSamplesPerTrip.Value, settings.TripMaxTripsRetained.Value), log, "1.0.1") : null);
			return telemetrySamplerOptions;
		}

		private void Update()
		{
			if (_failed)
			{
				return;
			}
			try
			{
				UpdateCore();
			}
			catch (Exception ex)
			{
				_failed = true;
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogError((object)("Cart telemetry pump failed and was disabled for this session: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private void UpdateCore()
		{
			TelemetrySampler sampler = _sampler;
			if (sampler == null)
			{
				return;
			}
			if (!CartAdapter.HasLocalPlayer())
			{
				if (!_resetWhileNoLocalPlayer)
				{
					sampler.Reset();
					_warnings?.Reset();
					LatestDescentRisk = null;
					_stuckDetector?.Reset();
					LatestDiagnostic = null;
					Brake?.ReleaseNow("left the world");
					_trips?.FlushAndReset(_lastKnownWorldUid);
					_lastKnownWorldUid = 0L;
					_resetWhileNoLocalPlayer = true;
				}
				return;
			}
			_resetWhileNoLocalPlayer = false;
			double unscaledTimeAsDouble = Time.unscaledTimeAsDouble;
			if (!sampler.Tick(unscaledTimeAsDouble))
			{
				return;
			}
			if (_warnings != null && _warningOptions != null)
			{
				foreach (KeyValuePair<string, CartTelemetry> item in sampler.TelemetryByCartId)
				{
					if (item.Value.SampleTimeSeconds == unscaledTimeAsDouble)
					{
						_warnings.Update(item.Value, _warningOptions);
					}
				}
				_warnings.Sweep(unscaledTimeAsDouble, sampler.Options.EvictAfterSeconds);
			}
			bool flag = false;
			foreach (KeyValuePair<string, CartTelemetry> item2 in sampler.TelemetryByCartId)
			{
				if (item2.Value.IsPulledByLocalPlayer)
				{
					flag = true;
					if (item2.Value.SampleTimeSeconds == unscaledTimeAsDouble && _lookaheadOptions != null)
					{
						object obj = CartAdapter.TryFindCartById(item2.Key);
						TerrainAdapter.LookaheadReading lookaheadReading = ((obj == null) ? TerrainAdapter.LookaheadReading.Unavailable : TerrainAdapter.TryReadDescentLookahead(obj, _lookaheadOptions));
						RiskVerdict current3 = DescentRiskEvaluator.EvaluateCurrent(_riskModel, item2.Value);
						RiskVerdict lookahead = DescentRiskEvaluator.EvaluateLookahead(_riskModel, item2.Value, lookaheadReading.Available, lookaheadReading.WorstDownGradePercent);
						LatestDescentRisk = new DescentRiskInfo(item2.Key, current3, lookaheadReading.Available, lookaheadReading.WorstDownGradePercent, lookahead, unscaledTimeAsDouble);
						LatestDiagnostic = _stuckDetector?.Update(item2.Value, CompatibilityAdapter.CartMassAdviceReliable);
						_trips?.FeedPulled(item2.Value);
						break;
					}
				}
			}
			if (!flag)
			{
				LatestDescentRisk = null;
				LatestDiagnostic = null;
				_stuckDetector?.Reset();
				_trips?.NotifyNotPulled(unscaledTimeAsDouble);
			}
			if (_trips != null && WorldContextAdapter.TryGetWorldUid(out var worldUid))
			{
				_lastKnownWorldUid = worldUid;
			}
			Brake?.Tick();
			TeamsterSettings settings = _settings;
			if (settings != null && settings.DebugLogging.Value && unscaledTimeAsDouble >= _nextDebugSummaryTime)
			{
				_nextDebugSummaryTime = unscaledTimeAsDouble + 5.0;
				string text = ((LatestDescentRisk == null) ? "." : ("; " + LatestDescentRisk.Describe() + (CompatibilityAdapter.CartMassAdviceReliable ? "." : " (mass/physics-altering mod detected — assumes vanilla physics).")));
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogDebug((object)($"Cart telemetry: {sampler.TrackedCartCount} tracked, " + $"{sampler.SampledOnLastDueTick} sampled this tick" + text));
				}
			}
		}

		private void OnDestroy()
		{
			Brake?.ReleaseNow("plugin shutdown");
			_trips?.FlushAndReset(_lastKnownWorldUid);
		}
	}
	public static class CompatibilityAdapter
	{
		private static IReadOnlyList<ModDetectionResult>? _results;

		public static IReadOnlyList<ModDetectionResult>? Results => _results;

		public static bool CartMassAdviceReliable => CompatibilityAdvisoryGate.CartMassAdviceReliable(_results ?? Array.Empty<ModDetectionResult>());

		public static IReadOnlyList<ModDetectionResult> EnsureProbed(ManualLogSource logger)
		{
			if (_results != null)
			{
				return _results;
			}
			_results = CompatibilityRegistry.Evaluate(CompatibilityKnownMods.Registry, Lookup);
			IReadOnlyList<string> readOnlyList = CompatibilityStatusPresenter.ComposeDetectedLines(_results);
			if (readOnlyList.Count == 0)
			{
				logger.LogInfo((object)CompatibilityStatusPresenter.ComposeNoneDetectedLine());
			}
			else
			{
				foreach (string item in readOnlyList)
				{
					logger.LogInfo((object)item);
				}
			}
			return _results;
		}

		private static (bool Found, string? Version) Lookup(string guid)
		{
			if (!Chainloader.PluginInfos.TryGetValue(guid, out var value) || value == null)
			{
				return (Found: false, Version: null);
			}
			BepInPlugin metadata = value.Metadata;
			return (Found: true, Version: (metadata == null) ? null : metadata.Version?.ToString());
		}
	}
	public static class GameLocalization
	{
		private static Func<string, string>? _localize;

		private static bool _resolved;

		public static string LocalizeOrRaw(string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return token;
			}
			try
			{
				Func<string, string> func = ResolveLocalize();
				if (func == null)
				{
					return token;
				}
				string text = func(token);
				return string.IsNullOrEmpty(text) ? token : text;
			}
			catch
			{
				return token;
			}
		}

		private static Func<string, string>? ResolveLocalize()
		{
			if (_resolved)
			{
				return _localize;
			}
			_resolved = true;
			try
			{
				Type type = Type.GetType("Localization, assembly_guiutils", throwOnError: false);
				if ((object)type == null)
				{
					return null;
				}
				object obj = type.GetField("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) ?? type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj == null)
				{
					_resolved = false;
					return null;
				}
				MethodInfo method = type.GetMethod("Localize", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
				if ((object)method == null || method.ReturnType != typeof(string))
				{
					return null;
				}
				_localize = (Func<string, string>)method.CreateDelegate(typeof(Func<string, string>), obj);
				return _localize;
			}
			catch
			{
				return null;
			}
		}
	}
	public static class GameVersionResolver
	{
		public static string Resolve()
		{
			try
			{
				Type type = Type.GetType("Version, assembly_valheim", throwOnError: false);
				if ((object)type == null)
				{
					return "unknown";
				}
				object obj = type.GetField("CurrentVersion", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) ?? type.GetProperty("CurrentVersion", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj != null)
				{
					return obj.ToString() ?? "unknown";
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					if (!(methodInfo.Name != "GetVersionString") && !(methodInfo.ReturnType != typeof(string)))
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						object[] array = new object[parameters.Length];
						for (int j = 0; j < parameters.Length; j++)
						{
							array[j] = (parameters[j].HasDefaultValue ? parameters[j].DefaultValue : (parameters[j].ParameterType.IsValueType ? Activator.CreateInstance(parameters[j].ParameterType) : null));
						}
						return (methodInfo.Invoke(null, array) as string) ?? "unknown";
					}
				}
			}
			catch
			{
			}
			return "unknown";
		}
	}
	public static class LocalizationFiles
	{
		public static string OverridePath => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedTeamster", "teamster-strings.tsv");

		public static string TemplatePath => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedTeamster", "teamster-strings-template.tsv");

		public static void Initialize(ManualLogSource log)
		{
			TeamsterStrings.MissingKeyReporter = delegate(string key)
			{
				log.LogWarning((object)("Localization key '" + key + "' has no English default; showing the raw key. This is a Concerned Teamster defect worth reporting."));
			};
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(TemplatePath));
				File.WriteAllLines(TemplatePath, new List<string>(TeamsterStrings.TranslatorTemplate()));
				if (File.Exists(OverridePath))
				{
					int skippedRows;
					Dictionary<string, string> dictionary = TeamsterStrings.ParseOverrides(File.ReadAllLines(OverridePath), out skippedRows);
					TeamsterStrings.LoadOverrides(dictionary);
					log.LogInfo((object)($"Loaded {dictionary.Count} translated string(s) from teamster-strings.tsv" + ((skippedRows > 0) ? $" ({skippedRows} row(s) skipped — malformed, unknown key, or placeholder mismatch)." : ".")));
				}
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("Localization overrides unavailable this session; using English: " + ex.GetType().Name));
			}
		}
	}
	internal sealed class LogTailRecorder
	{
		private const int MaxLines = 100;

		private readonly Queue<string> _lines = new Queue<string>();

		private readonly object _gate = new object();

		private ManualLogSource? _attached;

		public void Attach(ManualLogSource log)
		{
			_attached = log;
			log.LogEvent += HandleLogEvent;
		}

		public void Detach()
		{
			if (_attached != null)
			{
				_attached.LogEvent -= HandleLogEvent;
				_attached = null;
			}
		}

		public IReadOnlyList<string> Snapshot()
		{
			lock (_gate)
			{
				return new List<string>(_lines);
			}
		}

		private void HandleLogEvent(object sender, LogEventArgs args)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string item = "[" + ((object)args.Level/*cast due to .constrained prefix*/).ToString() + "] " + args.Data;
				lock (_gate)
				{
					_lines.Enqueue(item);
					while (_lines.Count > 100)
					{
						_lines.Dequeue();
					}
				}
			}
			catch
			{
			}
		}
	}
	internal static class SupportBundleExporter
	{
		private const string SidecarFilePrefix = "teamster_trips_";

		private const string SidecarFileSuffix = ".txt";

		public static string BundleDirectory => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedTeamster", "SupportBundles");

		public static (bool Success, string? Path, string? Error) Export(string pluginVersion, TeamsterSettings settings, TripRecordingService? trips, LogTailRecorder? logTail, DateTime generatedUtc)
		{
			IReadOnlyList<string> compatibilityLines = ComposeCompatibilityLines();
			int backupFileCount;
			List<SupportBundleComposer.SidecarSummary> sidecars = GatherSidecarSummaries(out backupFileCount);
			IReadOnlyList<RecoveryEvent> recoveryEvents = trips?.RecoveryEvents ?? Array.Empty<RecoveryEvent>();
			IReadOnlyList<string> recentLogLines = logTail?.Snapshot() ?? Array.Empty<string>();
			List<string> values = SupportBundleComposer.Compose(generatedUtc, pluginVersion, ComposeEffectiveConfigSummary(settings), compatibilityLines, sidecars, backupFileCount, recoveryEvents, recentLogLines);
			string path = "support-bundle-" + generatedUtc.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture) + ".txt";
			string text = Path.Combine(BundleDirectory, path);
			string error;
			bool num = SidecarFileStore.TryWriteAtomic(text, string.Join("\n", values), out error);
			return (Success: num, Path: num ? text : null, Error: error);
		}

		private static string ComposeEffectiveConfigSummary(TeamsterSettings settings)
		{
			return "Enabled=" + settings.Enabled.Value + ", DebugLogging=" + settings.DebugLogging.Value + ", Brake.Enabled=" + settings.BrakeEnabled.Value + ", Trips.Enabled=" + settings.TripsEnabled.Value + ", UiScale=" + settings.UiScale.Value.ToString("0.##", CultureInfo.InvariantCulture) + ", Profile=" + settings.ActiveProfile.Value.ToString() + ", ConfigSchemaVersion=" + settings.SchemaVersion.Value;
		}

		private static IReadOnlyList<string> ComposeCompatibilityLines()
		{
			IReadOnlyList<ModDetectionResult> results = CompatibilityAdapter.Results;
			if (results == null)
			{
				return new string[1] { "(not yet probed)" };
			}
			IReadOnlyList<string> readOnlyList = CompatibilityStatusPresenter.ComposeDetectedLines(results);
			if (readOnlyList.Count != 0)
			{
				return readOnlyList;
			}
			return new string[1] { CompatibilityStatusPresenter.ComposeNoneDetectedLine() };
		}

		private static List<SupportBundleComposer.SidecarSummary> GatherSidecarSummaries(out int backupFileCount)
		{
			List<SupportBundleComposer.SidecarSummary> list = new List<SupportBundleComposer.SidecarSummary>();
			backupFileCount = 0;
			string sidecarDirectory = TripRecordingService.SidecarDirectory;
			if (!Directory.Exists(sidecarDirectory))
			{
				return list;
			}
			backupFileCount = Directory.GetFiles(sidecarDirectory, "teamster_trips_*.txt.bak-*").Length;
			string[] files = Directory.GetFiles(sidecarDirectory, "teamster_trips_*.txt");
			foreach (string text in files)
			{
				string fileName = Path.GetFileName(text);
				if (long.TryParse(fileName.Substring("teamster_trips_".Length, fileName.Length - "teamster_trips_".Length - ".txt".Length), out var result))
				{
					string error;
					string text2 = SidecarFileStore.TryRead(text, out error);
					if (error == null && text2 != null)
					{
						TripSidecar.ParseResult parseResult = TripSidecar.Parse(text2, result);
						long kilobyteSize = (new FileInfo(text).Length + 1023) / 1024;
						list.Add(new SupportBundleComposer.SidecarSummary(fileName, kilobyteSize, parseResult.Trips.Count, parseResult.Errors.Count));
					}
				}
			}
			return list;
		}
	}
	public static class TerrainAdapter
	{
		public readonly struct GroundReading
		{
			public bool GradeAvailable { get; }

			public float InstantGradePercent { get; }

			public TerrainSurfaceKind Surface { get; }

			public static GroundReading Unavailable => new GroundReading(gradeAvailable: false, float.NaN, TerrainSurfaceKind.Unavailable);

			public GroundReading(bool gradeAvailable, float instantGradePercent, TerrainSurfaceKind surface)
			{
				GradeAvailable = gradeAvailable;
				InstantGradePercent = instantGradePercent;
				Surface = surface;
			}
		}

		public readonly struct LookaheadReading
		{
			public bool Available { get; }

			public float WorstDownGradePercent { get; }

			public static LookaheadReading Unavailable => new LookaheadReading(available: false, 0f);

			public LookaheadReading(bool available, float worstDownGradePercent)
			{
				Available = available;
				WorstDownGradePercent = worstDownGradePercent;
			}
		}

		public const float HalfRunMeters = 1.5f;

		public static GroundReading TryReadGround(object? cartComponent)
		{
			if (cartComponent == null || !CartAdapter.CapabilityEnabled)
			{
				return GroundReading.Unavailable;
			}
			try
			{
				return ReadGroundCore(cartComponent);
			}
			catch
			{
				return GroundReading.Unavailable;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static GroundReading ReadGroundCore(object cartComponent)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Vagon val = (Vagon)((cartComponent is Vagon) ? cartComponent : null);
			if ((Object)(object)val == (Object)null)
			{
				return GroundReading.Unavailable;
			}
			Vector3 position = ((Component)val).transform.position;
			bool gradeAvailable = false;
			float num = float.NaN;
			Vector3 val2 = ResolveHeading(val);
			if (((Vector3)(ref val2)).sqrMagnitude > 0f)
			{
				Vector3 val3 = position + val2 * 1.5f;
				Vector3 val4 = position - val2 * 1.5f;
				float heightAhead = default(float);
				float heightBehind = default(float);
				if (Heightmap.GetHeight(val3, ref heightAhead) && Heightmap.GetHeight(val4, ref heightBehind))
				{
					num = GradeMath.ComputeInstantGradePercent(heightAhead, heightBehind, 3f);
					gradeAvailable = !float.IsNaN(num);
				}
			}
			TerrainSurfaceKind surface = TerrainSurfaceKind.Unavailable;
			Heightmap val5 = Heightmap.FindHeightmap(position);
			if ((Object)(object)val5 != (Object)null)
			{
				int num2 = default(int);
				int num3 = default(int);
				val5.WorldToVertex(position, ref num2, ref num3);
				Color paintMask = val5.GetPaintMask(num2, num3);
				surface = TerrainPaint.Classify(paintMask.r, paintMask.g, paintMask.b, 0.4f);
			}
			return new GroundReading(gradeAvailable, num, surface);
		}

		public static LookaheadReading TryReadDescentLookahead(object? cartComponent, LookaheadOptions options)
		{
			if (cartComponent == null || options.Points == 0 || !CartAdapter.CapabilityEnabled)
			{
				return LookaheadReading.Unavailable;
			}
			try
			{
				return ReadDescentLookaheadCore(cartComponent, options);
			}
			catch
			{
				return LookaheadReading.Unavailable;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static LookaheadReading ReadDescentLookaheadCore(object cartComponent, LookaheadOptions options)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			Vagon val = (Vagon)((cartComponent is Vagon) ? cartComponent : null);
			if ((Object)(object)val == (Object)null)
			{
				return LookaheadReading.Unavailable;
			}
			Vector3 val2 = ResolveHeading(val);
			if (((Vector3)(ref val2)).sqrMagnitude <= 0f)
			{
				return LookaheadReading.Unavailable;
			}
			Vector3 position = ((Component)val).transform.position;
			float num = default(float);
			if (!Heightmap.GetHeight(position, ref num))
			{
				return LookaheadReading.Unavailable;
			}
			float num2 = 0f;
			float[] offsetsMeters = options.OffsetsMeters;
			float num3 = default(float);
			for (int i = 0; i < offsetsMeters.Length; i++)
			{
				if (!Heightmap.GetHeight(position + val2 * offsetsMeters[i], ref num3))
				{
					return LookaheadReading.Unavailable;
				}
				float num4 = 0f - (num3 - num) / 4f * 100f;
				if (num4 > num2)
				{
					num2 = num4;
				}
				num = num3;
			}
			return new LookaheadReading(available: true, num2);
		}

		public static bool TrySamplePoint(float x, float z, out float height, out TerrainSurfaceKind surface)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			height = float.NaN;
			surface = TerrainSurfaceKind.Unavailable;
			if (!CartAdapter.CapabilityEnabled)
			{
				return false;
			}
			try
			{
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(x, 0f, z);
				float num = default(float);
				if (!Heightmap.GetHeight(val, ref num))
				{
					return false;
				}
				height = num;
				Heightmap val2 = Heightmap.FindHeightmap(val);
				if ((Object)(object)val2 != (Object)null)
				{
					int num2 = default(int);
					int num3 = default(int);
					val2.WorldToVertex(val, ref num2, ref num3);
					Color paintMask = val2.GetPaintMask(num2, num3);
					surface = TerrainPaint.Classify(paintMask.r, paintMask.g, paintMask.b, 0.4f);
				}
				return true;
			}
			catch
			{
				height = float.NaN;
				surface = TerrainSurfaceKind.Unavailable;
				return false;
			}
		}

		private static Vector3 ResolveHeading(Vagon vagon)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			Transform attachPoint = vagon.m_attachPoint;
			Vector3 val = (((Object)(object)attachPoint != (Object)null) ? (attachPoint.position - ((Component)vagon).transform.position) : ((Component)vagon).transform.forward);
			val.y = 0f;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			if (sqrMagnitude < 1E-06f)
			{
				val = ((Component)vagon).transform.forward;
				val.y = 0f;
				sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < 1E-06f)
				{
					return Vector3.zero;
				}
			}
			return val / Mathf.Sqrt(sqrMagnitude);
		}
	}
	internal sealed class TripRecordingService
	{
		private const int MaxRecoveryEventsRetained = 50;

		private readonly TripRecorder _recorder;

		private readonly TripRecorderOptions _options;

		private readonly ManualLogSource _log;

		private readonly string _pluginVersion;

		private readonly List<RecoveryEvent> _recoveryEvents = new List<RecoveryEvent>();

		private readonly List<Trip> _pendingRetryTrips = new List<Trip>();

		private long _pendingRetryWorldUid;

		private bool _ioFailureLogged;

		private bool _refusalLogged;

		public IReadOnlyList<RecoveryEvent> RecoveryEvents => _recoveryEvents;

		public static string SidecarDirectory => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedTeamster");

		public TripRecordingService(TripRecorderOptions options, ManualLogSource log, string pluginVersion)
		{
			_options = options;
			_recorder = new TripRecorder(options);
			_log = log;
			_pluginVersion = pluginVersion;
		}

		public static string SidecarPathFor(long worldUid)
		{
			return Path.Combine(SidecarDirectory, "teamster_trips_" + worldUid.ToString(CultureInfo.InvariantCulture) + ".txt");
		}

		public void FeedPulled(CartTelemetry telemetry)
		{
			_recorder.FeedPulled(telemetry);
			PersistFinishedTrips();
		}

		public void NotifyNotPulled(double nowSeconds)
		{
			_recorder.NotifyNotPulled(nowSeconds);
			PersistFinishedTrips();
		}

		public void FlushAndReset(long lastKnownWorldUid)
		{
			IReadOnlyList<Trip> readOnlyList = _recorder.DrainOnReset();
			if (readOnlyList.Count > 0 || _pendingRetryTrips.Count > 0)
			{
				Persist(readOnlyList, lastKnownWorldUid);
			}
		}

		private void PersistFinishedTrips()
		{
			IReadOnlyList<Trip> readOnlyList = _recorder.DrainFinishedTrips();
			if (readOnlyList.Count != 0 || _pendingRetryTrips.Count != 0)
			{
				if (!WorldContextAdapter.TryGetWorldUid(out var worldUid))
				{
					WarnIoOnce("world UID unavailable; finished trip dropped rather than misfiled");
				}
				else
				{
					Persist(readOnlyList, worldUid);
				}
			}
		}

		private void Persist(IReadOnlyList<Trip> newTrips, long worldUid)
		{
			if (worldUid == 0L)
			{
				WarnIoOnce("world UID unavailable at flush; finished trip dropped rather than misfiled");
				return;
			}
			List<Trip> list = CombineWithPendingRetry(newTrips, worldUid);
			string text = SidecarPathFor(worldUid);
			string error;
			string text2 = SidecarFileStore.TryRead(text, out error);
			if (error != null)
			{
				WarnIoOnce("sidecar read failed: " + error + "; will retry with the next trip");
				RetainForRetry(list, worldUid);
				return;
			}
			TripSidecar.ParseResult existing = TripSidecar.Parse(text2, worldUid);
			TripPersistPlan.Plan plan = TripPersistPlan.Decide(existing);
			if (plan.BackupReason == "refused" && !_refusalLogged)
			{
				_refusalLogged = true;
				_log.LogWarning((object)("Trip sidecar at " + text + ": " + plan.LogWarning));
			}
			else if (plan.BackupReason == "malformed" && !_ioFailureLogged)
			{
				_ioFailureLogged = true;
				_log.LogWarning((object)plan.LogWarning);
			}
			if (plan.LogInfo != null)
			{
				_log.LogInfo((object)plan.LogInfo);
			}
			if (plan.BackupReason != null)
			{
				if (!SidecarFileStore.TryBackup(text, plan.BackupReason, out string error2))
				{
					WarnIoOnce("sidecar backup failed: " + error2 + "; will retry with the next trip");
					RetainForRetry(list, worldUid);
					return;
				}
				RecordRecoveryEvent(plan.BackupReason, text, plan.LogWarning ?? plan.LogInfo);
			}
			string content = TripSidecar.MergeAndCompose(existing, list, _options.MaxTripsRetained, worldUid, _pluginVersion);
			if (!SidecarFileStore.TryWriteAtomic(text, content, out string error3))
			{
				WarnIoOnce("sidecar write failed: " + error3 + "; previous file left intact; will retry with the next trip");
				RetainForRetry(list, worldUid);
			}
		}

		private List<Trip> CombineWithPendingRetry(IReadOnlyList<Trip> newTrips, long worldUid)
		{
			if (TripPersistPlan.ShouldDiscardPendingRetry(_pendingRetryTrips.Count, _pendingRetryWorldUid, worldUid))
			{
				int count = _pendingRetryTrips.Count;
				_pendingRetryTrips.Clear();
				WarnIoOnce(count + " trip(s) pending retry from a previous world were discarded; the world changed before they could be saved");
				RecordRecoveryEvent("world-changed", SidecarPathFor(_pendingRetryWorldUid), count + " trip(s) pending retry after an earlier save failure were discarded because the world changed before they could be saved.");
			}
			List<Trip> result = TripPersistPlan.CombineForRetry(_pendingRetryTrips, newTrips);
			_pendingRetryTrips.Clear();
			return result;
		}

		private void RetainForRetry(List<Trip> trips, long worldUid)
		{
			_pendingRetryWorldUid = worldUid;
			_pendingRetryTrips.AddRange(TripPersistPlan.BoundForRetry(trips, _options.MaxTripsRetained));
		}

		public (IReadOnlyList<Trip> Trips, RoadQualityIndex Segments, long WorldUid) LoadWorldData()
		{
			RoadQualityIndex item = new RoadQualityIndex();
			if (!WorldContextAdapter.TryGetWorldUid(out var worldUid))
			{
				return (Trips: Array.Empty<Trip>(), Segments: item, WorldUid: 0L);
			}
			string error;
			TripSidecar.ParseResult parseResult = TripSidecar.Parse(SidecarFileStore.TryRead(SidecarPathFor(worldUid), out error), worldUid);
			if (parseResult.Refused)
			{
				return (Trips: Array.Empty<Trip>(), Segments: item, WorldUid: worldUid);
			}
			RoadQualityIndex item2 = (parseResult.NeedsMigration ? RoadQualityIndex.ComputeFromTrips(parseResult.Trips) : parseResult.Segments);
			return (Trips: parseResult.Trips, Segments: item2, WorldUid: worldUid);
		}

		public bool DeleteTrip(int tripId)
		{
			if (!WorldContextAdapter.TryGetWorldUid(out var worldUid))
			{
				return false;
			}
			string path = SidecarPathFor(worldUid);
			string error;
			string text = SidecarFileStore.TryRead(path, out error);
			if (error != null || text == null)
			{
				return false;
			}
			TripSidecar.ParseResult parseResult = TripSidecar.Parse(text, worldUid);
			if (parseResult.Refused)
			{
				return false;
			}
			List<Trip> list = new List<Trip>();
			bool flag = false;
			foreach (Trip trip in parseResult.Trips)
			{
				if (trip.Id == tripId && !flag)
				{
					flag = true;
				}
				else
				{
					list.Add(trip);
				}
			}
			if (!flag)
			{
				return false;
			}
			string content = TripSidecar.Compose(TripSidecar.Prune(list, int.MaxValue), worldUid, _pluginVersion, parseResult.Segments);
			if (!SidecarFileStore.TryWriteAtomic(path, content, out string error2))
			{
				WarnIoOnce("sidecar write failed during delete: " + error2);
				return false;
			}
			return true;
		}

		private void WarnIoOnce(string message)
		{
			if (!_ioFailureLogged)
			{
				_ioFailureLogged = true;
				_log.LogWarning((object)("Trip recording: " + message + "."));
			}
		}

		private void RecordRecoveryEvent(string reason, string path, string message)
		{
			if (_recoveryEvents.Count < 50)
			{
				_recoveryEvents.Add(new RecoveryEvent(reason, Path.GetFileName(path), message));
			}
		}
	}
	public static class WorldContextAdapter
	{
		public static bool TryGetWorldUid(out long worldUid)
		{
			worldUid = 0L;
			if (!CartAdapter.CapabilityEnabled)
			{
				return false;
			}
			try
			{
				return GetWorldUidCore(out worldUid);
			}
			catch
			{
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool GetWorldUidCore(out long worldUid)
		{
			worldUid = 0L;
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			worldUid = instance.GetWorldUID();
			return worldUid != 0;
		}
	}
}