using System;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.Notifications;
using Il2CppSLZ.Marrow;
using LabFusion.Entities;
using LabFusion.Network;
using LabFusion.Network.Serialization;
using LabFusion.Player;
using LabFusion.Representation;
using LabFusion.SDK.Gamemodes;
using LabFusion.SDK.Modules;
using LabFusion.Safety;
using MelonLoader;
using Microsoft.CodeAnalysis;
using PowerTools;
using PowerTools.Tools;
using Powertools.Fusion;
using Powertools.Fusion.Tools;
using PowertoolsFusion;
using PowertoolsFusion.Messages;
using PowertoolsFusion.Serializables;
using PowertoolsFusion.Tools.Menus;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "PowertoolsFusion", "1.0.0", "pietr", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: MelonOptionalDependencies(new string[] { "LabFusion" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("PowertoolsFusion")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+550bb57e923aba920d18ed569f0edce6a1984eca")]
[assembly: AssemblyProduct("PowertoolsFusion")]
[assembly: AssemblyTitle("PowertoolsFusion")]
[assembly: NeutralResourcesLanguage("en-US")]
[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 PowertoolsFusion
{
	public class PowertoolsModule : Module
	{
		public override string Name => "Powertools";

		public override string Author => "freakycheesy";

		public override Version Version => new Version(1, 0, 0);

		public override ConsoleColor Color => ConsoleColor.Red;

		protected override void OnModuleRegistered()
		{
			ModuleMessageManager.LoadHandlers(Assembly.GetExecutingAssembly());
			FusionTool fusionTool = new FusionTool();
			ToolLoader.LoadTool((BaseTool)(object)fusionTool);
		}

		protected override void OnModuleUnregistered()
		{
		}
	}
}
namespace PowertoolsFusion.Tools.Menus
{
	public class AdminMenu
	{
		public static int RigID;

		public static bool GodModeSaved;

		public AdminMenu(Page Page)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Page val = Page.CreatePage("Admin Panel", Color.green, 0, true);
			val.CreateInt("Rig ID", Color.green, 0, 1, 0, 40, (Action<int>)delegate(int a)
			{
				RigID = a;
			});
			GamemodeManager.OnGamemodeStarted += GamemodeManager_OnGamemodeStarted;
			GamemodeManager.OnGamemodeStopped += GamemodeManager_OnGamemodeStopped;
			val.CreateFunction("Fling", Color.green, (Action)FlingPlayer);
			val.CreateFunction("Freeze Physics Rig", Color.green, (Action)FreezeRig);
			val.CreateFunction("Disable Godmode", Color.green, (Action)DisableGodmode);
			val.CreateFunction("Kill Rig", Color.green, (Action)Kill);
		}

		private void GamemodeManager_OnGamemodeStarted()
		{
			GodModeSaved = HealthSettings.GodMode.Value;
			while (GamemodeManager.IsGamemodeStarted)
			{
				HealthSettings.GodMode.Value = false;
			}
		}

		private void GamemodeManager_OnGamemodeStopped()
		{
			HealthSettings.GodMode.Value = GodModeSaved;
		}

		private void DisableGodmode()
		{
			FusionTool.SendMessage<DisableGodmode>((byte)RigID, "", (NetworkChannel)0);
		}

		private void Kill()
		{
			FusionTool.SendMessage<KillMessage>((byte)RigID, "", (NetworkChannel)0);
		}

		private void FreezeRig()
		{
			FusionTool.SendMessage<FreezeRigMessage>((byte)RigID, "", (NetworkChannel)0);
		}

		private void FlingPlayer()
		{
			FusionTool.SendMessage<FlingMessage>((byte)RigID, "", (NetworkChannel)0);
		}
	}
}
namespace PowertoolsFusion.Serializables
{
	public class MessageNetSerializable : INetSerializable
	{
		public PlayerID Sender = new PlayerID();

		public string Message = "1234";

		public int? GetSize()
		{
			return Sender.GetSize() + SizeExtensions.GetSize(Message.ToString());
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue<PlayerID>(serializer, ref Sender);
			serializer.SerializeValue(ref Message);
		}
	}
}
namespace PowertoolsFusion.Messages
{
	public class NotifcationMessage : ModuleMessage
	{
		public override PermissionLevel MinimumPermissionLevel { get; protected set; } = (PermissionLevel)(-1);


		protected override void ReceivedMessageEvent(NetworkPlayer localPlayer, NetworkPlayer sender, string message)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			base.ReceivedMessageEvent(localPlayer, sender, message);
			foreach (string word in ProfanityListManager.List.Words)
			{
				message = (message.Contains(word) ? "CENSORED" : message);
			}
			Notifier.Send(new Notification
			{
				Title = NotificationText.op_Implicit(sender.Username),
				Message = NotificationText.op_Implicit(sender.Username + " says: \"" + message + "\"")
			});
		}
	}
	public class FlingMessage : ModuleMessage
	{
		public override PermissionLevel MinimumPermissionLevel { get; protected set; } = (PermissionLevel)1;


		protected override void ReceivedMessageEvent(NetworkPlayer localPlayer, NetworkPlayer sender, string message)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			base.ReceivedMessageEvent(localPlayer, sender, message);
			Vector3.Scale(new Vector3(1f, 1f, 1f), new Vector3(1f, 1f, 1f));
			Vector3 val = GenerateRandomVector3(-6000, 6000);
			val.y = Random.Range(2000, 6000);
			localPlayer.RigSkeleton.physicsPelvis.AddForce(val, (ForceMode)1);
		}

		public static Vector3 GenerateRandomVector3(int minRange = 1, int maxRange = 30)
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)Random.Range(minRange, maxRange), (float)Random.Range(minRange, maxRange), (float)Random.Range(minRange, maxRange));
		}
	}
	public class FreezeRigMessage : ModuleMessage
	{
		public override PermissionLevel MinimumPermissionLevel { get; protected set; } = (PermissionLevel)1;


		protected override void ReceivedMessageEvent(NetworkPlayer localPlayer, NetworkPlayer sender, string message)
		{
			base.ReceivedMessageEvent(localPlayer, sender, message);
			localPlayer.RigSkeleton.physicsPelvis.isKinematic = !localPlayer.RigSkeleton.physicsPelvis.isKinematic;
		}
	}
	public class DisableGodmode : ModuleMessage
	{
		public override PermissionLevel MinimumPermissionLevel { get; protected set; } = (PermissionLevel)1;


		protected override void ReceivedMessageEvent(NetworkPlayer localPlayer, NetworkPlayer sender, string message)
		{
			base.ReceivedMessageEvent(localPlayer, sender, message);
			HealthSettings.GodMode.Value = false;
			Main.Save();
		}
	}
	public class KillMessage : ModuleMessage
	{
		public override PermissionLevel MinimumPermissionLevel { get; protected set; } = (PermissionLevel)1;


		protected override void ReceivedMessageEvent(NetworkPlayer localPlayer, NetworkPlayer sender, string message)
		{
			base.ReceivedMessageEvent(localPlayer, sender, message);
			Health health = localPlayer.RigSkeleton.health;
			if (health != null)
			{
				health.Dying(100f);
			}
			Health health2 = localPlayer.RigSkeleton.health;
			if (health2 != null)
			{
				health2.Death();
			}
			Health health3 = localPlayer.RigSkeleton.health;
			if (health3 != null)
			{
				health3.Respawn();
			}
		}
	}
	public abstract class ModuleMessage : ModuleMessageHandler
	{
		public abstract PermissionLevel MinimumPermissionLevel { get; protected set; }

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			MessageNetSerializable messageNetSerializable = ((ReceivedMessage)(ref received)).ReadData<MessageNetSerializable>();
			PlayerID sender = messageNetSerializable.Sender;
			string message = messageNetSerializable.Message;
			NetworkPlayer val = default(NetworkPlayer);
			NetworkPlayerManager.TryGetPlayer(Player.RigManager, ref val);
			NetworkPlayer val2 = default(NetworkPlayer);
			NetworkPlayerManager.TryGetPlayer(PlayerID.op_Implicit(sender), ref val2);
			PermissionLevel val3 = default(PermissionLevel);
			Color val4 = default(Color);
			FusionPermissions.FetchPermissionLevel(PlayerID.op_Implicit(sender), ref val3, ref val4);
			if (val3 >= MinimumPermissionLevel || val2.PlayerID == val.PlayerID)
			{
				ReceivedMessageEvent(val, val2, message);
			}
		}

		protected virtual void ReceivedMessageEvent(NetworkPlayer receiver, NetworkPlayer sender, string message)
		{
			MelonLogger.Msg($"Receiver: ({receiver.Username}) Sender: ({sender.Username}) Message: ({message})");
		}
	}
}
namespace Powertools.Fusion
{
	public class Core : MelonMod
	{
		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
			if (MelonBase.FindMelon("LabFusion", "Lakatrazz") != null)
			{
				LoadModule();
			}
		}

