using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BetterModeration;
using HarmonyLib;
using LabFusion.Marrow.Proxies;
using LabFusion.Menu;
using LabFusion.Network;
using LabFusion.Player;
using LabFusion.Senders;
using LabFusion.UI.Popups;
using LabFusion.Utilities;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Main), "Better Moderation", "1.0.0", "armyk_r3lv", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("BetterModeration")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BetterModeration")]
[assembly: AssemblyTitle("BetterModeration")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 BetterModeration
{
	internal sealed class TimedBan
	{
		public ulong PlatformId { get; set; }

		public string LastKnownName { get; set; } = "Unknown";

		public string Reason { get; set; } = "Host moderation";

		public DateTime CreatedUtc { get; set; }

		public DateTime ExpiresUtc { get; set; }
	}
	internal static class BanStore
	{
		private static readonly object Sync = new object();

		private static readonly string DirectoryPath = Path.Combine(MelonEnvironment.UserDataDirectory, "BetterModeration");

		private static readonly string FilePath = Path.Combine(DirectoryPath, "timed-bans.json");

		private static List<TimedBan> _bans = new List<TimedBan>();

		internal static IReadOnlyList<TimedBan> Active
		{
			get
			{
				lock (Sync)
				{
					PurgeExpired(save: true);
					return _bans.ToArray();
				}
			}
		}

		internal static void Load()
		{
			lock (Sync)
			{
				Directory.CreateDirectory(DirectoryPath);
				try
				{
					_bans = (File.Exists(FilePath) ? (JsonConvert.DeserializeObject<List<TimedBan>>(File.ReadAllText(FilePath)) ?? new List<TimedBan>()) : new List<TimedBan>());
				}
				catch (Exception ex)
				{
					MelonLogger.Error("Better Moderation could not read its ban file: " + ex.Message);
					_bans = new List<TimedBan>();
				}
				PurgeExpired(save: true);
			}
		}

		internal static bool TryGet(ulong platformId, out TimedBan? ban)
		{
			lock (Sync)
			{
				PurgeExpired(save: true);
				ban = _bans.FirstOrDefault((TimedBan item) => item.PlatformId == platformId);
				return ban != null;
			}
		}

		internal static void Add(ulong platformId, string name, TimeSpan duration, string reason)
		{
			if (duration <= TimeSpan.Zero || duration > TimeSpan.FromDays(30.0))
			{
				throw new ArgumentOutOfRangeException("duration", "Timed bans must be between one minute and 30 days.");
			}
			lock (Sync)
			{
				DateTime utcNow = DateTime.UtcNow;
				_bans.RemoveAll((TimedBan item) => item.PlatformId == platformId);
				_bans.Add(new TimedBan
				{
					PlatformId = platformId,
					LastKnownName = (string.IsNullOrWhiteSpace(name) ? "Unknown" : name),
					Reason = (string.IsNullOrWhiteSpace(reason) ? "Host moderation" : reason),
					CreatedUtc = utcNow,
					ExpiresUtc = utcNow.Add(duration)
				});
				Save();
			}
		}

		internal static bool Remove(ulong platformId)
		{
			lock (Sync)
			{
				bool num = _bans.RemoveAll((TimedBan item) => item.PlatformId == platformId) != 0;
				if (num)
				{
					Save();
				}
				return num;
			}
		}

		private static void PurgeExpired(bool save)
		{
			int num = _bans.RemoveAll((TimedBan item) => item.ExpiresUtc <= DateTime.UtcNow);
			if (save && num != 0)
			{
				Save();
			}
		}

		private static void Save()
		{
			Directory.CreateDirectory(DirectoryPath);
			string text = FilePath + ".tmp";
			File.WriteAllText(text, JsonConvert.SerializeObject((object)_bans, (Formatting)1));
			File.Copy(text, FilePath, overwrite: true);
			File.Delete(text);
		}
	}
	internal sealed class Main : MelonMod
	{
		[HarmonyPatch(typeof(ConnectionRequestMessage), "OnHandleMessage")]
		[HarmonyPriority(800)]
		private static class ConnectionRequestGuard
		{
			private static bool Prefix(ReceivedMessage received)
			{
				if (!NetworkInfo.IsHost)
				{
					return true;
				}
				ConnectionRequestData val = ((ReceivedMessage)(ref received)).ReadData<ConnectionRequestData>();
				ulong? platformID = ((ReceivedMessage)(ref received)).PlatformID;
				if (!platformID.HasValue || !ModerationService.ShouldDeny(platformID.Value, val.BackupPlatformID, out string reason))
				{
					return true;
				}
				ConnectionSender.SendConnectionDeny(platformID.Value, reason);
				MelonLogger.Warning($"Rejected connection from authenticated platform ID {platformID.Value}: {reason}.");
				return false;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action<NetworkLayer> <0>__PatchNativeUiAfterFusionLogin;

			public static ServerEvent <1>__StartNewSession;
		}

		private static bool _nativeUiPatched;

		public override void OnInitializeMelon()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			BanStore.Load();
			NetworkLayer.OnLoggedInEvent += PatchNativeUiAfterFusionLogin;
			object obj = <>O.<1>__StartNewSession;
			if (obj == null)
			{
				ServerEvent val = ModerationService.StartNewSession;
				<>O.<1>__StartNewSession = val;
				obj = (object)val;
			}
			MultiplayerHooking.OnJoinedServer += (ServerEvent)obj;
			object obj2 = <>O.<1>__StartNewSession;
			if (obj2 == null)
			{
				ServerEvent val2 = ModerationService.StartNewSession;
				<>O.<1>__StartNewSession = val2;
				obj2 = (object)val2;
			}
			MultiplayerHooking.OnDisconnected += (ServerEvent)obj2;
			MelonLogger.Msg("Better Moderation initialized; waiting for Fusion login before extending its Actions menu.");
		}

		private static void PatchNativeUiAfterFusionLogin(NetworkLayer _)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			if (!_nativeUiPatched)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(MenuLocation), "ApplyPlayerToElement", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(NativeFusionMenu), "Postfix", (Type[])null, (Type[])null);
				if (methodInfo == null || methodInfo2 == null)
				{
					MelonLogger.Error("Better Moderation could not locate Fusion's player Actions UI methods.");
					return;
				}
				new Harmony("BetterModeration.NativeFusionUi").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_nativeUiPatched = true;
				MelonLogger.Msg("Better Moderation added to Fusion's native player Actions menu after login.");
			}
		}
	}
	internal static class ModerationService
	{
		private static readonly Dictionary<ulong, string> SessionBans = new Dictionary<ulong, string>();

		internal static IReadOnlyDictionary<ulong, string> ActiveSessionBans => new Dictionary<ulong, string>(SessionBans);

		internal static void StartNewSession()
		{
			SessionBans.Clear();
			MelonLogger.Msg("Better Moderation: session-ban list cleared for the new server session.");
		}

		internal static bool IsSessionBanned(ulong platformId)
		{
			return SessionBans.ContainsKey(platformId);
		}

		internal static void Kick(PlayerID player)
		{
			if (CanModerate(player))
			{
				NetworkHelper.KickUser(player);
				MelonLogger.Warning($"Kicked {SafeName(player)} ({player.PlatformID}).");
			}
		}

		internal static void SessionBan(PlayerID player)
		{
			if (CanModerate(player))
			{
				SessionBans[player.PlatformID] = SafeName(player);
				NetworkHelper.KickUser(player);
				MelonLogger.Warning($"Session-banned {SafeName(player)} ({player.PlatformID}).");
			}
		}

		internal static void TimedBan(PlayerID player, TimeSpan duration)
		{
			if (CanModerate(player))
			{
				BanStore.Add(player.PlatformID, SafeName(player), duration, "Host moderation");
				NetworkHelper.KickUser(player);
				MelonLogger.Warning($"Timed-banned {SafeName(player)} ({player.PlatformID}) until {DateTime.UtcNow.Add(duration):O}.");
			}
		}

		internal static bool ShouldDeny(ulong authenticatedPlatformId, ulong claimedPlatformId, out string reason)
		{
			if (authenticatedPlatformId == 0L || authenticatedPlatformId != claimedPlatformId)
			{
				reason = "Identity verification failed";
				return true;
			}
			if (SessionBans.ContainsKey(authenticatedPlatformId))
			{
				reason = "Banned for this server session";
				return true;
			}
			if (BanStore.TryGet(authenticatedPlatformId, out TimedBan ban))
			{
				reason = $"Banned until {ban.ExpiresUtc:u}";
				return true;
			}
			reason = string.Empty;
			return false;
		}

		internal static bool ClearActions(ulong platformId)
		{
			bool num = SessionBans.Remove(platformId);
			bool flag = BanStore.Remove(platformId);
			if (num || flag)
			{
				MelonLogger.Msg($"Cleared moderation actions for platform ID {platformId}.");
			}
			return num || flag;
		}

		internal static string SafeName(PlayerID player)
		{
			try
			{
				string value = player.Metadata.Nickname.GetValue();
				string value2 = player.Metadata.Username.GetValue();
				string text = ((string.IsNullOrWhiteSpace(value) || value == "?") ? value2 : value);
				return string.IsNullOrWhiteSpace(text) ? "Unknown" : text;
			}
			catch
			{
				return "Unknown";
			}
		}

		private static bool CanModerate(PlayerID player)
		{
			if (!NetworkInfo.IsHost || player == null || !player.IsValid || player.IsHost)
			{
				MelonLogger.Warning("Better Moderation action ignored: only the host can moderate a valid non-host player.");
				return false;
			}
			return true;
		}
	}
	internal static class NativeFusionMenu
	{
		internal static void Postfix(PlayerElement element, PlayerID player)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)element == (Object)null || player == null || !player.IsValid || player.IsMe)
			{
				return;
			}
			GroupElement val = ((GroupElement)((element.ActionsElement.Pages.Count > 0) ? element.ActionsElement.Pages[0] : element.ActionsElement.AddPage())).AddElement<GroupElement>(BuildHeading(player.PlatformID));
			if (!NetworkInfo.IsHost || player.IsHost)
			{
				MenuChaining.WithInteractability<ButtonElement>(MenuChaining.WithColor<ButtonElement>(val.AddElement<ButtonElement>("Available to the lobby host"), Color.yellow), false);
				return;
			}
			MenuChaining.Do(MenuChaining.WithColor<FunctionElement>(val.AddElement<FunctionElement>("Ban for this session"), Color.red), (Action)delegate
			{
				ModerationService.SessionBan(player);
			});
			int minutes = 0;
			int hours = 0;
			int days = 0;
			MenuChaining.WithValue(MenuChaining.WithIncrement(MenuChaining.WithLimits(val.AddElement<IntElement>("Minutes"), 0, 59), 1), 0).OnValueChanged = delegate(int value)
			{
				minutes = value;
			};
			MenuChaining.WithValue(MenuChaining.WithIncrement(MenuChaining.WithLimits(val.AddElement<IntElement>("Hours"), 0, 23), 1), 0).OnValueChanged = delegate(int value)
			{
				hours = value;
			};
			MenuChaining.WithValue(MenuChaining.WithIncrement(MenuChaining.WithLimits(val.AddElement<IntElement>("Days"), 0, 30), 1), 0).OnValueChanged = delegate(int value)
			{
				days = value;
			};
			MenuChaining.Do(MenuChaining.WithColor<FunctionElement>(val.AddElement<FunctionElement>("Apply timed ban"), Color.red), (Action)delegate
			{
				ApplyTimedBan(player, days, hours, minutes);
			});
			MenuChaining.Do(MenuChaining.WithColor<FunctionElement>(val.AddElement<FunctionElement>("Clear this player's moderation"), Color.green), (Action)delegate
			{
				bool flag = ModerationService.ClearActions(player.PlatformID);
				Notify(flag ? "Moderation cleared" : "Nothing to clear", flag ? "This player's session and timed bans were removed." : "This player has no BetterModeration bans.", (NotificationType)(flag ? 3 : 0));
			});
		}

		private static void ApplyTimedBan(PlayerID player, int days, int hours, int minutes)
		{
			TimeSpan timeSpan = TimeSpan.FromDays(days) + TimeSpan.FromHours(hours) + TimeSpan.FromMinutes(minutes);
			if (timeSpan <= TimeSpan.Zero || timeSpan > TimeSpan.FromDays(30.0))
			{
				Notify("Invalid ban duration", "Choose at least one minute and no more than 30 days.", (NotificationType)2);
				return;
			}
			ModerationService.TimedBan(player, timeSpan);
			Notify("Timed ban applied", $"{ModerationService.SafeName(player)} was banned until {DateTime.Now.Add(timeSpan):g}.", (NotificationType)3);
		}

		private static string BuildHeading(ulong id)
		{
			bool flag = ModerationService.IsSessionBanned(id);
			TimedBan ban;
			bool flag2 = BanStore.TryGet(id, out ban);
			if (flag && flag2)
			{
				return $"BetterModeration (Session + until {ban.ExpiresUtc.ToLocalTime():g})";
			}
			if (flag)
			{
				return "BetterModeration (Session banned)";
			}
			if (flag2)
			{
				return $"BetterModeration (Banned until {ban.ExpiresUtc.ToLocalTime():g})";
			}
			return "BetterModeration";
		}

		private static void Notify(string title, string message, NotificationType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			Notifier.Send(new Notification
			{
				Title = NotificationText.op_Implicit(title),
				Message = NotificationText.op_Implicit(message),
				Type = type,
				PopupLength = 3f,
				SaveToMenu = true,
				ShowPopup = true,
				Tag = "BetterModeration"
			});
		}
	}
}