using System;
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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Afflictions;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.legocool.StaminaLinked")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("com.github.legocool.StaminaLinked")]
[assembly: AssemblyTitle("StaminaLinked")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace StaminaLinked
{
	[BepInPlugin("legocool.StaminaLinked", "StaminaLinked", "0.1.1")]
	public class StaminaLinked : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Character), "UseStamina")]
		public static class Patch_UseStamina
		{
			private static bool Prefix(Character __instance, float usage, bool useBonusStamina)
			{
				if (!__instance.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestUseStamina", (RpcTarget)2, new object[2] { usage, useBonusStamina });
				}
				return true;
			}

			private static void Postfix(CharacterAfflictions __instance, float usage, bool useBonusStamina)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					StaminaSync.Instance.BroadcastStamina();
				}
			}
		}

		[HarmonyPatch(typeof(Character), "AddExtraStamina")]
		public static class Patch_AddExtraStamina
		{
			private static bool Prefix(Character __instance, float add)
			{
				if (!__instance.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestAddExtraStamina", (RpcTarget)2, new object[1] { add });
					return false;
				}
				return true;
			}

			private static void Postfix(CharacterAfflictions __instance, float add)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					StaminaSync.Instance.BroadcastStamina();
				}
			}
		}

		[HarmonyPatch(typeof(Character), "SetExtraStamina")]
		public static class Patch_SetExtraStamina
		{
			private static bool Prefix(Character __instance, float amt)
			{
				if (!__instance.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestSetExtraStamina", (RpcTarget)2, new object[1] { amt });
					return false;
				}
				return true;
			}

			private static void Postfix(CharacterAfflictions __instance, float amt)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					StaminaSync.Instance.BroadcastStamina();
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "SubtractStatus")]
		public static class Patch_SubtractStatus
		{
			private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC = false)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected I4, but got Unknown
				if (!__instance.character.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestSubtractStatus", (RpcTarget)2, new object[2]
					{
						(int)statusType,
						amount
					});
					return false;
				}
				return true;
			}

			private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC = false)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					StaminaSync.Instance.BroadcastStatuses();
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
		public static class Patch_AddStatus
		{
			private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC = false)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Invalid comparison between Unknown and I4
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Invalid comparison between Unknown and I4
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected I4, but got Unknown
				if (!__instance.character.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					if ((int)statusType == 1)
					{
						return false;
					}
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestAddStatus", (RpcTarget)2, new object[2]
					{
						(int)statusType,
						amount
					});
					return false;
				}
				if ((int)statusType == 1)
				{
					amount *= PlayerHandler.GetAllPlayerCharacters().Count;
				}
				return true;
			}

			private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC = false)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					StaminaSync.Instance.BroadcastStatuses();
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "SetStatus")]
		public static class Patch_SetStatus
		{
			private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected I4, but got Unknown
				if (!__instance.character.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestSetStatus", (RpcTarget)2, new object[2]
					{
						(int)statusType,
						amount
					});
					return false;
				}
				return true;
			}

			private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					StaminaSync.Instance.BroadcastStatuses();
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
		public static class Patch_UpdateWeight
		{
			private static bool Prefix(CharacterAfflictions __instance)
			{
				int num = 0;
				int num2 = 0;
				float currentStatus = __instance.GetCurrentStatus((STATUSTYPE)9);
				for (int i = 0; i < __instance.character.player.itemSlots.Length; i++)
				{
					ItemSlot val = __instance.character.player.itemSlots[i];
					if ((Object)(object)val.prefab != (Object)null)
					{
						num += val.prefab.CarryWeight;
					}
				}
				BackpackSlot backpackSlot = __instance.character.player.backpackSlot;
				BackpackData val2 = default(BackpackData);
				if (!((ItemSlot)backpackSlot).IsEmpty() && ((ItemSlot)backpackSlot).data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val2))
				{
					for (int j = 0; j < val2.itemSlots.Length; j++)
					{
						ItemSlot val3 = val2.itemSlots[j];
						if (!val3.IsEmpty())
						{
							num += val3.prefab.CarryWeight;
						}
					}
				}
				ItemSlot itemSlot = __instance.character.player.GetItemSlot((byte)250);
				if (!itemSlot.IsEmpty())
				{
					num += itemSlot.prefab.CarryWeight;
				}
				if ((Object)(object)__instance.character.data.carriedPlayer != (Object)null)
				{
					num += 8;
				}
				foreach (StickyItemComponent aLL_STUCK_ITEM in StickyItemComponent.ALL_STUCK_ITEMS)
				{
					if ((Object)(object)aLL_STUCK_ITEM.stuckToCharacter == (Object)(object)__instance.character)
					{
						num += aLL_STUCK_ITEM.addWeightToStuckPlayer;
						num2 += aLL_STUCK_ITEM.addThornsToStuckPlayer;
					}
				}
				if (Object.op_Implicit((Object)(object)__instance.character.data.currentStickyItem))
				{
					num2 += __instance.character.data.currentStickyItem.addThornsToStuckPlayer;
				}
				num2 += __instance.GetTotalThornStatusIncrements();
				float num3 = 0.025f * (float)num2;
				if (num3 > currentStatus)
				{
					__instance.StatusSFX((STATUSTYPE)9, num3 - currentStatus);
					if (__instance.character.IsLocal && (Object)(object)__instance.character == (Object)(object)Character.observedCharacter)
					{
						GUIManager.instance.AddStatusFX((STATUSTYPE)9, num3 - currentStatus);
					}
					__instance.PlayParticle((STATUSTYPE)9);
				}
				((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_UpdateWeight", (RpcTarget)2, new object[2]
				{
					0.025f * (float)num,
					0.025f * (float)num2
				});
				return false;
			}
		}

		[HarmonyPatch(typeof(Action_ApplyInfiniteStamina), "RunAction")]
		public static class Patch_ApplyInfiniteStamina
		{
			private static bool Prefix(Action_ApplyInfiniteStamina __instance)
			{
				if (!((ItemActionBase)__instance).character.view.IsMine)
				{
					return false;
				}
				if (!PhotonNetwork.IsMasterClient)
				{
					((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_RequestInfiniteStamina", (RpcTarget)2, new object[1] { __instance.buffTime });
					return false;
				}
				((MonoBehaviourPun)StaminaSync.Instance).photonView.RPC("RPC_ApplyInfiniteStamina", (RpcTarget)1, new object[1] { __instance.buffTime });
				return false;
			}
		}

		private Harmony _harmony;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			_harmony = new Harmony("legocool.StaminaLinked");
			_harmony.PatchAll();
			GameObject val = new GameObject("StaminaSyncManager");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<StaminaSync>();
			PhotonView val2 = val.AddComponent<PhotonView>();
			val2.ViewID = 999999999;
			Log.LogInfo((object)"Plugin StaminaLinked is loaded!");
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
		}
	}
	public class StaminaSync : MonoBehaviourPun
	{
		public static StaminaSync Instance;

		private Dictionary<int, float> playerWeights = new Dictionary<int, float>();

		private Dictionary<int, float> playerThorns = new Dictionary<int, float>();

		private void Awake()
		{
			Instance = this;
		}

		[PunRPC]
		public void RPC_RequestUseStamina(float usage, bool useBonus)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.UseStamina(usage, useBonus);
				BroadcastStamina();
			}
		}

		[PunRPC]
		public void RPC_RequestAddExtraStamina(float add)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.AddExtraStamina(add);
				BroadcastStamina();
			}
		}

		[PunRPC]
		public void RPC_RequestSetExtraStamina(float amt)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.SetExtraStamina(amt);
				BroadcastStamina();
			}
		}

		[PunRPC]
		public void RPC_RequestAddStatus(int statusType, float amt)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.refs.afflictions.AddStatus((STATUSTYPE)statusType, amt, false);
				BroadcastStatuses();
			}
		}

		[PunRPC]
		public void RPC_RequestSubtractStatus(int statusType, float amt)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.refs.afflictions.SubtractStatus((STATUSTYPE)statusType, amt, false);
				BroadcastStatuses();
			}
		}

		[PunRPC]
		public void RPC_RequestSetStatus(int statusType, float amt)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)statusType, amt);
				BroadcastStatuses();
			}
		}

		[PunRPC]
		public void RPC_RequestInfiniteStamina(float buffTime)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (PhotonNetwork.IsMasterClient)
			{
				Character.localCharacter.refs.afflictions.AddAffliction((Affliction)new Affliction_InfiniteStamina(buffTime), false);
				((MonoBehaviourPun)this).photonView.RPC("RPC_ApplyInfiniteStamina", (RpcTarget)1, new object[1] { buffTime });
			}
		}

		[PunRPC]
		public void RPC_ApplyInfiniteStamina(float buffTime)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)new Affliction_InfiniteStamina(buffTime), false);
		}

		[PunRPC]
		public void RPC_UpdateWeight(float weight, float thorns, PhotonMessageInfo info)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			playerWeights[info.Sender.ActorNumber] = weight;
			playerThorns[info.Sender.ActorNumber] = thorns;
			float num = 0f;
			foreach (float value in playerWeights.Values)
			{
				num += value;
			}
			float num2 = 0f;
			foreach (float value2 in playerThorns.Values)
			{
				num2 += value2;
			}
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)7, num);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)9, num2);
			Debug.Log((object)$"playerWeights: {playerWeights}");
		}

		public void BroadcastStamina()
		{
			Character localCharacter = Character.localCharacter;
			((MonoBehaviourPun)this).photonView.RPC("RPC_SyncStamina", (RpcTarget)1, new object[4]
			{
				localCharacter.data.currentStamina,
				localCharacter.data.extraStamina,
				localCharacter.data.sinceUseStamina,
				localCharacter.infiniteStam
			});
		}

		public void BroadcastStatuses()
		{
			CharacterAfflictions afflictions = Character.localCharacter.refs.afflictions;
			((MonoBehaviourPun)this).photonView.RPC("RPC_SyncStatus", (RpcTarget)1, new object[5] { afflictions.currentStatuses, afflictions.currentIncrementalStatuses, afflictions.currentDecrementalStatuses, afflictions.lastAddedStatus, afflictions.lastAddedIncrementalStatus });
		}

		[PunRPC]
		public void RPC_SyncStamina(float current, float extra, float sinceUse, bool infinite)
		{
			if ((Object)(object)Character.localCharacter != (Object)null)
			{
				Character.localCharacter.data.currentStamina = current;
				Character.localCharacter.data.extraStamina = extra;
				Character.localCharacter.data.sinceUseStamina = sinceUse;
				Character.localCharacter.ClampStamina();
				GUIManager.instance.bar.ChangeBar();
			}
		}

		[PunRPC]
		public void RPC_SyncStatus(float[] current, float[] inc, float[] dec, float[] last, float[] lastInc)
		{
			if ((Object)(object)Character.localCharacter != (Object)null)
			{
				CharacterAfflictions afflictions = Character.localCharacter.refs.afflictions;
				Array.Copy(current, afflictions.currentStatuses, current.Length);
				Array.Copy(inc, afflictions.currentIncrementalStatuses, inc.Length);
				Array.Copy(dec, afflictions.currentDecrementalStatuses, dec.Length);
				Array.Copy(last, afflictions.lastAddedStatus, last.Length);
				Array.Copy(lastInc, afflictions.lastAddedIncrementalStatus, lastInc.Length);
				GUIManager.instance.bar.ChangeBar();
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}