using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CruiserJumpPractice.Core.Handlers;
using CruiserJumpPractice.Core.Ports;
using CruiserJumpPractice.Core.Presentation;
using CruiserJumpPractice.Core.Snapshots;
using CruiserJumpPractice.Core.State;
using CruiserJumpPractice.Core.UseCases;
using CruiserJumpPractice.Core.UseCases.Client;
using CruiserJumpPractice.Core.UseCases.Server;
using CruiserJumpPractice.Core.Validation;
using CruiserJumpPractice.Interop;
using CruiserJumpPractice.Interop.Game;
using CruiserJumpPractice.Interop.Game.Adapters;
using CruiserJumpPractice.Interop.Game.Behaviours;
using CruiserJumpPractice.Interop.Game.Patches;
using CruiserJumpPractice.Interop.InputUtils;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.aoirint.CruiserJumpPractice")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+e58abd29d5b04d7eefcb7d5ab4e9587839a48858")]
[assembly: AssemblyProduct("CruiserJumpPractice")]
[assembly: AssemblyTitle("com.aoirint.CruiserJumpPractice")]
[assembly: AssemblyVersion("0.2.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CruiserJumpPractice
{
	[BepInPlugin("com.aoirint.CruiserJumpPractice", "CruiserJumpPractice", "0.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("Lethal Company.exe")]
	public class CruiserJumpPractice : BaseUnityPlugin
	{
		private static PluginController? controller;

		internal static PluginController Controller => controller;

		private void Awake()
		{
			BepInExPluginLogger bepInExPluginLogger = new BepInExPluginLogger(((BaseUnityPlugin)this).Logger);
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "ValidationLogging", false, "Enable structured validation logs for release validation and troubleshooting.");
			IValidationLogger validationLogger;
			if (!val.Value)
			{
				IValidationLogger instance = DisabledValidationLogger.Instance;
				validationLogger = instance;
			}
			else
			{
				IValidationLogger instance = new BepInExValidationLogger(bepInExPluginLogger, DateTime.UtcNow);
				validationLogger = instance;
			}
			IValidationLogger validationLogger2 = validationLogger;
			validationLogger2.Record(ValidationLogRecord.PluginLoaded("0.2.0", val.Value));
			controller = PluginController.Create(bepInExPluginLogger, validationLogger2);
			HarmonyPatchInstaller.Install();
			bepInExPluginLogger.LogInfo("Plugin CruiserJumpPractice v0.2.0 is loaded!");
		}
	}
	internal sealed class PluginController
	{
		private readonly IGameInterop gameInterop;

		private readonly IValidationLogger validationLogger;

		private readonly FrameHandler frameHandler;

		private readonly StartupHandler startupHandler;

		private readonly BaseGameAppliedStateValidationHandler baseGameAppliedStateValidationHandler;

		private readonly SaveCruiserStateUseCase saveCruiserStateUseCase;

		private readonly LoadCruiserStateUseCase loadCruiserStateUseCase;

		private readonly PresentSaveCruiserStateResultUseCase presentSaveCruiserStateResultUseCase;

		private readonly PresentLoadCruiserStateResultUseCase presentLoadCruiserStateResultUseCase;

		private PluginController(IGameInterop gameInterop, IValidationLogger validationLogger, FrameHandler frameHandler, StartupHandler startupHandler, BaseGameAppliedStateValidationHandler baseGameAppliedStateValidationHandler, SaveCruiserStateUseCase saveCruiserStateUseCase, LoadCruiserStateUseCase loadCruiserStateUseCase, PresentSaveCruiserStateResultUseCase presentSaveCruiserStateResultUseCase, PresentLoadCruiserStateResultUseCase presentLoadCruiserStateResultUseCase)
		{
			this.gameInterop = gameInterop;
			this.validationLogger = validationLogger;
			this.frameHandler = frameHandler;
			this.startupHandler = startupHandler;
			this.baseGameAppliedStateValidationHandler = baseGameAppliedStateValidationHandler;
			this.saveCruiserStateUseCase = saveCruiserStateUseCase;
			this.loadCruiserStateUseCase = loadCruiserStateUseCase;
			this.presentSaveCruiserStateResultUseCase = presentSaveCruiserStateResultUseCase;
			this.presentLoadCruiserStateResultUseCase = presentLoadCruiserStateResultUseCase;
		}

		public static PluginController Create(IPluginLogger logger, IValidationLogger validationLogger)
		{
			InputUtilsPracticeInput practiceInput = new InputUtilsPracticeInput(new InputUtilsActions());
			IGameInterop gameInterop = new GameInterop(logger, validationLogger);
			CruiserStateStore cruiserStateStore = new CruiserStateStore();
			BaseGameAppliedStateValidationStore stateStore = new BaseGameAppliedStateValidationStore();
			validationLogger.Record(ValidationLogRecord.StateStoreCreated());
			SaveCruiserStateUseCase saveCruiserStateUseCase = new SaveCruiserStateUseCase(gameInterop, cruiserStateStore, logger, validationLogger);
			LoadCruiserStateUseCase loadCruiserStateUseCase = new LoadCruiserStateUseCase(gameInterop, cruiserStateStore, logger, validationLogger);
			RequestSaveCruiserStateUseCase requestSaveCruiserStateUseCase = new RequestSaveCruiserStateUseCase(gameInterop, validationLogger);
			RequestLoadCruiserStateUseCase requestLoadCruiserStateUseCase = new RequestLoadCruiserStateUseCase(gameInterop, validationLogger);
			ToggleMagnetUseCase toggleMagnetUseCase = new ToggleMagnetUseCase(gameInterop, validationLogger);
			PresentSaveCruiserStateResultUseCase presentSaveCruiserStateResultUseCase = new PresentSaveCruiserStateResultUseCase(gameInterop, logger);
			PresentLoadCruiserStateResultUseCase presentLoadCruiserStateResultUseCase = new PresentLoadCruiserStateResultUseCase(gameInterop, logger);
			FrameHandler frameHandler = new FrameHandler(gameInterop, practiceInput, validationLogger, requestSaveCruiserStateUseCase, requestLoadCruiserStateUseCase, toggleMagnetUseCase);
			validationLogger.Record(ValidationLogRecord.ControllerCreated());
			return new PluginController(gameInterop, validationLogger, frameHandler, new StartupHandler(gameInterop, validationLogger), new BaseGameAppliedStateValidationHandler(gameInterop, validationLogger, stateStore), saveCruiserStateUseCase, loadCruiserStateUseCase, presentSaveCruiserStateResultUseCase, presentLoadCruiserStateResultUseCase);
		}

		public void HandleStartup()
		{
			startupHandler.HandleStartup();
		}

		public void HandleFrame()
		{
			frameHandler.HandleFrame();
		}

		public SaveCruiserStateResult SaveCruiserState()
		{
			return saveCruiserStateUseCase.Execute();
		}

		public LoadCruiserStateResult LoadCruiserState()
		{
			return loadCruiserStateUseCase.Execute();
		}

		public void PresentSaveCruiserStateResult(SaveCruiserStateResult result)
		{
			presentSaveCruiserStateResultUseCase.Execute(result);
		}

		public void PresentLoadCruiserStateResult(LoadCruiserStateResult result)
		{
			presentLoadCruiserStateResultUseCase.Execute(result);
		}

		public void RecordSaveServerRpcReceived()
		{
			validationLogger.Record(ValidationLogRecord.SaveServerRpcReceived(GetRole()));
		}

		public void RecordSaveClientRpcReceived(SaveCruiserStateResult result)
		{
			validationLogger.Record(ValidationLogRecord.SaveClientRpcReceived(GetRole(), result));
		}

		public void RecordLoadServerRpcReceived()
		{
			validationLogger.Record(ValidationLogRecord.LoadServerRpcReceived(GetRole()));
		}

		public void RecordLoadClientRpcReceived(LoadCruiserStateResult result)
		{
			validationLogger.Record(ValidationLogRecord.LoadClientRpcReceived(GetRole(), result));
		}

		public void HandleBaseGameEngineOilClientRpcEntered()
		{
			baseGameAppliedStateValidationHandler.EnterEngineOilClientRpc();
		}

		public void HandleBaseGameEngineOilClientRpcExited()
		{
			baseGameAppliedStateValidationHandler.ExitEngineOilClientRpc();
		}

		public void HandleBaseGameEngineOilLocalPreApply()
		{
			baseGameAppliedStateValidationHandler.HandleEngineOilLocalPreApply();
		}

		public void HandleBaseGameEngineOilLocalApplied()
		{
			baseGameAppliedStateValidationHandler.HandleEngineOilLocalApplied();
		}

		public void HandleBaseGameTurboClientRpcEntered()
		{
			baseGameAppliedStateValidationHandler.EnterTurboClientRpc();
		}

		public void HandleBaseGameTurboClientRpcExited()
		{
			baseGameAppliedStateValidationHandler.ExitTurboClientRpc();
		}

		public void HandleBaseGameTurboLocalPreApply()
		{
			baseGameAppliedStateValidationHandler.HandleTurboLocalPreApply();
		}

		public void HandleBaseGameTurboLocalApplied()
		{
			baseGameAppliedStateValidationHandler.HandleTurboLocalApplied();
		}

		public void HandleBaseGameShipMagnetLocalPreApply()
		{
			baseGameAppliedStateValidationHandler.HandleShipMagnetLocalPreApply();
		}

		public void HandleBaseGameShipMagnetLocalApplied()
		{
			baseGameAppliedStateValidationHandler.HandleShipMagnetLocalApplied();
		}

		public void HandleBaseGameShipMagnetClientRpcPreApply()
		{
			baseGameAppliedStateValidationHandler.HandleShipMagnetClientRpcPreApply();
		}

		public void HandleBaseGameShipMagnetClientRpcApplied()
		{
			baseGameAppliedStateValidationHandler.HandleShipMagnetClientRpcApplied();
		}

		private ValidationLogRole GetRole()
		{
			if (!gameInterop.IsHost())
			{
				return ValidationLogRole.Client;
			}
			return ValidationLogRole.Host;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.aoirint.CruiserJumpPractice";

		public const string PLUGIN_NAME = "CruiserJumpPractice";

		public const string PLUGIN_VERSION = "0.2.0";
	}
}
namespace CruiserJumpPractice.Interop
{
	internal sealed class BepInExPluginLogger : IPluginLogger
	{
		private readonly ManualLogSource logger;

		public BepInExPluginLogger(ManualLogSource logger)
		{
			this.logger = logger;
		}

		public void LogDebug(string message)
		{
			logger.LogDebug((object)message);
		}

		public void LogInfo(string message)
		{
			logger.LogInfo((object)message);
		}

		public void LogError(string message)
		{
			logger.LogError((object)message);
		}
	}
	internal sealed class BepInExValidationLogger : IValidationLogger
	{
		private const int SchemaVersion = 1;

		private const string Prefix = "[CJP_VALIDATION] ";

		private readonly IPluginLogger logger;

		private readonly string runId;

		private int sequence;

		public BepInExValidationLogger(IPluginLogger logger, DateTime startupTimeUtc)
		{
			this.logger = logger;
			runId = CreateRunId(startupTimeUtc);
		}

		public void Record(ValidationLogRecord record)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>
			{
				["schema"] = 1,
				["ts"] = FormatTimestamp(DateTime.UtcNow),
				["run"] = runId,
				["seq"] = ++sequence,
				["event"] = record.EventName
			};
			if (record.Fields != null)
			{
				foreach (KeyValuePair<string, object> field in record.Fields)
				{
					dictionary[field.Key] = field.Value;
				}
			}
			logger.LogInfo("[CJP_VALIDATION] " + JsonConvert.SerializeObject((object)dictionary, (Formatting)0));
		}

		private static string CreateRunId(DateTime startupTimeUtc)
		{
			string text = startupTimeUtc.ToString("yyyyMMdd'T'HHmmss'Z'", CultureInfo.InvariantCulture);
			string text2 = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture).Substring(0, 6);
			return text + "-" + text2;
		}

		private static string FormatTimestamp(DateTime timestampUtc)
		{
			return timestampUtc.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'", CultureInfo.InvariantCulture);
		}
	}
}
namespace CruiserJumpPractice.Interop.InputUtils
{
	internal sealed class InputUtilsActions : LcInputActions
	{
		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction? LoadCruiserKey { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction? SaveCruiserKey { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction? ToggleMagnetKey { get; set; }
	}
	internal sealed class InputUtilsPracticeInput : IPracticeInput
	{
		private readonly InputUtilsActions inputActions;

		public bool SaveCruiserTriggered
		{
			get
			{
				InputAction? saveCruiserKey = inputActions.SaveCruiserKey;
				if (saveCruiserKey == null)
				{
					return false;
				}
				return saveCruiserKey.triggered;
			}
		}

		public bool LoadCruiserTriggered
		{
			get
			{
				InputAction? loadCruiserKey = inputActions.LoadCruiserKey;
				if (loadCruiserKey == null)
				{
					return false;
				}
				return loadCruiserKey.triggered;
			}
		}

		public bool ToggleMagnetTriggered
		{
			get
			{
				InputAction? toggleMagnetKey = inputActions.ToggleMagnetKey;
				if (toggleMagnetKey == null)
				{
					return false;
				}
				return toggleMagnetKey.triggered;
			}
		}

		public InputUtilsPracticeInput(InputUtilsActions inputActions)
		{
			this.inputActions = inputActions;
		}
	}
}
namespace CruiserJumpPractice.Interop.Game
{
	internal sealed class GameInterop : IGameInterop
	{
		private readonly NetworkAdapter networkInterop;

		private readonly IValidationLogger validationLogger;

		private readonly PlayerAdapter playerInterop;

		private readonly HudAdapter hudInterop;

		private readonly RpcSurrogateAdapter rpcSurrogateInterop;

		private readonly CruiserAdapter cruiserInterop;

		private readonly ShipMagnetAdapter shipMagnetInterop;

		public GameInterop(IPluginLogger logger, IValidationLogger validationLogger)
		{
			this.validationLogger = validationLogger;
			GameObjectAdapter gameObjects = new GameObjectAdapter(logger);
			networkInterop = new NetworkAdapter(logger, gameObjects);
			playerInterop = new PlayerAdapter(logger, gameObjects);
			hudInterop = new HudAdapter(logger, gameObjects);
			rpcSurrogateInterop = new RpcSurrogateAdapter(logger, gameObjects, validationLogger);
			cruiserInterop = new CruiserAdapter(logger, gameObjects);
			shipMagnetInterop = new ShipMagnetAdapter(logger, gameObjects);
		}

		public bool IsHost()
		{
			return networkInterop.IsHost();
		}

		public LocalPlayerBusyState GetLocalPlayerBusyState()
		{
			return playerInterop.GetLocalPlayerBusyState();
		}

		public void DisplayTip(HudTipMessage message)
		{
			validationLogger.Record(ValidationLogRecord.HudTip(GetRole(), message));
			hudInterop.DisplayTip(message.HeaderText, message.BodyText);
		}

		public RpcSurrogateSpawnResult SpawnRpcSurrogate()
		{
			return rpcSurrogateInterop.SpawnRpcSurrogate();
		}

		public void RequestSaveCruiserState()
		{
			rpcSurrogateInterop.GetRpcSurrogateBehaviour().SaveCruiserStateServerRpc();
		}

		public void RequestLoadCruiserState()
		{
			rpcSurrogateInterop.GetRpcSurrogateBehaviour().LoadCruiserStateServerRpc();
		}

		public bool CruiserExists()
		{
			return (Object)(object)cruiserInterop.FindCruiser() != (Object)null;
		}

		public CruiserSnapshot? CaptureCruiser()
		{
			VehicleController val = cruiserInterop.FindCruiser();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return cruiserInterop.CaptureCruiser(val);
		}

		public int? GetCruiserCarHP()
		{
			VehicleController val = cruiserInterop.FindCruiser();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return CruiserAdapter.GetCarHP(val);
		}

		public int? GetCruiserTurboBoosts()
		{
			VehicleController val = cruiserInterop.FindCruiser();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return CruiserAdapter.GetTurboBoosts(val);
		}

		public CruiserRestoreObservation RestoreCruiser(CruiserSnapshot snapshot)
		{
			VehicleController val = cruiserInterop.FindCruiser();
			if ((Object)(object)val == (Object)null)
			{
				throw new GameInteropException("No cruiser found.");
			}
			return cruiserInterop.RestoreCruiser(val, snapshot);
		}

		public bool IsCruiserMagnetedToShip()
		{
			VehicleController val = cruiserInterop.FindCruiser();
			if ((Object)(object)val == (Object)null)
			{
				throw new GameInteropException("No cruiser found.");
			}
			return cruiserInterop.IsCruiserMagnetedToShip(val);
		}

		public bool IsShipMagnetOn()
		{
			return shipMagnetInterop.IsShipMagnetOn();
		}

		public void ToggleShipMagnet()
		{
			shipMagnetInterop.ToggleShipMagnet();
		}

		private ValidationLogRole GetRole()
		{
			if (!IsHost())
			{
				return ValidationLogRole.Client;
			}
			return ValidationLogRole.Host;
		}
	}
	internal sealed class GameInteropException : Exception
	{
		public GameInteropException(string message)
			: base(message)
		{
		}
	}
}
namespace CruiserJumpPractice.Interop.Game.Patches
{
	internal static class HarmonyPatchInstaller
	{
		private static readonly Harmony harmony = new Harmony("com.aoirint.CruiserJumpPractice");

		public static void Install()
		{
			harmony.PatchAll(typeof(HarmonyPatchInstaller).Assembly);
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class HUDManagerPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void AwakePostfix()
		{
			CruiserJumpPractice.Controller.HandleStartup();
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void UpdatePostfix()
		{
			CruiserJumpPractice.Controller.HandleFrame();
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatch
	{
		[HarmonyPatch("SetMagnetOn", new Type[] { typeof(bool) })]
		[HarmonyPrefix]
		public static void SetMagnetOnPrefix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameShipMagnetLocalPreApply();
			});
		}

		[HarmonyPatch("SetMagnetOn", new Type[] { typeof(bool) })]
		[HarmonyPostfix]
		public static void SetMagnetOnPostfix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameShipMagnetLocalApplied();
			});
		}

		[HarmonyPatch("SetMagnetOnClientRpc", new Type[] { typeof(bool) })]
		[HarmonyPrefix]
		public static void SetMagnetOnClientRpcPrefix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameShipMagnetClientRpcPreApply();
			});
		}

		[HarmonyPatch("SetMagnetOnClientRpc", new Type[] { typeof(bool) })]
		[HarmonyPostfix]
		public static void SetMagnetOnClientRpcPostfix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameShipMagnetClientRpcApplied();
			});
		}

		private static void TryNotifyAppliedStateValidation(Action notify)
		{
			try
			{
				notify();
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(VehicleController))]
	internal static class VehicleControllerPatch
	{
		[HarmonyPatch("AddEngineOilClientRpc", new Type[]
		{
			typeof(int),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static void AddEngineOilClientRpcPrefix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameEngineOilClientRpcEntered();
			});
		}

		[HarmonyPatch("AddEngineOilClientRpc", new Type[]
		{
			typeof(int),
			typeof(int)
		})]
		[HarmonyFinalizer]
		public static void AddEngineOilClientRpcFinalizer()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameEngineOilClientRpcExited();
			});
		}

		[HarmonyPatch("AddEngineOilOnLocalClient", new Type[] { typeof(int) })]
		[HarmonyPrefix]
		public static void AddEngineOilOnLocalClientPrefix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameEngineOilLocalPreApply();
			});
		}

		[HarmonyPatch("AddEngineOilOnLocalClient", new Type[] { typeof(int) })]
		[HarmonyPostfix]
		public static void AddEngineOilOnLocalClientPostfix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameEngineOilLocalApplied();
			});
		}

		[HarmonyPatch("AddTurboBoostClientRpc", new Type[]
		{
			typeof(int),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static void AddTurboBoostClientRpcPrefix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameTurboClientRpcEntered();
			});
		}

		[HarmonyPatch("AddTurboBoostClientRpc", new Type[]
		{
			typeof(int),
			typeof(int)
		})]
		[HarmonyFinalizer]
		public static void AddTurboBoostClientRpcFinalizer()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameTurboClientRpcExited();
			});
		}

		[HarmonyPatch("AddTurboBoostOnLocalClient", new Type[] { typeof(int) })]
		[HarmonyPrefix]
		public static void AddTurboBoostOnLocalClientPrefix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameTurboLocalPreApply();
			});
		}

		[HarmonyPatch("AddTurboBoostOnLocalClient", new Type[] { typeof(int) })]
		[HarmonyPostfix]
		public static void AddTurboBoostOnLocalClientPostfix()
		{
			TryNotifyAppliedStateValidation(delegate
			{
				CruiserJumpPractice.Controller.HandleBaseGameTurboLocalApplied();
			});
		}

		private static void TryNotifyAppliedStateValidation(Action notify)
		{
			try
			{
				notify();
			}
			catch
			{
			}
		}
	}
}
namespace CruiserJumpPractice.Interop.Game.Behaviours
{
	internal class RpcSurrogateBehaviour : NetworkBehaviour
	{
		[ServerRpc(RequireOwnership = true)]
		public void SaveCruiserStateServerRpc()
		{
			CruiserJumpPractice.Controller.RecordSaveServerRpcReceived();
			SaveCruiserStateResult result = CruiserJumpPractice.Controller.SaveCruiserState();
			SaveCruiserStateDoneClientRpc(result);
		}

