using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("RightsManager")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f46a21aecbead1b7bf05e3100fa98dd5145a387e")]
[assembly: AssemblyProduct("RightsManager")]
[assembly: AssemblyTitle("RightsManager")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RightsManager;

[HarmonyPatch(typeof(ChatManager))]
internal class ChatManagerPatch
{
	[HarmonyPatch("MessageSend")]
	[HarmonyPrefix]
	private static bool MessageSend_Prefix(ChatManager __instance, ref string ___chatMessage)
	{
		string[] array = ___chatMessage.Replace("<b>|</b>", string.Empty).ToLower().Split(' ');
		string text = array[0];
		string text2 = text;
		if (text2 == "!rm")
		{
			UI.instance.OpenList();
			return false;
		}
		return true;
	}
}
internal static class Data
{
	public const string Name = "Rights Manager";

	public const string GUID = "com.coolchair.rightsmanager";

	public const string Version = "1.0.0";
}
internal static class Lib
{
	internal static Player GetPlayer(PlayerHealth health)
	{
		try
		{
			return GetPlayer(((Component)health).GetComponent<PlayerAvatar>());
		}
		catch
		{
			return null;
		}
	}

	internal static Player GetPlayer(PhysGrabber grabber)
	{
		try
		{
			return GetPlayer(((Component)grabber).GetComponent<PlayerAvatar>());
		}
		catch
		{
			return null;
		}
	}

	internal static Player GetPlayer(PlayerTumble tumble)
	{
		try
		{
			return GetPlayer(((Component)((Component)tumble).transform.parent).GetComponentInChildren<PlayerAvatar>());
		}
		catch
		{
			return null;
		}
	}

	internal static Player GetPlayer(PlayerAvatar avatar)
	{
		try
		{
			return ((Component)avatar).GetComponent<PhotonView>().Owner;
		}
		catch
		{
			return null;
		}
	}

	internal static PlayerAvatar GetAvatar(Player p)
	{
		if (p == null)
		{
			return null;
		}
		try
		{
			return SemiFunc.PlayerAvatarGetFromPhotonPlayer(p);
		}
		catch
		{
			return null;
		}
	}

	internal static PlayerDeathHead GetHead(Player p)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Expected O, but got Unknown
		try
		{
			PlayerAvatar avatar = GetAvatar(p);
			if ((Object)(object)avatar == (Object)null)
			{
				return null;
			}
			return (PlayerDeathHead)GetValue(avatar, "playerDeathHead");
		}
		catch
		{
			return null;
		}
	}

	internal static PlayerTumble GetTumble(Player p)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Expected O, but got Unknown
		try
		{
			PlayerAvatar avatar = GetAvatar(p);
			if ((Object)(object)avatar == (Object)null)
			{
				return null;
			}
			return (PlayerTumble)GetValue(avatar, "tumble");
		}
		catch
		{
			return null;
		}
	}

	internal static void Revive(Player p)
	{
		try
		{
			GetAvatar(p).Revive(false);
		}
		catch
		{
		}
	}

	internal static void Death(Player p)
	{
		try
		{
			GetAvatar(p).PlayerDeath(-1);
		}
		catch
		{
		}
	}

	internal static void Teleport(Player p, Vector3 pos)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			PlayerAvatar avatar = GetAvatar(p);
			if (!((Object)(object)avatar == (Object)null))
			{
				if ((bool)GetValue(avatar, "deadSet"))
				{
					Transform(((Component)GetHead(p)).gameObject, pos);
				}
				else if ((bool)GetValue(avatar, "isTumbling"))
				{
					Transform(((Component)GetTumble(p)).gameObject, pos);
				}
				else
				{
					avatar.Spawn(pos, Quaternion.identity);
				}
			}
		}
		catch
		{
		}
	}

	internal static void Transform(GameObject go, Vector3 position)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		Transform(go, position, go.transform.rotation);
	}

	internal static void Transform(GameObject go, Vector3 position, Quaternion rotation)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		if (!SemiFunc.IsMasterClientOrSingleplayer())
		{
			return;
		}
		Rigidbody val = go.GetComponent<Rigidbody>();
		if ((Object)(object)val == (Object)null)
		{
			val = go.GetComponentInChildren<Rigidbody>();
			if ((Object)(object)val == (Object)null)
			{
				if (SemiFunc.IsMultiplayer())
				{
					return;
				}
				go.transform.position = position;
				go.transform.rotation = rotation;
			}
		}
		val.Move(position, rotation);
	}

	internal static bool IsChatOpened()
	{
		return (Object)(object)ChatManager.instance != (Object)null && (bool)GetValue(ChatManager.instance, "chatActive");
	}

	internal static bool IsAvaiable()
	{
		return SemiFunc.IsMasterClient() && SemiFunc.IsMultiplayer() && !SemiFunc.IsMainMenu() && !SemiFunc.IsSplashScreen();
	}

	internal static bool GetKeyDown(KeyCode key)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return Input.GetKeyDown(key) && !IsChatOpened();
	}

	internal static FieldInfo GetField(object inst, string field)
	{
		return inst.GetType().GetField(field, BindingFlags.Instance | BindingFlags.NonPublic);
	}

	internal static object GetValue(object inst, string field)
	{
		return GetField(inst, field).GetValue(inst);
	}
}
[BepInPlugin("com.coolchair.rightsmanager", "Rights Manager", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class Loader : BaseUnityPlugin
{
	internal static ConfigEntry<KeyCode> menuKey;

	private void Awake()
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading...");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Patching...");
		new Harmony("com.coolchair.rightsmanager").PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Patched!");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading configs...");
		menuKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Binds", "Menu", (KeyCode)291, (ConfigDescription)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Configs loaded!");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded!");
	}
}
[HarmonyPatch(typeof(PlayerHealth))]
internal static class PlayerHealthPatch
{
	[HarmonyPatch("UpdateHealthRPC")]
	[HarmonyPrefix]
	private static bool UpdateHealthRPC_Prefix(PlayerHealth __instance, int healthNew, int healthMax, bool effect, bool hurtByHeal, PhotonMessageInfo _info = default(PhotonMessageInfo))
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "health_lose") && (int)Lib.GetValue(__instance, "health") > healthNew)
		{
			((Component)__instance).GetComponent<PhotonView>().RPC("UpdateHealthRPC", (RpcTarget)1, new object[4]
			{
				(int)Lib.GetValue(__instance, "health"),
				healthMax,
				false,
				false
			});
			return false;
		}
		if (!RM.HasRight(player, "health_get") && (int)Lib.GetValue(__instance, "health") < healthNew)
		{
			((Component)__instance).GetComponent<PhotonView>().RPC("UpdateHealthRPC", (RpcTarget)1, new object[4]
			{
				(int)Lib.GetValue(__instance, "health"),
				healthMax,
				false,
				false
			});
			return false;
		}
		return true;
	}

	[HarmonyPatch("HurtOther")]
	[HarmonyPrefix]
	private static bool HurtOther_Prefix(PlayerHealth __instance, int damage, Vector3 hurtPosition, bool savingGrace, int enemyIndex = -1, bool hurtByHeal = false)
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "health_lose"))
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(PlayerTumble))]
internal static class PlayerTumblePatch
{
	[HarmonyPatch("TumbleForceRPC")]
	[HarmonyPrefix]
	private static bool TumbleForceRPC_Prefix(PlayerTumble __instance)
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "tumble_jump"))
		{
			return false;
		}
		return true;
	}

	[HarmonyPatch("TumbleTorqueRPC")]
	[HarmonyPrefix]
	private static bool TumbleTorqueRPC_Prefix(PlayerTumble __instance)
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "tumble_jump"))
		{
			return false;
		}
		return true;
	}

	[HarmonyPatch("TumbleRequestRPC")]
	[HarmonyPrefix]
	private static bool TumbleRequestRPC_Prefix(PlayerTumble __instance, bool _isTumbling)
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "tumble_start") && _isTumbling)
		{
			return false;
		}
		if (!RM.HasRight(player, "tumble_end") && !_isTumbling)
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(PlayerAvatar))]
internal static class PlayerAvatarPatch
{
	[HarmonyPatch("PlayerDeath")]
	[HarmonyPrefix]
	private static bool PlayerDeath_Prefix(PlayerAvatar __instance)
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "health_death"))
		{
			return false;
		}
		return true;
	}

	[HarmonyPatch("PlayerDeathRPC")]
	[HarmonyPrefix]
	private static bool PlayerDeathRPC_Prefix(PlayerAvatar __instance)
	{
		Player player = Lib.GetPlayer(__instance);
		if (player == null)
		{
			return true;
		}
		if (!RM.HasRight(player, "health_death"))
		{
			Lib.Revive(player);
			return true;
		}
		return true;
	}
}
[HarmonyPatch(typeof(ItemEquippable))]
internal static class ItemEquippablePatch
{
	[HarmonyPatch("RPC_RequestEquip")]
	[HarmonyPrefix]
	private static bool RPC_RequestEquip_Prefix(ItemEquippable __instance, int physGrabberPhotonViewID)
	{
		Player owner = PhotonView.Find(physGrabberPhotonViewID).Owner;
		try
		{
			return RM.HasRight(owner, "item_equip");
		}
		catch
		{
			return true;
		}
	}
}
[HarmonyPatch(typeof(PhysGrabObject))]
internal static class PhysGrabObjectPatch
{
	private static bool CheckGrab(PhysGrabObject __instance, int playerPhotonID)
	{
		if ((Object)(object)((Component)__instance).GetComponent<ValuableObject>() != (Object)null && !RM.HasRight(PhotonView.Find(playerPhotonID).Owner, "valuable_grab"))
		{
			return false;
		}
		if ((Object)(object)((Component)__instance).GetComponent<ItemAttributes>() != (Object)null && !RM.HasRight(PhotonView.Find(playerPhotonID).Owner, "item_grab"))
		{
			return false;
		}
		if ((Object)(object)((Component)__instance).GetComponent<PlayerTumble>() != (Object)null && !RM.HasRight(PhotonView.Find(playerPhotonID).Owner, "tumble_grab"))
		{
			return false;
		}
		if ((Object)(object)((Component)__instance).GetComponent<PlayerDeathHead>() != (Object)null && !RM.HasRight(PhotonView.Find(playerPhotonID).Owner, "head_grab"))
		{
			return false;
		}
		return true;
	}

