using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
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("AdminCheats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+04a6f40c234702a90518ebd6fd6e194b07bf9d70")]
[assembly: AssemblyProduct("AdminCheats")]
[assembly: AssemblyTitle("AdminCheats")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AdminCheats;

public static class Helpers
{
	private static FieldInfo _commandsField;

	private static MethodInfo _updateCommandListMethod;

	public static Dictionary<string, ConsoleCommand> GetCommands()
	{
		if (_commandsField == null)
		{
			_commandsField = typeof(Terminal).GetField("commands", BindingFlags.Static | BindingFlags.NonPublic);
		}
		return (Dictionary<string, ConsoleCommand>)_commandsField.GetValue(null);
	}

	public static void UpdateCommandList(Terminal terminal)
	{
		if (_updateCommandListMethod == null)
		{
			_updateCommandListMethod = typeof(Terminal).GetMethod("updateCommandList", BindingFlags.Instance | BindingFlags.NonPublic);
		}
		_updateCommandListMethod.Invoke(terminal, null);
	}
}
public static class Overrides
{
	public static bool Cheats;

	public static bool Server;

	public static bool Network;

	public static bool Secret;

	public const string green = "#aaffaa";

	public const string red = "#ff6666";

	public const string yellow = "#ffff88";

	public static bool EffectiveCheats(bool real)
	{
		return Cheats || real;
	}

	public static bool EffectiveServer(bool real)
	{
		return Server || real;
	}

	public static bool EffectiveNetwork(bool real)
	{
		return Network || real;
	}

	public static bool EffectiveSecret(bool real)
	{
		return Secret || real;
	}

	public static string FormatFlag(string name, bool real, bool overridden)
	{
		if (overridden && !real)
		{
			return "<color=#ffff88>" + name + "=OVERRIDE</color>";
		}
		string arg = (real ? "#aaffaa" : "#ff6666");
		return $"<color={arg}>{name}={real}</color>";
	}

	public static string FormatStatus(string name, bool real, bool forced)
	{
		if (forced && !real)
		{
			return "<color=#ffff88>" + name + "</color>";
		}
		return "<color=" + (real ? "#aaffaa" : "#ff6666") + ">" + name + "</color>";
	}

	public static void PrintStatus(Terminal context)
	{
		bool flag = Object.op_Implicit((Object)(object)ZNet.instance);
		bool real = flag && ZNet.instance.IsServer();
		if (flag)
		{
			ZNet.instance.LocalPlayerIsAdminOrHost();
		}
		else
			_ = 0;
		bool real2 = context.IsCheatsEnabled();
		context.AddString("Override status:");
		context.AddString("  cheats:  " + FormatFlag("real", real2, overridden: false) + "  " + FormatFlag("override", Cheats, overridden: false) + "  => " + FormatFlag("effective", EffectiveCheats(real2), overridden: false));
		context.AddString("  server:  " + FormatFlag("real", real, overridden: false) + "  " + FormatFlag("override", Server, overridden: false) + "  => " + FormatFlag("effective", EffectiveServer(real), overridden: false));
		context.AddString("  network: " + FormatFlag("real", flag, overridden: false) + "  " + FormatFlag("override", Network, overridden: false) + "  => " + FormatFlag("effective", EffectiveNetwork(flag), overridden: false));
		context.AddString("  secret:  " + FormatFlag("override", Secret, overridden: false));
	}
}
[HarmonyPatch(typeof(Terminal), "IsCheatsEnabled")]
public static class IsCheatsEnabledPatch
{
	private static void Postfix(ref bool __result)
	{
		if (!__result)
		{
			if (Overrides.EffectiveCheats(real: false))
			{
				__result = true;
			}
			else if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.LocalPlayerIsAdminOrHost())
			{
				__result = true;
			}
		}
	}
}
[HarmonyPatch(typeof(ConsoleCommand), "IsValid")]
public static class IsValidPatch
{
	private static void Postfix(ConsoleCommand __instance, Terminal context, ref bool __result)
	{
		if (__result)
		{
			return;
		}
		bool flag = Object.op_Implicit((Object)(object)ZNet.instance);
		if (flag && ZNet.instance.LocalPlayerIsAdminOrHost())
		{
			bool num = !__instance.IsCheat || Overrides.EffectiveCheats(context.IsCheatsEnabled());
			bool flag2 = !__instance.IsNetwork || Overrides.EffectiveNetwork(flag);
			if (num && flag2)
			{
				__result = true;
			}
			return;
		}
		bool num2 = !__instance.IsCheat || Overrides.EffectiveCheats(context.IsCheatsEnabled());
		bool flag3 = !__instance.IsNetwork || Overrides.EffectiveNetwork(flag);
		bool flag4 = !__instance.OnlyServer || Overrides.EffectiveServer(flag && ZNet.instance.IsServer());
		if (num2 && flag3 && flag4)
		{
			__result = true;
		}
	}
}
[HarmonyPatch(typeof(ConsoleCommand), "ShowCommand")]
public static class ShowCommandPatch
{
	private static void Postfix(ConsoleCommand __instance, ref bool __result)
	{
		if (!__result && (!__instance.IsSecret || Overrides.Secret) && ((Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.LocalPlayerIsAdminOrHost()) || Overrides.Secret))
		{
			__result = true;
		}
	}
}
[HarmonyPatch(typeof(Terminal), "TryRunCommand")]
public static class TryRunCommandPatch
{
	private static bool Prefix(Terminal __instance, string text, bool silentFail)
	{
		string text2 = text.Split(' ')[0].ToLower();
		if (!Helpers.GetCommands().TryGetValue(text2, out var value))
		{
			return true;
		}
		if (value.IsValid(__instance, false))
		{
			return true;
		}
		if (silentFail)
		{
			return true;
		}
		bool flag = Object.op_Implicit((Object)(object)ZNet.instance);
		bool val2 = flag && ZNet.instance.IsServer();
		bool val3 = flag && ZNet.instance.LocalPlayerIsAdminOrHost();
		bool val4 = __instance.IsCheatsEnabled();
		__instance.AddString("<color=#ff6666>'" + text2 + "' failed validation. Diagnostics:</color>");
		__instance.AddString("  " + CV("IsCheat", value.IsCheat, needsTrue: false) + "  " + CV("IsCheatsEnabled", val4, needsTrue: true));
		__instance.AddString("  " + CV("OnlyServer", value.OnlyServer, needsTrue: false) + "  " + CV("IsServer", val2, needsTrue: true));
		__instance.AddString("  " + CV("OnlyAdmin", value.OnlyAdmin, needsTrue: false) + "  " + CV("IsAdmin", val3, needsTrue: true));
		__instance.AddString("  " + CV("IsNetwork", value.IsNetwork, needsTrue: false) + "  " + CV("HasZNet", flag, needsTrue: true));
		__instance.AddString("  " + CV("RemoteCommand", value.RemoteCommand, needsTrue: false));
		__instance.AddString("  " + CV("IsSecret", value.IsSecret, needsTrue: false));
		__instance.AddString("Tip: use <color=#ffff88>flags [flag]</color> to toggle overrides.");
		return false;
		static string CV(string label, bool val, bool needsTrue)
		{
			string arg = ((val == needsTrue) ? "#aaffaa" : "#ff6666");
			return $"<color={arg}>{label}={val}</color>";
		}
	}
}
public static class ModSync
{
	private static Terminal _pendingContext;