		[ClientRpc]
		public void SaveCruiserStateDoneClientRpc(SaveCruiserStateResult result)
		{
			CruiserJumpPractice.Controller.RecordSaveClientRpcReceived(result);
			CruiserJumpPractice.Controller.PresentSaveCruiserStateResult(result);
		}

		[ServerRpc(RequireOwnership = true)]
		public void LoadCruiserStateServerRpc()
		{
			CruiserJumpPractice.Controller.RecordLoadServerRpcReceived();
			LoadCruiserStateResult result = CruiserJumpPractice.Controller.LoadCruiserState();
			LoadCruiserStateDoneClientRpc(result);
		}

		[ClientRpc]
		public void LoadCruiserStateDoneClientRpc(LoadCruiserStateResult result)
		{
			CruiserJumpPractice.Controller.RecordLoadClientRpcReceived(result);
			CruiserJumpPractice.Controller.PresentLoadCruiserStateResult(result);
		}
	}
}
namespace CruiserJumpPractice.Interop.Game.Adapters
{
	internal sealed class CruiserAdapter
	{
		private static readonly FieldInfo? turboBoostsField = typeof(VehicleController).GetField("turboBoosts", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly IPluginLogger logger;

		private readonly GameObjectAdapter gameObjects;

		public CruiserAdapter(IPluginLogger logger, GameObjectAdapter gameObjects)
		{
			this.logger = logger;
			this.gameObjects = gameObjects;
		}

		public VehicleController? FindCruiser()
		{
			try
			{
				VehicleController[] array = Object.FindObjectsOfType<VehicleController>();
				if (array == null)
				{
					logger.LogError("Failed to find VehicleController objects.");
					return null;
				}
				if (array.Length == 0)
				{
					logger.LogInfo("No VehicleController objects found.");
					return null;
				}
				return array[0];
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting cruiser: {arg}");
				throw new GameInteropException($"Exception while getting cruiser: {arg}");
			}
		}

		public CruiserSnapshot CaptureCruiser(VehicleController cruiser)
		{
			//IL_0006: 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)
			try
			{
				return new CruiserSnapshot(FromUnityVector3(((Component)cruiser).transform.position), FromUnityVector3(((Component)cruiser).transform.eulerAngles), cruiser.moveInputVector.x, cruiser.EngineRPM, cruiser.carHP, GetTurboBoosts(cruiser));
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while capturing cruiser state: {arg}");
				throw new GameInteropException($"Exception while capturing cruiser state: {arg}");
			}
		}

		public CruiserRestoreObservation RestoreCruiser(VehicleController cruiser, CruiserSnapshot snapshot)
		{
			//IL_0012: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			int localPlayerId = gameObjects.GetLocalPlayerId();
			try
			{
				Vector3Value beforeCarPosition = FromUnityVector3(((Component)cruiser).transform.position);
				int carHP = cruiser.carHP;
				int turboBoosts = GetTurboBoosts(cruiser);
				((Component)cruiser).transform.position = ToUnityVector3(snapshot.CarPosition);
				((Component)cruiser).transform.eulerAngles = ToUnityVector3(snapshot.CarRotation);
				cruiser.moveInputVector.x = snapshot.SteeringInput;
				cruiser.EngineRPM = snapshot.EngineRPM;
				cruiser.AddEngineOilOnLocalClient(snapshot.CarHP);
				cruiser.AddEngineOilServerRpc(localPlayerId, snapshot.CarHP);
				cruiser.AddTurboBoostOnLocalClient(snapshot.TurboBoosts);
				cruiser.AddTurboBoostServerRpc(localPlayerId, snapshot.TurboBoosts);
				return new CruiserRestoreObservation(snapshot.CarPosition, snapshot.CarRotation, beforeCarPosition, FromUnityVector3(((Component)cruiser).transform.position), snapshot.CarHP, carHP, cruiser.carHP, snapshot.TurboBoosts, turboBoosts, GetTurboBoosts(cruiser));
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while restoring cruiser state: {arg}");
				throw new GameInteropException($"Exception while restoring cruiser state: {arg}");
			}
		}

		public bool IsCruiserMagnetedToShip(VehicleController cruiser)
		{
			try
			{
				return cruiser.magnetedToShip;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting 'magnetedToShip': {arg}");
				throw new GameInteropException($"Exception while getting 'magnetedToShip': {arg}");
			}
		}

		internal static int GetCarHP(VehicleController cruiser)
		{
			return cruiser.carHP;
		}

		internal static int GetTurboBoosts(VehicleController cruiser)
		{
			if (turboBoostsField == null)
			{
				throw new GameInteropException("Failed to get 'turboBoosts' field from VehicleController.");
			}
			object value = turboBoostsField.GetValue(cruiser);
			if (value is int)
			{
				return (int)value;
			}
			throw new GameInteropException("'turboBoosts' field is not of type int.");
		}

		private static Vector3Value FromUnityVector3(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3Value(value.x, value.y, value.z);
		}

		private static Vector3 ToUnityVector3(Vector3Value value)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(value.X, value.Y, value.Z);
		}
	}
	internal sealed class GameObjectAdapter
	{
		private readonly IPluginLogger logger;

