using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CruiseControl.Configuration;
using CruiseControl.Localization;
using CruiseControl.Runtime;
using CruiseControl.UI;
using Fusion;
using HarmonyLib;
using ModSettingsMenu.Api;
using SunkenlandLocalizationAPI.Api;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("CruiseControl")]
[assembly: AssemblyDescription("Cruise control mod for Sunkenland by Ice Box Studio")]
[assembly: AssemblyCompany("Ice Box Studio")]
[assembly: AssemblyProduct("CruiseControl")]
[assembly: AssemblyCopyright("Copyright © 2026 Ice Box Studio All rights reserved.")]
[assembly: ComVisible(false)]
[assembly: Guid("c668fef8-d6f1-4e45-a154-1e558cbe9bf4")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.1.0")]
namespace CruiseControl
{
	[BepInPlugin("IceBoxStudio.Sunkenland.CruiseControl", "CruiseControl", "1.0.1")]
	[BepInDependency("IceBoxStudio.Sunkenland.ModSettingsMenu", "1.2.0")]
	[BepInDependency("IceBoxStudio.Sunkenland.LocalizationAPI", "1.1.0")]
	public sealed class CruiseControl : BaseUnityPlugin
	{
		private Harmony _harmony;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			LocalizationApi.LanguageChanged += OnLanguageChanged;
			try
			{
				Log.LogInfo((object)"=============================================");
				Log.LogInfo((object)("CruiseControl " + I18n.Text("plugin.initializing")));
				Log.LogInfo((object)(I18n.Text("plugin.author_prefix") + "Ice Box Studio(https://steamcommunity.com/id/ibox666/)"));
				ConfigManager.Bind(((BaseUnityPlugin)this).Config);
				RegisterSettings();
				_harmony = new Harmony("IceBoxStudio.Sunkenland.CruiseControl");
				_harmony.PatchAll(Assembly.GetExecutingAssembly());
				Log.LogInfo((object)("CruiseControl " + I18n.Text("plugin.initialized")));
				Log.LogInfo((object)"=============================================");
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to initialize Cruise Control: {arg}");
			}
		}

		private static void RegisterSettings()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0065: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			ModSettingsRegistry.Register("IceBoxStudio.Sunkenland.CruiseControl", new ModSettingsModOptions
			{
				Name = "Cruise Control",
				LocalizedName = () => I18n.Text("mod.name"),
				Description = I18n.Text("mod.description"),
				Author = "Ice Box Studio",
				Version = "1.0.1",
				NexusModsId = 82,
				ThunderstoreTeam = "Ice_Box_Studio_Sunkenland",
				ThunderstoreModName = "CruiseControl"
			});
		}

		private static void OnLanguageChanged(string language)
		{
			RegisterSettings();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "IceBoxStudio.Sunkenland.CruiseControl";

		public const string PLUGIN_NAME = "CruiseControl";

		public const string PLUGIN_VERSION = "1.0.1";
	}
}
namespace CruiseControl.UI
{
	internal static class VehicleSpeedDisplay
	{
		internal static void Append(TextMeshProUGUI speedText)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)speedText == (Object)null) && global::CruiseControl.Runtime.CruiseControl.TryGetPrompt(out var active, out var boat, out var _))
			{
				if (active && (Object)(object)boat != (Object)null && Object.op_Implicit((Object)(object)boat.Rigid))
				{
					Vector3 velocity = boat.Rigid.velocity;
					string text = (((Vector3)(ref velocity)).magnitude * 10f).ToString("f1") + "km/h";
					((TMP_Text)speedText).text = ((boat.MoveState < 0) ? ("-" + text) : text);
				}
				((TMP_Text)speedText).enableWordWrapping = false;
				((TMP_Text)speedText).text = ((TMP_Text)speedText).text + Prompt(active, ((TMP_Text)speedText).fontSize);
			}
		}

		internal static void Append(Text speedText)
		{
			if (!((Object)(object)speedText == (Object)null) && global::CruiseControl.Runtime.CruiseControl.TryGetPrompt(out var active, out var _, out var _))
			{
				speedText.text += Prompt(active, speedText.fontSize);
			}
		}

		private static string Prompt(bool active, float fontSize)
		{
			int num = Mathf.Max(12, Mathf.RoundToInt(fontSize * 0.55f));
			string text = I18n.Text(active ? "ui.cruise.cancel" : "ui.cruise.enable", ConfigManager.CruiseKeyText);
			return "\n<size=" + num + ">" + text.TrimStart(Array.Empty<char>()) + "</size>";
		}
	}
}
namespace CruiseControl.Runtime
{
	internal static class CruiseControl
	{
		private static Boat _boat;

