using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Content.Server.Administration;
using Content.Server.Administration.Managers;
using Content.Server.Afk;
using Content.Server.Afk.Events;
using Content.Server.Database;
using Content.Server.Discord;
using Content.Server.GameTicking;
using Content.Server.Players.RateLimiting;
using Content.Server.Preferences.Managers;
using Content.Shared._DV.CCVars;
using Content.Shared._DV.Curation;
using Content.Shared.Administration;
using Content.Shared.CCVar;
using Content.Shared.Database;
using Content.Shared.GameTicking;
using Content.Shared.Mind;
using Content.Shared.Players.RateLimiting;
using Robust.Server.Player;
using Robust.Shared;
using Robust.Shared.Configuration;
using Robust.Shared.Enums;
using Robust.Shared.Network;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using Robust.Shared.Utility;

namespace Content.Server._DV.Curation.Systems;

public sealed partial class CwoinkSystem : SharedCwoinkSystem
{
    private const string RateLimitKey = "CuratorHelp";

    [Dependency] private readonly IPlayerManager _playerManager = default!;
    [Dependency] private readonly IAdminManager _adminManager = default!;
    [Dependency] private readonly IBanManager _banManager = default!; // Starlight
    [Dependency] private readonly IConfigurationManager _config = default!;
    [Dependency] private readonly IGameTiming _timing = default!;
    [Dependency] private readonly IPlayerLocator _playerLocator = default!;
    [Dependency] private readonly GameTicker _gameTicker = default!;
    [Dependency] private readonly SharedMindSystem _minds = default!;
    [Dependency] private readonly IAfkManager _afkManager = default!;
    [Dependency] private readonly IServerDbManager _dbManager = default!;
    [Dependency] private readonly PlayerRateLimitManager _rateLimit = default!;
    [Dependency] private readonly IServerPreferencesManager _preferencesManager = default!; // Frontier

    [GeneratedRegex(@"^https://(?:(?:canary|ptb)\.)?discord\.com/api/webhooks/(\d+)/((?!.*/).*)$")] // Frontier: support alt discords
    private static partial Regex DiscordRegex();

    private string _webhookUrl = string.Empty;
    private WebhookData? _webhookData;

    private readonly HttpClient _httpClient = new();

    private string _footerIconUrl = string.Empty;
    private string _avatarUrl = string.Empty;
    private string _serverName = string.Empty;

    private readonly Dictionary<NetUserId, DiscordRelayInteraction> _relayMessages = [];

    private Dictionary<NetUserId, string> _oldMessageIds = [];
    private readonly Dictionary<NetUserId, Queue<DiscordRelayedData>> _messageQueues = [];
    private readonly HashSet<NetUserId> _processingChannels = [];
    private readonly Dictionary<NetUserId, (TimeSpan Timestamp, bool Typing)> _typingUpdateTimestamps = [];
    private string _overrideClientName = string.Empty;

    // Max embed description length is 4096, according to https://discord.com/developers/docs/resources/channel#embed-object-embed-limits
    // Keep small margin, just to be safe
    private const ushort DescriptionMax = 4000;

    // Maximum length a message can be before it is cut off
    // Should be shorter than DescriptionMax
    private const ushort MessageLengthCap = 3000;

    private readonly TimeSpan _messageCooldown = TimeSpan.FromSeconds(2);

    private readonly Queue<(NetUserId Channel, string Text, TimeSpan Timestamp)> _recentMessages = new();
    private const int MaxRecentMessages = 10;

    // Text to be used to cut off messages that are too long. Should be shorter than MessageLengthCap
    private const string TooLongText = "... **(too long)**";

    private int _maxAdditionalChars;
    private readonly Dictionary<NetUserId, DateTime> _activeConversations = [];

    // CHelp config settings
    private bool _useAdminOOCColorInBwoinks = true;
    private bool _useDiscordRoleColor = false;
    private bool _useDiscordRoleName = false;
    private string _discordReplyPrefix = "(DISCORD) ";
    private string _adminBwoinkColor = "#9552cc";
    private string _discordReplyColor = string.Empty;

    // CHelp admin cache
    private readonly HashSet<INetChannel> _activeCurators = [];
    private readonly HashSet<INetChannel> _nonAfkCurators = [];