		public GameObjectAdapter(IPluginLogger logger)
		{
			this.logger = logger;
		}

		public HUDManager GetHUDManager()
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					throw new GameInteropException("HUDManager.Instance is null.");
				}
				return instance;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting HUDManager: {arg}");
				throw new GameInteropException($"Exception while getting HUDManager: {arg}");
			}
		}

		public NetworkManager GetNetworkManager()
		{
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if ((Object)(object)singleton == (Object)null)
				{
					throw new GameInteropException("NetworkManager.Singleton is null.");
				}
				return singleton;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting NetworkManager: {arg}");
				throw new GameInteropException($"Exception while getting NetworkManager: {arg}");
			}
		}

		public PlayerControllerB GetLocalPlayer()
		{
			try
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					throw new GameInteropException("GameNetworkManager.Instance is null.");
				}
				PlayerControllerB localPlayerController = instance.localPlayerController;
				if ((Object)(object)localPlayerController == (Object)null)
				{
					throw new GameInteropException("localPlayerController is null.");
				}
				return localPlayerController;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting local player: {arg}");
				throw new GameInteropException($"Exception while getting local player: {arg}");
			}
		}

		public int GetLocalPlayerId()
		{
			try
			{
				return (int)GetLocalPlayer().playerClientId;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting local player ID: {arg}");
				throw new GameInteropException($"Exception while getting local player ID: {arg}");
			}
		}

		public StartOfRound GetStartOfRound()
		{
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					throw new GameInteropException("StartOfRound.Instance is null.");
				}
				return instance;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting StartOfRound: {arg}");
				throw new GameInteropException($"Exception while getting StartOfRound: {arg}");
			}
		}
	}
	internal sealed class HudAdapter
	{
		private readonly IPluginLogger logger;

		private readonly GameObjectAdapter gameObjects;

		public HudAdapter(IPluginLogger logger, GameObjectAdapter gameObjects)
		{
			this.logger = logger;
			this.gameObjects = gameObjects;
		}

		public void DisplayTip(string headerText, string bodyText)
		{
			HUDManager hUDManager = gameObjects.GetHUDManager();
			try
			{
				hUDManager.DisplayTip(headerText, bodyText, false, false, "LC_Tip1");
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while displaying tip: {arg}");
				throw new GameInteropException($"Exception while displaying tip: {arg}");
			}
		}
	}
	internal sealed class NetworkAdapter
	{
		private readonly IPluginLogger logger;

		private readonly GameObjectAdapter gameObjects;

		public NetworkAdapter(IPluginLogger logger, GameObjectAdapter gameObjects)
		{
			this.logger = logger;
			this.gameObjects = gameObjects;
		}

		public bool IsHost()
		{
			try
			{
				return gameObjects.GetNetworkManager().IsHost;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting 'IsHost': {arg}");
				throw new GameInteropException($"Exception while getting 'IsHost': {arg}");
			}
		}
	}
	internal sealed class PlayerAdapter
	{
		private readonly IPluginLogger logger;

		private readonly GameObjectAdapter gameObjects;

		public PlayerAdapter(IPluginLogger logger, GameObjectAdapter gameObjects)
		{
			this.logger = logger;
			this.gameObjects = gameObjects;
		}

		public LocalPlayerBusyState GetLocalPlayerBusyState()
		{
			PlayerControllerB localPlayer = gameObjects.GetLocalPlayer();
			try
			{
				QuickMenuManager quickMenuManager = localPlayer.quickMenuManager;
				if ((Object)(object)quickMenuManager == (Object)null)
				{
					throw new GameInteropException("quickMenuManager is null.");
				}
				return new LocalPlayerBusyState(quickMenuManager.isMenuOpen, localPlayer.inTerminalMenu, localPlayer.isTypingChat);
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting local player status: {arg}");
				throw new GameInteropException($"Exception while getting local player status: {arg}");
			}
		}
	}
	internal sealed class RpcSurrogateAdapter
	{
		private readonly IPluginLogger logger;

		private readonly GameObjectAdapter gameObjects;

		private readonly IValidationLogger validationLogger;

		private RpcSurrogateBehaviour? cachedRpcSurrogateBehaviour;

		public RpcSurrogateAdapter(IPluginLogger logger, GameObjectAdapter gameObjects, IValidationLogger validationLogger)
		{
			this.logger = logger;
			this.gameObjects = gameObjects;
			this.validationLogger = validationLogger;
		}

		public RpcSurrogateSpawnResult SpawnRpcSurrogate()
		{
			try
			{
				GameObject gameObject = ((Component)gameObjects.GetHUDManager()).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					logger.LogError("HUDManager.gameObject is null.");
					return RpcSurrogateSpawnResult.Missing;
				}
				RpcSurrogateBehaviour component = gameObject.GetComponent<RpcSurrogateBehaviour>();
				if ((Object)(object)component != (Object)null)
				{
					cachedRpcSurrogateBehaviour = component;
					logger.LogDebug("RPC surrogate already exists on HUDManager.");
					return RpcSurrogateSpawnResult.Reused;
				}
				cachedRpcSurrogateBehaviour = gameObject.AddComponent<RpcSurrogateBehaviour>();
				logger.LogInfo("Spawned RPC surrogate on HUDManager.");
				return RpcSurrogateSpawnResult.Added;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while spawning RPC surrogate: {arg}");
				return RpcSurrogateSpawnResult.Error;
			}
		}

		public RpcSurrogateBehaviour GetRpcSurrogateBehaviour()
		{
			if ((Object)(object)cachedRpcSurrogateBehaviour != (Object)null)
			{
				RecordResolved(ValidationLogRpcSurrogateResolveSource.Cache, ValidationLogRpcSurrogateResolveResult.Success);
				return cachedRpcSurrogateBehaviour;
			}
			try
			{
				RpcSurrogateBehaviour component = ((Component)gameObjects.GetHUDManager()).GetComponent<RpcSurrogateBehaviour>();
				if ((Object)(object)component == (Object)null)
				{
					throw new GameInteropException("RpcSurrogateBehaviour component not found on HUDManager instance.");
				}
				cachedRpcSurrogateBehaviour = component;
				RecordResolved(ValidationLogRpcSurrogateResolveSource.Lookup, ValidationLogRpcSurrogateResolveResult.Success);
				return component;
			}
			catch (Exception arg)
			{
				RecordResolved(ValidationLogRpcSurrogateResolveSource.Lookup, ValidationLogRpcSurrogateResolveResult.Error);
				logger.LogError($"Exception while getting RpcSurrogateBehaviour: {arg}");
				throw new GameInteropException($"Exception while getting RpcSurrogateBehaviour: {arg}");
			}
		}

		private void RecordResolved(ValidationLogRpcSurrogateResolveSource source, ValidationLogRpcSurrogateResolveResult result)
		{
			validationLogger.Record(ValidationLogRecord.RpcSurrogateResolved(source, result));
		}
	}
	internal sealed class ShipMagnetAdapter
	{
		private readonly IPluginLogger logger;

		private readonly GameObjectAdapter gameObjects;

		public ShipMagnetAdapter(IPluginLogger logger, GameObjectAdapter gameObjects)
		{
			this.logger = logger;
			this.gameObjects = gameObjects;
		}

		public bool IsShipMagnetOn()
		{
			try
			{
				return gameObjects.GetStartOfRound().magnetOn;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while getting 'magnetOn': {arg}");
				throw new GameInteropException($"Exception while getting 'magnetOn': {arg}");
			}
		}

		public void ToggleShipMagnet()
		{
			try
			{
				AnimatedObjectTrigger magnetLever = gameObjects.GetStartOfRound().magnetLever;
				if ((Object)(object)magnetLever == (Object)null)
				{
					throw new GameInteropException("StartOfRound.magnetLever is null.");
				}
				magnetLever.TriggerAnimation(gameObjects.GetLocalPlayer());
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while toggling magnet: {arg}");
				throw new GameInteropException($"Exception while toggling magnet: {arg}");
			}
		}
	}
}
namespace CruiserJumpPractice.Core.Validation
{
	internal sealed class DisabledValidationLogger : IValidationLogger
	{
		public static DisabledValidationLogger Instance { get; } = new DisabledValidationLogger();


