using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Pigeon.Movement;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ReloadAnyTime")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ReloadAnyTime")]
[assembly: AssemblyTitle("ReloadAnyTime")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
[BepInPlugin("sparroh.reloadanytime", "ReloadAnyTime", "1.0.1")]
[MycoMod(/*Could not decode attribute arguments.*/)]
public class SparrohPlugin : BaseUnityPlugin
{
	private struct OriginalAimConstraints
	{
		public ActionFireMode CanAimWhileSliding;

		public bool CanAimWhileReloading;

		public bool LockSprinting;
	}

	public const string PluginGUID = "sparroh.reloadanytime";

	public const string PluginName = "ReloadAnyTime";

	public const string PluginVersion = "1.0.1";

	internal static ManualLogSource Logger;

	internal static ConfigEntry<bool> enableCanAimWhileSliding;

	internal static ConfigEntry<bool> enableCanAimWhileReloading;

	internal static ConfigEntry<bool> enableCanAimWhileSprinting;

	private static readonly FieldInfo lockSprintingField = AccessTools.Field(typeof(Gun), "lockSprinting");

	private static readonly FieldInfo gunDataField = AccessTools.Field(typeof(Gun), "gunData");

	private static readonly Dictionary<int, OriginalAimConstraints> originalConstraints = new Dictionary<int, OriginalAimConstraints>();

	private Harmony harmony;

	private FileSystemWatcher configWatcher;

	private static volatile bool pendingConstraintRefresh;

	private void Awake()
	{
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Expected O, but got Unknown
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Expected O, but got Unknown
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Expected O, but got Unknown
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0215: Expected O, but got Unknown
		//IL_026d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Expected O, but got Unknown
		Logger = ((BaseUnityPlugin)this).Logger;
		enableCanAimWhileSliding = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Can Aim While Sliding", true, "Allows aiming weapons while sliding.");
		enableCanAimWhileReloading = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Can Aim While Reloading", true, "Allows aiming weapons while reloading.");
		enableCanAimWhileSprinting = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Can Aim While Sprinting", true, "Allows aiming weapons while sprinting.");
		enableCanAimWhileSliding.SettingChanged += OnAimConstraintSettingChanged;
		enableCanAimWhileReloading.SettingChanged += OnAimConstraintSettingChanged;
		enableCanAimWhileSprinting.SettingChanged += OnAimConstraintSettingChanged;
		try
		{
			SetupFileWatcher();
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error setting up config file watcher: " + ex.Message));
		}
		harmony = new Harmony("sparroh.reloadanytime");
		try
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(Gun), "Setup", new Type[3]
			{
				typeof(Player),
				typeof(PlayerAnimation),
				typeof(IGear)
			}, (Type[])null);
			if (methodInfo == null)
			{
				Logger.LogError((object)"Could not find Gun.Setup method for patching.");
			}
			else
			{
				HarmonyMethod val = new HarmonyMethod(typeof(SparrohPlugin), "ModifyWeaponPrefix", (Type[])null);
				harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}
		catch (Exception ex2)
		{
			Logger.LogError((object)("Error patching Gun.Setup: " + ex2.Message));
		}
		try
		{
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Gun), "OnStartAim", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				Logger.LogError((object)"Could not find Gun.OnStartAim method!");
			}
			else
			{
				HarmonyMethod val2 = new HarmonyMethod(typeof(SparrohPlugin), "OnStartAimPrefix", (Type[])null);
				HarmonyMethod val3 = new HarmonyMethod(typeof(SparrohPlugin), "OnStartAimPostfix", (Type[])null);
				harmony.Patch((MethodBase)methodInfo2, val2, val3, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			MethodInfo methodInfo3 = AccessTools.Method(typeof(Gun), "CanAim", (Type[])null, (Type[])null);
			if (methodInfo3 == null)
			{
				Logger.LogError((object)"Could not find Gun.CanAim method!");
			}
			else
			{
				HarmonyMethod val4 = new HarmonyMethod(typeof(SparrohPlugin), "CanAimPrefix", (Type[])null);
				harmony.Patch((MethodBase)methodInfo3, val4, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}
		catch (Exception ex3)
		{
			Logger.LogError((object)("Error setting up aiming patches: " + ex3.Message));
		}
		Logger.LogInfo((object)"ReloadAnyTime v1.0.1 loaded successfully.");
	}

	private void Update()
	{
		if (pendingConstraintRefresh)
		{
			pendingConstraintRefresh = false;
			ApplyAimConstraintsToAllGuns();
		}
	}

	private void SetupFileWatcher()
	{
		configWatcher = new FileSystemWatcher(Paths.ConfigPath, "sparroh.reloadanytime.cfg");
		configWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite;
		configWatcher.Changed += OnConfigFileChanged;
		configWatcher.Created += OnConfigFileChanged;
		configWatcher.Renamed += OnConfigFileChanged;
		configWatcher.EnableRaisingEvents = true;
	}

	private void OnConfigFileChanged(object sender, FileSystemEventArgs e)
	{
		try
		{
			((BaseUnityPlugin)this).Config.Reload();
			pendingConstraintRefresh = true;
			Logger.LogInfo((object)"Config reloaded from disk.");
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error reloading config: " + ex.Message));
		}
	}

	private static void OnAimConstraintSettingChanged(object sender, EventArgs e)
	{
		pendingConstraintRefresh = true;
	}

	public static void ModifyWeaponPrefix(Gun __instance, IGear prefab)
	{
		Gun val = (Gun)(object)((prefab is Gun) ? prefab : null);
		if (val != null)
		{
			AimStateData aimStateData = ((Component)__instance).gameObject.GetComponent<AimStateData>();
			if ((Object)(object)aimStateData == (Object)null)
			{
				aimStateData = ((Component)__instance).gameObject.AddComponent<AimStateData>();
			}
			ApplyAimConstraints(val, aimStateData);
		}
	}

	internal static void ApplyAimConstraintsToAllGuns()
	{
		try
		{
			Gun[] array = Object.FindObjectsOfType<Gun>();
			foreach (Gun val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					AimStateData aimStateData = ((Component)val).gameObject.GetComponent<AimStateData>();
					if ((Object)(object)aimStateData == (Object)null)
					{
						aimStateData = ((Component)val).gameObject.AddComponent<AimStateData>();
					}
					ApplyAimConstraints(val, aimStateData);
				}
			}
			Logger.LogInfo((object)$"Re-applied aim constraints to {array.Length} gun(s).");
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error re-applying aim constraints: " + ex.Message));
		}
	}

	internal static void ApplyAimConstraints(Gun gun, AimStateData aimData)
	{
		if ((Object)(object)gun == (Object)null)
		{
			return;
		}
		try
		{
			object obj = gunDataField?.GetValue(gun);
			if (obj != null)
			{
				ApplyAimConstraintsToGunDataObject(gun, obj, aimData);
			}
			else
			{
				ApplyAimConstraintsToGunData(gun, ref gun.GunData, aimData);
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error applying aim constraints: " + ex.Message));
		}
	}

	private static OriginalAimConstraints GetOrCaptureOriginals(Gun gun, ActionFireMode canAimWhileSliding, bool canAimWhileReloading, bool lockSprinting)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		int instanceID = ((Object)gun).GetInstanceID();
		if (!originalConstraints.TryGetValue(instanceID, out var value))
		{
			value = new OriginalAimConstraints
			{
				CanAimWhileSliding = canAimWhileSliding,
				CanAimWhileReloading = canAimWhileReloading,
				LockSprinting = lockSprinting
			};
			originalConstraints[instanceID] = value;
		}
		return value;
	}

	private static void ApplyAimConstraintsToGunData(Gun gun, ref GunData gunData, AimStateData aimData)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		bool lockSprinting = lockSprintingField != null && (bool)lockSprintingField.GetValue(gun);
		OriginalAimConstraints orCaptureOriginals = GetOrCaptureOriginals(gun, gunData.fireConstraints.canAimWhileSliding, gunData.fireConstraints.canAimWhileReloading, lockSprinting);
		gunData.fireConstraints.canAimWhileSliding = (ActionFireMode)(enableCanAimWhileSliding.Value ? 1 : ((int)orCaptureOriginals.CanAimWhileSliding));
		gunData.fireConstraints.canAimWhileReloading = enableCanAimWhileReloading.Value || orCaptureOriginals.CanAimWhileReloading;
		if ((Object)(object)aimData != (Object)null)
		{
			aimData.CanAimWhileSprinting = enableCanAimWhileSprinting.Value;
		}
		if (lockSprintingField != null)
		{
			bool flag = !enableCanAimWhileSprinting.Value && orCaptureOriginals.LockSprinting;
			lockSprintingField.SetValue(gun, flag);
		}
	}

	private static void ApplyAimConstraintsToGunDataObject(Gun gun, object gunDataObj, AimStateData aimData)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		FieldInfo field = gunDataObj.GetType().GetField("fireConstraints");
		if (field == null)
		{
			return;
		}
		object value = field.GetValue(gunDataObj);
		if (value == null)
		{
			return;
		}
		Type type = value.GetType();
		FieldInfo field2 = type.GetField("canAimWhileSliding");
		FieldInfo field3 = type.GetField("canAimWhileReloading");
		if (!(field2 == null) && !(field3 == null))
		{
			bool lockSprinting = lockSprintingField != null && (bool)lockSprintingField.GetValue(gun);
			OriginalAimConstraints orCaptureOriginals = GetOrCaptureOriginals(gun, (ActionFireMode)field2.GetValue(value), (bool)field3.GetValue(value), lockSprinting);
			object value2 = (object)(ActionFireMode)(enableCanAimWhileSliding.Value ? 1 : ((int)orCaptureOriginals.CanAimWhileSliding));
			object value3 = enableCanAimWhileReloading.Value || orCaptureOriginals.CanAimWhileReloading;
			field2.SetValue(value, value2);
			field3.SetValue(value, value3);
			field.SetValue(gunDataObj, value);
			if (gunDataField != null && gunDataField.FieldType.IsValueType)
			{
				gunDataField.SetValue(gun, gunDataObj);
			}
			if ((Object)(object)aimData != (Object)null)
			{
				aimData.CanAimWhileSprinting = enableCanAimWhileSprinting.Value;
			}
			if (lockSprintingField != null)
			{
				bool flag = !enableCanAimWhileSprinting.Value && orCaptureOriginals.LockSprinting;
				lockSprintingField.SetValue(gun, flag);
			}
		}
	}

	public static bool OnStartAimPrefix(Gun __instance)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Expected O, but got Unknown
		try
		{
			AimStateData component = ((Component)__instance).gameObject.GetComponent<AimStateData>();
			if ((Object)(object)component != (Object)null && component.CanAimWhileSprinting)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Gun), "player");
				if (fieldInfo != null)
				{
					Player val = (Player)fieldInfo.GetValue(__instance);
					if ((Object)(object)val != (Object)null)
					{
						PropertyInfo propertyInfo = AccessTools.Property(typeof(Player), "IsSprinting");
						if (propertyInfo != null)
						{
							component.WasSprinting = (bool)propertyInfo.GetValue(val);
						}
					}
				}
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error in OnStartAimPrefix: " + ex.Message));
		}
		return true;
	}

	public static void OnStartAimPostfix(Gun __instance)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		try
		{
			AimStateData component = ((Component)__instance).gameObject.GetComponent<AimStateData>();
			if (!((Object)(object)component != (Object)null) || !component.CanAimWhileSprinting || !component.WasSprinting)
			{
				return;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(Gun), "player");
			if (fieldInfo != null)
			{
				Player val = (Player)fieldInfo.GetValue(__instance);
				if ((Object)(object)val != (Object)null)
				{
					MethodInfo methodInfo = AccessTools.Method(typeof(Player), "ResumeSprint", (Type[])null, (Type[])null);
					if (methodInfo != null)
					{
						methodInfo.Invoke(val, null);
					}
				}
			}
			component.WasSprinting = false;
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error in OnStartAimPostfix: " + ex.Message));
		}
	}

	public static bool CanAimPrefix(Gun __instance, ref bool __result)
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Expected O, but got Unknown
		try
		{
			AimStateData component = ((Component)__instance).gameObject.GetComponent<AimStateData>();
			if ((Object)(object)component != (Object)null && component.CanAimWhileSprinting)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Gun), "player");
				if (fieldInfo != null)
				{
					Player val = (Player)fieldInfo.GetValue(__instance);
					if ((Object)(object)val != (Object)null)
					{
						PropertyInfo propertyInfo = AccessTools.Property(typeof(Player), "IsSprinting");
						if (propertyInfo != null && (bool)propertyInfo.GetValue(val))
						{
							FieldInfo fieldInfo2 = AccessTools.Field(typeof(Gun), "isAimInputHeld");
							if (fieldInfo2 != null && (bool)fieldInfo2.GetValue(__instance))
							{
								__result = true;
								return false;
							}
						}
					}
				}
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Error in CanAimPrefix: " + ex.Message));
		}
		return true;
	}

	private void OnDestroy()
	{
		if (enableCanAimWhileSliding != null)
		{
			enableCanAimWhileSliding.SettingChanged -= OnAimConstraintSettingChanged;
		}
		if (enableCanAimWhileReloading != null)
		{
			enableCanAimWhileReloading.SettingChanged -= OnAimConstraintSettingChanged;
		}
		if (enableCanAimWhileSprinting != null)
		{
			enableCanAimWhileSprinting.SettingChanged -= OnAimConstraintSettingChanged;
		}
		if (configWatcher != null)
		{
			configWatcher.EnableRaisingEvents = false;
			configWatcher.Changed -= OnConfigFileChanged;
			configWatcher.Created -= OnConfigFileChanged;
			configWatcher.Renamed -= OnConfigFileChanged;
			configWatcher.Dispose();
			configWatcher = null;
		}
		Harmony obj = harmony;
		if (obj != null)
		{
			obj.UnpatchSelf();
		}
	}
}
public class AimStateData : MonoBehaviour
{
	public bool CanAimWhileSprinting { get; set; }

	public bool WasSprinting { get; set; }
}
namespace ReloadAnyTime
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ReloadAnyTime";

		public const string PLUGIN_NAME = "ReloadAnyTime";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}