using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Unity.IL2CPP;
using GTFO.API;
using GTFO.API.Utilities;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Player;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SprintReloadCancel")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+03abdeaaa296c87fd848075276a3990b9961708e")]
[assembly: AssemblyProduct("SprintReloadCancel")]
[assembly: AssemblyTitle("SprintReloadCancel")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
namespace SprintReloadCancel
{
	internal static class Configuration
	{
		public static bool SprintCancelEnabled = true;

		public static bool AimCancelEnabled = false;

		public static bool ShootCancelEnabled = false;

		public static bool SwapBuffer = true;

		private static ConfigFile configFile;

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			configFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "SprintReloadCancel.cfg"), true);
			BindAll(configFile);
			LiveEdit.CreateListener(Paths.ConfigPath, "SprintReloadCancel.cfg", false).FileChanged += new LiveEditEventHandler(OnFileChanged);
		}

		private static void OnFileChanged(LiveEditEventArgs _)
		{
			configFile.Reload();
			SprintCancelEnabled = (bool)configFile["Base Settings", "Sprint to Reload Cancel"].BoxedValue;
			AimCancelEnabled = (bool)configFile["Base Settings", "Aim to Reload Cancel"].BoxedValue;
			ShootCancelEnabled = (bool)configFile["Base Settings", "Shoot to Reload Cancel"].BoxedValue;
			SwapBuffer = (bool)configFile["Base Settings", "Reload Cancel Swap Buffer"].BoxedValue;
		}

		private static void BindAll(ConfigFile config)
		{
			SprintCancelEnabled = config.Bind<bool>("Base Settings", "Sprint to Reload Cancel", SprintCancelEnabled, "Sprinting will cancel reloads.").Value;
			AimCancelEnabled = config.Bind<bool>("Base Settings", "Aim to Reload Cancel", AimCancelEnabled, "Aiming will cancel reloads.").Value;
			ShootCancelEnabled = config.Bind<bool>("Base Settings", "Shoot to Reload Cancel", ShootCancelEnabled, "Shooting will cancel reloads.").Value;
			SwapBuffer = config.Bind<bool>("Base Settings", "Reload Cancel Swap Buffer", SwapBuffer, "After a reload cancel, buffers swap inputs until the next possible time.\nThis can mitigate missed inputs when you attempt to swap weapons right after reload canceling.").Value;
		}
	}
	[BepInPlugin("Dinorush.SprintReloadCancel", "SprintReloadCancel", "1.3.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal sealed class EntryPoint : BasePlugin
	{
		public const string MODNAME = "SprintReloadCancel";

		public override void Load()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("SprintReloadCancel").PatchAll();
			Configuration.Init();
			AssetAPI.OnStartupAssetsLoaded += delegate
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected O, but got Unknown
				ClassInjector.RegisterTypeInIl2Cpp<ReloadCancelHandler>();
				GameObject val = new GameObject("SprintReloadCancel");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<ReloadCancelHandler>();
			};
			((BasePlugin)this).Log.LogMessage((object)"Loaded SprintReloadCancel");
		}
	}
	public sealed class ReloadCancelHandler : MonoBehaviour
	{
		private enum CancelState
		{
			Reload,
			SwapBack,
			SwapBuffer
		}

		private PlayerAgent? _owner;

		private ItemEquippable? _item;

		private CancelState _currentState;

		private InventorySlot _swapSlot;

		private float _reloadEndTime;

		private bool _bufferPush;

		private float _bufferEndTime;

		private const float SwapTime = 0.2f;

		private static readonly Dictionary<InputAction, InventorySlot> SwapActions = new Dictionary<InputAction, InventorySlot>
		{
			{
				(InputAction)23,
				(InventorySlot)1
			},
			{
				(InputAction)24,
				(InventorySlot)2
			},
			{
				(InputAction)25,
				(InventorySlot)3
			},
			{
				(InputAction)26,
				(InventorySlot)10
			},
			{
				(InputAction)28,
				(InventorySlot)5
			},
			{
				(InputAction)29,
				(InventorySlot)11
			},
			{
				(InputAction)27,
				(InventorySlot)4
			}
		};

		public static ReloadCancelHandler Instance { get; private set; } = null;


		public ReloadCancelHandler(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Awake()
		{
			Instance = this;
			((Behaviour)this).enabled = false;
		}

		private void ClearState()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			_item = null;
			_owner = null;
			_currentState = CancelState.Reload;
			_swapSlot = (InventorySlot)0;
			_bufferPush = false;
			((Behaviour)this).enabled = false;
		}

		public void OnReloadStart(ItemEquippable item, float reloadEndTime)
		{
			PlayerAgent owner = ((Item)item).Owner;
			if (!((Object)(object)owner == (Object)null) && ((Agent)owner).IsLocallyOwned)
			{
				_item = item;
				_owner = owner;
				_reloadEndTime = reloadEndTime;
				_currentState = CancelState.Reload;
				((Behaviour)this).enabled = true;
			}
		}

		private void Update()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if ((Object)(object)_owner == (Object)null || (Object)(object)_item == (Object)null)
			{
				ClearState();
				return;
			}
			switch (_currentState)
			{
			case CancelState.Reload:
				if (!_item.IsReloading)
				{
					ClearState();
				}
				else if (ShouldCancel())
				{
					_swapSlot = ((PlayerInventoryBase)_owner.FPItemHolder.m_inventoryLocal).WieldedSlot;
					_owner.FPItemHolder.MeleeAttackShortcut();
					_currentState = CancelState.SwapBack;
				}
				break;
			case CancelState.SwapBack:
				_owner.Sync.WantsToWieldSlot(_swapSlot, false);
				if (Configuration.SwapBuffer)
				{
					_currentState = CancelState.SwapBuffer;
					_bufferEndTime = Clock.Time + 0.2f;
				}
				else
				{
					ClearState();
				}
				break;
			case CancelState.SwapBuffer:
				CheckSwapBuffer();
				break;
			}
		}

		private bool ShouldCancel()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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)
			eFocusState inputFilter = _owner.InputFilter;
			if (!Configuration.SprintCancelEnabled || !InputMapper.GetButtonDown.Invoke((InputAction)9, inputFilter) || !_owner.Locomotion.InputIsForwardEnoughForRun())
			{
				if (_reloadEndTime - 0.2f > Clock.Time)
				{
					if (!Configuration.AimCancelEnabled || !InputMapper.GetButtonDown.Invoke((InputAction)7, inputFilter))
					{
						if (Configuration.ShootCancelEnabled)
						{
							return InputMapper.GetButtonDown.Invoke((InputAction)8, inputFilter);
						}
						return false;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		private void CheckSwapBuffer()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Invalid comparison between Unknown and I4
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			eFocusState inputFilter = _owner.InputFilter;
			if (Clock.Time < _bufferEndTime)
			{
				foreach (KeyValuePair<InputAction, InventorySlot> swapAction in SwapActions)
				{
					if (InputMapper.GetButtonDown.Invoke(swapAction.Key, inputFilter))
					{
						_swapSlot = swapAction.Value;
						_bufferPush = false;
					}
				}
				if (InputMapper.GetButtonDown.Invoke((InputAction)12, inputFilter))
				{
					_bufferPush = true;
				}
				return;
			}
			if ((int)((PlayerInventoryBase)_owner.FPItemHolder.m_inventoryLocal).WieldedSlot != 8)
			{
				if (_bufferPush)
				{
					_owner.FPItemHolder.MeleeAttackShortcut();
				}
				else if ((int)_swapSlot != 0)
				{
					_owner.Sync.WantsToWieldSlot(_swapSlot, false);
				}
			}
			ClearState();
		}
	}
	[HarmonyPatch]
	internal static class ReloadCancelPatches
	{
		[HarmonyPatch(typeof(ItemEquippable), "TryTriggerReloadAnimationSequence")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void TrackReloadTime(ItemEquippable __instance, bool __result)
		{
			if (!__result || (Object)(object)((Item)__instance).Owner == (Object)null || !((Agent)((Item)__instance).Owner).IsLocallyOwned)
			{
				return;
			}
			GearFrontPartDataBlock frontData = __instance.GearPartHolder.FrontData;
			List<WeaponAnimSequenceItem> obj = ((((frontData == null) ? null : frontData.ReloadSequence?.Count).GetValueOrDefault() > 0) ? __instance.GearPartHolder.FrontData.ReloadSequence : __instance.GearPartHolder.StockData.ReloadSequence);
			float triggerTime = obj[obj.Count - 1].TriggerTime;
			float num = __instance.ReloadTime / triggerTime;
			float num2 = 0f;
			Enumerator<WeaponAnimSequenceItem> enumerator = obj.GetEnumerator();
			while (enumerator.MoveNext())
			{
				WeaponAnimSequenceItem current = enumerator.Current;
				if (current.TriggerTime > num2)
				{
					num2 = current.TriggerTime;
				}
			}
			ReloadCancelHandler.Instance.OnReloadStart(__instance, Clock.Time + num2 * num);
		}
	}
}