		private static HelicopterController _helicopter;

		private static float _targetSpeed;

		internal static bool IsActive
		{
			get
			{
				if (!((Object)(object)_boat != (Object)null))
				{
					return (Object)(object)_helicopter != (Object)null;
				}
				return true;
			}
		}

		internal static void Toggle()
		{
			//IL_006b: 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_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)
			if (Object.op_Implicit((Object)(object)Global.code) && Global.code.OnGUI)
			{
				return;
			}
			Boat boat;
			HelicopterController helicopter;
			if (IsActive)
			{
				Clear();
			}
			else if (TryGetCurrentVehicle(out boat, out helicopter) && CanEnable(boat, helicopter))
			{
				_boat = boat;
				_helicopter = helicopter;
				Vector3 velocity;
				float magnitude;
				if (!((Object)(object)boat != (Object)null))
				{
					velocity = helicopter.Rigid.velocity;
					magnitude = ((Vector3)(ref velocity)).magnitude;
				}
				else
				{
					velocity = boat.Rigid.velocity;
					magnitude = ((Vector3)(ref velocity)).magnitude;
				}
				_targetSpeed = magnitude;
			}
		}

		internal static void Tick()
		{
			if (!IsActive)
			{
				return;
			}
			if (!TryGetCurrentVehicle(out var boat, out var helicopter) || (Object)(object)boat != (Object)(object)_boat || (Object)(object)helicopter != (Object)(object)_helicopter)
			{
				Clear();
			}
			else if ((Object)(object)boat != (Object)null)
			{
				if (!SupportsCruise(boat) || !HasInputAuthority(boat) || !boat.EngineOn || HasBoatOverrideInput())
				{
					Clear();
				}
			}
			else if (!HasInputAuthority(helicopter) || !helicopter.EngineOn || HasHelicopterOverrideInput())
			{
				Clear();
			}
		}

		internal static bool IsActiveFor(Boat boat, HelicopterController helicopter)
		{
			if (IsActive && (Object)(object)boat == (Object)(object)_boat)
			{
				return (Object)(object)helicopter == (Object)(object)_helicopter;
			}
			return false;
		}

		internal static void UpdateBoatInput(Boat boat, ref BoatNetworkInput input)
		{
			if (SupportsCruise(boat) && IsActiveFor(boat, null) && HasInputAuthority(boat) && !HasBoatOverrideInput())
			{
				input.MoveState = 1;
			}
		}

		internal static void MaintainBoat(Boat boat)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if (!SupportsCruise(boat) || !IsActiveFor(boat, null) || !HasInputAuthority(boat) || HasBoatOverrideInput())
			{
				return;
			}
			if (!boat.EngineOn || !Object.op_Implicit((Object)(object)boat.Rigid) || boat.Rigid.isKinematic)
			{
				Clear();
				return;
			}
			Vector3 boatForward = GetBoatForward(boat);
			float num = Vector3.Dot(boat.Rigid.velocity, boatForward);
			if (num <= 0.1f)
			{
				Clear();
				return;
			}
			Rigidbody rigid = boat.Rigid;
			rigid.velocity += boatForward * (_targetSpeed - num);
		}

		internal static void UpdateBoatForce(Boat boat, ref int force)
		{
			if (SupportsCruise(boat) && IsActiveFor(boat, null) && !HasBoatOverrideInput())
			{
				force = 1;
			}
		}

