using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.Logging;
using BetterChat;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PersistentData;
using SteamworksNative;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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 PermissionGroups
{
	public static class Api
	{
		internal static Dictionary<string, PermissionGroup> permissionGroups = new Dictionary<string, PermissionGroup>();

		public static string DefaultPermissionGroupId;

		public static string HostPermissionGroupId;

		public static string PermissionGroupsPath => Path.Combine(Paths.ConfigPath, "lammas123.PermissionGroups");

		public static string[] GetPermissionGroupIds()
		{
			return permissionGroups.Keys.ToArray();
		}

		public static bool HasPermissionGroup(string permissionGroupId)
		{
			return permissionGroups.ContainsKey(permissionGroupId);
		}

		public static string GetPermissionGroupName(string permissionGroupId)
		{
			if (!HasPermissionGroup(permissionGroupId))
			{
				return permissionGroupId;
			}
			return permissionGroups[permissionGroupId].Name;
		}

		public static bool PermissionGroupHasPermission(string permissionGroupId, string permission)
		{
			if (HasPermissionGroup(permissionGroupId))
			{
				return permissionGroups[permissionGroupId].HasPermission(permission);
			}
			return false;
		}

		public static string GetClientPermissionGroup(ulong clientId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ClientDataFile clientDataFile = Api.GetClientDataFile(clientId);
			string text = ((ClientDataFile)(ref clientDataFile)).Get("PermissionGroup");
			if (text != null && HasPermissionGroup(text))
			{
				return text;
			}
			((ClientDataFile)(ref clientDataFile)).Set("PermissionGroup", DefaultPermissionGroupId);
			((ClientDataFile)(ref clientDataFile)).SaveFile();
			return DefaultPermissionGroupId;
		}

		public static bool SetClientPermissionGroup(ulong clientId, string permissionGroupId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!HasPermissionGroup(permissionGroupId))
			{
				return false;
			}
			ClientDataFile clientDataFile = Api.GetClientDataFile(clientId);
			((ClientDataFile)(ref clientDataFile)).Set("PermissionGroup", permissionGroupId);
			((ClientDataFile)(ref clientDataFile)).SaveFile();
			return true;
		}
	}
	public struct PermissionGroup
	{
		public string Id { get; internal set; }

		public string Name { get; internal set; }

		public string[] Permissions { get; internal set; }

		internal PermissionGroup(string id, string name, string[] permissions)
		{
			Id = id;
			Name = name;
			Permissions = permissions;
		}

		public readonly bool HasPermission(string permission)
		{
			if (Permissions.Length != 1 || !(Permissions[0] == "*"))
			{
				return Permissions.Contains(permission);
			}
			return true;
		}
	}
	internal static class BetterChatCompatibility
	{
		internal static bool? enabled;

		internal static bool Enabled
		{
			get
			{
				if (enabled.HasValue)
				{
					return enabled.Value;
				}
				bool? flag = (enabled = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("lammas123.BetterChat"));
				return flag.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool RegisterFormatting(string formatting, Func<ulong, string> func)
		{
			return Api.RegisterFormatting(formatting, func);
		}
	}
	internal static class Patches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "StartLobby")]
		[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "StartPracticeLobby")]
		[HarmonyPostfix]
		internal static void PostLobbyManagerStartLobby()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			ClientDataFile clientDataFile = Api.GetClientDataFile(SteamUser.GetSteamID().m_SteamID);
			((ClientDataFile)(ref clientDataFile)).Set("PermissionGroup", Api.HostPermissionGroupId);
			((ClientDataFile)(ref clientDataFile)).SaveFile();
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "OnPlayerJoinLeaveUpdate")]
		[HarmonyPostfix]
		internal static void PostLobbyManagerOnPlayerJoinLeaveUpdate(CSteamID param_1, bool param_2)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && param_2)
			{
				ClientDataFile clientDataFile = Api.GetClientDataFile(param_1.m_SteamID);
				string text = ((ClientDataFile)(ref clientDataFile)).Get("PermissionGroup");
				if (text == null || !Api.HasPermissionGroup(text))
				{
					((ClientDataFile)(ref clientDataFile)).Set("PermissionGroup", Api.DefaultPermissionGroupId);
					((ClientDataFile)(ref clientDataFile)).SaveFile();
				}
			}
		}
	}
	[BepInPlugin("lammas123.PermissionGroups", "PermissionGroups", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class PermissionGroups : BasePlugin
	{
		internal static PermissionGroups Instance;

		public override void Load()
		{
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Expected O, but got Unknown
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
			Instance = this;
			Api.DefaultPermissionGroupId = ((BasePlugin)this).Config.Bind<string>("Permission Groups", "Api.DefaultPermissionGroupId", "member", "The id of the default permission group.").Value.ToLower();
			if (Api.DefaultPermissionGroupId.Length == 0)
			{
				Api.DefaultPermissionGroupId = "member";
			}
			Api.HostPermissionGroupId = ((BasePlugin)this).Config.Bind<string>("Permission Groups", "Api.HostPermissionGroupId", "host", "The id of the host permission group.").Value.ToLower();
			if (Api.HostPermissionGroupId.Length == 0)
			{
				Api.HostPermissionGroupId = "host";
			}
			Directory.CreateDirectory(Api.PermissionGroupsPath);
			string[] files = Directory.GetFiles(Api.PermissionGroupsPath);
			foreach (string path in files)
			{
				string text = Path.GetFileNameWithoutExtension(Path.GetFileName(path)).Replace(' ', '_').ToLower();
				if (text.Length == 0 || Api.permissionGroups.ContainsKey(text))
				{
					continue;
				}
				string[] array = File.ReadAllLines(path);
				if (array.Length == 0 || array[0].Length == 0)
				{
					continue;
				}
				string name = array[0];
				List<string> list = new List<string>();
				string[] subArray = array[1..];
				foreach (string text2 in subArray)
				{
					if (text2.Length != 0 && !text2.StartsWith('#'))
					{
						list.Add(text2);
					}
				}
				Api.permissionGroups.Add(text, new PermissionGroup(text, name, list.ToArray()));
			}
			if (!Api.permissionGroups.ContainsKey(Api.DefaultPermissionGroupId))
			{
				string text3 = Api.DefaultPermissionGroupId[0].ToString().ToUpper();
				string defaultPermissionGroupId = Api.DefaultPermissionGroupId;
				string text4 = text3 + defaultPermissionGroupId.Substring(1, defaultPermissionGroupId.Length - 1);
				Api.permissionGroups.Add(Api.DefaultPermissionGroupId, new PermissionGroup(Api.DefaultPermissionGroupId, text4, Array.Empty<string>()));
				File.WriteAllLines(Path.Combine(Api.PermissionGroupsPath, Api.DefaultPermissionGroupId + ".txt"), new string[1] { text4 });
			}
			if (!Api.permissionGroups.ContainsKey(Api.HostPermissionGroupId))
			{
				string text5 = Api.HostPermissionGroupId[0].ToString().ToUpper();
				string defaultPermissionGroupId = Api.HostPermissionGroupId;
				string text6 = text5 + defaultPermissionGroupId.Substring(1, defaultPermissionGroupId.Length - 1);
				Api.permissionGroups.Add(Api.HostPermissionGroupId, new PermissionGroup(Api.HostPermissionGroupId, text6, new string[1] { "*" }));
				File.WriteAllLines(Path.Combine(Api.PermissionGroupsPath, Api.HostPermissionGroupId + ".txt"), new string[2] { text6, "*" });
			}
			if (BetterChatCompatibility.Enabled)
			{
				BetterChatCompatibility.RegisterFormatting("PERMISSION_GROUP", FormatPermissionGroup);
				BetterChatCompatibility.RegisterFormatting("PERMISSION_GROUP_ID", FormatPermissionGroupId);
			}
			new Harmony("PermissionGroups").PatchAll(typeof(Patches));
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initialized [");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("PermissionGroups");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.1.1");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("]");
			}
			log.LogInfo(val);
		}

		internal static string FormatPermissionGroup(ulong clientId)
		{
			return Api.GetPermissionGroupName(Api.GetClientPermissionGroup(clientId));
		}

		internal static string FormatPermissionGroupId(ulong clientId)
		{
			return Api.GetClientPermissionGroup(clientId);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "lammas123.PermissionGroups";

		public const string PLUGIN_NAME = "PermissionGroups";

		public const string PLUGIN_VERSION = "1.1.1";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}