using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("HurepoHappyTimes")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HurepoHappyTimes")]
[assembly: AssemblyTitle("HurepoHappyTimes")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HurepoHappyTimes;

internal static class Log
{
	private const string PREFIX = "[Hura] ";

	public static void Message(string text)
	{
		Mod.ModLogger.LogMessage((object)("[Hura] " + text));
	}

	public static void Warning(string text)
	{
		Mod.ModLogger.LogWarning((object)("[Hura] " + text));
	}

	public static void Error(string text)
	{
		Mod.ModLogger.LogError((object)("[Hura] " + text));
	}
}
[BepInPlugin("Hura.HurepoHappyTimes", "HurepoHappyTimes", "1.0.2")]
public class Mod : BaseUnityPlugin
{
	private const string GUID = "Hura.HurepoHappyTimes";

	private const string NAME = "HurepoHappyTimes";

	private const string VERSION = "1.0.2";

	private readonly Harmony _harmony = new Harmony("Hura.HurepoHappyTimes");

	private readonly Type[] _patches = new Type[8]
	{
		typeof(InstantReviveHead),
		typeof(SharedConsumables_MaxHealth),
		typeof(SharedConsumables_Stamina),
		typeof(SharedConsumables_SprintSpeed),
		typeof(SharedConsumables_Strength),
		typeof(SharedConsumables_Range),
		typeof(SharedConsumables_Throw),
		typeof(SharedConsumables_TumbleLaunch)
	};

	internal static Mod Instance { get; private set; }

	internal static ManualLogSource ModLogger => ((BaseUnityPlugin)Instance).Logger;

	private void Awake()
	{
		Instance = this;
		try
		{
			Settings.Bind(this);
			RepoReflection.Initialize();
		}
		catch (Exception ex)
		{
			Log.Error(ex.Message);
		}
		Patch();
	}

	private void Patch()
	{
		Type[] patches = _patches;
		foreach (Type type in patches)
		{
			_harmony.PatchAll(type);
		}
	}
}
internal static class RepoReflection
{
	private static FieldInfo DeathHeadVolumeCheckField;

	private static FieldInfo IsInExtractionPointVolumeCheckField;

	private static FieldInfo AvatarSteamIDField;

	internal static void Initialize()
	{
		DeathHeadVolumeCheckField = GetFieldOrLog(typeof(PlayerDeathHead), "roomVolumeCheck", BindingFlags.Instance | BindingFlags.NonPublic);
		IsInExtractionPointVolumeCheckField = GetFieldOrLog(typeof(RoomVolumeCheck), "inExtractionPoint", BindingFlags.Instance | BindingFlags.NonPublic);
		AvatarSteamIDField = GetFieldOrLog(typeof(PlayerAvatar), "steamID", BindingFlags.Instance | BindingFlags.NonPublic);
	}

	private static FieldInfo GetFieldOrLog(Type type, string fieldName, BindingFlags bindingFlags)
	{
		FieldInfo? field = type.GetField(fieldName, bindingFlags);
		if (field == null)
		{
			Log.Error($"Couldn't find field info {fieldName} on type {type}");
		}
		return field;
	}

	public static T GetValueFromField<T>(FieldInfo field, object instance)
	{
		if (field == null || instance == null)
		{
			return default(T);
		}
		return (T)field.GetValue(instance);
	}

	internal static RoomVolumeCheck GetPlayerHeadVolumeCheck(this PlayerDeathHead head)
	{
		return GetValueFromField<RoomVolumeCheck>(DeathHeadVolumeCheckField, head);
	}

	internal static bool IsInExtractionPoint(this RoomVolumeCheck volumeCheck)
	{
		return GetValueFromField<bool>(IsInExtractionPointVolumeCheckField, volumeCheck);
	}

	internal static string GetSteamID(this PlayerAvatar avatar)
	{
		return GetValueFromField<string>(AvatarSteamIDField, avatar);
	}
}
internal static class Settings
{
	private static ConfigEntry<bool> _enableInstantReviveEntry;

	private static ConfigEntry<bool> _enableSharedConsumables;

	internal static bool EnableInstantRevive => _enableInstantReviveEntry.Value;

	internal static bool EnableSharedConsumables => _enableSharedConsumables.Value;

	internal static void Bind(Mod mod)
	{
		_enableInstantReviveEntry = ((BaseUnityPlugin)mod).Config.Bind<bool>("General", "Enable Instant Revive", true, "When enabled, player will instantly revive when their head is in the extraction point.");
		_enableSharedConsumables = ((BaseUnityPlugin)mod).Config.Bind<bool>("General", "Enable Shared Consumables", true, "When enabled, some consumables will be applied on all players.");
		((BaseUnityPlugin)mod).Config.Save();
	}
}
[HarmonyPatch(typeof(PlayerDeathHead))]
internal class InstantReviveHead
{
	private const float UPDATE_INTERVAL = 1f;

	private static float lastUpdateTime;

	[HarmonyPatch("Update")]
	[HarmonyPostfix]
	internal static void UpdatePatch(PlayerDeathHead __instance)
	{
		if (Settings.EnableInstantRevive && GameManager.Multiplayer() && PhotonNetwork.IsMasterClient && lastUpdateTime + 1f < Time.time)
		{
			RoomVolumeCheck playerHeadVolumeCheck = __instance.GetPlayerHeadVolumeCheck();
			if ((Object)(object)playerHeadVolumeCheck != (Object)null && playerHeadVolumeCheck.IsInExtractionPoint())
			{
				__instance.Revive();
			}
			lastUpdateTime = Time.time;
		}
	}
}
internal static class SharedConsumablesUtility
{
	internal static bool UpgradeOnAll(Action<string> upgradeAction)
	{
		if (!Settings.EnableSharedConsumables)
		{
			return true;
		}
		if (!GameManager.Multiplayer())
		{
			return true;
		}
		foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
		{
			string steamID = player.GetSteamID();
			upgradeAction?.Invoke(steamID);
		}
		return false;
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerHealth))]
internal class SharedConsumables_MaxHealth
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerHealth(steamID);
		});
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerGrabRange))]
internal class SharedConsumables_Range
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerGrabRange(steamID);
		});
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerSprintSpeed))]
internal class SharedConsumables_SprintSpeed
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerSprintSpeed(steamID);
		});
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerEnergy))]
internal class SharedConsumables_Stamina
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerEnergy(steamID);
		});
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerGrabStrength))]
internal class SharedConsumables_Strength
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerGrabStrength(steamID);
		});
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerGrabThrow))]
internal class SharedConsumables_Throw
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerThrowStrength(steamID);
		});
	}
}
[HarmonyPatch(typeof(ItemUpgradePlayerTumbleLaunch))]
internal class SharedConsumables_TumbleLaunch
{
	[HarmonyPatch("Upgrade")]
	[HarmonyPrefix]
	internal static bool UpgradePatch()
	{
		return SharedConsumablesUtility.UpgradeOnAll(delegate(string steamID)
		{
			PunManager.instance.UpgradePlayerTumbleLaunch(steamID);
		});
	}
}