	public static void Register()
	{
		ZRoutedRpc.instance.Register("HelpDesk_RequestMods", (Action<long>)OnRequestMods);
		ZRoutedRpc.instance.Register<string>("HelpDesk_ReceiveMods", (Action<long, string>)OnReceiveMods);
		ZRoutedRpc.instance.Register<long>("HelpDesk_RequestClientMods", (Action<long, long>)OnRequestClientMods);
		ZRoutedRpc.instance.Register<string, string>("HelpDesk_ReceiveClientMods", (Action<long, string, string>)OnReceiveClientMods);
	}

	private static void OnRequestMods(long sender)
	{
		if (ZNet.instance.IsServer())
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "HelpDesk_ReceiveMods", new object[1] { BuildModString() });
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "HelpDesk_RequestClientMods", new object[1] { sender });
		}
	}

	private static void OnReceiveMods(long sender, string data)
	{
		if (!((Object)(object)_pendingContext == (Object)null))
		{
			PrintModList(_pendingContext, "Server", data);
		}
	}

	private static void OnRequestClientMods(long sender, long requesterPeerID)
	{
		if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsServer() && ZNet.GetUID() != requesterPeerID)
		{
			string text = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetPlayerName() : "Unknown");
			ZRoutedRpc.instance.InvokeRoutedRPC(requesterPeerID, "HelpDesk_ReceiveClientMods", new object[2]
			{
				text,
				BuildModString()
			});
		}
	}

	private static void OnReceiveClientMods(long sender, string playerName, string data)
	{
		if (!((Object)(object)_pendingContext == (Object)null))
		{
			PrintModList(_pendingContext, playerName, data);
		}
	}

	private static void PrintModList(Terminal context, string label, string data)
	{
		string[] array = data.Split('\n');
		context.AddString(string.Format("<color={0}>--- {1} mods ({2}) ---</color>", "#aaffaa", label, array.Length));
		string[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			string[] array3 = array2[i].Split('|');
			if (array3.Length == 3)
			{
				context.AddString("  <color=#aaffaa>" + array3[0] + "</color> <color=#ffff88>v" + array3[1] + "</color>  <color=#888888>" + array3[2] + "</color>");
			}
		}
	}

	public static string BuildModString()
	{
		List<string> list = new List<string>();
		foreach (PluginInfo value in Chainloader.PluginInfos.Values)
		{
			list.Add($"{value.Metadata.Name}|{value.Metadata.Version}|{value.Metadata.GUID}");
		}
		return string.Join("\n", list);
	}

	public static void RequestFromServer(Terminal context)
	{
		_pendingContext = context;
		ZRoutedRpc.instance.InvokeRoutedRPC("HelpDesk_RequestMods", Array.Empty<object>());
	}
}
public static class PingManager
{
	private static FieldInfo _peersField;