    public override void Initialize()
    {
        base.Initialize();

        Subs.CVar(_config, CVars.GameHostName, OnServerNameChanged, true);

        Subs.CVar(_config, DCCVars.DiscordCHelpWebhook, OnWebhookChanged, true);
        Subs.CVar(_config, DCCVars.DiscordCHelpFooterIcon, OnFooterIconChanged, true);
        Subs.CVar(_config, DCCVars.DiscordCHelpAvatar, OnAvatarChanged, true);

        Subs.CVar(_config, DCCVars.CuratorChelpOverrideClientName, OnOverrideChanged, true);
        Subs.CVar(_config, DCCVars.UseAdminOOCColorInCwoinks, OnUseAdminOOCColorInBwoinksChanged, true);
        Subs.CVar(_config, DCCVars.UseDiscordRoleColorInCwoinks, OnUseDiscordRoleColorChanged, true);
        Subs.CVar(_config, DCCVars.UseDiscordRoleNameInCwoinks, OnUseDiscordRoleNameChanged, true);
        Subs.CVar(_config, DCCVars.DiscordCwoinkReplyPrefix, OnDiscordReplyPrefixChanged, true);
        Subs.CVar(_config, DCCVars.CuratorCwoinkColor, OnAdminBwoinkColorChanged, true);
        Subs.CVar(_config, DCCVars.DiscordCwoinkReplyColor, OnDiscordReplyColorChanged, true);

        var defaultParams = new CHelpMessageParams(
            string.Empty,
            string.Empty,
            true,
            _gameTicker.RoundDuration().ToString("hh\\:mm\\:ss"),
            _gameTicker.RunLevel,
            playedSound: false
        );
        _maxAdditionalChars = GenerateAHelpMessage(defaultParams, _discordReplyPrefix).Message.Length;
        _playerManager.PlayerStatusChanged += OnPlayerStatusChanged;

        SubscribeLocalEvent<GameRunLevelChangedEvent>(OnGameRunLevelChanged);
        SubscribeNetworkEvent<CwoinkClientTypingUpdated>(OnClientTypingUpdated);
        SubscribeLocalEvent<RoundRestartCleanupEvent>(_ => _activeConversations.Clear());
        SubscribeLocalEvent<AFKEvent>(OnAFK);
        SubscribeLocalEvent<UnAFKEvent>(OnUnAFK);

        _adminManager.OnPermsChanged += OnAdminPermsChanged;

        _rateLimit.Register(
            RateLimitKey,
            new RateLimitRegistration(CCVars.AhelpRateLimitPeriod,
                CCVars.AhelpRateLimitCount,
                PlayerRateLimitedAction)
        );

        ResetCache();
    }

    private void ResetCache()
    {
        _activeCurators.Clear();
        _nonAfkCurators.Clear();

        foreach (var admin in _adminManager.ActiveAdmins)
        {
            if (!(_adminManager.GetAdminData(admin)?.HasFlag(AdminFlags.CuratorHelp) ?? false))
                continue;

            _activeCurators.Add(admin.Channel);

            if (_afkManager.IsAfk(admin))
                continue;

            _nonAfkCurators.Add(admin.Channel);
        }
    }

    private void OnAFK(ref AFKEvent ev)
    {
        _nonAfkCurators.Remove(ev.Session.Channel);
    }

    private void OnUnAFK(ref UnAFKEvent ev)
    {
        if (_activeCurators.Contains(ev.Session.Channel))
            _nonAfkCurators.Add(ev.Session.Channel);
    }

    private void OnAdminPermsChanged(AdminPermsChangedEventArgs args)
    {
        if (((args.Flags ?? 0) & AdminFlags.CuratorHelp) != 0)
            _activeCurators.Add(args.Player.Channel);
        else
        {
            _activeCurators.Remove(args.Player.Channel);
            _nonAfkCurators.Remove(args.Player.Channel);
        }
    }

    private void OnDiscordReplyColorChanged(string newValue)
    {
        _discordReplyColor = newValue;
    }

    private void OnAdminBwoinkColorChanged(string newValue)
    {
        _adminBwoinkColor = newValue;
    }

    private void OnDiscordReplyPrefixChanged(string newValue)
    {
        var defaultParams = new CHelpMessageParams(
            string.Empty,
            string.Empty,
            true,
            _gameTicker.RoundDuration().ToString("hh\\:mm\\:ss"),
            _gameTicker.RunLevel,
            playedSound: false
        );

        _discordReplyPrefix = newValue;
        _maxAdditionalChars = GenerateAHelpMessage(defaultParams, _discordReplyPrefix).Message.Length;
    }

    private void OnUseDiscordRoleNameChanged(bool newValue)
    {
        _useDiscordRoleName = newValue;
    }

