using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Unity.IL2CPP;
using Clonesoft.Json;
using TheArchive;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.Localization;
using TheArchive.Features.Security;
using TheArchive.Interfaces;
using TheArchive.Loader;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Hikaria.GlobalBan")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e48bb37e985df0620d253c53956ecaeecfb9e67f")]
[assembly: AssemblyProduct("Hikaria.GlobalBan")]
[assembly: AssemblyTitle("Hikaria.GlobalBan")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Hikaria.GlobalBan.Features
{
	[EnableFeatureByDefault]
	[AutomatedFeature]
	[HideInModSettings]
	public class GlobalBan : Feature
	{
		public class GlobalBanListSettings
		{
			[JsonIgnore]
			private List<BannedPlayerEntry> __bannedPlayers = new List<BannedPlayerEntry>();

			[JsonIgnore]
			[FSDisplayName("封禁玩家")]
			public List<BannedPlayerEntry> BannedPlayers
			{
				get
				{
					int i;
					for (i = 0; i < _bannedPlayers.Count; i++)
					{
						if (!__bannedPlayers.Any((BannedPlayerEntry p) => p.SteamID == _bannedPlayers[i].SteamID64))
						{
							__bannedPlayers.Add(new BannedPlayerEntry(_bannedPlayers[i]));
						}
					}
					return __bannedPlayers;
				}
				set
				{
				}
			}
		}

		public class BannedPlayerEntry
		{
			[FSSeparator]
			[FSReadOnly(true)]
			[FSDisplayName("SteamID")]
			public ulong SteamID { get; set; }

			[FSReadOnly(true)]
			[FSDisplayName("封禁原因")]
			public string Reason { get; set; }

			public BannedPlayerEntry(BannedPlayer bannedPlayer)
			{
				SteamID = bannedPlayer.SteamID64;
				Reason = bannedPlayer.Reason;
			}
		}

		public struct BannedPlayer
		{
			public ulong SteamID64 { get; set; }

			public string Reason { get; set; }
		}

		private static List<BannedPlayer> _bannedPlayers = new List<BannedPlayer>();

		private const string API_BANLIST = "https://q1w2e3r4t5y6u7i8o9p0.top:50001/api/gtfo/bannedplayers";

		private static HttpClient _client;

		private static Task<List<BannedPlayer>> _task;

		public override string Name => "在线全局封禁名单";

		public override string Description => "支持在线更新的全局封禁名单";

		public override FeatureGroup Group => FeatureGroups.Security;

		[FeatureConfig]
		public static GlobalBanListSettings Settings { get; set; }

		public override void Init()
		{
			_client = new HttpClient();
			_client.DefaultRequestHeaders.Accept.Clear();
			_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
			_client.DefaultRequestHeaders.Add("User-Agent", "GTFO Global Ban List");
		}

		public override void OnEnable()
		{
			if (_task == null || _task.IsCompleted || _task.IsFaulted || _task.IsCanceled)
			{
				_task = Task.Run((Func<Task<List<BannedPlayer>>?>)GetBannedPlayers);
			}
		}

		public override void Update()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			if (_task == null || _task.IsCanceled || _task.IsFaulted)
			{
				InitSingletonBase<FeatureManager>.Instance.DisableFeature((Feature)(object)this, false);
			}
			else
			{
				if (!_task.IsCompleted)
				{
					return;
				}
				_bannedPlayers = _task.Result;
				for (int i = 0; i < _bannedPlayers.Count; i++)
				{
					BannedPlayer bannedPlayer = _bannedPlayers[i];
					if (!PlayerLobbyManagement.IsPlayerBanned(bannedPlayer.SteamID64))
					{
						PlayerLobbyManagement.Settings.BanList.Add(new BanListEntry
						{
							SteamID = bannedPlayer.SteamID64,
							Name = "From Global Ban",
							Timestamp = DateTime.UtcNow.Ticks
						});
					}
				}
				InitSingletonBase<FeatureManager>.Instance.DisableFeature((Feature)(object)this, false);
			}
		}

		private static async Task<List<BannedPlayer>> GetBannedPlayers()
		{
			return JsonConvert.DeserializeObject<List<BannedPlayer>>(await GetFromWebAPI("https://q1w2e3r4t5y6u7i8o9p0.top:50001/api/gtfo/bannedplayers"));
		}

		private static async Task<string> GetFromWebAPI(string url)
		{
			return await _client.GetStringAsync(url);
		}
	}
}
namespace Hikaria.GlobalBanList
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Hikaria.GlobalBan", "GlobalBan", "1.0.0")]
	public class EntryPoint : BasePlugin, IArchiveModule
	{
		public static EntryPoint Instance { get; private set; }

		public bool ApplyHarmonyPatches => false;

		public bool UsesLegacyPatches => false;

		public ArchiveLegacyPatcher Patcher { get; set; }

		public string ModuleGroup => FeatureGroup.op_Implicit(FeatureGroups.GetOrCreateModuleGroup("Global Ban", (Dictionary<Language, string>)null));

		public Dictionary<Language, string> ModuleGroupLanguages => new Dictionary<Language, string>
		{
			{
				(Language)1,
				"全局在线封禁列表"
			},
			{
				(Language)0,
				"Global Ban"
			}
		};

		public override void Load()
		{
			Instance = this;
			ArchiveMod.RegisterArchiveModule(typeof(EntryPoint));
			Logs.LogMessage("OK");
		}

		public void Init()
		{
		}

		public void OnExit()
		{
		}

		public void OnLateUpdate()
		{
		}

		public void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
		}
	}
	internal static class Logs
	{
		private static IArchiveLogger _logger;

		private static IArchiveLogger Logger => _logger ?? (_logger = LoaderWrapper.CreateLoggerInstance("Hikaria.GlobalBan", ConsoleColor.White));

		public static void LogDebug(object data)
		{
			Logger.Debug(data.ToString());
		}

		public static void LogError(object data)
		{
			Logger.Error(data.ToString());
		}

		public static void LogInfo(object data)
		{
			Logger.Info(data.ToString());
		}

		public static void LogMessage(object data)
		{
			Logger.Msg(ConsoleColor.White, data.ToString());
		}

		public static void LogWarning(object data)
		{
			Logger.Warning(data.ToString());
		}

		public static void LogNotice(object data)
		{
			Logger.Notice(data.ToString());
		}

		public static void LogSuccess(object data)
		{
			Logger.Success(data.ToString());
		}

		public static void LogException(Exception ex)
		{
			Logger.Exception(ex);
		}
	}
	public static class PluginInfo
	{
		public const string GUID = "Hikaria.GlobalBan";

		public const string NAME = "GlobalBan";

		public const string VERSION = "1.0.0";
	}
}