	private static Terminal _pendingContext;

	private static long _requesterPeerID;

	private static readonly Dictionary<long, long> _probeTimestamps = new Dictionary<long, long>();

	private static readonly Dictionary<long, long> _results = new Dictionary<long, long>();

	private static List<ZNetPeer> _probedPeers = new List<ZNetPeer>();

	private static float _elapsed;

	private static bool _waiting;

	private const float Timeout = 3f;

	public static void Register()
	{
		ZRoutedRpc.instance.Register("HelpDesk_RequestPing", (Action<long>)OnRequestPing);
		ZRoutedRpc.instance.Register("HelpDesk_PingProbe", (Action<long>)OnPingProbe);
		ZRoutedRpc.instance.Register("HelpDesk_PingPong", (Action<long>)OnPingPong);
		ZRoutedRpc.instance.Register<string>("HelpDesk_PingResults", (Action<long, string>)OnPingResults);
	}

	private static List<ZNetPeer> GetPeers()
	{
		if (_peersField == null)
		{
			_peersField = typeof(ZRoutedRpc).GetField("m_peers", BindingFlags.Instance | BindingFlags.NonPublic);
		}
		return (List<ZNetPeer>)_peersField.GetValue(ZRoutedRpc.instance);
	}

	public static void RequestPings(Terminal context)
	{
		_pendingContext = context;
		ZRoutedRpc.instance.InvokeRoutedRPC("HelpDesk_RequestPing", Array.Empty<object>());
	}

	public static void RunPingsLocally(Terminal context)
	{
		StartProbing(context, 0L);
	}

	private static void OnRequestPing(long sender)
	{
		if (ZNet.instance.IsServer())
		{
			StartProbing(null, sender);
		}
	}