    private void OnUseDiscordRoleColorChanged(bool newValue)
    {
        _useDiscordRoleColor = newValue;
    }

    private void OnUseAdminOOCColorInBwoinksChanged(bool newValue)
    {
        _useAdminOOCColorInBwoinks = newValue;
    }

    private void PlayerRateLimitedAction(ICommonSession obj)
    {
        RaiseNetworkEvent(
            new CwoinkTextMessage(obj.UserId, default, Loc.GetString("bwoink-system-rate-limited"), playSound: false),
            obj.Channel);
    }

    private void OnOverrideChanged(string obj)
    {
        _overrideClientName = obj;
    }

    private async void OnPlayerStatusChanged(object? sender, SessionStatusEventArgs e)
    {
        if (e.NewStatus == SessionStatus.Disconnected)
        {
            if (_activeConversations.TryGetValue(e.Session.UserId, out var lastMessageTime))
            {
                var timeSinceLastMessage = DateTime.Now - lastMessageTime;
                if (timeSinceLastMessage > TimeSpan.FromMinutes(5))
                {
                    _activeConversations.Remove(e.Session.UserId);
                    return; // Do not send disconnect message if timeout exceeded
                }
            }

            // Check if the user has been banned
            var ban = await _dbManager.GetServerBanAsync(null, e.Session.UserId, null, null);
            if (ban != null)
            {
                _activeConversations.Remove(e.Session.UserId);
                return;
            }
        }

        // Notify all admins if a player disconnects or reconnects
        var message = e.NewStatus switch
        {
            SessionStatus.Connected => Loc.GetString("bwoink-system-player-reconnecting"),
            SessionStatus.Disconnected => Loc.GetString("bwoink-system-player-disconnecting"),
            _ => null
        };

        if (message != null)
        {
            var statusType = e.NewStatus == SessionStatus.Connected
                ? PlayerStatusType.Connected
                : PlayerStatusType.Disconnected;
            NotifyAdmins(e.Session, message, statusType);
        }

        if (e.NewStatus != SessionStatus.InGame)
            return;

        RaiseNetworkEvent(new CwoinkDiscordRelayUpdated(!string.IsNullOrWhiteSpace(_webhookUrl)), e.Session);
    }

    private void NotifyAdmins(ICommonSession session, string message, PlayerStatusType statusType)
    {
        if (!_activeConversations.ContainsKey(session.UserId))
        {
            // If the user is not part of an active conversation, do not notify admins.
            return;
        }

        // Get the current timestamp
        var timestamp = DateTime.Now.ToString("HH:mm:ss");
        var roundTime = _gameTicker.RoundDuration().ToString("hh\\:mm\\:ss");

        // Determine the icon based on the status type
        var icon = statusType switch
        {
            PlayerStatusType.Connected => ":green_circle:",
            PlayerStatusType.Disconnected => ":red_circle:",
            PlayerStatusType.Banned => ":red_circle:",
            _ => ":question:"
        };

        // Create the message parameters for Discord
        var messageParams = new CHelpMessageParams(
            session.Name,
            message,
            true,
            roundTime,
            _gameTicker.RunLevel,
            playedSound: true,
            icon: icon
        );

        // Create the message for in-game with username
        var color = statusType switch
        {
            PlayerStatusType.Connected => Color.Green.ToHex(),
            PlayerStatusType.Disconnected => Color.Yellow.ToHex(),
            PlayerStatusType.Banned => Color.Yellow.ToHex(),
            _ => Color.Gray.ToHex(),
        };
        var inGameMessage = $"[color={color}]{session.Name} {message}[/color]";

        var cwoinkMessage = new CwoinkTextMessage(
            userId: session.UserId,
            trueSender: SystemUserId,
            text: inGameMessage,
            sentAt: DateTime.Now,
            playSound: false
        );

        var admins = _activeCurators;
        foreach (var admin in admins)
        {
            RaiseNetworkEvent(cwoinkMessage, admin);
        }

        // Enqueue the message for Discord relay
        if (_webhookUrl != string.Empty)
        {
            var queue = _messageQueues.GetOrNew(session.UserId);
            var escapedText = FormattedMessage.EscapeText(message);
            messageParams.Message = escapedText;
            var discordMessage = GenerateAHelpMessage(messageParams, _discordReplyPrefix);
            queue.Enqueue(discordMessage);
        }
    }