		private DisabledValidationLogger()
		{
		}

		public void Record(ValidationLogRecord record)
		{
		}
	}
	internal enum ValidationLogRole
	{
		Host,
		Client
	}
	internal enum ValidationLogInputAction
	{
		Save,
		Load,
		ToggleMagnet
	}
	internal enum ValidationLogRpcSurrogateResolveSource
	{
		Cache,
		Lookup
	}
	internal enum ValidationLogRpcSurrogateResolveResult
	{
		Success,
		Error
	}
	internal enum ValidationLogBaseGameApplySource
	{
		LocalApply,
		ClientRpcApply,
		Unknown
	}
	internal sealed class ValidationLogRecord
	{
		public string EventName { get; }

		public Dictionary<string, object?>? Fields { get; }

		private ValidationLogRecord(string eventName, Dictionary<string, object?>? fields = null)
		{
			EventName = eventName;
			Fields = fields;
		}

		public static ValidationLogRecord PluginLoaded(string version, bool validationLogging)
		{
			return new ValidationLogRecord("plugin_loaded", new Dictionary<string, object>
			{
				["version"] = version,
				["validation_logging"] = validationLogging
			});
		}

		public static ValidationLogRecord StateStoreCreated()
		{
			return new ValidationLogRecord("state_store_created");
		}

		public static ValidationLogRecord ControllerCreated()
		{
			return new ValidationLogRecord("controller_created");
		}

		public static ValidationLogRecord HudStartup(RpcSurrogateSpawnResult surrogateResult)
		{
			return new ValidationLogRecord("hud_startup", new Dictionary<string, object> { ["surrogate"] = ToSurrogateResultToken(surrogateResult) });
		}

		public static ValidationLogRecord InputTriggered(ValidationLogInputAction action, ValidationLogRole role)
		{
			return new ValidationLogRecord("input_triggered", new Dictionary<string, object>
			{
				["action"] = ToValidationActionToken(action),
				["role"] = ToValidationRoleToken(role),
				["busy"] = false
			});
		}

		public static ValidationLogRecord InputSuppressed(ValidationLogInputAction action, ValidationLogRole role, LocalPlayerBusyState busyState)
		{
			return new ValidationLogRecord("input_suppressed", new Dictionary<string, object>
			{
				["action"] = ToValidationActionToken(action),
				["role"] = ToValidationRoleToken(role),
				["reason"] = busyState.GetBusyReasonToken() ?? "unknown",
				["menu"] = busyState.IsMenuOpen,
				["terminal"] = busyState.IsInTerminal,
				["chat"] = busyState.IsTypingChat
			});
		}

		public static ValidationLogRecord RequestSaveResult(ValidationLogRole role, RequestSaveCruiserStateResult result)
		{
			return Result("request_save_result", role, ToValidationResultToken(result));
		}

		public static ValidationLogRecord RequestLoadResult(ValidationLogRole role, RequestLoadCruiserStateResult result)
		{
			return Result("request_load_result", role, ToValidationResultToken(result));
		}

		public static ValidationLogRecord ToggleMagnetResultEvent(ValidationLogRole role, ToggleMagnetResult result)
		{
			return Result("toggle_magnet_result", role, ToValidationResultToken(result));
		}

		public static ValidationLogRecord MagnetToggle(MagnetToggleObservation observation)
		{
			return new ValidationLogRecord("magnet_toggle", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(ValidationLogRole.Host),
				["before"] = ToValidationStateToken(observation.BeforeState),
				["expected_after"] = ToValidationStateToken(observation.ExpectedAfterState),
				["observed_after"] = ToValidationStateToken(observation.ObservedAfterState)
			});
		}

