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 Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("PeakLobbyBoost")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+467b1027a4fbc0ddb98a643aa1f47e2de9ebdd57")]
[assembly: AssemblyProduct("PeakLobbyBoost")]
[assembly: AssemblyTitle("PeakLobbyBoost")]
[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 PeakLobbyBoost
{
	[BepInPlugin("com.mountainfarmer.peaklobbyboost", "Peak Lobby Boost", "1.0.0")]
	[BepInProcess("PEAK.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public const string ModGuid = "com.mountainfarmer.peaklobbyboost";

		public const string ModName = "Peak Lobby Boost";

		public const string ModVersion = "1.0.0";

		private const float SPEED_MULTIPLIER = 1.5f;

		private const float STAMINA_REFILL_AMOUNT = 100f;

		private const float JUMP_MULTIPLIER = 2.5f;

		private const float CLIMB_MULTIPLIER = 4.5f;

		private FieldInfo localCharacterField;

		private PropertyInfo inAirportProperty;

		private FieldInfo characterDataField;

		private PropertyInfo currentStaminaProperty;

		private FieldInfo refsField;

		private FieldInfo movementField;

		private FieldInfo movementModifierField;

		private FieldInfo sprintMultiplierField;

		private FieldInfo jumpImpulseField;

		private FieldInfo climbingField;

		private FieldInfo climbSpeedModField;

		private PropertyInfo playerCharacterProperty;

		private MethodInfo getAllPlayersMethod;

		private Dictionary<object, float> originalMovementModifiers = new Dictionary<object, float>();

		private Dictionary<object, float> originalSprintMultipliers = new Dictionary<object, float>();

		private Dictionary<object, float> originalJumpImpulses = new Dictionary<object, float>();

		private Dictionary<object, float> originalClimbSpeeds = new Dictionary<object, float>();

		private HashSet<object> playersInAirport = new HashSet<object>();

		private void Awake()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Peak Lobby Boost v1.0.0 loaded!");
			CacheReflection();
		}

		private void CacheReflection()
		{
			try
			{
				Type type = Type.GetType("Character, Assembly-CSharp");
				if (type != null)
				{
					localCharacterField = type.GetField("localCharacter", BindingFlags.Static | BindingFlags.Public);
					inAirportProperty = type.GetProperty("inAirport", BindingFlags.Instance | BindingFlags.Public);
					characterDataField = type.GetField("data", BindingFlags.Instance | BindingFlags.Public);
					refsField = type.GetField("refs", BindingFlags.Instance | BindingFlags.Public);
				}
				Type type2 = Type.GetType("CharacterData, Assembly-CSharp");
				if (type2 != null)
				{
					currentStaminaProperty = type2.GetProperty("currentStamina", BindingFlags.Instance | BindingFlags.Public);
				}
				Type type3 = Type.GetType("Character+CharacterRefs, Assembly-CSharp");
				if (type3 != null)
				{
					movementField = type3.GetField("movement", BindingFlags.Instance | BindingFlags.Public);
					climbingField = type3.GetField("climbing", BindingFlags.Instance | BindingFlags.Public);
				}
				Type type4 = Type.GetType("CharacterMovement, Assembly-CSharp");
				if (type4 != null)
				{
					movementModifierField = type4.GetField("movementModifier", BindingFlags.Instance | BindingFlags.Public);
					sprintMultiplierField = type4.GetField("sprintMultiplier", BindingFlags.Instance | BindingFlags.Public);
					jumpImpulseField = type4.GetField("jumpImpulse", BindingFlags.Instance | BindingFlags.Public);
				}
				Type type5 = Type.GetType("CharacterClimbing, Assembly-CSharp");
				if (type5 != null)
				{
					climbSpeedModField = type5.GetField("climbSpeedMod", BindingFlags.Instance | BindingFlags.Public);
				}
				Type typeFromHandle = typeof(Player);
				playerCharacterProperty = typeFromHandle.GetProperty("character", BindingFlags.Instance | BindingFlags.Public);
				Type type6 = Type.GetType("PlayerHandler, Assembly-CSharp");
				if (type6 != null)
				{
					getAllPlayersMethod = type6.GetMethod("GetAllPlayers", BindingFlags.Static | BindingFlags.Public);
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Reflection cached successfully");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to cache reflection: " + ex.Message));
			}
		}

		private void Update()
		{
			try
			{
				object localCharacter = GetLocalCharacter();
				if (localCharacter != null)
				{
					bool flag = IsInAirport(localCharacter);
					bool flag2 = playersInAirport.Contains(localCharacter);
					if (flag && !flag2)
					{
						OnPlayerEnterAirport(localCharacter);
						playersInAirport.Add(localCharacter);
					}
					else if (!flag && flag2)
					{
						OnPlayerExitAirport(localCharacter);
						playersInAirport.Remove(localCharacter);
					}
					if (flag)
					{
						ApplyInfiniteStamina(localCharacter);
					}
				}
			}
			catch
			{
			}
		}

		private object GetLocalCharacter()
		{
			try
			{
				if (localCharacterField == null)
				{
					return null;
				}
				return localCharacterField.GetValue(null);
			}
			catch
			{
				return null;
			}
		}

		private IEnumerable GetAllPlayers()
		{
			try
			{
				if (getAllPlayersMethod != null)
				{
					return getAllPlayersMethod.Invoke(null, null) as IEnumerable;
				}
				return Object.FindObjectsOfType<Player>();
			}
			catch
			{
				return null;
			}
		}

		private object GetCharacterFromPlayer(object player)
		{
			try
			{
				if (playerCharacterProperty == null)
				{
					return null;
				}
				return playerCharacterProperty.GetValue(player);
			}
			catch
			{
				return null;
			}
		}

		private bool IsInAirport(object character)
		{
			try
			{
				if (inAirportProperty == null)
				{
					return false;
				}
				return (bool)inAirportProperty.GetValue(character);
			}
			catch
			{
				return false;
			}
		}

		private void OnPlayerEnterAirport(object character)
		{
			try
			{
				object characterMovement = GetCharacterMovement(character);
				if (characterMovement != null)
				{
					if (movementModifierField != null && !originalMovementModifiers.ContainsKey(character))
					{
						float num = (float)movementModifierField.GetValue(characterMovement);
						originalMovementModifiers[character] = num;
						movementModifierField.SetValue(characterMovement, num * 1.5f);
					}
					if (sprintMultiplierField != null && !originalSprintMultipliers.ContainsKey(character))
					{
						float num2 = (float)sprintMultiplierField.GetValue(characterMovement);
						originalSprintMultipliers[character] = num2;
						sprintMultiplierField.SetValue(characterMovement, num2 * 1.5f);
					}
					if (jumpImpulseField != null && !originalJumpImpulses.ContainsKey(character))
					{
						float num3 = (float)jumpImpulseField.GetValue(characterMovement);
						originalJumpImpulses[character] = num3;
						jumpImpulseField.SetValue(characterMovement, num3 * 2.5f);
					}
				}
				object characterClimbing = GetCharacterClimbing(character);
				if (characterClimbing != null && climbSpeedModField != null && !originalClimbSpeeds.ContainsKey(character))
				{
					float num4 = (float)climbSpeedModField.GetValue(characterClimbing);
					originalClimbSpeeds[character] = num4;
					climbSpeedModField.SetValue(characterClimbing, num4 * 4.5f);
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Player entered airport - all boosts applied!");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to apply boosts: " + ex.Message));
			}
		}

		private void OnPlayerExitAirport(object character)
		{
			try
			{
				object characterMovement = GetCharacterMovement(character);
				if (characterMovement != null)
				{
					if (movementModifierField != null && originalMovementModifiers.TryGetValue(character, out var value))
					{
						movementModifierField.SetValue(characterMovement, value);
						originalMovementModifiers.Remove(character);
					}
					if (sprintMultiplierField != null && originalSprintMultipliers.TryGetValue(character, out var value2))
					{
						sprintMultiplierField.SetValue(characterMovement, value2);
						originalSprintMultipliers.Remove(character);
					}
					if (jumpImpulseField != null && originalJumpImpulses.TryGetValue(character, out var value3))
					{
						jumpImpulseField.SetValue(characterMovement, value3);
						originalJumpImpulses.Remove(character);
					}
				}
				object characterClimbing = GetCharacterClimbing(character);
				if (characterClimbing != null && climbSpeedModField != null && originalClimbSpeeds.TryGetValue(character, out var value4))
				{
					climbSpeedModField.SetValue(characterClimbing, value4);
					originalClimbSpeeds.Remove(character);
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Player exited airport - all values restored");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to restore values: " + ex.Message));
			}
		}

		private void ApplyInfiniteStamina(object character)
		{
			try
			{
				if (!(characterDataField == null))
				{
					object value = characterDataField.GetValue(character);
					if (value != null && !(currentStaminaProperty == null))
					{
						currentStaminaProperty.SetValue(value, 100f);
					}
				}
			}
			catch
			{
			}
		}

		private object GetCharacterMovement(object character)
		{
			try
			{
				if (refsField == null)
				{
					return null;
				}
				object value = refsField.GetValue(character);
				if (value == null)
				{
					return null;
				}
				if (movementField == null)
				{
					return null;
				}
				return movementField.GetValue(value);
			}
			catch
			{
				return null;
			}
		}

		private object GetCharacterClimbing(object character)
		{
			try
			{
				if (refsField == null)
				{
					return null;
				}
				object value = refsField.GetValue(character);
				if (value == null)
				{
					return null;
				}
				if (climbingField == null)
				{
					return null;
				}
				return climbingField.GetValue(value);
			}
			catch
			{
				return null;
			}
		}
	}
}