using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Dash")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A Dash mod for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3421b26455eed0caf2df65dccf377dc2ba0344bb")]
[assembly: AssemblyProduct("Dash")]
[assembly: AssemblyTitle("Dash")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
namespace Dash
{
	public sealed class Config : LcInputActions
	{
		[HarmonyPatch]
		public class SyncLimitations
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static HandleNamedMessageDelegate <>9__2_0;

				internal void <Initialize>b__2_0(ulong clientId, FastBufferReader reader)
				{
					Instance.Enabled.Value = false;
					Plugin.mls.LogMessage((object)"Disabled by host.");
				}
			}

			private const string DISABLED_RECEIVE = "Niro.Dash_DisabledReceive";

			private const string DISABLED_REQUEST = "Niro.Dash_DisabledRequest";

			[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
			[HarmonyPostfix]
			public static void Initialize()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: 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_0067: Expected O, but got Unknown
				if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
				{
					NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("Niro.Dash_DisabledRequest", new HandleNamedMessageDelegate(DisabledRequest));
					return;
				}
				CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
				object obj = <>c.<>9__2_0;
				if (obj == null)
				{
					HandleNamedMessageDelegate val = delegate
					{
						Instance.Enabled.Value = false;
						Plugin.mls.LogMessage((object)"Disabled by host.");
					};
					<>c.<>9__2_0 = val;
					obj = (object)val;
				}
				customMessagingManager.RegisterNamedMessageHandler("Niro.Dash_DisabledReceive", (HandleNamedMessageDelegate)obj);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("Niro.Dash_DisabledRequest", 0uL, new FastBufferWriter(0, (Allocator)2, -1), (NetworkDelivery)3);
			}

			public static void DisabledRequest(ulong clientId, FastBufferReader reader)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!Instance.Enabled.Value)
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("Niro.Dash_DisabledReceive", clientId, new FastBufferWriter(0, (Allocator)2, -1), (NetworkDelivery)3);
				}
			}
		}

		private static Config instance;

		public ConfigEntry<bool> Enabled { get; set; }

		public ConfigEntry<float> StaminaCost { get; set; }

		public ConfigEntry<float> Cooldown { get; set; }

		public ConfigEntry<float> Precision { get; set; }

		public ConfigEntry<float> Power { get; set; }

		public ConfigEntry<float> Speed { get; set; }

		public ConfigEntry<float> FromSize { get; set; }

		public ConfigEntry<float> ToSize { get; set; }

		public InputAction DashKey => ((LcInputActions)this).Asset["dashkey"];

		public ConfigEntry<bool> UseDashKey { get; set; }

		public static Config Instance
		{
			get
			{
				if (instance == null)
				{
					instance = new Config();
				}
				return instance;
			}
		}

		public void Setup()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			Enabled = Plugin.BepInExConfig().Bind<bool>("General", "Enabled", true, "Enable / Disable this mod (Syncing with host!)");
			StaminaCost = Plugin.BepInExConfig().Bind<float>("General", "StaminaCost", 0.15f, new ConfigDescription("Stamina cost for one dash.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			Cooldown = Plugin.BepInExConfig().Bind<float>("General", "Cooldown", 0.75f, new ConfigDescription("Cooldown in seconds.", (AcceptableValueBase)null, Array.Empty<object>()));
			Precision = Plugin.BepInExConfig().Bind<float>("General", "Precision", 0.2f, new ConfigDescription("Time in which a key of the double-tap has to follow to the previous one. Higher = Easier.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.5f), Array.Empty<object>()));
			Power = Plugin.BepInExConfig().Bind<float>("General", "Power", 15f, new ConfigDescription("The power of a dash.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f), Array.Empty<object>()));
			Speed = Plugin.BepInExConfig().Bind<float>("General", "Speed", 0.4f, new ConfigDescription("The duration / speed of the dash.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			FromSize = Plugin.BepInExConfig().Bind<float>("General", "FromSize", 0f, "Player minimum size to be able to dash (value included). Default player size is 1.");
			ToSize = Plugin.BepInExConfig().Bind<float>("General", "ToSize", 0f, "Player maximum size to be able to dash (value included). Default player size is 1. Use 0 to enable dashing for any size.");
			UseDashKey = Plugin.BepInExConfig().Bind<bool>("SeperateKey", "UseDashKey", false, "Use a seperate key for dashing.");
		}

		public override void CreateInputActions(in InputActionMapBuilder builder)
		{
			string value = Plugin.BepInExConfig().Bind<string>("SeperateKey", "DashKeyKeyboard", "<Keyboard>/f", "Seperate keyboard key for dashing. Requires a restart after changing.").Value;
			Plugin.mls.LogInfo((object)("CreateInputActions -> " + value));
			string value2 = Plugin.BepInExConfig().Bind<string>("SeperateKey", "DashKeyGamepad", "<Gamepad>/rightShoulder", "Seperate gamepad key for dashing. Requires a restart after changing.").Value;
			Plugin.mls.LogInfo((object)("CreateInputActions -> " + value2));
			builder.NewActionBinding().WithActionId("dashkey").WithActionType((InputActionType)1)
				.WithBindingName("DashKey")
				.WithKbmPath(value)
				.WithGamepadPath(value2)
				.Finish();
		}
	}
	internal class DashHandler
	{
		public enum Direction
		{
			Forward,
			Backward,
			Left,
			Right
		}

		public float lastDashedAt;

		private bool DashKeyRegistered;

		internal Dictionary<Direction, int> dashProgressMap = new Dictionary<Direction, int>
		{
			{
				Direction.Forward,
				0
			},
			{
				Direction.Backward,
				0
			},
			{
				Direction.Left,
				0
			},
			{
				Direction.Right,
				0
			}
		};

		internal Dictionary<Direction, float> lastKeyChangeMap = new Dictionary<Direction, float>
		{
			{
				Direction.Forward,
				0f
			},
			{
				Direction.Backward,
				0f
			},
			{
				Direction.Left,
				0f
			},
			{
				Direction.Right,
				0f
			}
		};

		public void RegisterDashKey()
		{
			if (DashKeyRegistered)
			{
				if (!InputUtilsCompat.Enabled || !InputUtilsCompat.UseDashKey)
				{
					InputUtilsCompat.DashKey.performed -= OnDashKeyPressed;
					DashKeyRegistered = false;
				}
			}
			else if (InputUtilsCompat.Enabled && InputUtilsCompat.UseDashKey)
			{
				InputUtilsCompat.DashKey.performed += OnDashKeyPressed;
				DashKeyRegistered = true;
			}
		}

		internal void OnUpdate()
		{
			if (FulfillsDashConditions())
			{
				if (((ButtonControl)Keyboard.current.wKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.wKey).wasReleasedThisFrame)
				{
					HandleDashInDirection(Direction.Forward);
				}
				else if (((ButtonControl)Keyboard.current.sKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.sKey).wasReleasedThisFrame)
				{
					HandleDashInDirection(Direction.Backward);
				}
				else if (((ButtonControl)Keyboard.current.aKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.aKey).wasReleasedThisFrame)
				{
					HandleDashInDirection(Direction.Left);
				}
				else if (((ButtonControl)Keyboard.current.dKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.dKey).wasReleasedThisFrame)
				{
					HandleDashInDirection(Direction.Right);
				}
			}
		}

		internal void OnDashKeyPressed(CallbackContext dashContext)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (FulfillsDashConditions())
			{
				PerformDash(((Component)StartOfRound.Instance.localPlayerController.gameplayCamera).transform.forward);
			}
		}

		internal bool FulfillsDashConditions()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StartOfRound.Instance.localPlayerController == (Object)null)
			{
				return false;
			}
			if (!Config.Instance.Enabled.Value)
			{
				return false;
			}
			if (Config.Instance.ToSize.Value > 0f)
			{
				float y = ((Component)StartOfRound.Instance.localPlayerController).gameObject.transform.localScale.y;
				if (y < Config.Instance.FromSize.Value || y > Config.Instance.ToSize.Value)
				{
					return false;
				}
			}
			if (StartOfRound.Instance.localPlayerController.sprintMeter < Config.Instance.StaminaCost.Value)
			{
				return false;
			}
			if (Time.time - lastDashedAt < Config.Instance.Cooldown.Value)
			{
				return false;
			}
			return true;
		}

		internal void HandleDashInDirection(Direction direction)
		{
			float num = Time.time - lastKeyChangeMap[direction];
			lastKeyChangeMap[direction] = Time.time;
			if (num < Config.Instance.Precision.Value)
			{
				dashProgressMap[direction]++;
				if (dashProgressMap[direction] >= 3)
				{
					PerformDash(direction);
					dashProgressMap[direction] = 0;
				}
			}
			else
			{
				dashProgressMap[direction] = 0;
			}
		}

		internal void PerformDash(Direction direction)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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)
			//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)
			//IL_004d: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_006f: 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_0075: 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)
			Vector3 val = ((Component)StartOfRound.Instance.localPlayerController.gameplayCamera).transform.forward;
			switch (direction)
			{
			case Direction.Backward:
				val *= -1f;
				break;
			case Direction.Left:
				val = Quaternion.Euler(0f, -90f, 0f) * val;
				break;
			case Direction.Right:
				val = Quaternion.Euler(0f, 90f, 0f) * val;
				break;
			}
			PerformDash(val);
		}

		internal void PerformDash(Vector3 direction)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			direction.y = 0f;
			DashRoutine.StartRoutine(StartOfRound.Instance.localPlayerController, direction, Config.Instance.Power.Value, Config.Instance.Speed.Value);
			StartOfRound.Instance.localPlayerController.sprintMeter = Mathf.Clamp(StartOfRound.Instance.localPlayerController.sprintMeter - Config.Instance.StaminaCost.Value, 0f, 1f);
			lastDashedAt = Time.time;
		}
	}
	internal class DashRoutine : MonoBehaviour
	{
		public static void StartRoutine(PlayerControllerB targetPlayer, Vector3 direction, float force, float duration = 0.5f, Action onComplete = null)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)((targetPlayer != null) ? ((Component)targetPlayer).gameObject : null) == (Object)null))
			{
				DashRoutine dashRoutine = ((Component)targetPlayer).gameObject.AddComponent<DashRoutine>();
				((MonoBehaviour)dashRoutine).StartCoroutine(dashRoutine.Run(targetPlayer, direction, force, duration));
			}
		}

		private IEnumerator Run(PlayerControllerB targetPlayer, Vector3 direction, float force, float duration)
		{
			//IL_000e: 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)
			float time = 0f;
			Vector3 startForce = direction * force;
			while (time < duration)
			{
				float num = Mathf.Lerp(MathF.PI / 2f, 0f, time / duration);
				Vector3 externalForces = startForce * num;
				targetPlayer.externalForces = externalForces;
				time += Time.deltaTime;
				yield return null;
			}
			targetPlayer.externalForces = Vector3.zero;
		}
	}
	internal static class InputUtilsCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.rune580.LethalCompanyInputUtils");

		public static bool UseDashKey => Config.Instance.UseDashKey.Value;

		public static InputAction DashKey => Config.Instance.DashKey;
	}
	[HarmonyPatch]
	internal class PlayerControllerBPatch
	{
		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		public static void OnUpdate(PlayerControllerB __instance)
		{
			if ((!InputUtilsCompat.Enabled || !InputUtilsCompat.UseDashKey) && !((Object)(object)StartOfRound.Instance.localPlayerController == (Object)null) && StartOfRound.Instance.localPlayerController.playerClientId == __instance.playerClientId)
			{
				Plugin.dashHandler.OnUpdate();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void ConnectClientToPlayerObject()
		{
			Plugin.dashHandler.RegisterDashKey();
		}
	}
	[BepInPlugin("Niro.Dash", "Dash", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string modGUID = "Niro.Dash";

		public const string modName = "Dash";

		public const string modVersion = "1.1.1";

		private readonly Harmony harmony = new Harmony("Niro.Dash");

		private static Plugin instance;

		internal static ManualLogSource mls;

		internal static DashHandler dashHandler = new DashHandler();

		public static ConfigFile BepInExConfig()
		{
			return ((BaseUnityPlugin)instance).Config;
		}

		public void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			mls = Logger.CreateLogSource("Niro.Dash");
			Config.Instance.Setup();
			mls.LogMessage((object)"Plugin Dash loaded!");
			harmony.PatchAll(typeof(Config.SyncLimitations));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}