	private static void StartProbing(Terminal context, long requesterPeerID)
	{
		_pendingContext = context;
		_requesterPeerID = requesterPeerID;
		_probeTimestamps.Clear();
		_results.Clear();
		_probedPeers = new List<ZNetPeer>();
		_elapsed = 0f;
		_waiting = true;
		foreach (ZNetPeer peer in GetPeers())
		{
			if (peer.IsReady())
			{
				_probeTimestamps[peer.m_uid] = DateTime.UtcNow.Ticks;
				_probedPeers.Add(peer);
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "HelpDesk_PingProbe", Array.Empty<object>());
			}
		}
		if (_probedPeers.Count == 0)
		{
			FlushResults();
		}
	}

	private static void OnPingProbe(long sender)
	{
		ZRoutedRpc.instance.InvokeRoutedRPC("HelpDesk_PingPong", Array.Empty<object>());
	}

	private static void OnPingPong(long sender)
	{
		if (_waiting)
		{
			if (_probeTimestamps.TryGetValue(sender, out var value))
			{
				_results[sender] = (DateTime.UtcNow.Ticks - value) / 10000;
			}
			if (_results.Count >= _probedPeers.Count)
			{
				FlushResults();
			}
		}
	}

	public static void OnUpdate()
	{
		if (_waiting)
		{
			_elapsed += Time.deltaTime;
			if (_elapsed >= 3f)
			{
				FlushResults();
			}
		}
	}

	private static void FlushResults()
	{
		if (!_waiting)
		{
			return;
		}
		_waiting = false;
		List<string> list = new List<string>();
		foreach (ZNetPeer probedPeer in _probedPeers)
		{
			string text = ((probedPeer.m_playerName.Length > 0) ? probedPeer.m_playerName : $"uid:{probedPeer.m_uid}");
			long value;
			string text2 = (_results.TryGetValue(probedPeer.m_uid, out value) ? value.ToString() : "timeout");
			list.Add(text + "|" + text2);
		}
		string text3 = string.Join("\n", list);
		if (_requesterPeerID != 0L)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(_requesterPeerID, "HelpDesk_PingResults", new object[1] { text3 });
		}
		else
		{
			PrintResults(_pendingContext, text3);
		}
		_pendingContext = null;
	}

	private static void OnPingResults(long sender, string data)
	{
		if (!((Object)(object)_pendingContext == (Object)null))
		{
			PrintResults(_pendingContext, data);
			_pendingContext = null;
		}
	}

	public static void PrintResults(Terminal context, string data)
	{
		if ((Object)(object)context == (Object)null)
		{
			return;
		}
		if (string.IsNullOrEmpty(data))
		{
			context.AddString("No connected peers.");
			return;
		}
		context.AddString("<color=#aaffaa>--- Ping results ---</color>");
		string[] array = data.Split('\n');
		for (int i = 0; i < array.Length; i++)
		{
			string[] array2 = array[i].Split('|');
			if (array2.Length == 2)
			{
				bool num = array2[1] == "timeout";
				string text = (num ? "#ff6666" : "#aaffaa");
				string text2 = (num ? "timeout" : (array2[1] + "ms"));
				context.AddString("  <color=#aaffaa>" + array2[0] + "</color>  <color=" + text + ">" + text2 + "</color>");
			}
		}
	}
}
[HarmonyPatch(typeof(ZNet), "Start")]
public static class ZNetStartPatch
{
	private static void Postfix()
	{
		ModSync.Register();
		PingManager.Register();
	}
}
[HarmonyPatch(typeof(ZNet), "Update")]
public static class ZNetUpdatePatch
{
	private static void Postfix()
	{
		PingManager.OnUpdate();
	}
}
[HarmonyPatch(typeof(Terminal), "InitTerminal")]
public static class CommandRegistration
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static ConsoleEvent <>9__0_0;

		public static ConsoleOptionsFetcher <>9__0_1;

		public static ConsoleEvent <>9__0_2;

		public static ConsoleEvent <>9__0_3;

		public static ConsoleEvent <>9__0_4;

		internal void <Postfix>b__0_0(ConsoleEventArgs args)
		{
			if (args.Length < 2)
			{
				Overrides.PrintStatus(args.Context);
				return;
			}
			string text = args[1].ToLower();
			switch (text)
			{
			case "cheats":
			case "cheat":
				Overrides.Cheats = !Overrides.Cheats;
				args.Context.AddString(string.Format("Cheats override: <color={0}>{1}</color>", Overrides.Cheats ? "#aaffaa" : "#ff6666", Overrides.Cheats));
				break;
			case "server":
				Overrides.Server = !Overrides.Server;
				args.Context.AddString(string.Format("Server override: <color={0}>{1}</color>", Overrides.Server ? "#aaffaa" : "#ff6666", Overrides.Server));
				break;
			case "network":
				Overrides.Network = !Overrides.Network;
				args.Context.AddString(string.Format("Network override: <color={0}>{1}</color>", Overrides.Network ? "#aaffaa" : "#ff6666", Overrides.Network));
				break;
			case "secret":
				Overrides.Secret = !Overrides.Secret;
				args.Context.AddString(string.Format("Secret override: <color={0}>{1}</color>", Overrides.Secret ? "#aaffaa" : "#ff6666", Overrides.Secret));
				break;
			case "all":
			{
				bool num = Overrides.Cheats && Overrides.Server && Overrides.Network && Overrides.Secret;
				Overrides.Cheats = !num;
				Overrides.Server = !num;
				Overrides.Network = !num;
				Overrides.Secret = !num;
				string text2 = ((!num) ? "<color=#aaffaa>ON</color>" : "<color=#ff6666>OFF</color>");
				args.Context.AddString("All overrides: " + text2);
				break;
			}
			case "reset":
			case "off":
				Overrides.Cheats = false;
				Overrides.Server = false;
				Overrides.Network = false;
				Overrides.Secret = false;
				args.Context.AddString("All overrides: <color=#ff6666>OFF</color>");
				break;
			default:
				args.Context.AddString("Unknown flag '" + text + "'. Use: cheats, server, network, secret, all, off");
				break;
			}
			Helpers.UpdateCommandList(args.Context);
		}

		internal List<string> <Postfix>b__0_1()
		{
			return new List<string> { "cheats", "server", "network", "secret", "all", "off" };
		}

		internal void <Postfix>b__0_2(ConsoleEventArgs args)
		{
			bool flag = Object.op_Implicit((Object)(object)ZNet.instance);
			bool real = flag && ZNet.instance.IsServer();
			bool real2 = flag && ZNet.instance.LocalPlayerIsAdminOrHost();
			bool real3 = args.Context.IsCheatsEnabled();
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<string, ConsoleCommand> command in Helpers.GetCommands())
			{
				ConsoleCommand value = command.Value;
				if (!(value.Command == "help"))
				{
					List<string> list3 = new List<string>();
					if (value.IsCheat)
					{
						list3.Add(Overrides.FormatStatus("cheat", real3, Overrides.Cheats));
					}
					if (value.OnlyServer)
					{
						list3.Add(Overrides.FormatStatus("server", real, Overrides.Server));
					}
					if (value.OnlyAdmin)
					{
						list3.Add(Overrides.FormatStatus("admin", real2, forced: false));
					}
					if (value.IsNetwork)
					{
						list3.Add(Overrides.FormatStatus("network", flag, Overrides.Network));
					}
					if (value.RemoteCommand)
					{
						list3.Add("<color=#aaffaa>remote</color>");
					}
					if (value.IsSecret)
					{
						list3.Add(Overrides.FormatStatus("secret", real: false, Overrides.Secret));
					}
					string text = ((list3.Count > 0) ? (" [" + string.Join(", ", list3) + "]") : "");
					string item = value.Command + " - " + value.Description + text;
					if (value.IsValid(args.Context, false))
					{
						list.Add(item);
					}
					else
					{
						list2.Add(item);
					}
				}
			}
			list.Sort();
			list2.Sort();
			args.Context.AddString(string.Format("<color={0}>--- Allowed ({1}) ---</color>", "#aaffaa", list.Count));
			foreach (string item2 in list)
			{
				args.Context.AddString("  " + item2);
			}
			if (list2.Count > 0)
			{
				args.Context.AddString(string.Format("<color={0}>--- Blocked ({1}) ---</color>", "#ff6666", list2.Count));
				foreach (string item3 in list2)
				{
					args.Context.AddString("  " + item3);
				}
			}
			args.Context.AddString("");
			args.Context.AddString("Context: " + Overrides.FormatFlag("cheats", real3, Overrides.Cheats) + ", " + Overrides.FormatFlag("server", real, Overrides.Server));
		}

		internal void <Postfix>b__0_3(ConsoleEventArgs args)
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				args.Context.AddString("Not connected.");
				return;
			}
			args.Context.AddString("<color=#ffff88>Pinging all peers...</color>");
			if (ZNet.instance.IsServer())
			{
				PingManager.RunPingsLocally(args.Context);
			}
			else
			{
				PingManager.RequestPings(args.Context);
			}
		}

		internal void <Postfix>b__0_4(ConsoleEventArgs args)
		{
			Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
			args.Context.AddString(string.Format("<color={0}>--- Client mods ({1}) ---</color>", "#aaffaa", pluginInfos.Count));
			foreach (KeyValuePair<string, PluginInfo> item in pluginInfos)
			{
				BepInPlugin metadata = item.Value.Metadata;
				args.Context.AddString(string.Format("  <color={0}>{1}</color> <color={2}>v{3}</color>  <color=#888888>{4}</color>", "#aaffaa", metadata.Name, "#ffff88", metadata.Version, metadata.GUID));
			}
			if (!((Object)(object)ZNet.instance == (Object)null))
			{
				if (!ZNet.instance.IsServer())
				{
					args.Context.AddString("<color=#ffff88>Requesting server mod list...</color>");
					ModSync.RequestFromServer(args.Context);
				}
				else
				{
					args.Context.AddString("<color=#888888>(Host/server — server mods same as client)</color>");
				}
			}
		}
	}

	private static void Postfix()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Expected O, but got Unknown
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Expected O, but got Unknown
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Expected O, but got Unknown
		object obj = <>c.<>9__0_0;
		if (obj == null)
		{
			ConsoleEvent val = delegate(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					Overrides.PrintStatus(args.Context);
				}
				else
				{
					string text2 = args[1].ToLower();
					switch (text2)
					{
					case "cheats":
					case "cheat":
						Overrides.Cheats = !Overrides.Cheats;
						args.Context.AddString(string.Format("Cheats override: <color={0}>{1}</color>", Overrides.Cheats ? "#aaffaa" : "#ff6666", Overrides.Cheats));
						break;
					case "server":
						Overrides.Server = !Overrides.Server;
						args.Context.AddString(string.Format("Server override: <color={0}>{1}</color>", Overrides.Server ? "#aaffaa" : "#ff6666", Overrides.Server));
						break;
					case "network":
						Overrides.Network = !Overrides.Network;
						args.Context.AddString(string.Format("Network override: <color={0}>{1}</color>", Overrides.Network ? "#aaffaa" : "#ff6666", Overrides.Network));
						break;
					case "secret":
						Overrides.Secret = !Overrides.Secret;
						args.Context.AddString(string.Format("Secret override: <color={0}>{1}</color>", Overrides.Secret ? "#aaffaa" : "#ff6666", Overrides.Secret));
						break;
					case "all":
					{
						bool num = Overrides.Cheats && Overrides.Server && Overrides.Network && Overrides.Secret;
						Overrides.Cheats = !num;
						Overrides.Server = !num;
						Overrides.Network = !num;
						Overrides.Secret = !num;
						string text3 = ((!num) ? "<color=#aaffaa>ON</color>" : "<color=#ff6666>OFF</color>");
						args.Context.AddString("All overrides: " + text3);
						break;
					}
					case "reset":
					case "off":
						Overrides.Cheats = false;
						Overrides.Server = false;
						Overrides.Network = false;
						Overrides.Secret = false;
						args.Context.AddString("All overrides: <color=#ff6666>OFF</color>");
						break;
					default:
						args.Context.AddString("Unknown flag '" + text2 + "'. Use: cheats, server, network, secret, all, off");
						break;
					}
					Helpers.UpdateCommandList(args.Context);
				}
			};
			<>c.<>9__0_0 = val;
			obj = (object)val;
		}
		object obj2 = <>c.<>9__0_1;
		if (obj2 == null)
		{
			ConsoleOptionsFetcher val2 = () => new List<string> { "cheats", "server", "network", "secret", "all", "off" };
			<>c.<>9__0_1 = val2;
			obj2 = (object)val2;
		}
		new ConsoleCommand("flags", "[flag] toggle overrides: cheats, server, network, secret. No args = show status.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
		object obj3 = <>c.<>9__0_2;
		if (obj3 == null)
		{
			ConsoleEvent val3 = delegate(ConsoleEventArgs args)
			{
				bool flag = Object.op_Implicit((Object)(object)ZNet.instance);
				bool real = flag && ZNet.instance.IsServer();
				bool real2 = flag && ZNet.instance.LocalPlayerIsAdminOrHost();
				bool real3 = args.Context.IsCheatsEnabled();
				List<string> list = new List<string>();
				List<string> list2 = new List<string>();
				foreach (KeyValuePair<string, ConsoleCommand> command in Helpers.GetCommands())
				{
					ConsoleCommand value = command.Value;
					if (!(value.Command == "help"))
					{
						List<string> list3 = new List<string>();
						if (value.IsCheat)
						{
							list3.Add(Overrides.FormatStatus("cheat", real3, Overrides.Cheats));
						}
						if (value.OnlyServer)
						{
							list3.Add(Overrides.FormatStatus("server", real, Overrides.Server));
						}
						if (value.OnlyAdmin)
						{
							list3.Add(Overrides.FormatStatus("admin", real2, forced: false));
						}
						if (value.IsNetwork)
						{
							list3.Add(Overrides.FormatStatus("network", flag, Overrides.Network));
						}
						if (value.RemoteCommand)
						{
							list3.Add("<color=#aaffaa>remote</color>");
						}
						if (value.IsSecret)
						{
							list3.Add(Overrides.FormatStatus("secret", real: false, Overrides.Secret));
						}
						string text = ((list3.Count > 0) ? (" [" + string.Join(", ", list3) + "]") : "");
						string item = value.Command + " - " + value.Description + text;
						if (value.IsValid(args.Context, false))
						{
							list.Add(item);
						}
						else
						{
							list2.Add(item);
						}
					}
				}
				list.Sort();
				list2.Sort();
				args.Context.AddString(string.Format("<color={0}>--- Allowed ({1}) ---</color>", "#aaffaa", list.Count));
				foreach (string item2 in list)
				{
					args.Context.AddString("  " + item2);
				}
				if (list2.Count > 0)
				{
					args.Context.AddString(string.Format("<color={0}>--- Blocked ({1}) ---</color>", "#ff6666", list2.Count));
					foreach (string item3 in list2)
					{
						args.Context.AddString("  " + item3);
					}
				}
				args.Context.AddString("");
				args.Context.AddString("Context: " + Overrides.FormatFlag("cheats", real3, Overrides.Cheats) + ", " + Overrides.FormatFlag("server", real, Overrides.Server));
			};
			<>c.<>9__0_2 = val3;
			obj3 = (object)val3;
		}
		new ConsoleCommand("help", "Shows all console commands with permission status", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		object obj4 = <>c.<>9__0_3;
		if (obj4 == null)
		{
			ConsoleEvent val4 = delegate(ConsoleEventArgs args)
			{
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					args.Context.AddString("Not connected.");
				}
				else
				{
					args.Context.AddString("<color=#ffff88>Pinging all peers...</color>");
					if (ZNet.instance.IsServer())
					{
						PingManager.RunPingsLocally(args.Context);
					}
					else
					{
						PingManager.RequestPings(args.Context);
					}
				}
			};
			<>c.<>9__0_3 = val4;
			obj4 = (object)val4;
		}
		new ConsoleCommand("ping", "Measure ping to all connected clients", (ConsoleEvent)obj4, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		object obj5 = <>c.<>9__0_4;
		if (obj5 == null)
		{
			ConsoleEvent val5 = delegate(ConsoleEventArgs args)
			{
				Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
				args.Context.AddString(string.Format("<color={0}>--- Client mods ({1}) ---</color>", "#aaffaa", pluginInfos.Count));
				foreach (KeyValuePair<string, PluginInfo> item4 in pluginInfos)
				{
					BepInPlugin metadata = item4.Value.Metadata;
					args.Context.AddString(string.Format("  <color={0}>{1}</color> <color={2}>v{3}</color>  <color=#888888>{4}</color>", "#aaffaa", metadata.Name, "#ffff88", metadata.Version, metadata.GUID));
				}
				if (!((Object)(object)ZNet.instance == (Object)null))
				{
					if (!ZNet.instance.IsServer())
					{
						args.Context.AddString("<color=#ffff88>Requesting server mod list...</color>");
						ModSync.RequestFromServer(args.Context);
					}
					else
					{
						args.Context.AddString("<color=#888888>(Host/server — server mods same as client)</color>");
					}
				}
			};
			<>c.<>9__0_4 = val5;
			obj5 = (object)val5;
		}
		new ConsoleCommand("mods", "List loaded BepInEx mods on client and server", (ConsoleEvent)obj5, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
	}
}
[BepInPlugin("helpdesk", "HelpDesk", "1.0.2")]
public class Plugin : BaseUnityPlugin
{
	public const string PluginGUID = "helpdesk";

	public const string PluginName = "HelpDesk";

	public const string PluginVersion = "1.0.2";

	internal static ManualLogSource Log;

	private Harmony _harmony;

	private void Awake()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		_harmony = new Harmony("helpdesk");
		_harmony.PatchAll();
		Log.LogInfo((object)"HelpDesk v1.0.2 loaded.");
	}

	private void OnDestroy()
	{
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
	}
}