using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using JetpackSafety.Patches;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("JetpackSafety")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("JetpackSafety")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("09921379-6b32-4bc0-ad08-d65d6be0946e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace JetpackSafety
{
	internal static class ModInfo
	{
		internal const string modGUID = "PixelIndieDev_JetpackSafety";

		internal const string modName = "Jetpack Safety";

		internal const string modVersion = "1.2.0.0";
	}
	[BepInPlugin("PixelIndieDev_JetpackSafety", "Jetpack Safety", "1.2.0.0")]
	public class JetpackPlayerDamagePatchBase : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("PixelIndieDev_JetpackSafety");

		private static JetpackPlayerDamagePatchBase instance;

		internal ManualLogSource logSource;

		private void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			logSource = Logger.CreateLogSource("PixelIndieDev_JetpackSafety");
			harmony.PatchAll(typeof(JetpackPlayerDamagePatchBase));
			harmony.PatchAll(typeof(JetpackPatch));
			harmony.PatchAll(typeof(PlayerControllerPatch));
			harmony.PatchAll(typeof(NetworkPatch));
			logSource.LogInfo((object)"Jetpack Safety (version - 1.2.0.0): patches applied successfully");
		}
	}
}
namespace JetpackSafety.Patches
{
	[HarmonyPatch(typeof(JetpackItem))]
	internal static class JetpackPatch
	{
		[HarmonyPatch("ExplodeJetpackServerRpc")]
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool PreventExplosionsOnServer()
		{
			return false;
		}

		[HarmonyPatch("ExplodeJetpackClientRpc")]
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool PreventExplosionsOnClient()
		{
			return false;
		}

		[HarmonyPatch("SetJetpackAudios")]
		[HarmonyPostfix]
		[HarmonyPriority(800)]
		private static void PreventBeeps(JetpackItem __instance, ref bool ___jetpackPlayingWarningBeep, AudioSource ___jetpackBeepsAudio)
		{
			if (___jetpackPlayingWarningBeep)
			{
				___jetpackPlayingWarningBeep = false;
				___jetpackBeepsAudio.Stop();
			}
		}
	}
	[HarmonyPatch(typeof(NetworkManager))]
	internal static class NetworkPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetSingleton")]
		private static void RegisterPrefab()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PixelIndieDev_JetpackSafety Prefab");
			((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x3D);
			Object.DontDestroyOnLoad((Object)(object)val);
			NetworkObject obj = val.AddComponent<NetworkObject>();
			typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(obj, GetHash("PixelIndieDev_JetpackSafety"));
			NetworkManager.Singleton.PrefabHandler.AddNetworkPrefab(val);
		}

		private static uint GetHash(string value)
		{
			return value?.Aggregate(17u, (uint current, char c) => (current * 31) ^ c) ?? 0;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PlayerControllerPatch
	{
		private static bool isFlying = false;

		private static float gracePeriodDuration = 2.5f;

		private static float graceTimer = 0f;

		[HarmonyPatch("KillPlayer")]
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool PreventDeath(PlayerControllerB __instance, CauseOfDeath causeOfDeath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)causeOfDeath == 2 && IsUsingJetpack(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("DamagePlayer")]
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool PreventDamage(PlayerControllerB __instance, CauseOfDeath causeOfDeath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)causeOfDeath == 2 && IsUsingJetpack(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void CheckIfFlying(PlayerControllerB __instance)
		{
			if (IsJetpackActive(__instance))
			{
				graceTimer = 0f;
				isFlying = true;
			}
			else if (isFlying)
			{
				isFlying = false;
				graceTimer = gracePeriodDuration;
			}
			if (graceTimer > 0f)
			{
				graceTimer -= Time.deltaTime;
				if (graceTimer < 0f)
				{
					graceTimer = 0f;
				}
			}
		}

		private static bool IsJetpackActive(PlayerControllerB player)
		{
			if (player.jetpackControls)
			{
				return !player.disablingJetpackControls;
			}
			return false;
		}

		private static bool IsUsingJetpack(PlayerControllerB player)
		{
			if (!isFlying)
			{
				return graceTimer > 0f;
			}
			return true;
		}
	}
}