using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Network;
using ProjectM.Physics;
using ProjectM.Scripting;
using Protector.Helpers;
using Protector.Services;
using Steamworks;
using Stunlock.Network;
using Unity.Collections;
using Unity.Entities;
using UnityEngine;
using VampireCommandFramework;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Protector")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Whitelist mod")]
[assembly: AssemblyFileVersion("0.1.10.0")]
[assembly: AssemblyInformationalVersion("0.1.10+1.Branch.main.Sha.c33d0879382e1a0da34861ec55914ba7e637a80e.a440a4ae0990915c07065d07636f6c38d1fd8a93")]
[assembly: AssemblyProduct("Protector")]
[assembly: AssemblyTitle("Protector")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.10.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 Protector
{
	internal static class Core
	{
		public static GateKeeperService gKs;

		private static bool hasInitialized;

		public static World Server { get; } = GetWorld("Server") ?? throw new Exception("There is no Server world (yet)...");


		public static EntityManager EntityManager { get; } = Server.EntityManager;


		public static ServerScriptMapper ServerScriptMapper { get; internal set; }

		public static ServerGameManager ServerGameManager => ServerScriptMapper.GetServerGameManager();

		public static PrefabCollectionSystem PrefabCollectionSystem { get; internal set; }

		public static ManualLogSource Log => Plugin.LogInstance;

		public static void Initialize()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (!hasInitialized)
			{
				Whitelist.Config(Plugin.GateKeeperWhitelistFile.Value);
				ServerScriptMapper = Server.GetExistingSystemManaged<ServerScriptMapper>();
				PrefabCollectionSystem = Server.GetExistingSystemManaged<PrefabCollectionSystem>();
				CommandRegistry.RegisterAll();
				ManualLogSource log = Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(20, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("Protector");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("0.1.10");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] core initialized!");
				}
				log.LogInfo(val);
				gKs = new GateKeeperService();
				hasInitialized = true;
			}
		}

		private static World GetWorld(string name)
		{
			Enumerator<World> enumerator = World.s_AllWorlds.GetEnumerator();
			while (enumerator.MoveNext())
			{
				World current = enumerator.Current;
				if (current.Name == name)
				{
					return current;
				}
			}
			return null;
		}

		internal static bool IsUserEnabled(ulong m_SteamID)
		{
			return gKs.IsUserEnabled(m_SteamID);
		}
	}
	[BepInPlugin("Protector", "Protector", "0.1.10")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		private Harmony _harmony;

		public static readonly string RootConfigPath = Path.Combine(Paths.ConfigPath, "Protector");

		public static ConfigEntry<bool> GateKeeperKickPlayer;

		public static ConfigEntry<bool> GateKeeperFileWatcherEnabled;

		public static ConfigEntry<int> GateKeeperUpdateInterval;

		public static ConfigEntry<bool> GateKeeperUpdateEnabled;

		public static ConfigEntry<string> GateKeeperWhitelistFile;

		internal static Plugin Instance { get; private set; }

		public static ManualLogSource LogInstance => ((BasePlugin)Instance).Log;

		public override void Load()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			Instance = this;
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(28, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("Protector");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" version ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("0.1.10");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is loading!");
			}
			log.LogInfo(val);
			InitConfig();
			_harmony = new Harmony("Protector");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			CommandRegistry.RegisterAll();
			ManualLogSource log2 = ((BasePlugin)this).Log;
			val = new BepInExInfoLogInterpolatedStringHandler(27, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("Protector");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" version ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("0.1.10");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is loaded!");
			}
			log2.LogInfo(val);
		}

		private static void InitConfig()
		{
			CreateDirectories(RootConfigPath);
			GateKeeperFileWatcherEnabled = InitConfigEntry("Config", "GateKeeperFileWatcherEnabled", defaultValue: true, "Enable or disable hot monitor of configuration file.");
			GateKeeperUpdateInterval = InitConfigEntry("Config", "GateKeeperUpdateInterval", 9999, "Delay for background processor in minutes.");
			GateKeeperUpdateEnabled = InitConfigEntry("Config", "GateKeeperUpdateEnabled", defaultValue: false, "Enable background processor.");
			GateKeeperKickPlayer = InitConfigEntry("Config", "GateKeeperKickPlayer", defaultValue: true, "Enable kick for not whitelisted players.");
			GateKeeperWhitelistFile = InitConfigEntry("Config", "GateKeeperWhitelistFile", Path.Combine(RootConfigPath, "WhiteList.txt"), "Path to the WhiteList file.");
		}

		private static ConfigEntry<T> InitConfigEntry<T>(string section, string key, T defaultValue, string description)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<T> val = ((BasePlugin)Instance).Config.Bind<T>(section, key, defaultValue, description);
			string text = Path.Combine(Paths.ConfigPath, "Protector.cfg");
			ConfigEntry<T> val2 = default(ConfigEntry<T>);
			if (File.Exists(text) && new ConfigFile(text, true).TryGetEntry<T>(section, key, ref val2))
			{
				val.Value = val2.Value;
			}
			return val;
		}

		public override bool Unload()
		{
			CommandRegistry.UnregisterAssembly();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			return true;
		}

		private static void CreateDirectories(string path)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			bool flag = default(bool);
			if (!Directory.Exists(path))
			{
				ManualLogSource logInstance = LogInstance;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(49, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No configuration folder found at [");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(path);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("], creating it.");
				}
				logInstance.LogWarning(val);
				Directory.CreateDirectory(path);
			}
			else
			{
				ManualLogSource logInstance2 = LogInstance;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(33, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Configuration folder found at [");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(path);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("].");
				}
				logInstance2.LogInfo(val2);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Protector";

		public const string PLUGIN_NAME = "Protector";

		public const string PLUGIN_VERSION = "0.1.10";
	}
}
namespace Protector.Services
{
	internal class GateKeeperService
	{
		private List<ulong> OldWhitelisted;

