using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
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 UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BetterSwimming")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyProduct("BetterSwimming")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[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.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]
	[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;
		}
	}
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		public ExtensionMarkerAttribute(string name)
		{
		}
	}
}
namespace BetterSwimming
{
	[HarmonyPatch(typeof(PlayerMovement), "Move")]
	internal static class PlayerMovementMovePatch
	{
		private static PlayerInput? _input;

		private static InputAction? _jump;

		private static float _nextStroke;

		private static float _swimVel;

		private static bool _wasSwimming;

		internal static void RaiseSwimVel(float velY)
		{
			_swimVel = Mathf.Max(_swimVel, velY);
			_wasSwimming = true;
		}

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_0030: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if (!BetterSwimmingPlugin.IsEnabled || !BetterSwimmingPlugin.IsLocal(__instance))
			{
				return;
			}
			if (!__instance._isSwimming || __instance.OnBoat)
			{
				_wasSwimming = false;
				return;
			}
			Rigidbody rig = __instance._rig;
			float num = WaterManager.GetWaterHeight(rig.position) - rig.position.y;
			bool flag = BetterSwimmingPlugin.HoldToSwim.Value.IsOn() && JumpHeld();
			float num2;
			if (flag)
			{
				num2 = BetterSwimmingPlugin.SwimUpSpeed.Value;
			}
			else if (__instance._crouchInput)
			{
				num2 = 0f - BetterSwimmingPlugin.DiveSpeed.Value;
			}
			else
			{
				float num3 = num - BetterSwimmingPlugin.FloatDepth.Value;
				num2 = ((num3 > 0f) ? Mathf.Min(num3 * 2f, BetterSwimmingPlugin.BuoyancySpeed.Value) : (0f - BetterSwimmingPlugin.SinkSpeed.Value));
			}
			if (!_wasSwimming)
			{
				_swimVel = Mathf.Max(rig.linearVelocity.y, -10f);
				_wasSwimming = true;
			}
			_swimVel = Mathf.MoveTowards(_swimVel, num2, BetterSwimmingPlugin.SwimAccel.Value * Time.fixedDeltaTime);
			if (!__instance.Grounded || !(num2 <= 0f))
			{
				Vector3 linearVelocity = rig.linearVelocity;
				linearVelocity.y = _swimVel;
				rig.linearVelocity = linearVelocity;
				StrokeSound(flag);
			}
		}

		private static bool JumpHeld()
		{
			PlayerInput input = GameInfo.Input;
			if (!Object.op_Implicit((Object)(object)input))
			{
				return false;
			}
			if ((Object)(object)_input == (Object)(object)input && _jump != null)
			{
				return _jump.IsPressed();
			}
			_input = input;
			_jump = input.actions["PlayerJump"];
			return _jump.IsPressed();
		}