		public static ValidationLogRecord SaveServerRpcReceived(ValidationLogRole role)
		{
			return Role("save_server_rpc_received", role);
		}

		public static ValidationLogRecord SaveClientRpcReceived(ValidationLogRole role, SaveCruiserStateResult result)
		{
			return Result("save_client_rpc_received", role, ToValidationResultToken(result));
		}

		public static ValidationLogRecord LoadServerRpcReceived(ValidationLogRole role)
		{
			return Role("load_server_rpc_received", role);
		}

		public static ValidationLogRecord LoadClientRpcReceived(ValidationLogRole role, LoadCruiserStateResult result)
		{
			return Result("load_client_rpc_received", role, ToValidationResultToken(result));
		}

		public static ValidationLogRecord SaveNoCruiserFound()
		{
			return new ValidationLogRecord("save_result", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(ValidationLogRole.Host),
				["result"] = ToValidationResultToken(SaveCruiserStateResult.NoCruiserFound),
				["cruiser_found"] = false
			});
		}

		public static ValidationLogRecord SaveUnexpectedState()
		{
			return Result("save_result", ValidationLogRole.Host, "unexpected_state");
		}

		public static ValidationLogRecord SaveSuccess(CruiserSnapshot cruiserState)
		{
			return new ValidationLogRecord("save_result", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(ValidationLogRole.Host),
				["result"] = ToValidationResultToken(SaveCruiserStateResult.Success),
				["cruiser_found"] = true,
				["pos"] = Vector3(cruiserState.CarPosition, 1),
				["rot"] = Vector3(cruiserState.CarRotation, 1),
				["hp"] = cruiserState.CarHP,
				["turbo"] = cruiserState.TurboBoosts,
				["steering"] = Number(cruiserState.SteeringInput, 2),
				["rpm"] = Number(cruiserState.EngineRPM, 2)
			});
		}

		public static ValidationLogRecord LoadNoCruiserFound(bool savedState)
		{
			return LoadResult(ToValidationResultToken(LoadCruiserStateResult.NoCruiserFound), cruiserFound: false, savedState, "unknown");
		}

		public static ValidationLogRecord LoadNoSavedState()
		{
			return LoadResult(ToValidationResultToken(LoadCruiserStateResult.NoSavedState), cruiserFound: true, savedState: false, "unknown");
		}

		public static ValidationLogRecord LoadMagnetedToShip()
		{
			return LoadResult(ToValidationResultToken(LoadCruiserStateResult.MagnetedToShip), cruiserFound: true, savedState: true, true);
		}

		public static ValidationLogRecord LoadSuccess()
		{
			return LoadResult(ToValidationResultToken(LoadCruiserStateResult.Success), cruiserFound: true, savedState: true, false);
		}

		public static ValidationLogRecord LoadUnexpectedState()
		{
			return Result("load_result", ValidationLogRole.Host, "unexpected_state");
		}

		public static ValidationLogRecord RestoreApplied(CruiserRestoreObservation observation)
		{
			return new ValidationLogRecord("restore_applied", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(ValidationLogRole.Host),
				["saved_pos"] = Vector3(observation.SavedCarPosition, 1),
				["saved_rot"] = Vector3(observation.SavedCarRotation, 1),
				["before_pos"] = Vector3(observation.BeforeCarPosition, 1),
				["after_pos"] = Vector3(observation.AfterCarPosition, 1),
				["saved_hp"] = observation.SavedCarHP,
				["before_hp"] = observation.BeforeCarHP,
				["after_hp"] = observation.AfterCarHP,
				["saved_turbo"] = observation.SavedTurboBoosts,
				["before_turbo"] = observation.BeforeTurboBoosts,
				["after_turbo"] = observation.AfterTurboBoosts
			});
		}

		public static ValidationLogRecord BaseGameEngineOilApplied(ValidationLogRole role, int? beforeCarHP, int? afterCarHP, ValidationLogBaseGameApplySource source)
		{
			return new ValidationLogRecord("base_game_engine_oil_applied", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(role),
				["before_hp"] = beforeCarHP,
				["after_hp"] = afterCarHP,
				["source"] = ToBaseGameApplySourceToken(source)
			});
		}

		public static ValidationLogRecord BaseGameTurboApplied(ValidationLogRole role, int? beforeTurbo, int? afterTurbo, ValidationLogBaseGameApplySource source)
		{
			return new ValidationLogRecord("base_game_turbo_applied", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(role),
				["before_turbo"] = beforeTurbo,
				["after_turbo"] = afterTurbo,
				["source"] = ToBaseGameApplySourceToken(source)
			});
		}

		public static ValidationLogRecord BaseGameShipMagnetApplied(ValidationLogRole role, bool? before, bool after, ValidationLogBaseGameApplySource source)
		{
			return new ValidationLogRecord("base_game_ship_magnet_applied", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(role),
				["before"] = before,
				["after"] = after,
				["source"] = ToBaseGameApplySourceToken(source)
			});
		}

		public static ValidationLogRecord HudTip(ValidationLogRole role, HudTipMessage message)
		{
			return new ValidationLogRecord("hud_tip", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(role),
				["message"] = message.Token
			});
		}

		public static ValidationLogRecord RpcSurrogateResolved(ValidationLogRpcSurrogateResolveSource source, ValidationLogRpcSurrogateResolveResult result)
		{
			return new ValidationLogRecord("rpc_surrogate_resolved", new Dictionary<string, object>
			{
				["source"] = ToRpcSurrogateResolveSourceToken(source),
				["result"] = ToRpcSurrogateResolveResultToken(result)
			});
		}

		private static ValidationLogRecord LoadResult(string result, bool cruiserFound, bool savedState, object? magneted)
		{
			return new ValidationLogRecord("load_result", new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(ValidationLogRole.Host),
				["result"] = result,
				["cruiser_found"] = cruiserFound,
				["saved_state"] = savedState,
				["magneted"] = magneted
			});
		}

		private static ValidationLogRecord Result(string eventName, ValidationLogRole role, string result)
		{
			return new ValidationLogRecord(eventName, new Dictionary<string, object>
			{
				["role"] = ToValidationRoleToken(role),
				["result"] = result
			});
		}

		private static ValidationLogRecord Role(string eventName, ValidationLogRole role)
		{
			return new ValidationLogRecord(eventName, new Dictionary<string, object> { ["role"] = ToValidationRoleToken(role) });
		}

		private static object? Number(float value, int decimalPlaces)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return null;
			}
			return Math.Round(value, decimalPlaces, MidpointRounding.AwayFromZero);
		}

		private static object?[] Vector3(Vector3Value value, int decimalPlaces)
		{
			return new object[3]
			{
				Number(value.X, decimalPlaces),
				Number(value.Y, decimalPlaces),
				Number(value.Z, decimalPlaces)
			};
		}

		private static string ToSurrogateResultToken(RpcSurrogateSpawnResult result)
		{
			return result switch
			{
				RpcSurrogateSpawnResult.Added => "added", 
				RpcSurrogateSpawnResult.Reused => "reused", 
				RpcSurrogateSpawnResult.Missing => "missing", 
				RpcSurrogateSpawnResult.Error => "error", 
				_ => "error", 
			};
		}

		private static string ToValidationRoleToken(ValidationLogRole role)
		{
			return role switch
			{
				ValidationLogRole.Host => "host", 
				ValidationLogRole.Client => "client", 
				_ => "client", 
			};
		}

		private static string ToValidationActionToken(ValidationLogInputAction action)
		{
			return action switch
			{
				ValidationLogInputAction.Save => "save", 
				ValidationLogInputAction.Load => "load", 
				ValidationLogInputAction.ToggleMagnet => "toggle_magnet", 
				_ => "toggle_magnet", 
			};
		}

		private static string ToRpcSurrogateResolveSourceToken(ValidationLogRpcSurrogateResolveSource source)
		{
			return source switch
			{
				ValidationLogRpcSurrogateResolveSource.Cache => "cache", 
				ValidationLogRpcSurrogateResolveSource.Lookup => "lookup", 
				_ => "lookup", 
			};
		}

		private static string ToRpcSurrogateResolveResultToken(ValidationLogRpcSurrogateResolveResult result)
		{
			return result switch
			{
				ValidationLogRpcSurrogateResolveResult.Success => "success", 
				ValidationLogRpcSurrogateResolveResult.Error => "error", 
				_ => "error", 
			};
		}

		private static string ToBaseGameApplySourceToken(ValidationLogBaseGameApplySource source)
		{
			return source switch
			{
				ValidationLogBaseGameApplySource.LocalApply => "local_apply", 
				ValidationLogBaseGameApplySource.ClientRpcApply => "client_rpc_apply", 
				ValidationLogBaseGameApplySource.Unknown => "unknown", 
				_ => "unknown", 
			};
		}

		private static string ToValidationResultToken(SaveCruiserStateResult result)
		{
			return result switch
			{
				SaveCruiserStateResult.Success => "success", 
				SaveCruiserStateResult.NoCruiserFound => "no_cruiser_found", 
				SaveCruiserStateResult.UnexpectedState => "unexpected_state", 
				_ => "unexpected_state", 
			};
		}

		private static string ToValidationResultToken(LoadCruiserStateResult result)
		{
			return result switch
			{
				LoadCruiserStateResult.Success => "success", 
				LoadCruiserStateResult.NoCruiserFound => "no_cruiser_found", 
				LoadCruiserStateResult.NoSavedState => "no_saved_state", 
				LoadCruiserStateResult.MagnetedToShip => "magneted_to_ship", 
				LoadCruiserStateResult.UnexpectedState => "unexpected_state", 
				_ => "unexpected_state", 
			};
		}

		private static string ToValidationResultToken(RequestSaveCruiserStateResult result)
		{
			return result switch
			{
				RequestSaveCruiserStateResult.Success => "success", 
				RequestSaveCruiserStateResult.HostOnly => "host_only", 
				_ => "host_only", 
			};
		}

		private static string ToValidationResultToken(RequestLoadCruiserStateResult result)
		{
			return result switch
			{
				RequestLoadCruiserStateResult.Success => "success", 
				RequestLoadCruiserStateResult.HostOnly => "host_only", 
				_ => "host_only", 
			};
		}

		private static string ToValidationResultToken(ToggleMagnetResult result)
		{
			return result switch
			{
				ToggleMagnetResult.MagnetOn => "magnet_on", 
				ToggleMagnetResult.MagnetOff => "magnet_off", 
				ToggleMagnetResult.HostOnly => "host_only", 
				_ => "host_only", 
			};
		}

		private static string ToValidationStateToken(MagnetState state)
		{
			return state switch
			{
				MagnetState.On => "on", 
				MagnetState.Off => "off", 
				MagnetState.Unknown => "unknown", 
				_ => "unknown", 
			};
		}
	}
}
namespace CruiserJumpPractice.Core.UseCases
{
	internal enum RequestSaveCruiserStateResult
	{
		Success,
		HostOnly
	}
	internal enum RequestLoadCruiserStateResult
	{
		Success,
		HostOnly
	}
	internal enum SaveCruiserStateResult
	{
		Success,
		NoCruiserFound,
		UnexpectedState
	}
	internal enum LoadCruiserStateResult
	{
		Success,
		NoCruiserFound,
		NoSavedState,
		MagnetedToShip,
		UnexpectedState
	}
	internal enum ToggleMagnetResult
	{
		HostOnly,
		MagnetOn,
		MagnetOff
	}
}
namespace CruiserJumpPractice.Core.UseCases.Server
{
	internal sealed class LoadCruiserStateUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly CruiserStateStore cruiserStateStore;