		private static void LoadModule()
		{
			ModuleManager.RegisterModule<PowertoolsModule>();
		}
	}
}
namespace Powertools.Fusion.Tools
{
	public class FusionTool : BaseTool
	{
		public static string message;

		public override string ToolName => "Fusion Tools";

		public override void BoneMenuCreator()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			((BaseTool)this).BoneMenuCreator();
			new AdminMenu(base.Page);
			base.Page.CreateString("Message", Color.green, string.Empty, (Action<string>)delegate(string a)
			{
				message = a;
			});
			base.Page.CreateFunction("Send Message", Color.green, (Action)delegate
			{
				SendMessage<NotifcationMessage>((RelayType)2, message, (NetworkChannel)0);
			});
		}

		public override void OnSetEnabled(bool value)
		{
			((BaseTool)this).OnSetEnabled(value);
		}

		public override void Reset()
		{
			((BaseTool)this).Reset();
		}

		public static void SendMessage<T>(byte targetId, string message = "", NetworkChannel network = 0) where T : ModuleMessage
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			NetworkPlayer val = default(NetworkPlayer);
			NetworkPlayer val2 = default(NetworkPlayer);
			if (NetworkPlayerManager.TryGetPlayer(Player.RigManager, ref val) && NetworkPlayerManager.TryGetPlayer(targetId, ref val2))
			{
				if (string.IsNullOrEmpty(message))
				{
					message = typeof(T).FullName.ToLower();
				}
				MessageNetSerializable messageNetSerializable = new MessageNetSerializable
				{
					Sender = val.PlayerID,
					Message = message
				};
				MessageRelay.RelayModule<T, MessageNetSerializable>(messageNetSerializable, new MessageRoute(targetId, network));
			}
		}

		public static void SendMessage<T>(RelayType relayType, string message = null, NetworkChannel network = 0) where T : ModuleMessage
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			NetworkPlayer val = default(NetworkPlayer);
			if (NetworkPlayerManager.TryGetPlayer(Player.RigManager, ref val))
			{
				if (string.IsNullOrEmpty(message))
				{
					message = typeof(T).FullName.ToLower();
				}
				MessageNetSerializable messageNetSerializable = new MessageNetSerializable
				{
					Sender = val.PlayerID,
					Message = message
				};
				MessageRelay.RelayModule<T, MessageNetSerializable>(messageNetSerializable, new MessageRoute(relayType, network));
			}
		}
	}
}