	[HarmonyPatch("GrabStartedRPC")]
	[HarmonyPrefix]
	private static bool GrabStartedRPC_Prefix(PhysGrabObject __instance, int playerPhotonID)
	{
		return CheckGrab(__instance, playerPhotonID);
	}
}
[HarmonyPatch(typeof(GameplayManager))]
internal static class GameplayManagerPatch
{
	[HarmonyPatch("Start")]
	[HarmonyPostfix]
	private static void Start_Postfix(GameplayManager __instance)
	{
		((Component)__instance).gameObject.AddComponent<UI>();
	}
}
internal static class RM
{
	private static Dictionary<Player, Collection<string>> Rights = new Dictionary<Player, Collection<string>>();

	internal static Collection<string> GetBaseRights()
	{
		Collection<string> collection = new Collection<string>();
		collection.Add("valuable_grab");
		collection.Add("item_grab");
		collection.Add("item_equip");
		collection.Add("tumble_start");
		collection.Add("tumble_end");
		collection.Add("tumble_jump");
		collection.Add("tumble_grab");
		collection.Add("head_grab");
		collection.Add("health_lose");
		collection.Add("health_get");
		collection.Add("health_death");
		return collection;
	}

	private static Collection<string> Validate(Player p)
	{
		if (!Rights.ContainsKey(p))
		{
			Rights.Add(p, GetBaseRights());
		}
		return Rights[p];
	}

