using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("DropDischargeDisable")]
[assembly: AssemblyDescription("Prevent accidental discharges in single action revolvers when dropped")]
[assembly: AssemblyCompany("BitWizrd")]
[assembly: AssemblyProduct("DropDischargeDisable")]
[assembly: AssemblyCopyright("Copyright © BitWizrd 2024")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BitWizrd.DropDischargeDisable
{
	public class DropDischargeMonitor : MonoBehaviour
	{
		private class RevolverState
		{
			public float LastCollisionTime { get; set; }

			public float LastVelocityMagnitude { get; set; }

			public bool WasRecentlyCollided { get; set; }
		}

		private static DropDischargeMonitor _instance;

		private Dictionary<SingleActionRevolver, RevolverState> monitoredRevolvers = new Dictionary<SingleActionRevolver, RevolverState>();

		private List<SingleActionRevolver> revolversToRemove = new List<SingleActionRevolver>();

		private Dictionary<SingleActionRevolver, bool> hasReportedDischarge = new Dictionary<SingleActionRevolver, bool>();

		public static DropDischargeMonitor Instance
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("DropDischargeMonitor");
					_instance = val.AddComponent<DropDischargeMonitor>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return _instance;
			}
		}

		private void Update()
		{
			revolversToRemove.Clear();
			foreach (KeyValuePair<SingleActionRevolver, RevolverState> monitoredRevolver in monitoredRevolvers)
			{
				if ((Object)(object)monitoredRevolver.Key == (Object)null)
				{
					revolversToRemove.Add(monitoredRevolver.Key);
				}
			}
			foreach (SingleActionRevolver item in revolversToRemove)
			{
				monitoredRevolvers.Remove(item);
				hasReportedDischarge.Remove(item);
			}
			foreach (KeyValuePair<SingleActionRevolver, RevolverState> monitoredRevolver2 in monitoredRevolvers)
			{
				UpdateRevolverState(monitoredRevolver2.Key, monitoredRevolver2.Value);
			}
		}

		public void RegisterRevolver(SingleActionRevolver revolver)
		{
			if (!monitoredRevolvers.ContainsKey(revolver))
			{
				monitoredRevolvers[revolver] = new RevolverState
				{
					LastCollisionTime = Time.time,
					LastVelocityMagnitude = 0f,
					WasRecentlyCollided = false
				};
				DropDischargeDisablePlugin.LogInfo("Registered revolver for drop discharge monitoring: " + ((Object)revolver).name);
			}
		}

		private void UpdateRevolverState(SingleActionRevolver revolver, RevolverState state)
		{
			if (state.WasRecentlyCollided && Time.time - state.LastCollisionTime > 1f)
			{
				state.WasRecentlyCollided = false;
				hasReportedDischarge[revolver] = false;
			}
		}

		public bool ShouldPreventDischarge(SingleActionRevolver revolver, Collision collision)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			RegisterRevolver(revolver);
			RevolverState revolverState = monitoredRevolvers[revolver];
			float time = Time.time;
			Vector3 relativeVelocity = collision.relativeVelocity;
			float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
			revolverState.LastCollisionTime = time;
			revolverState.LastVelocityMagnitude = magnitude;
			bool hasTransferBarSafety = revolver.HasTransferBarSafety;
			FVRFireArmChamber obj = revolver.Cylinder.Chambers[revolver.CurChamber];
			bool isFull = obj.IsFull;
			bool isSpent = obj.IsSpent;
			if (!(!hasTransferBarSafety && isFull) || isSpent)
			{
				return false;
			}
			relativeVelocity = collision.relativeVelocity;
			bool num = ((Vector3)(ref relativeVelocity)).magnitude > 2f;
			if (!hasReportedDischarge.ContainsKey(revolver))
			{
				hasReportedDischarge[revolver] = false;
			}
			if (num && !hasReportedDischarge[revolver])
			{
				string[] obj2 = new string[5]
				{
					"Drop discharge prevented for ",
					((Object)revolver).name,
					" (velocity: ",
					null,
					null
				};
				relativeVelocity = collision.relativeVelocity;
				obj2[3] = ((Vector3)(ref relativeVelocity)).magnitude.ToString("F1");
				obj2[4] = " m/s)";
				DropDischargeDisablePlugin.LogInfo(string.Concat(obj2));
				hasReportedDischarge[revolver] = true;
			}
			return true;
		}
	}
	[BepInPlugin("BitWizrd.DropDischargeDisable", "Drop Discharge Disable", "1.0.0")]
	[BepInProcess("h3vr.exe")]
	public class DropDischargeDisablePlugin : BaseUnityPlugin
	{
		private static ManualLogSource _logger;

		private Harmony harmony;

		internal static ManualLogSource Logger => _logger;

		private void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (((BaseUnityPlugin)this).Logger != null)
			{
				_logger = ((BaseUnityPlugin)this).Logger;
			}
			Logger.LogInfo((object)"Initializing Drop Discharge Disable plugin");
			harmony = new Harmony("BitWizrd.DropDischargeDisable");
			harmony.PatchAll();
			Logger.LogInfo((object)"Applied Harmony patches");
		}

		public static void LogInfo(string message)
		{
			if (_logger != null)
			{
				_logger.LogInfo((object)message);
			}
		}

		public static void LogWarning(string message)
		{
			if (_logger != null)
			{
				_logger.LogWarning((object)message);
			}
		}

		public static void LogError(string message)
		{
			if (_logger != null)
			{
				_logger.LogError((object)message);
			}
		}

		private void OnDestroy()
		{
			Logger.LogInfo((object)"Destroying Drop Discharge Disable plugin");
			if (harmony != null)
			{
				harmony.UnpatchAll((string)null);
			}
		}
	}
}
namespace BitWizrd.DropDischargeDisable.Patches
{
	[HarmonyPatch(typeof(SingleActionRevolver), "OnCollisionEnter")]
	public static class SingleActionRevolverCollisionPatches
	{
		private static bool Prefix(SingleActionRevolver __instance, Collision col)
		{
			try
			{
				if ((Object)(object)DropDischargeMonitor.Instance == (Object)null)
				{
					return true;
				}
				return !DropDischargeMonitor.Instance.ShouldPreventDischarge(__instance, col);
			}
			catch (Exception ex)
			{
				DropDischargeDisablePlugin.LogError("Error in collision prevention: " + ex.Message);
				return true;
			}
		}
	}
}