		private FileSystemWatcher fileWatcher;

		private readonly IgnorePhysicsDebugSystem tokenMonoBehaviour;

		public const int MAX_REPLY_LENGTH = 509;

		private List<ulong> Whitelisted { get; set; }

		public static ManualLogSource Log => Plugin.LogInstance;

		public GateKeeperService()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			LoadLists();
			tokenMonoBehaviour = new GameObject("GateKeeperService").AddComponent<IgnorePhysicsDebugSystem>();
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val;
			if (Plugin.GateKeeperUpdateEnabled.Value)
			{
				((MonoBehaviour)tokenMonoBehaviour).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(UpdateLoop()));
				ManualLogSource log = Log;
				val = new BepInExInfoLogInterpolatedStringHandler(37, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("GateKeeper background updater started");
				}
				log.LogInfo(val);
			}
			if (Plugin.GateKeeperFileWatcherEnabled.Value)
			{
				initializeFileWatcher();
				ManualLogSource log2 = Log;
				val = new BepInExInfoLogInterpolatedStringHandler(41, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("GateKeeper background filewatcher started");
				}
				log2.LogInfo(val);
			}
			((MonoBehaviour)tokenMonoBehaviour).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(KickLoop()));
			ManualLogSource log3 = Log;
			val = new BepInExInfoLogInterpolatedStringHandler(47, 0, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("GateKeeper background Whitelist monitor started");
			}
			log3.LogInfo(val);
		}

		private IEnumerator UpdateLoop()
		{
			WaitForSeconds waitForSeconds = new WaitForSeconds((float)(Plugin.GateKeeperUpdateInterval.Value * 60));
			while (true)
			{
				yield return waitForSeconds;
				MarkForReload();
			}
		}

		private IEnumerator KickLoop()
		{
			while (true)
			{
				if (Whitelist.NeedsReload)
				{
					Whitelist.NeedsReload = false;
					object[] array = Whitelist.Read();
					Whitelisted = (List<ulong>)array[0];
					OldWhitelisted = (List<ulong>)array[1];
					KickUsers(OldWhitelisted);
				}
				yield return 0;
			}
		}

		public static void KickUsers(List<ulong> oldWhitelisted)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.GateKeeperKickPlayer.Value || oldWhitelisted == null || oldWhitelisted.Count == 0)
			{
				return;
			}
			EntityManager entityManager = Core.Server.EntityManager;
			EntityQuery val = ((EntityManager)(ref entityManager)).CreateEntityQuery((ComponentType[])(object)new ComponentType[1] { ComponentType.ReadOnly<User>() });
			NativeArray<Entity> val2 = ((EntityQuery)(ref val)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
			foreach (ulong item in oldWhitelisted)
			{
				if (Whitelist.Get().Contains(item))
				{
					continue;
				}
				Enumerator<Entity> enumerator2 = val2.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					Entity current2 = enumerator2.Current;
					User componentData = ((EntityManager)(ref entityManager)).GetComponentData<User>(current2);
					if (componentData.PlatformId == item && componentData.IsConnected)
					{
						KickUser(item);
					}
				}
			}
		}

		public void LoadLists()
		{
			object[] array = Whitelist.Read();
			Whitelisted = (List<ulong>)array[0];
			OldWhitelisted = (List<ulong>)array[1];
		}

		public bool IsUserEnabled(ulong playerId)
		{
			if (Whitelisted.Contains(playerId))
			{
				return true;
			}
			return false;
		}

		private static void KickUser(ulong playerId)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			Core.Server.GetExistingSystemManaged<ServerBootstrapSystem>().Kick(playerId, (ConnectionStatusChangeReason)19, true);
			ManualLogSource log = Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(56, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(playerId);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] was kicked because it was removed from the whitelist.");
			}
			log.LogInfo(val);
		}

		private void initializeFileWatcher()
		{
			fileWatcher = new FileSystemWatcher(Path.GetDirectoryName(Plugin.GateKeeperWhitelistFile.Value))
			{
				NotifyFilter = NotifyFilters.LastWrite,
				Filter = Path.GetFileName(Plugin.GateKeeperWhitelistFile.Value)
			};
			fileWatcher.Changed += delegate
			{
				MarkForReload();
			};
			fileWatcher.EnableRaisingEvents = true;
		}

		public List<ulong> getWhitelisted()
		{
			return new List<ulong>(Whitelisted);
		}

		public void MarkForReload()
		{
			Whitelist.NeedsReload = true;
		}
	}
}
namespace Protector.Patches
{
	[HarmonyPatch(typeof(SpawnTeamSystem_OnPersistenceLoad), "OnUpdate")]
	public static class InitializationPatch
	{
		[HarmonyPostfix]
		public static void OnUpdatePostfix()
		{
			Core.Initialize();
		}
	}
	[HarmonyPatch(typeof(SteamGameServer))]
	public class SteamGameServerPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("BeginAuthSession")]
		public static void BeginAuthSession(object[] __args, ref object __result)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			CSteamID val = (CSteamID)__args[2];
			bool flag = default(bool);
			if (Core.IsUserEnabled(val.m_SteamID))
			{
				ManualLogSource log = GateKeeperService.Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(45, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("FOUND IN WHITELISTED:[");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<ulong>(val.m_SteamID);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("] was allowed to login.");
				}
				log.LogInfo(val2);
				return;
			}
			ManualLogSource log2 = GateKeeperService.Log;
			BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(51, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("NOT FOUND IN WHITELISTED:[");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<ulong>(val.m_SteamID);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("] was prevented to login.");
			}
			log2.LogWarning(val3);
			__result = (object)(EBeginAuthSessionResult)1;
		}
	}
}
namespace Protector.Helpers
{
	public static class Whitelist
	{
		private static List<ulong> Whitelisted;