    private void OnGameRunLevelChanged(GameRunLevelChangedEvent args)
    {
        // Don't make a new embed if we
        // 1. were in the lobby just now, and
        // 2. are not entering the lobby or directly into a new round.
        if (args.Old is GameRunLevel.PreRoundLobby ||
            args.New is not (GameRunLevel.PreRoundLobby or GameRunLevel.InRound))
        {
            return;
        }

        // Store the Discord message IDs of the previous round
        _oldMessageIds.Clear();
        foreach (var (user, interaction) in _relayMessages)
        {
            var id = interaction.Id;
            if (id == null)
                return;

            _oldMessageIds[user] = id;
        }

        _relayMessages.Clear();
    }

    private void OnClientTypingUpdated(CwoinkClientTypingUpdated msg, EntitySessionEventArgs args)
    {
        if (_typingUpdateTimestamps.TryGetValue(args.SenderSession.UserId, out var tuple) &&
            tuple.Typing == msg.Typing &&
            _timing.RealTime - tuple.Timestamp < TimeSpan.FromSeconds(1))
        {
            return;
        }

        _typingUpdateTimestamps[args.SenderSession.UserId] = (_timing.RealTime, msg.Typing);

        // Non-admins can only ever type on their own ahelp, guard against fake messages
        var isAdmin = _adminManager.GetAdminData(args.SenderSession)?.HasFlag(AdminFlags.CuratorHelp) ?? false;
        var channel = isAdmin ? msg.Channel : args.SenderSession.UserId;
        var update = new CwoinkPlayerTypingUpdated(channel, args.SenderSession.Name, msg.Typing);

        foreach (var admin in _activeCurators)
        {
            if (admin.UserId == args.SenderSession.UserId)
                continue;

            RaiseNetworkEvent(update, admin);
        }
    }

    private void OnServerNameChanged(string obj)
    {
        _serverName = obj;
    }

    private async void OnWebhookChanged(string url)
    {
        _webhookUrl = url;

        RaiseNetworkEvent(new CwoinkDiscordRelayUpdated(!string.IsNullOrWhiteSpace(url)));

        if (url == string.Empty)
            return;

        // Basic sanity check and capturing webhook ID and token
        var match = DiscordRegex().Match(url);

        if (!match.Success)
        {
            // TODO: Ideally, CVar validation during setting should be better integrated
            Log.Warning("Webhook URL does not appear to be valid. Using anyways...");
            await GetWebhookData(url); // Frontier - Support for Custom URLS, we still want to see if theres Webhook data available
            return;
        }

        if (match.Groups.Count <= 2)
        {
            Log.Error("Could not get webhook ID or token.");
            return;
        }

        // Fire and forget
        await GetWebhookData(url); // Frontier - Support for Custom URLS
    }

    private async Task<WebhookData?> GetWebhookData(string url) // Frontier - Support for Custom URLS
    {
        var response = await _httpClient.GetAsync(url); // Frontier

        var content = await response.Content.ReadAsStringAsync();
        if (!response.IsSuccessStatusCode)
        {
            Log.Error(
                $"Discord returned bad status code when trying to get webhook data (perhaps the webhook URL is invalid?): {response.StatusCode}\nResponse: {content}");
            return null;
        }

        return JsonSerializer.Deserialize<WebhookData>(content);
    }

    private void OnFooterIconChanged(string url)
    {
        _footerIconUrl = url;
    }

    private void OnAvatarChanged(string url)
    {
        _avatarUrl = url;
    }