		private readonly IPluginLogger logger;

		private readonly IValidationLogger validationLogger;

		public LoadCruiserStateUseCase(IGameInterop gameInterop, CruiserStateStore cruiserStateStore, IPluginLogger logger, IValidationLogger validationLogger)
		{
			this.gameInterop = gameInterop;
			this.cruiserStateStore = cruiserStateStore;
			this.logger = logger;
			this.validationLogger = validationLogger;
		}

		public LoadCruiserStateResult Execute()
		{
			try
			{
				if (!gameInterop.CruiserExists())
				{
					logger.LogInfo("No cruiser found.");
					validationLogger.Record(ValidationLogRecord.LoadNoCruiserFound(cruiserStateStore.SavedCruiserState != null));
					return LoadCruiserStateResult.NoCruiserFound;
				}
				CruiserSnapshot savedCruiserState = cruiserStateStore.SavedCruiserState;
				if (savedCruiserState == null)
				{
					logger.LogInfo("No saved cruiser state found.");
					validationLogger.Record(ValidationLogRecord.LoadNoSavedState());
					return LoadCruiserStateResult.NoSavedState;
				}
				if (gameInterop.IsCruiserMagnetedToShip())
				{
					logger.LogInfo("Cruiser is currently magneted to the ship. Cannot load state.");
					validationLogger.Record(ValidationLogRecord.LoadMagnetedToShip());
					return LoadCruiserStateResult.MagnetedToShip;
				}
				CruiserRestoreObservation observation = gameInterop.RestoreCruiser(savedCruiserState);
				RecordRestoreApplied(observation);
				validationLogger.Record(ValidationLogRecord.LoadSuccess());
				return LoadCruiserStateResult.Success;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while loading cruiser state: {arg}");
				validationLogger.Record(ValidationLogRecord.LoadUnexpectedState());
				return LoadCruiserStateResult.UnexpectedState;
			}
		}

		private void RecordRestoreApplied(CruiserRestoreObservation observation)
		{
			validationLogger.Record(ValidationLogRecord.RestoreApplied(observation));
		}
	}
	internal sealed class SaveCruiserStateUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly CruiserStateStore cruiserStateStore;

		private readonly IPluginLogger logger;

		private readonly IValidationLogger validationLogger;

		public SaveCruiserStateUseCase(IGameInterop gameInterop, CruiserStateStore cruiserStateStore, IPluginLogger logger, IValidationLogger validationLogger)
		{
			this.gameInterop = gameInterop;
			this.cruiserStateStore = cruiserStateStore;
			this.logger = logger;
			this.validationLogger = validationLogger;
		}

		public SaveCruiserStateResult Execute()
		{
			try
			{
				CruiserSnapshot cruiserSnapshot = gameInterop.CaptureCruiser();
				if (cruiserSnapshot == null)
				{
					logger.LogInfo("No cruiser found.");
					validationLogger.Record(ValidationLogRecord.SaveNoCruiserFound());
					return SaveCruiserStateResult.NoCruiserFound;
				}
				cruiserStateStore.SavedCruiserState = cruiserSnapshot;
				RecordSaveSuccess(cruiserSnapshot);
				return SaveCruiserStateResult.Success;
			}
			catch (Exception arg)
			{
				logger.LogError($"Exception while saving cruiser state: {arg}");
				validationLogger.Record(ValidationLogRecord.SaveUnexpectedState());
				return SaveCruiserStateResult.UnexpectedState;
			}
		}

		private void RecordSaveSuccess(CruiserSnapshot cruiserState)
		{
			validationLogger.Record(ValidationLogRecord.SaveSuccess(cruiserState));
		}
	}
}
namespace CruiserJumpPractice.Core.UseCases.Client
{
	internal enum MagnetState
	{
		Unknown,
		On,
		Off
	}
	internal sealed class MagnetToggleObservation
	{
		public MagnetState BeforeState { get; }

		public MagnetState ExpectedAfterState { get; }

		public MagnetState ObservedAfterState { get; }

		private MagnetToggleObservation(MagnetState beforeState, MagnetState expectedAfterState, MagnetState observedAfterState)
		{
			BeforeState = beforeState;
			ExpectedAfterState = expectedAfterState;
			ObservedAfterState = observedAfterState;
		}

		public static MagnetToggleObservation FromBeforeState(bool beforeIsOn)
		{
			int beforeState = (beforeIsOn ? 1 : 2);
			MagnetState expectedAfterState = ((!beforeIsOn) ? MagnetState.On : MagnetState.Off);
			return new MagnetToggleObservation((MagnetState)beforeState, expectedAfterState, MagnetState.Unknown);
		}
	}
	internal sealed class PresentLoadCruiserStateResultUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly IPluginLogger logger;

		public PresentLoadCruiserStateResultUseCase(IGameInterop gameInterop, IPluginLogger logger)
		{
			this.gameInterop = gameInterop;
			this.logger = logger;
		}

		public void Execute(LoadCruiserStateResult result)
		{
			switch (result)
			{
			case LoadCruiserStateResult.Success:
				DisplayTip(HudTipMessage.LoadSuccess);
				break;
			case LoadCruiserStateResult.NoCruiserFound:
				DisplayTip(HudTipMessage.LoadNoCruiser);
				break;
			case LoadCruiserStateResult.NoSavedState:
				DisplayTip(HudTipMessage.LoadNoSavedState);
				break;
			case LoadCruiserStateResult.MagnetedToShip:
				DisplayTip(HudTipMessage.LoadMagnetedToShip);
				break;
			default:
				logger.LogError($"Unknown LoadCruiserStateResult: {result}");
				break;
			}
		}