		private static string confFile;

		public static ManualLogSource Log => Plugin.LogInstance;

		public static bool NeedsReload { get; internal set; }

		public static bool Exists()
		{
			return File.Exists(confFile);
		}

		public static void Config(string configurationFile)
		{
			confFile = configurationFile;
		}

		public static void Initialize()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("#");
			stringBuilder.AppendLine("# Edit this file to add or remove player from the whitelist.");
			stringBuilder.AppendLine("#");
			stringBuilder.AppendLine("# If you have enabled HotReload in configuration file, it'll be automatically reloaded");
			stringBuilder.AppendLine("# without needing server restart. And if you use KickPlayer option, removed SteamID will");
			stringBuilder.AppendLine("# be automatically kicked out the server if connected.");
			stringBuilder.AppendLine("#");
			stringBuilder.AppendLine("# You can use comments in this file with # character, but be aware, you cannot put a");
			stringBuilder.AppendLine("# comment on the same line of an SteamID or it'll be skipped by the plugin.");
			stringBuilder.AppendLine("#");
			stringBuilder.AppendLine("# 10101010101010101");
			stringBuilder.AppendLine("#");
			File.WriteAllText(confFile, stringBuilder.ToString());
		}

		public static object[] Read()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			bool flag = default(bool);
			if (!Exists())
			{
				ManualLogSource log = Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(69, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No whitelist file found at [");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(confFile);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("], initializing it with default settings.");
				}
				log.LogWarning(val);
				Initialize();
			}
			List<ulong> whitelisted = Whitelisted;
			List<ulong> list = ((whitelisted != null && whitelisted.Count > 0) ? Whitelisted : null);
			Whitelisted = new List<ulong>();
			string[] array = WriteSafeReadAllLines(confFile);
			if (array.Length == 0)
			{
				ManualLogSource log2 = Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(25, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("There's no SteamIDs in [");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(confFile);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("]");
				}
				log2.LogWarning(val);
				return new object[2];
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (!text.StartsWith("#") && !text.Contains("#") && !string.IsNullOrEmpty(text) && ulong.TryParse(text, out var result) && !Whitelisted.Contains(result))
				{
					Whitelisted.Add(result);
				}
			}
			return new object[2] { Whitelisted, list };
		}

		public static string[] WriteSafeReadAllLines(string path)
		{
			using FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
			using StreamReader streamReader = new StreamReader(stream);
			List<string> list = new List<string>();
			while (!streamReader.EndOfStream)
			{
				list.Add(streamReader.ReadLine());
			}
			return list.ToArray();
		}

		public static List<ulong> Get()
		{
			return Whitelisted;
		}
	}
}
namespace Protector.Commands
{
	public static class ProtectorCommands
	{
		[CommandGroup("Protector", null)]
		internal class Protector
		{
			[Command("list", "l", null, "Returns the list of current whitelisted clients.", null, true)]
			public static void List(ChatCommandContext ctx)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Whitelisted SteamIDs:");
				bool flag = true;
				foreach (ulong item in Core.gKs.getWhitelisted())
				{
					flag = false;
					stringBuilder.AppendLine(item.ToString() ?? "");
				}
				if (flag)
				{
					stringBuilder.AppendLine("No ids whitelisted");
				}
				ctx.Reply(stringBuilder.ToString());
			}

			[Command("reload", "r", null, "Forces the reload of the whitelist file.", null, true)]
			public static void Reload(ChatCommandContext ctx)
			{
				Core.gKs.MarkForReload();
				ctx.Reply("List marked for reload");
			}
		}
	}
}