		internal static void MaintainHelicopter(HelicopterController helicopter)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (IsActiveFor(null, helicopter) && HasInputAuthority(helicopter) && !HasHelicopterOverrideInput())
			{
				if (!helicopter.EngineOn || !Object.op_Implicit((Object)(object)helicopter.Rigid) || helicopter.Rigid.isKinematic)
				{
					Clear();
					return;
				}
				Vector3 velocity = helicopter.Rigid.velocity;
				Vector3 val = ((((Vector3)(ref velocity)).sqrMagnitude > 0.01f) ? ((Vector3)(ref velocity)).normalized : ((Component)helicopter).transform.forward);
				helicopter.Rigid.velocity = val * _targetSpeed;
			}
		}

		internal static bool TryGetPrompt(out bool active, out Boat boat, out HelicopterController helicopter)
		{
			active = false;
			if (!TryGetCurrentVehicle(out boat, out helicopter))
			{
				return false;
			}
			if ((Object)(object)boat != (Object)null && !SupportsCruise(boat))
			{
				return false;
			}
			active = IsActiveFor(boat, helicopter);
			if (!active)
			{
				return CanEnable(boat, helicopter);
			}
			return true;
		}

		private static bool CanEnable(Boat boat, HelicopterController helicopter)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_0046: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			Vector3 velocity;
			if ((Object)(object)boat != (Object)null)
			{
				if (SupportsCruise(boat) && HasInputAuthority(boat) && boat.EngineOn && Object.op_Implicit((Object)(object)boat.Rigid) && !boat.Rigid.isKinematic)
				{
					velocity = boat.Rigid.velocity;
					if (!(((Vector3)(ref velocity)).magnitude * 10f < ConfigManager.ActivationSpeedKmh))
					{
						return Vector3.Dot(boat.Rigid.velocity, GetBoatForward(boat)) > 0.1f;
					}
				}
				return false;
			}
			if (HasInputAuthority(helicopter) && helicopter.EngineOn && Object.op_Implicit((Object)(object)helicopter.Rigid) && !helicopter.Rigid.isKinematic)
			{
				velocity = helicopter.Rigid.velocity;
				return ((Vector3)(ref velocity)).magnitude * 10f >= ConfigManager.ActivationSpeedKmh;
			}
			return false;
		}

		private static bool SupportsCruise(Boat boat)
		{
			if ((Object)(object)boat != (Object)null && !Object.op_Implicit((Object)(object)boat.M_Sail))
			{
				return !boat.SeparatWaterObject;
			}
			return false;
		}

		private static bool HasInputAuthority(Boat boat)
		{
			if ((Object)(object)boat != (Object)null && Object.op_Implicit((Object)(object)((SimulationBehaviour)boat).Object))
			{
				return ((SimulationBehaviour)boat).Object.HasInputAuthority;
			}
			return false;
		}

		private static bool HasInputAuthority(HelicopterController helicopter)
		{
			if ((Object)(object)helicopter != (Object)null && Object.op_Implicit((Object)(object)((SimulationBehaviour)helicopter).Object))
			{
				return ((SimulationBehaviour)helicopter).Object.HasInputAuthority;
			}
			return false;
		}

		private static bool TryGetCurrentVehicle(out Boat boat, out HelicopterController helicopter)
		{
			boat = null;
			helicopter = null;
			if (!Object.op_Implicit((Object)(object)Global.code) || !Object.op_Implicit((Object)(object)Global.code.Player))
			{
				return false;
			}
			boat = Global.code.Player.drivingObject;
			if ((Object)(object)boat != (Object)null)
			{
				return true;
			}
			helicopter = Global.code.Player.CurHelicopter;
			return (Object)(object)helicopter != (Object)null;
		}

		private static Vector3 GetBoatForward(Boat boat)
		{
			//IL_001e: 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_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_002d: 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)
			Transform engineForward = boat.engineForward;
			Vector3 val = Vector3.ProjectOnPlane(((Object)(object)engineForward != (Object)null) ? engineForward.forward : ((Component)boat).transform.forward, Vector3.up);
			return ((Vector3)(ref val)).normalized;
		}

		private static bool HasBoatOverrideInput()
		{
			InputManager instance = InputManager.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				if (!instance.BackHold)
				{
					if (instance.BoatBoostHold)
					{
						return !UsesCruiseKey(instance.BoatBoostKeyAction);
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static bool UsesCruiseKey(KeyAction keyAction)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (keyAction != null)
			{
				return ConfigManager.UsesKey(keyAction.keyCode);
			}
			return false;
		}

		private static bool HasHelicopterOverrideInput()
		{
			InputManager instance = InputManager.Instance;
			if ((!((Object)(object)instance != (Object)null) || (!instance.HelicopterThrottlePositiveHold && !instance.HelicopterThrottleNegativeHold && !instance.HelicopterYawNegativeHold && !instance.HelicopterYawPositiveHold)) && !(Mathf.Abs(Input.GetAxis("Mouse X")) > 0.01f))
			{
				return Mathf.Abs(Input.GetAxis("Mouse Y")) > 0.01f;
			}
			return true;
		}

		private static void Clear()
		{
			_boat = null;
			_helicopter = null;
			_targetSpeed = 0f;
		}
	}
	internal static class CruiseInput
	{
		internal static void Run()
		{
			if (ConfigManager.IsDown())
			{
				CruiseControl.Toggle();
			}
			CruiseControl.Tick();
		}
	}
}
namespace CruiseControl.Patches
{
	[HarmonyPatch(typeof(Boat), "AddForce", new Type[] { typeof(int) })]
	internal static class BoatAddForcePatch
	{
		private static void Prefix(Boat __instance, ref int __0)
		{
			global::CruiseControl.Runtime.CruiseControl.UpdateBoatForce(__instance, ref __0);
		}
	}
	[HarmonyPatch(typeof(Boat), "FixedUpdate")]
	internal static class BoatFixedUpdatePatch
	{
		private static void Postfix(Boat __instance)
		{
			global::CruiseControl.Runtime.CruiseControl.MaintainBoat(__instance);
		}
	}
	[HarmonyPatch(typeof(Boat), "PrepareInput")]
	internal static class BoatPrepareInputPatch
	{
		private static void Postfix(Boat __instance, ref BoatNetworkInput __result)
		{
			global::CruiseControl.Runtime.CruiseControl.UpdateBoatInput(__instance, ref __result);
		}
	}
	[HarmonyPatch(typeof(HelicopterController), "FixedUpdate")]
	internal static class HelicopterFixedUpdatePatch
	{
		private static void Postfix(HelicopterController __instance)
		{
			global::CruiseControl.Runtime.CruiseControl.MaintainHelicopter(__instance);
		}
	}
	[HarmonyPatch(typeof(HelicopterHUD), "FixedUpdate")]
	internal static class HelicopterSpeedUiPatch
	{
		private static void Postfix(HelicopterHUD __instance)
		{
			VehicleSpeedDisplay.Append(__instance.speedTxt);
		}
	}
	[HarmonyPatch(typeof(InputManager), "Update")]
	internal static class InputManagerUpdatePatch
	{
		private static void Postfix()
		{
			CruiseInput.Run();
		}
	}
	[HarmonyPatch(typeof(UICombat), "Update")]
	internal static class VehicleSpeedUiPatch
	{
		private static void Postfix(TextMeshProUGUI ___tmpVehicleSpeed)
		{
			VehicleSpeedDisplay.Append(___tmpVehicleSpeed);
		}
	}
}
namespace CruiseControl.Localization
{
	internal static class I18n
	{
		private const string FileName = "CruiseControl.Localization.json";