		private void DisplayTip(HudTipMessage message)
		{
			gameInterop.DisplayTip(message);
		}
	}
	internal sealed class PresentSaveCruiserStateResultUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly IPluginLogger logger;

		public PresentSaveCruiserStateResultUseCase(IGameInterop gameInterop, IPluginLogger logger)
		{
			this.gameInterop = gameInterop;
			this.logger = logger;
		}

		public void Execute(SaveCruiserStateResult result)
		{
			switch (result)
			{
			case SaveCruiserStateResult.Success:
				DisplayTip(HudTipMessage.SaveSuccess);
				break;
			case SaveCruiserStateResult.NoCruiserFound:
				DisplayTip(HudTipMessage.SaveNoCruiser);
				break;
			default:
				logger.LogError($"Unknown SaveCruiserStateResult: {result}");
				break;
			}
		}

		private void DisplayTip(HudTipMessage message)
		{
			gameInterop.DisplayTip(message);
		}
	}
	internal sealed class RequestLoadCruiserStateUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly IValidationLogger validationLogger;

		public RequestLoadCruiserStateUseCase(IGameInterop gameInterop, IValidationLogger validationLogger)
		{
			this.gameInterop = gameInterop;
			this.validationLogger = validationLogger;
		}

		public RequestLoadCruiserStateResult Execute()
		{
			if (!gameInterop.IsHost())
			{
				gameInterop.DisplayTip(HudTipMessage.LoadHostOnly);
				RecordResult(ValidationLogRole.Client, RequestLoadCruiserStateResult.HostOnly);
				return RequestLoadCruiserStateResult.HostOnly;
			}
			RecordResult(ValidationLogRole.Host, RequestLoadCruiserStateResult.Success);
			gameInterop.RequestLoadCruiserState();
			return RequestLoadCruiserStateResult.Success;
		}

		private void RecordResult(ValidationLogRole role, RequestLoadCruiserStateResult result)
		{
			validationLogger.Record(ValidationLogRecord.RequestLoadResult(role, result));
		}
	}
	internal sealed class RequestSaveCruiserStateUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly IValidationLogger validationLogger;

		public RequestSaveCruiserStateUseCase(IGameInterop gameInterop, IValidationLogger validationLogger)
		{
			this.gameInterop = gameInterop;
			this.validationLogger = validationLogger;
		}

		public RequestSaveCruiserStateResult Execute()
		{
			if (!gameInterop.IsHost())
			{
				gameInterop.DisplayTip(HudTipMessage.SaveHostOnly);
				RecordResult(ValidationLogRole.Client, RequestSaveCruiserStateResult.HostOnly);
				return RequestSaveCruiserStateResult.HostOnly;
			}
			RecordResult(ValidationLogRole.Host, RequestSaveCruiserStateResult.Success);
			gameInterop.RequestSaveCruiserState();
			return RequestSaveCruiserStateResult.Success;
		}

		private void RecordResult(ValidationLogRole role, RequestSaveCruiserStateResult result)
		{
			validationLogger.Record(ValidationLogRecord.RequestSaveResult(role, result));
		}
	}
	internal sealed class ToggleMagnetUseCase
	{
		private readonly IGameInterop gameInterop;

		private readonly IValidationLogger validationLogger;

		public ToggleMagnetUseCase(IGameInterop gameInterop, IValidationLogger validationLogger)
		{
			this.gameInterop = gameInterop;
			this.validationLogger = validationLogger;
		}

		public ToggleMagnetResult Execute()
		{
			if (!gameInterop.IsHost())
			{
				gameInterop.DisplayTip(HudTipMessage.MagnetHostOnly);
				RecordResult(ValidationLogRole.Client, ToggleMagnetResult.HostOnly);
				return ToggleMagnetResult.HostOnly;
			}
			MagnetToggleObservation magnetToggleObservation = MagnetToggleObservation.FromBeforeState(gameInterop.IsShipMagnetOn());
			gameInterop.ToggleShipMagnet();
			validationLogger.Record(ValidationLogRecord.MagnetToggle(magnetToggleObservation));
			ToggleMagnetResult toggleMagnetResult = ((magnetToggleObservation.ExpectedAfterState == MagnetState.On) ? ToggleMagnetResult.MagnetOn : ToggleMagnetResult.MagnetOff);
			validationLogger.Record(ValidationLogRecord.ToggleMagnetResultEvent(ValidationLogRole.Host, toggleMagnetResult));
			HudTipMessage message = ((toggleMagnetResult == ToggleMagnetResult.MagnetOn) ? HudTipMessage.MagnetOn : HudTipMessage.MagnetOff);
			gameInterop.DisplayTip(message);
			return toggleMagnetResult;
		}

		private void RecordResult(ValidationLogRole role, ToggleMagnetResult result)
		{
			validationLogger.Record(ValidationLogRecord.ToggleMagnetResultEvent(role, result));
		}
	}
}
namespace CruiserJumpPractice.Core.State
{
	internal sealed class BaseGameAppliedStateValidationStore
	{
		private int engineOilClientRpcDepth;

		private int turboClientRpcDepth;

		private int? preEngineOilLocalApplyCarHP;

		private int? preTurboLocalApplyBoosts;

		private bool? preMagnetLocalApplyState;

		private bool? preMagnetClientRpcApplyState;

		public bool IsEngineOilClientRpcApplyActive => engineOilClientRpcDepth > 0;

		public bool IsTurboClientRpcApplyActive => turboClientRpcDepth > 0;

		public int? PreEngineOilLocalApplyCarHP => preEngineOilLocalApplyCarHP;

		public int? PreTurboLocalApplyBoosts => preTurboLocalApplyBoosts;

		public bool? PreMagnetLocalApplyState => preMagnetLocalApplyState;

		public bool? PreMagnetClientRpcApplyState => preMagnetClientRpcApplyState;

		public void SetPreEngineOilLocalApplyCarHP(int? value)
		{
			preEngineOilLocalApplyCarHP = value;
		}

		public void SetPreTurboLocalApplyBoosts(int? value)
		{
			preTurboLocalApplyBoosts = value;
		}

		public void SetPreMagnetLocalApplyState(bool? value)
		{
			preMagnetLocalApplyState = value;
		}

		public void SetPreMagnetClientRpcApplyState(bool? value)
		{
			preMagnetClientRpcApplyState = value;
		}

		public void EnterEngineOilClientRpc()
		{
			engineOilClientRpcDepth++;
		}

		public void ExitEngineOilClientRpc()
		{
			if (engineOilClientRpcDepth > 0)
			{
				engineOilClientRpcDepth--;
			}
		}

		public void EnterTurboClientRpc()
		{
			turboClientRpcDepth++;
		}

		public void ExitTurboClientRpc()
		{
			if (turboClientRpcDepth > 0)
			{
				turboClientRpcDepth--;
			}
		}
	}
	internal sealed class CruiserStateStore
	{
		public CruiserSnapshot? SavedCruiserState { get; set; }
	}
	internal readonly struct LocalPlayerBusyState
	{
		public const string MenuReasonToken = "menu";

		public const string TerminalReasonToken = "terminal";

		public const string ChatReasonToken = "chat";

		public const string MultipleReasonToken = "multiple";

		public bool IsMenuOpen { get; }

		public bool IsInTerminal { get; }

		public bool IsTypingChat { get; }

		public bool IsBusy
		{
			get
			{
				if (!IsMenuOpen && !IsInTerminal)
				{
					return IsTypingChat;
				}
				return true;
			}
		}

		public LocalPlayerBusyState(bool isMenuOpen, bool isInTerminal, bool isTypingChat)
		{
			IsMenuOpen = isMenuOpen;
			IsInTerminal = isInTerminal;
			IsTypingChat = isTypingChat;
		}

		public string? GetBusyReasonToken()
		{
			if (0 + (IsMenuOpen ? 1 : 0) + (IsInTerminal ? 1 : 0) + (IsTypingChat ? 1 : 0) > 1)
			{
				return "multiple";
			}
			if (IsMenuOpen)
			{
				return "menu";
			}
			if (IsInTerminal)
			{
				return "terminal";
			}
			if (IsTypingChat)
			{
				return "chat";
			}
			return null;
		}
	}
}
namespace CruiserJumpPractice.Core.Snapshots
{
	internal sealed class CruiserRestoreObservation
	{
		public Vector3Value SavedCarPosition { get; }

		public Vector3Value SavedCarRotation { get; }

		public Vector3Value BeforeCarPosition { get; }

		public Vector3Value AfterCarPosition { get; }

		public int SavedCarHP { get; }

		public int BeforeCarHP { get; }

		public int AfterCarHP { get; }

		public int SavedTurboBoosts { get; }

		public int BeforeTurboBoosts { get; }

		public int AfterTurboBoosts { get; }

		public CruiserRestoreObservation(Vector3Value savedCarPosition, Vector3Value savedCarRotation, Vector3Value beforeCarPosition, Vector3Value afterCarPosition, int savedCarHP, int beforeCarHP, int afterCarHP, int savedTurboBoosts, int beforeTurboBoosts, int afterTurboBoosts)
		{
			SavedCarPosition = savedCarPosition;
			SavedCarRotation = savedCarRotation;
			BeforeCarPosition = beforeCarPosition;
			AfterCarPosition = afterCarPosition;
			SavedCarHP = savedCarHP;
			BeforeCarHP = beforeCarHP;
			AfterCarHP = afterCarHP;
			SavedTurboBoosts = savedTurboBoosts;
			BeforeTurboBoosts = beforeTurboBoosts;
			AfterTurboBoosts = afterTurboBoosts;
		}
	}
	internal sealed class CruiserSnapshot
	{
		public Vector3Value CarPosition { get; }

		public Vector3Value CarRotation { get; }

		public float SteeringInput { get; }

		public float EngineRPM { get; }

		public int CarHP { get; }

		public int TurboBoosts { get; }

		public CruiserSnapshot(Vector3Value carPosition, Vector3Value carRotation, float steeringInput, float engineRPM, int carHP, int turboBoosts)
		{
			CarPosition = carPosition;
			CarRotation = carRotation;
			SteeringInput = steeringInput;
			EngineRPM = engineRPM;
			CarHP = carHP;
			TurboBoosts = turboBoosts;
		}
	}
	internal readonly struct Vector3Value
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public Vector3Value(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}
	}
}
namespace CruiserJumpPractice.Core.Presentation
{
	internal sealed class HudTipMessage
	{
		private const string DefaultHeaderText = "CruiserJumpPractice";

		public static readonly HudTipMessage SaveSuccess = new HudTipMessage("save_success", "CruiserJumpPractice", "Cruiser state saved.");

		public static readonly HudTipMessage SaveNoCruiser = new HudTipMessage("save_no_cruiser", "CruiserJumpPractice", "No cruiser found to save.");

		public static readonly HudTipMessage SaveHostOnly = new HudTipMessage("save_host_only", "CruiserJumpPractice", "Only the host can save the cruiser state.");

		public static readonly HudTipMessage LoadSuccess = new HudTipMessage("load_success", "CruiserJumpPractice", "Cruiser state loaded.");

		public static readonly HudTipMessage LoadNoCruiser = new HudTipMessage("load_no_cruiser", "CruiserJumpPractice", "No cruiser found to load.");

		public static readonly HudTipMessage LoadNoSavedState = new HudTipMessage("load_no_saved_state", "CruiserJumpPractice", "No saved cruiser state to load.");

		public static readonly HudTipMessage LoadMagnetedToShip = new HudTipMessage("load_magneted_to_ship", "CruiserJumpPractice", "Cannot load cruiser state while magneted to ship.");