    private async void ProcessQueue(NetUserId userId, Queue<DiscordRelayedData> messages)
    {
        // Whether an embed already exists for this player
        var exists = _relayMessages.TryGetValue(userId, out var existingEmbed);

        // Whether the message will become too long after adding these new messages
        var tooLong = exists && messages.Sum(msg => Math.Min(msg.Message.Length, MessageLengthCap) + "\n".Length)
            + existingEmbed?.Description.Length > DescriptionMax;

        // If there is no existing embed, or it is getting too long, we create a new embed
        if (!exists || tooLong)
        {
            var lookup = await _playerLocator.LookupIdAsync(userId);

            if (lookup == null)
            {
                Log.Error(
                    $"Unable to find player for NetUserId {userId} when sending discord webhook.");
                _relayMessages.Remove(userId);
                return;
            }

            var linkToPrevious = string.Empty;

            // If we have all the data required, we can link to the embed of the previous round or embed that was too long
            if (_webhookData is { GuildId: { } guildId, ChannelId: { } channelId })
            {
                if (tooLong && existingEmbed?.Id != null)
                {
                    linkToPrevious =
                        $"**[Go to previous embed of this round](https://discord.com/channels/{guildId}/{channelId}/{existingEmbed.Id})**\n";
                }
                else if (_oldMessageIds.TryGetValue(userId, out var id) && !string.IsNullOrEmpty(id))
                {
                    linkToPrevious =
                        $"**[Go to last round's conversation with this player](https://discord.com/channels/{guildId}/{channelId}/{id})**\n";
                }
            }

            var characterName = _minds.GetCharacterName(userId);
            existingEmbed = new DiscordRelayInteraction()
            {
                Id = null,
                CharacterName = characterName,
                Description = linkToPrevious,
                Username = lookup.Username,
                LastRunLevel = _gameTicker.RunLevel,
            };

            _relayMessages[userId] = existingEmbed;
        }

        // Previous message was in another RunLevel, so show that in the embed
        if (existingEmbed!.LastRunLevel != _gameTicker.RunLevel)
        {
            existingEmbed.Description += _gameTicker.RunLevel switch
            {
                GameRunLevel.PreRoundLobby => "\n\n:arrow_forward: _**Pre-round lobby started**_\n",
                GameRunLevel.InRound => "\n\n:arrow_forward: _**Round started**_\n",
                GameRunLevel.PostRound => "\n\n:stop_button: _**Post-round started**_\n",
                _ => throw new ArgumentOutOfRangeException(nameof(_gameTicker.RunLevel),
                    $"{_gameTicker.RunLevel} was not matched."),
            };

            existingEmbed.LastRunLevel = _gameTicker.RunLevel;
        }

        // Add available messages to the embed description
        while (messages.TryDequeue(out var message))
        {
            string text;

            // In case someone thinks they're funny
            if (message.Message.Length > MessageLengthCap)
                text = message.Message[..(MessageLengthCap - TooLongText.Length)] + TooLongText;
            else
                text = message.Message;

            existingEmbed.Description += $"\n{text}";
        }

        var payload = GeneratePayload(existingEmbed.Description,
            existingEmbed.Username,
            userId.UserId, // Frontier, this is used to identify the players in the webhook
            existingEmbed.CharacterName);

        // If there is no existing embed, create a new one
        // Otherwise patch (edit) it
        if (existingEmbed.Id == null)
        {
            var request = await _httpClient.PostAsync($"{_webhookUrl}?wait=true",
                new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json"));

            var content = await request.Content.ReadAsStringAsync();
            if (!request.IsSuccessStatusCode)
            {
                Log.Error(
                    $"Discord returned bad status code when posting message (perhaps the message is too long?): {request.StatusCode}\nResponse: {content}");
                _relayMessages.Remove(userId);
                return;
            }

            var id = JsonNode.Parse(content)?["id"];
            if (id == null)
            {
                Log.Error(
                    $"Could not find id in json-content returned from discord webhook: {content}");
                _relayMessages.Remove(userId);
                return;
            }

            existingEmbed.Id = id.ToString();
        }
        else
        {
            var request = await _httpClient.PatchAsync($"{_webhookUrl}/messages/{existingEmbed.Id}",
                new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json"));

            if (!request.IsSuccessStatusCode)
            {
                var content = await request.Content.ReadAsStringAsync();
                Log.Error(
                    $"Discord returned bad status code when patching message (perhaps the message is too long?): {request.StatusCode}\nResponse: {content}");
                _relayMessages.Remove(userId);
                return;
            }
        }

        _relayMessages[userId] = existingEmbed;

        _processingChannels.Remove(userId);
    }

    private WebhookPayload GeneratePayload(string messages, string username, Guid userId, string? characterName = null) // Frontier: added Guid
    {
        // Add character name
        if (characterName != null)
            username += $" ({characterName})";

        // If no admins are online, set embed color to red. Otherwise green
        var color = _nonAfkCurators.Count > 0 ? 0x41F097 : 0xFF0000;

        // Limit server name to 1500 characters, in case someone tries to be a little funny
        var serverName = _serverName[..Math.Min(_serverName.Length, 1500)];

        var round = _gameTicker.RunLevel switch
        {
            GameRunLevel.PreRoundLobby => _gameTicker.RoundId == 0
                ? "pre-round lobby after server restart" // first round after server restart has ID == 0
                : $"pre-round lobby for round {_gameTicker.RoundId + 1}",
            GameRunLevel.InRound => $"round {_gameTicker.RoundId}",
            GameRunLevel.PostRound => $"post-round {_gameTicker.RoundId}",
            _ => throw new ArgumentOutOfRangeException(nameof(_gameTicker.RunLevel),
                $"{_gameTicker.RunLevel} was not matched."),
        };

        return new WebhookPayload
        {
            Username = username,
            UserID = userId, // Frontier, this is used to identify the players in the webhook
            AvatarUrl = string.IsNullOrWhiteSpace(_avatarUrl) ? null : _avatarUrl,
            Embeds =
            [
                new()
                {
                    Description = messages,
                    Color = color,
                    Footer = new WebhookEmbedFooter
                    {
                        Text = $"{serverName} ({round})",
                        IconUrl = string.IsNullOrWhiteSpace(_footerIconUrl) ? null : _footerIconUrl
                    },
                }
            ]
        };
    }

    public override void Update(float frameTime)
    {
        base.Update(frameTime);

        foreach (var userId in _messageQueues.Keys.ToArray())
        {
            if (_processingChannels.Contains(userId))
                continue;

            var queue = _messageQueues[userId];
            _messageQueues.Remove(userId);
            if (queue.Count == 0)
                continue;

            _processingChannels.Add(userId);

            ProcessQueue(userId, queue);
        }
    }

    protected override void OnCwoinkTextMessage(CwoinkTextMessage message, EntitySessionEventArgs eventArgs)
    {
        base.OnCwoinkTextMessage(message, eventArgs);

        var senderSession = eventArgs.SenderSession;

        // TODO: Sanitize text?
        // Confirm that this person is actually allowed to send a message here.
        var personalChannel = senderSession.UserId == message.UserId;
        var senderAdmin = _adminManager.GetAdminData(senderSession);
        var senderAHelpAdmin = senderAdmin?.HasFlag(AdminFlags.CuratorHelp) ?? false;
        var authorized = personalChannel && !message.AdminOnly || senderAHelpAdmin;
        if (!authorized)
        {
            // Unauthorized cwoink (log?)
            return;
        }

        // Begin Starlight Changes
        var currentTime = _timing.RealTime;

        if (IsOnCooldown(message.UserId, currentTime))
            return;

        if (IsSpam(message.UserId, message.Text))
            _banManager.CreateServerBan(senderSession.UserId, senderSession.Name, null, null, null, 0, NoteSeverity.High, "Automatic AHELP Antispam system Ban, If this ban is wrong, file an appeal.");

        AddToRecentMessages(message.UserId, message.Text, currentTime);
        // End Starlight Changes

        if (_rateLimit.CountAction(eventArgs.SenderSession, RateLimitKey) != RateLimitStatus.Allowed)
            return;

        var cwoinkParams = new CwoinkParams(message,
            eventArgs.SenderSession.UserId,
            senderAdmin,
            eventArgs.SenderSession.Name,
            eventArgs.SenderSession.Channel,
            false,
            true,
            false);
        OnCwoinkInternal(cwoinkParams);
    }

    /// <summary>
    /// Sends a cwoink. Common to both internal messages (sent via the ahelp or admin interface) and webhook messages (sent through the webhook, e.g. via Discord)
    /// </summary>
    /// <param name="cwoinkParams">The parameters of the message being sent.</param>
    private void OnCwoinkInternal(CwoinkParams cwoinkParams)
    {
        var fromWebhook = cwoinkParams.FromWebhook;
        var message = cwoinkParams.Message;
        var roleColor = cwoinkParams.RoleColor;
        var roleName = cwoinkParams.RoleName;
        var senderAdmin = cwoinkParams.SenderAdmin;
        var senderChannel = cwoinkParams.SenderChannel;
        var senderId = cwoinkParams.SenderId;
        var senderName = cwoinkParams.SenderName;
        var userOnly = cwoinkParams.UserOnly;
        var sendWebhook = cwoinkParams.SendWebhook;

        _activeConversations[message.UserId] = DateTime.Now;

        var escapedText = FormattedMessage.EscapeText(message.Text);
        var adminColor = _adminBwoinkColor;
        var adminPrefix = "";
        var cwoinkText = $"{senderName}";

        //Getting an administrator position
        if (_config.GetCVar(CCVars.AhelpAdminPrefix))
        {
            if (senderAdmin is not null && senderAdmin.Title is not null)
                adminPrefix = $"[bold]\\[{senderAdmin.Title}\\][/bold] ";

            if (_useDiscordRoleName && roleName is not null)
                adminPrefix = $"[bold]\\[{roleName}\\][/bold] ";
        }

        if (!fromWebhook
            && _useAdminOOCColorInBwoinks
            && senderAdmin is not null)
        {
            var prefs = _preferencesManager.GetPreferences(senderId);
            adminColor = prefs.AdminOOCColor.ToHex();
        }

        // If role color is enabled and exists, use it, otherwise use the discord reply color
        if (_discordReplyColor != string.Empty && fromWebhook)
            adminColor = _discordReplyColor;

        if (_useDiscordRoleColor && roleColor is not null)
            adminColor = roleColor;

        if (senderAdmin is not null && (fromWebhook || senderAdmin.HasFlag(AdminFlags.CuratorHelp) || senderAdmin.HasFlag(AdminFlags.Adminhelp)))
        {
            cwoinkText = $"[color={adminColor}]{adminPrefix}{senderName}[/color]";
        }

        if (fromWebhook)
            cwoinkText = $"{_discordReplyPrefix}{cwoinkText}";

        cwoinkText = $"{(message.AdminOnly ? Loc.GetString("cwoink-message-curator-only") : !message.PlaySound ? Loc.GetString("cwoink-message-silent") : "")} {cwoinkText}: {escapedText}";

        // If it's not an admin / admin chooses to keep the sound and message is not an admin only message, then play it.
        var playSound = (senderAdmin == null || message.PlaySound) && !message.AdminOnly;
        var msg = new CwoinkTextMessage(message.UserId, senderId, cwoinkText, playSound: playSound, adminOnly: message.AdminOnly);

        LogCwoink(msg);

        var admins = _activeCurators;

        // Notify all admins
        if (!userOnly)
        {
            foreach (var channel in admins)
            {
                RaiseNetworkEvent(msg, channel);
            }
        }

        var adminPrefixWebhook = string.Empty;

        if (_config.GetCVar(CCVars.AhelpAdminPrefixWebhook) && senderAdmin is not null && senderAdmin.Title is not null)
        {
            adminPrefixWebhook = $"[bold]\\[{senderAdmin.Title}\\][/bold] ";
        }

        // Notify player
        if (_playerManager.TryGetSessionById(message.UserId, out var session) && !message.AdminOnly)
        {
            if (!admins.Contains(session.Channel))
            {
                // If _overrideClientName is set, we generate a new message with the override name. The admins name will still be the original name for the webhooks.
                if (_overrideClientName != string.Empty)
                {
                    string overrideMsgText;

                    if (senderAdmin is not null && senderAdmin.HasFlag(AdminFlags.CuratorHelp))
                        overrideMsgText = $"[color={_adminBwoinkColor}]{adminPrefixWebhook}{_overrideClientName}[/color]";
                    else
                        overrideMsgText = $"{senderName}"; // Not an admin, name is not overridden.

                    if (fromWebhook)
                        overrideMsgText = $"{_discordReplyPrefix}{overrideMsgText}";

                    overrideMsgText = $"{(message.PlaySound ? "" : "(S) ")}{overrideMsgText}: {escapedText}";

                    RaiseNetworkEvent(new CwoinkTextMessage(message.UserId,
                            senderId,
                            overrideMsgText,
                            playSound: playSound),
                        session.Channel);
                }
                else
                    RaiseNetworkEvent(msg, session.Channel);
            }
        }

        var sendsWebhook = _webhookUrl != string.Empty;
        if (sendsWebhook && sendWebhook)
        {
            if (!_messageQueues.ContainsKey(msg.UserId))
                _messageQueues[msg.UserId] = new Queue<DiscordRelayedData>();

            var str = message.Text;
            var unameLength = senderName.Length;

            if (unameLength + str.Length + _maxAdditionalChars > DescriptionMax)
            {
                str = str[..(DescriptionMax - _maxAdditionalChars - unameLength)];
            }

            var nonAfkAdmins = _nonAfkCurators;
            var messageParams = new CHelpMessageParams(
                senderName,
                str,
                senderId != message.UserId,
                _gameTicker.RoundDuration().ToString("hh\\:mm\\:ss"),
                _gameTicker.RunLevel,
                playedSound: playSound,
                isDiscord: fromWebhook, // DeltaV
                curatorOnly: message.AdminOnly,
                noReceivers: nonAfkAdmins.Count == 0
            );
            _messageQueues[msg.UserId].Enqueue(GenerateAHelpMessage(messageParams, _discordReplyPrefix));
        }

        if (admins.Count != 0 || sendsWebhook)
            return;

        // No admin online, let the player know
        if (senderChannel != null)
        {
            var systemText = Loc.GetString("cwoink-system-starmute-message-no-other-users");
            var starMuteMsg = new CwoinkTextMessage(message.UserId, SystemUserId, systemText);
            RaiseNetworkEvent(starMuteMsg, senderChannel);
        }
    }

    private DiscordRelayedData GenerateAHelpMessage(CHelpMessageParams parameters, string? discordReplyPrefix = "(DISCORD)") // DeltaV - added reply prefix
    {
        var stringbuilder = new StringBuilder();

        if (parameters.Icon != null)
            stringbuilder.Append(parameters.Icon);
        else if (parameters.IsCurator)
            stringbuilder.Append(":outbox_tray:");
        else if (parameters.NoReceivers)
            stringbuilder.Append(":sleeping:");
        else
            stringbuilder.Append(":inbox_tray:");

        if (parameters.RoundTime != string.Empty && parameters.RoundState == GameRunLevel.InRound)
            stringbuilder.Append($" **{parameters.RoundTime}**");
        if (!parameters.PlayedSound)
            stringbuilder.Append($" **{(parameters.CuratorOnly ? Loc.GetString("cwoink-message-admin-only") : Loc.GetString("cwoink-message-silent"))}**");

        if (parameters.IsDiscord) // Frontier - Discord Indicator
            stringbuilder.Append($" **{discordReplyPrefix}**");

        if (parameters.Icon == null)
            stringbuilder.Append($" **{parameters.Username}:** ");
        else
            stringbuilder.Append($" **{parameters.Username}** ");
        stringbuilder.Append(parameters.Message);

        return new DiscordRelayedData()
        {
            Receivers = !parameters.NoReceivers,
            Message = stringbuilder.ToString(),
        };
    }

    private record struct DiscordRelayedData
    {
        /// <summary>
        /// Was anyone online to receive it.
        /// </summary>
        public bool Receivers;

        /// <summary>
        /// What's the payload to send to discord.
        /// </summary>
        public string Message;
    }

    /// <summary>
    ///  Class specifically for holding information regarding existing Discord embeds
    /// </summary>
    private sealed class DiscordRelayInteraction
    {
        public string? Id;

        public string Username = string.Empty;

        public string? CharacterName;

        /// <summary>
        /// Contents for the discord message.
        /// </summary>
        public string Description = string.Empty;

        /// <summary>
        /// Run level of the last interaction. If different we'll link to the last Id.
        /// </summary>
        public GameRunLevel LastRunLevel;
    }

    private void AddToRecentMessages(NetUserId channelId, string text, TimeSpan timestamp)
    {
        _recentMessages.Enqueue((channelId, text, timestamp));

        if (_recentMessages.Count > MaxRecentMessages)
        {
            _recentMessages.Dequeue();
        }
    }

    private bool IsOnCooldown(NetUserId channelId, TimeSpan currentTime)
    {
        var lastMessage = _recentMessages
            .Where(msg => msg.Channel == channelId)
            .OrderByDescending(msg => msg.Timestamp)
            .FirstOrDefault();

        return lastMessage != default && (currentTime - lastMessage.Timestamp) < _messageCooldown;
    }

    private bool IsSpam(NetUserId channelId, string text)
    {
        var recentMessages = _recentMessages
            .Where(msg => msg.Channel == channelId)
            .OrderByDescending(msg => msg.Timestamp)
            .Take(10);

        return recentMessages.All(msg => msg.Text == text) && recentMessages.Count() >= 5;
    }

    public IEnumerable<(NetUserId Channel, string Text, TimeSpan Timestamp)> GetRecentMessages()
    {
        return _recentMessages;
    }
}

public struct CHelpMessageParams(
    string username,
    string message,
    bool isCurator,
    string roundTime,
    GameRunLevel roundState,
    bool playedSound,
    bool isDiscord = false,
    bool curatorOnly = false,
    bool noReceivers = false,
    string? icon = null)
{
    public string Username { get; set; } = username;
    public string Message { get; set; } = message;
    public bool IsCurator { get; set; } = isCurator;
    public string RoundTime { get; set; } = roundTime;
    public GameRunLevel RoundState { get; set; } = roundState;
    public bool PlayedSound { get; set; } = playedSound;
    public readonly bool CuratorOnly = curatorOnly;
    public bool NoReceivers { get; set; } = noReceivers;
    public bool IsDiscord { get; set; } = isDiscord;
    public string? Icon { get; set; } = icon;
}

public enum PlayerStatusType
{
    Connected,
    Disconnected,
    Banned,
}