		private static void StrokeSound(bool swimmingUp)
		{
			if (!swimmingUp)
			{
				_nextStroke = 0f;
			}
			else if (!(Time.time < _nextStroke))
			{
				_nextStroke = Time.time + BetterSwimmingPlugin.StrokeSoundInterval.Value;
				AudioManager.PlayRandomGlobalClip(GameInfo.WaterStepSound, 1, GameInfo.StepSoundCount, true, 0.2f, 0.1f);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "Jump")]
	internal static class PlayerMovementJumpPatch
	{
		private static bool Prefix(PlayerMovement __instance)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!BetterSwimmingPlugin.IsEnabled)
			{
				return true;
			}
			if (!__instance._isSwimming || __instance.Grounded)
			{
				return true;
			}
			if (!BetterSwimmingPlugin.IsLocal(__instance))
			{
				return true;
			}
			if (BetterSwimmingPlugin.HoldToSwim.Value.IsOn())
			{
				Vector3 linearVelocity = __instance._rig.linearVelocity;
				linearVelocity.y = Mathf.Max(linearVelocity.y, BetterSwimmingPlugin.StrokeForce.Value);
				__instance._rig.linearVelocity = linearVelocity;
				return false;
			}
			if (BetterSwimmingPlugin.UnlimitedStrokes.Value.IsOn())
			{
				__instance._swimJumpCount = 0;
			}
			return true;
		}

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (BetterSwimmingPlugin.IsEnabled && BetterSwimmingPlugin.IsLocal(__instance) && __instance._isSwimming)
			{
				PlayerMovementMovePatch.RaiseSwimVel(__instance._rig.linearVelocity.y);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "UpdateMoveSpeed")]
	internal static class PlayerMovementUpdateMoveSpeedPatch
	{
		private static void Postfix(PlayerMovement __instance)
		{
			if (BetterSwimmingPlugin.IsEnabled && __instance._isSwimming && BetterSwimmingPlugin.IsLocal(__instance))
			{
				__instance._curMoveSpeed *= BetterSwimmingPlugin.SwimSpeedMulti.Value;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "UnderWaterCheck")]
	internal static class PlayerMovementUnderWaterCheckPatch
	{
		private static void Prefix(PlayerMovement __instance)
		{
			if (BetterSwimmingPlugin.IsEnabled && BetterSwimmingPlugin.IsLocal(__instance))
			{
				__instance._damageFromWater = BetterSwimmingPlugin.UnderwaterDamage.Value;
				__instance._underwaterDamageDelay = BetterSwimmingPlugin.UnderwaterDamageDelay.Value;
			}
		}

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			if (BetterSwimmingPlugin.IsEnabled && BetterSwimmingPlugin.IsLocal(__instance) && !BetterSwimmingPlugin.WaveAccurate.Value.IsOff())
			{
				Vector3 position = __instance._player.Transform.position;
				__instance._isSwimming = position.y <= WaterManager.GetWaterHeight(position);
			}
		}
	}
	[BepInPlugin("Azumatt.BetterSwimming", "BetterSwimming", "1.0.0")]
	public class BetterSwimmingPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		internal const string ModName = "BetterSwimming";

		internal const string ModVersion = "1.0.0";

		internal const string Author = "Azumatt";

		private const string ModGUID = "Azumatt.BetterSwimming";

		private static string ConfigFileName = "Azumatt.BetterSwimming.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("Azumatt.BetterSwimming");

		public static readonly ManualLogSource BetterSwimmingLogger;

		internal static ConfigEntry<Toggle> ModEnabled;

		internal static ConfigEntry<Toggle> HoldToSwim;

		internal static ConfigEntry<float> SwimUpSpeed;

		internal static ConfigEntry<float> DiveSpeed;

		internal static ConfigEntry<float> SwimAccel;

		internal static ConfigEntry<float> SwimSpeedMulti;

		internal static ConfigEntry<float> FloatDepth;

		internal static ConfigEntry<float> BuoyancySpeed;

		internal static ConfigEntry<float> SinkSpeed;

		internal static ConfigEntry<Toggle> WaveAccurate;

		internal static ConfigEntry<Toggle> UnlimitedStrokes;

		internal static ConfigEntry<float> StrokeForce;

		internal static ConfigEntry<float> StrokeSoundInterval;

		internal static ConfigEntry<int> UnderwaterDamage;

		internal static ConfigEntry<float> UnderwaterDamageDelay;

		internal static bool IsEnabled
		{
			get
			{
				ConfigEntry<Toggle> modEnabled = ModEnabled;
				if (modEnabled != null)
				{
					return modEnabled.Value == Toggle.On;
				}
				return false;
			}
		}

		public void Awake()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Expected O, but got Unknown
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Expected O, but got Unknown
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			ModEnabled = config("1 - General", "Enabled", Toggle.On, "Turn the whole mod off without unloading it.");
			HoldToSwim = config("2 - Swimming", "Hold To Swim Up", Toggle.On, "Hold jump to rise instead of mashing it. Off falls back to vanilla strokes.");
			SwimUpSpeed = config("2 - Swimming", "Swim Up Speed", 3.5f, new ConfigDescription("Units per second you climb while holding jump.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 15f), Array.Empty<object>()));
			DiveSpeed = config("2 - Swimming", "Dive Speed", 3f, new ConfigDescription("Units per second you go down while holding crouch. Watch the drowning timer.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			SwimAccel = config("2 - Swimming", "Swim Acceleration", 25f, new ConfigDescription("How hard vertical speed chases its target. Has to beat the game's extra gravity, so don't go tiny.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f), Array.Empty<object>()));
			SwimSpeedMulti = config("2 - Swimming", "Swim Speed Multiplier", 1f, new ConfigDescription("Multiplies horizontal move speed while swimming (you can't sprint in water).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 3f), Array.Empty<object>()));
			FloatDepth = config("3 - Buoyancy", "Float Depth", 0.4f, new ConfigDescription("How far under the surface you settle when you're not pressing anything.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			BuoyancySpeed = config("3 - Buoyancy", "Buoyancy Speed", 1.5f, new ConfigDescription("Cap on how fast you get pushed back up to the float depth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			SinkSpeed = config("3 - Buoyancy", "Sink Speed", 0.35f, new ConfigDescription("Idle drift downwards once you're at the float depth. Vanilla just sinks forever.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
			WaveAccurate = config("3 - Buoyancy", "Wave Accurate Water Line", Toggle.On, "Use the Gerstner wave height instead of the flat water plane, so swells actually lift you.");
			UnlimitedStrokes = config("4 - Strokes", "Unlimited Strokes", Toggle.On, "Kills the stroke decay. Only matters when Hold To Swim Up is off.");
			StrokeForce = config("4 - Strokes", "Stroke Force", 3f, new ConfigDescription("Little kick a jump press gives while Hold To Swim Up is on.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			StrokeSoundInterval = config("4 - Strokes", "Stroke Sound Interval", 0.55f, new ConfigDescription("Seconds between swim sounds while you hold jump. 0 spams it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			UnderwaterDamage = config("5 - Drowning", "Underwater Damage", 10, new ConfigDescription("Damage per half second once your head has been under too long. 0 to never drown.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			UnderwaterDamageDelay = config("5 - Drowning", "Underwater Damage Delay", 2f, new ConfigDescription("Grace period in seconds before the drowning damage starts.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 60f), Array.Empty<object>()));
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
				((BaseUnityPlugin)this).Config.Save();
			}
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				BetterSwimmingLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				BetterSwimmingLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		internal static bool IsLocal(PlayerMovement move)
		{
			if ((Object)(object)Player.LocalPlayer != (Object)null)
			{
				return (Object)(object)move._player == (Object)(object)Player.LocalPlayer;
			}
			return false;
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description)
		{
			return ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, string description)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		static BetterSwimmingPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			BetterSwimmingLogger = Logger.CreateLogSource("BetterSwimming");
			ModEnabled = null;
			HoldToSwim = null;
			SwimUpSpeed = null;
			DiveSpeed = null;
			SwimAccel = null;
			SwimSpeedMulti = null;
			FloatDepth = null;
			BuoyancySpeed = null;
			SinkSpeed = null;
			WaveAccurate = null;
			UnlimitedStrokes = null;
			StrokeForce = null;
			StrokeSoundInterval = null;
			UnderwaterDamage = null;
			UnderwaterDamageDelay = null;
		}
	}
	public static class ToggleExtensions
	{
		[SpecialName]
		public sealed class <G>$4EFB485ABB76B8E3D0C1BC397C89D8B9
		{
			[SpecialName]
			public static class <M>$C59917F68A58EC5D02708E1A6E1BABC0
			{
			}

			[ExtensionMarker("<M>$C59917F68A58EC5D02708E1A6E1BABC0")]
			public bool IsOn()
			{
				throw null;
			}

			[ExtensionMarker("<M>$C59917F68A58EC5D02708E1A6E1BABC0")]
			public bool IsOff()
			{
				throw null;
			}
		}

		public static bool IsOn(this BetterSwimmingPlugin.Toggle toggle)
		{
			return toggle == BetterSwimmingPlugin.Toggle.On;
		}

		public static bool IsOff(this BetterSwimmingPlugin.Toggle toggle)
		{
			return toggle == BetterSwimmingPlugin.Toggle.Off;
		}
	}
}