		public static readonly HudTipMessage LoadHostOnly = new HudTipMessage("load_host_only", "CruiserJumpPractice", "Only the host can load the cruiser state.");

		public static readonly HudTipMessage MagnetHostOnly = new HudTipMessage("magnet_host_only", "CruiserJumpPractice", "Only the host can toggle the magnet.");

		public static readonly HudTipMessage MagnetOn = new HudTipMessage("magnet_on", "CruiserJumpPractice", "Magnet is now ON.");

		public static readonly HudTipMessage MagnetOff = new HudTipMessage("magnet_off", "CruiserJumpPractice", "Magnet is now OFF.");

		public string Token { get; }

		public string HeaderText { get; }

		public string BodyText { get; }

		private HudTipMessage(string token, string headerText, string bodyText)
		{
			Token = token;
			HeaderText = headerText;
			BodyText = bodyText;
		}
	}
}
namespace CruiserJumpPractice.Core.Ports
{
	internal interface IGameInterop
	{
		bool IsHost();

		LocalPlayerBusyState GetLocalPlayerBusyState();

		void DisplayTip(HudTipMessage message);

		RpcSurrogateSpawnResult SpawnRpcSurrogate();

		void RequestSaveCruiserState();

		void RequestLoadCruiserState();

		bool CruiserExists();

		CruiserSnapshot? CaptureCruiser();

		int? GetCruiserCarHP();

		int? GetCruiserTurboBoosts();

		CruiserRestoreObservation RestoreCruiser(CruiserSnapshot snapshot);

		bool IsCruiserMagnetedToShip();

		bool IsShipMagnetOn();

		void ToggleShipMagnet();
	}
	internal enum RpcSurrogateSpawnResult
	{
		Added,
		Reused,
		Missing,
		Error
	}
	internal interface IPluginLogger
	{
		void LogDebug(string message);

		void LogInfo(string message);

		void LogError(string message);
	}
	internal interface IPracticeInput
	{
		bool SaveCruiserTriggered { get; }

		bool LoadCruiserTriggered { get; }

		bool ToggleMagnetTriggered { get; }
	}
	internal interface IValidationLogger
	{
		void Record(ValidationLogRecord record);
	}
}
namespace CruiserJumpPractice.Core.Handlers
{
	internal sealed class BaseGameAppliedStateValidationHandler
	{
		private readonly IGameInterop gameInterop;

		private readonly IValidationLogger validationLogger;

		private readonly BaseGameAppliedStateValidationStore stateStore;

		public BaseGameAppliedStateValidationHandler(IGameInterop gameInterop, IValidationLogger validationLogger, BaseGameAppliedStateValidationStore stateStore)
		{
			this.gameInterop = gameInterop;
			this.validationLogger = validationLogger;
			this.stateStore = stateStore;
		}

		public void EnterEngineOilClientRpc()
		{
			stateStore.EnterEngineOilClientRpc();
		}

		public void ExitEngineOilClientRpc()
		{
			stateStore.ExitEngineOilClientRpc();
		}

		public void HandleEngineOilLocalPreApply()
		{
			stateStore.SetPreEngineOilLocalApplyCarHP(gameInterop.GetCruiserCarHP());
		}

		public void HandleEngineOilLocalApplied()
		{
			if (stateStore.IsEngineOilClientRpcApplyActive)
			{
				validationLogger.Record(ValidationLogRecord.BaseGameEngineOilApplied(GetRole(), stateStore.PreEngineOilLocalApplyCarHP, gameInterop.GetCruiserCarHP(), ValidationLogBaseGameApplySource.ClientRpcApply));
			}
		}

		public void EnterTurboClientRpc()
		{
			stateStore.EnterTurboClientRpc();
		}

		public void ExitTurboClientRpc()
		{
			stateStore.ExitTurboClientRpc();
		}

		public void HandleTurboLocalPreApply()
		{
			stateStore.SetPreTurboLocalApplyBoosts(gameInterop.GetCruiserTurboBoosts());
		}

		public void HandleTurboLocalApplied()
		{
			if (stateStore.IsTurboClientRpcApplyActive)
			{
				validationLogger.Record(ValidationLogRecord.BaseGameTurboApplied(GetRole(), stateStore.PreTurboLocalApplyBoosts, gameInterop.GetCruiserTurboBoosts(), ValidationLogBaseGameApplySource.ClientRpcApply));
			}
		}

		public void HandleShipMagnetLocalPreApply()
		{
			stateStore.SetPreMagnetLocalApplyState(gameInterop.IsShipMagnetOn());
		}

		public void HandleShipMagnetLocalApplied()
		{
			HandleShipMagnetApplied(stateStore.PreMagnetLocalApplyState, gameInterop.IsShipMagnetOn(), ValidationLogBaseGameApplySource.LocalApply);
		}

		public void HandleShipMagnetClientRpcPreApply()
		{
			stateStore.SetPreMagnetClientRpcApplyState(gameInterop.IsShipMagnetOn());
		}

		public void HandleShipMagnetClientRpcApplied()
		{
			HandleShipMagnetApplied(stateStore.PreMagnetClientRpcApplyState, gameInterop.IsShipMagnetOn(), ValidationLogBaseGameApplySource.ClientRpcApply);
		}

		private void HandleShipMagnetApplied(bool? before, bool after, ValidationLogBaseGameApplySource source)
		{
			validationLogger.Record(ValidationLogRecord.BaseGameShipMagnetApplied(GetRole(), before, after, source));
		}

		private ValidationLogRole GetRole()
		{
			if (!gameInterop.IsHost())
			{
				return ValidationLogRole.Client;
			}
			return ValidationLogRole.Host;
		}
	}
	internal sealed class FrameHandler
	{
		private readonly IGameInterop gameInterop;

		private readonly IPracticeInput practiceInput;

		private readonly IValidationLogger validationLogger;

		private readonly RequestSaveCruiserStateUseCase requestSaveCruiserStateUseCase;

		private readonly RequestLoadCruiserStateUseCase requestLoadCruiserStateUseCase;

		private readonly ToggleMagnetUseCase toggleMagnetUseCase;

		public FrameHandler(IGameInterop gameInterop, IPracticeInput practiceInput, IValidationLogger validationLogger, RequestSaveCruiserStateUseCase requestSaveCruiserStateUseCase, RequestLoadCruiserStateUseCase requestLoadCruiserStateUseCase, ToggleMagnetUseCase toggleMagnetUseCase)
		{
			this.gameInterop = gameInterop;
			this.practiceInput = practiceInput;
			this.validationLogger = validationLogger;
			this.requestSaveCruiserStateUseCase = requestSaveCruiserStateUseCase;
			this.requestLoadCruiserStateUseCase = requestLoadCruiserStateUseCase;
			this.toggleMagnetUseCase = toggleMagnetUseCase;
		}

		public void HandleFrame()
		{
			bool saveCruiserTriggered = practiceInput.SaveCruiserTriggered;
			bool loadCruiserTriggered = practiceInput.LoadCruiserTriggered;
			bool toggleMagnetTriggered = practiceInput.ToggleMagnetTriggered;
			if (!saveCruiserTriggered && !loadCruiserTriggered && !toggleMagnetTriggered)
			{
				return;
			}
			LocalPlayerBusyState localPlayerBusyState = gameInterop.GetLocalPlayerBusyState();
			if (localPlayerBusyState.IsBusy)
			{
				RecordSuppressedInput(saveCruiserTriggered, loadCruiserTriggered, toggleMagnetTriggered, localPlayerBusyState);
				return;
			}
			if (saveCruiserTriggered)
			{
				RecordTriggeredInput(ValidationLogInputAction.Save);
				requestSaveCruiserStateUseCase.Execute();
			}
			if (loadCruiserTriggered)
			{
				RecordTriggeredInput(ValidationLogInputAction.Load);
				requestLoadCruiserStateUseCase.Execute();
			}
			if (toggleMagnetTriggered)
			{
				RecordTriggeredInput(ValidationLogInputAction.ToggleMagnet);
				toggleMagnetUseCase.Execute();
			}
		}

		private void RecordSuppressedInput(bool saveTriggered, bool loadTriggered, bool toggleMagnetTriggered, LocalPlayerBusyState busyState)
		{
			if (saveTriggered)
			{
				RecordSuppressedInput(ValidationLogInputAction.Save, busyState);
			}
			if (loadTriggered)
			{
				RecordSuppressedInput(ValidationLogInputAction.Load, busyState);
			}
			if (toggleMagnetTriggered)
			{
				RecordSuppressedInput(ValidationLogInputAction.ToggleMagnet, busyState);
			}
		}

		private void RecordTriggeredInput(ValidationLogInputAction action)
		{
			validationLogger.Record(ValidationLogRecord.InputTriggered(action, GetRole()));
		}

		private void RecordSuppressedInput(ValidationLogInputAction action, LocalPlayerBusyState busyState)
		{
			validationLogger.Record(ValidationLogRecord.InputSuppressed(action, GetRole(), busyState));
		}

		private ValidationLogRole GetRole()
		{
			if (!gameInterop.IsHost())
			{
				return ValidationLogRole.Client;
			}
			return ValidationLogRole.Host;
		}
	}
	internal sealed class StartupHandler
	{
		private readonly IGameInterop gameInterop;

		private readonly IValidationLogger validationLogger;

		public StartupHandler(IGameInterop gameInterop, IValidationLogger validationLogger)
		{
			this.gameInterop = gameInterop;
			this.validationLogger = validationLogger;
		}

		public void HandleStartup()
		{
			RpcSurrogateSpawnResult surrogateResult = gameInterop.SpawnRpcSurrogate();
			validationLogger.Record(ValidationLogRecord.HudStartup(surrogateResult));
		}
	}
}