using System;
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.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Kai")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3c6685d2be258c04809d5508067885a3078e2480")]
[assembly: AssemblyProduct("DeathHeadBatteryPlus")]
[assembly: AssemblyTitle("DeathHeadBatteryPlus")]
[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.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;
		}
	}
	[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 DeathHeadBatteryPlus
{
	internal static class ConfigManager
	{
		public static float drainMultiplier;

		public static float jumpChargeDrainMultiplier;

		public static float rechargeRatioFromBaseDrain;

		public static float rechargeUpgradeScale;

		public static bool fuullCargeOnDeath;

		internal static ConfigEntry<float> HeadDrainMultiplier;

		internal static ConfigEntry<float> HeadJumpChargeDrainMultiplier;

		internal static ConfigEntry<float> HeadRechargeRatioFromBaseDrain;

		internal static ConfigEntry<float> HeadRechargeUpgradeScale;

		internal static ConfigEntry<bool> FullChargeOnDeath;

		public static void Build(ConfigFile config)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			HeadDrainMultiplier = config.Bind<float>("DeathHeadBattery", "HeadDrainMultiplier", 1f, new ConfigDescription("死亡ヘッド操作中の通常消費倍率。1.0でバニラ、0.5で半分、2.0で2倍消費。", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			HeadJumpChargeDrainMultiplier = config.Bind<float>("DeathHeadBattery", "HeadJumpChargeDrainMultiplier", 1f, new ConfigDescription("死亡ヘッドのジャンプチャージ中に追加される消費倍率。1.0でバニラ。通常消費とは別枠。", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			HeadRechargeRatioFromBaseDrain = config.Bind<float>("DeathHeadBattery", "HeadRechargeRatioFromBaseDrain", 0.25f, new ConfigDescription("死亡ヘッドの回復速度。初期通常消費速度を基準に、1.0なら同速、0.5なら半分。バニラ回復は0.25相当。", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			HeadRechargeUpgradeScale = config.Bind<float>("DeathHeadBattery", "HeadRechargeUpgradeScale", 0.25f, new ConfigDescription("DeathHeadBatteryアップグレード1段階ごとの回復速度倍率加算。0.25なら1段階ごとに+25%。", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			FullChargeOnDeath = config.Bind<bool>("DeathHeadBattery", "FullChargeOnDeath", false, "死亡直後にデスヘッドバッテリーを満タンにします。");
		}

		public static void Configinit()
		{
			drainMultiplier = HeadDrainMultiplier.Value;
			jumpChargeDrainMultiplier = HeadJumpChargeDrainMultiplier.Value;
			rechargeRatioFromBaseDrain = HeadRechargeRatioFromBaseDrain.Value;
			fuullCargeOnDeath = FullChargeOnDeath.Value;
		}
	}
	[BepInPlugin("Kai.DeathHeadBatteryPlus", "DeathHeadBatteryPlus", "1.0.1")]
	public class DeathHeadBatteryPlus : BaseUnityPlugin
	{
		internal static DeathHeadBatteryPlus Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			ConfigManager.Build(((BaseUnityPlugin)this).Config);
			ConfigManager.Configinit();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0025: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}
	}
	internal static class DeathHeadEnergyHelper
	{
		private const float BaseUseSeconds = 25f;

		private const float FirstUpgradeAddSecond = 5f;

		private const float UpgradeAddDecay = 0.8f;

		public static float GetVanillaUseSeconds(float upgradeDeathHeadBattery)
		{
			float num = 25f;
			float num2 = 5f;
			for (float num3 = upgradeDeathHeadBattery - 1f; num3 > 0f; num3 -= 1f)
			{
				num += num2;
				num2 *= 0.8f;
			}
			return Mathf.Max(0.01f, num);
		}

		public static float GetDrainPerSecond(float upgradeDeathHeadBattery, float multiplier)
		{
			float vanillaUseSeconds = GetVanillaUseSeconds(upgradeDeathHeadBattery);
			return 1f / vanillaUseSeconds * Mathf.Max(0f, multiplier);
		}

		public static float GetJumpChargeDrainPerSecond(float upgradeDeathHeadBattery, float multiplier)
		{
			float vanillaUseSeconds = GetVanillaUseSeconds(upgradeDeathHeadBattery);
			return 1f / vanillaUseSeconds * Mathf.Max(0f, multiplier);
		}

		public static float GetRechargePerSecond(float upgradeDeathHeadBattery, float rechargeRatioFromBaseDrain, float upgradeRechargeScale)
		{
			float num = 0.04f;
			float num2 = Mathf.Max(0f, rechargeRatioFromBaseDrain);
			float num3 = Mathf.Max(0f, upgradeRechargeScale);
			float num4 = 1f + Mathf.Max(0f, upgradeDeathHeadBattery - 1f) * num3;
			return num * num2 * num4;
		}
	}
}
namespace DeathHeadBatteryPlus.Patchs
{
	[HarmonyPatch(typeof(SpectateCamera), "SetDeath")]
	internal static class SpectateCamera_SetDeath_DeathHeadBatteryPatch
	{
		private static void Postfix(SpectateCamera __instance)
		{
			if (ConfigManager.fuullCargeOnDeath)
			{
				PlayerAvatar val = PlayerController.instance?.playerAvatarScript;
				if (!((Object)(object)val == (Object)null) && val.isLocal)
				{
					__instance.headEnergy = 1f;
					__instance.headEnergyEnough = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(PunManager), "Start")]
	public static class PunManager_patches
	{
		private static void Postfix(PunManager __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<DeathHeadEnagyConfigSync>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<DeathHeadEnagyConfigSync>();
			}
		}
	}
	public class DeathHeadEnagyConfigSync : MonoBehaviour
	{
		[PunRPC]
		public void SyncDeathHeadConfigs(float drainMultiplier, float jumpChargeDrainMultiplier, float rechargeRatioFromBaseDrain, float rechargeUpgradeScale, bool fuullCargeOnDeath)
		{
			ConfigManager.drainMultiplier = drainMultiplier;
			ConfigManager.jumpChargeDrainMultiplier = jumpChargeDrainMultiplier;
			ConfigManager.rechargeRatioFromBaseDrain = rechargeRatioFromBaseDrain;
			ConfigManager.rechargeUpgradeScale = rechargeUpgradeScale;
			ConfigManager.fuullCargeOnDeath = fuullCargeOnDeath;
		}
	}
	[HarmonyPatch(typeof(SemiFunc), "OnLevelGenDone")]
	internal static class SemiFunc_OnlevelChangePatch
	{
		public static void Postfix()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				ConfigManager.Configinit();
			}
			else if (SemiFunc.IsMultiplayer())
			{
				PunManager.instance.photonView.RPC("SyncDeathHeadConfigs", (RpcTarget)1, new object[5]
				{
					ConfigManager.drainMultiplier,
					ConfigManager.jumpChargeDrainMultiplier,
					ConfigManager.rechargeRatioFromBaseDrain,
					ConfigManager.rechargeUpgradeScale,
					ConfigManager.fuullCargeOnDeath
				});
			}
		}
	}
	[HarmonyPatch(typeof(SpectateCamera), "HeadEnergyLogic")]
	internal static class SpectateCamera_HeadEnergyLogic_Patch
	{
		private static readonly FieldRef<SpectateCamera, bool> HeadOverrideRef = AccessTools.FieldRefAccess<SpectateCamera, bool>("headOverride");

		private static bool Prefix(SpectateCamera __instance)
		{
			PlayerAvatar val = PlayerController.instance?.playerAvatarScript;
			PlayerDeathHead val2 = val?.playerDeathHead;
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if (__instance.headEnergyPauseTimer > 0f)
			{
				__instance.headEnergyPauseTimer -= Time.deltaTime;
				__instance.headEnergy = Mathf.Clamp01(__instance.headEnergy);
				return false;
			}
			float upgradeDeathHeadBattery = val.upgradeDeathHeadBattery;
			if (__instance.CheckState((State)2))
			{
				if (!HeadOverrideRef.Invoke(__instance))
				{
					__instance.headEnergy -= Time.deltaTime * DeathHeadEnergyHelper.GetDrainPerSecond(upgradeDeathHeadBattery, ConfigManager.drainMultiplier);
					if (val2.spectatedJumpCharging)
					{
						__instance.headEnergy -= Time.deltaTime * DeathHeadEnergyHelper.GetJumpChargeDrainPerSecond(upgradeDeathHeadBattery, ConfigManager.jumpChargeDrainMultiplier);
					}
				}
				__instance.headEnergyEnough = false;
			}
			else if (__instance.CheckState((State)1))
			{
				__instance.headEnergy += Time.deltaTime * DeathHeadEnergyHelper.GetRechargePerSecond(upgradeDeathHeadBattery, ConfigManager.rechargeRatioFromBaseDrain, ConfigManager.rechargeUpgradeScale);
				__instance.headEnergyEnough = __instance.headEnergy >= 0.25f;
			}
			__instance.headEnergy = Mathf.Clamp01(__instance.headEnergy);
			return false;
		}
	}
}