		private static readonly ModLocalizer _localizer = Load();

		internal static ModLocalizer Localizer => _localizer;

		internal static string Text(string key, params object[] args)
		{
			return _localizer.GetLocalizedText(key, args);
		}

		private static ModLocalizer Load()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			ModLocalizer obj = LocalizationApi.For("IceBoxStudio.Sunkenland.CruiseControl");
			obj.RegisterJson(Path.Combine(directoryName, "CruiseControl.Localization.json"));
			return obj;
		}
	}
}
namespace CruiseControl.Configuration
{
	internal static class ConfigManager
	{
		private static ConfigEntry<float> _activationSpeedKmh;

		private static ConfigEntry<KeyCode> _cruiseKey;

		internal static float ActivationSpeedKmh => Math.Max(0.1f, (_activationSpeedKmh == null) ? 5f : _activationSpeedKmh.Value);

		internal static KeyCode CruiseKey
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				if (_cruiseKey != null)
				{
					return _cruiseKey.Value;
				}
				return (KeyCode)306;
			}
		}

		internal static string CruiseKeyText
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Invalid comparison between Unknown and I4
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Invalid comparison between Unknown and I4
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if ((int)CruiseKey == 306 || (int)CruiseKey == 305)
				{
					return I18n.Text("key.ctrl");
				}
				return ((object)CruiseKey/*cast due to .constrained prefix*/).ToString();
			}
		}

		internal static bool IsDown()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if ((int)CruiseKey != 0)
			{
				return Input.GetKeyDown(CruiseKey);
			}
			return false;
		}

		internal static bool UsesKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return CruiseKey == key;
		}

		internal static void Bind(ConfigFile config)
		{
			_activationSpeedKmh = config.Bind<float>("Cruise Control", "ActivationSpeedKmh", 5f, I18n.Localizer.Config("config.activation_speed", 10, "Cruise Control", "config.section", 10, (AcceptableValueBase)null));
			_cruiseKey = config.Bind<KeyCode>("Cruise Control", "CruiseKey", (KeyCode)306, I18n.Localizer.Config("config.cruise_key", 20, "Cruise Control", "config.section", 10, (AcceptableValueBase)null));
		}
	}
}