	internal static bool HasRight(Player p, string right)
	{
		return Validate(p).Contains(right);
	}

	internal static void AddRight(Player p, string right)
	{
		if (Lib.IsAvaiable() && !HasRight(p, right))
		{
			Validate(p).Add(right);
		}
	}

	internal static void RemoveRight(Player p, string right)
	{
		if (Lib.IsAvaiable() && HasRight(p, right))
		{
			Validate(p).Remove(right);
		}
	}
}
internal class UI : MonoBehaviour
{
	internal static UI instance;

	internal static REPOPopupPage playerslist;

	internal static REPOPopupPage rightslist;

	internal static Player selectedPlayer;

	internal static Dictionary<string, REPOButton> rb;

	private void Awake()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		instance = this;
		playerslist = null;
		rightslist = null;
		selectedPlayer = null;
		rb = new Dictionary<string, REPOButton>();
		if (Lib.IsAvaiable())
		{
			MenuAPI.AddElementToEscapeMenu((BuilderDelegate)delegate(Transform parent)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				MenuAPI.CreateREPOButton("Rights", (Action)OpenList, parent, new Vector2(200f, 65f));
			});
		}
	}

	internal void ReloadRights()
	{
		if ((Object)(object)rightslist != (Object)null && ((Behaviour)rightslist).isActiveAndEnabled)
		{
			rightslist.ClosePage(false);
			Object.Destroy((Object)(object)rightslist);
		}
		rightslist = null;
		OpenRights();
	}

	private void OpenRights()
	{
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Expected O, but got Unknown
		if ((Object)(object)rightslist == (Object)null)
		{
			rb = new Dictionary<string, REPOButton>();
			rightslist = MenuAPI.CreateREPOPopupPage("Rights", (PresetSide)1, false, false, 0f);
			foreach (string right in RM.GetBaseRights())
			{
				rightslist.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
				{
					//IL_0051: Unknown result type (might be due to invalid IL or missing references)
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					REPOButton val = MenuAPI.CreateREPOButton(right + " " + (RM.HasRight(selectedPlayer, right) ? "V" : "X"), (Action)delegate
					{
						if (RM.HasRight(selectedPlayer, right))
						{
							RM.RemoveRight(selectedPlayer, right);
							((TMP_Text)rb[right].labelTMP).text = right + " " + (RM.HasRight(selectedPlayer, right) ? "V" : "X");
						}
						else
						{
							RM.AddRight(selectedPlayer, right);
							((TMP_Text)rb[right].labelTMP).text = right + " " + (RM.HasRight(selectedPlayer, right) ? "V" : "X");
						}
					}, parent, default(Vector2));
					rb.Add(right, val);
					return ((REPOElement)val).rectTransform;
				}, 0f, 0f);
			}
			rightslist.OpenPage(true);
		}
		else if (!((Behaviour)rightslist).isActiveAndEnabled)
		{
			rightslist.OpenPage(true);
		}
	}

	internal void OpenList()
	{
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Expected O, but got Unknown
		if (!Lib.IsAvaiable())
		{
			return;
		}
		if ((Object)(object)playerslist != (Object)null && ((Behaviour)playerslist).isActiveAndEnabled)
		{
			playerslist.ClosePage(false);
			Object.Destroy((Object)(object)playerslist);
		}
		playerslist = MenuAPI.CreateREPOPopupPage("Players", (PresetSide)0, false, false, 0f);
		Player[] playerList = PhotonNetwork.PlayerList;
		foreach (Player p in playerList)
		{
			playerslist.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
			{
				//IL_002e: 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)
				REPOButton val = MenuAPI.CreateREPOButton(p.NickName, (Action)delegate
				{
					selectedPlayer = p;
					ReloadRights();
				}, parent, default(Vector2));
				return ((REPOElement)val).rectTransform;
			}, 0f, 0f);
		}
		playerslist.OpenPage(true);
	}

	private void Update()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		if (Lib.IsAvaiable() && Lib.GetKeyDown(Loader.menuKey.Value))
		{
			OpenList();
		}
	}
}