using System.Collections.Frozen;
using System.Linq;
using System.Text.RegularExpressions;
using Content.Shared.ActionBlocker;
using Content.Shared.CCVar;
using Content.Shared.Chat.Prototypes;
using Content.Shared.Popups;
using Content.Shared.Radio;
using Content.Shared.Speech;
using Content.Shared.Whitelist;
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Console;
using Robust.Shared.Network;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Utility;

namespace Content.Shared.Chat;

public abstract partial class SharedChatSystem : EntitySystem
{
    public const char RadioCommonPrefix = ';';
    public const char RadioChannelPrefix = ':';
    public const char RadioChannelAltPrefix = '.';
    public const char LocalPrefix = '>';
    public const char ConsolePrefix = '/';
    public const char DeadPrefix = '\\';
    public const char LOOCPrefix = '(';
    public const char OOCPrefix = '[';
    public const char EmotesPrefix = '@';
    public const char EmotesAltPrefix = '*';
    public const char AdminPrefix = ']';
    public const char WhisperPrefix = ',';
    public const char DefaultChannelKey = 'h';

    public const int VoiceRange = 10; // how far voice goes in world units
    public const int WhisperClearRange = 2; // how far whisper goes while still being understandable, in world units
    public const int WhisperMuffledRange = 5; // how far whisper goes at all, in world units
    public static readonly SoundSpecifier DefaultAnnouncementSound
        = new SoundPathSpecifier("/Audio/Announcements/announce.ogg");

    public static readonly ProtoId<RadioChannelPrototype> CommonChannel = "Common";
    public bool ChatNameLinks { get; private set; }

    public static readonly string DefaultChannelPrefix = $"{RadioChannelPrefix}{DefaultChannelKey}";
    public static readonly ProtoId<SpeechVerbPrototype> DefaultSpeechVerb = "Default";

    [Dependency] protected IConfigurationManager Config = default!;
    [Dependency] private INetManager _net = default!;
    [Dependency] protected IRobustRandom Random = default!;
    [Dependency] private ISharedPlayerManager _player = default!;
    [Dependency] private ActionBlockerSystem _actionBlocker = default!;
    [Dependency] private EntityWhitelistSystem _whitelist = default!;
    [Dependency] private SharedAudioSystem _audio = default!;
    [Dependency] private SharedPopupSystem _popup = default!;

    /// <summary>
    /// Cache of the keycodes for faster lookup.
    /// </summary>
    private FrozenDictionary<char, RadioChannelPrototype> _keyCodes = default!;

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

        DebugTools.Assert(ProtoMan.HasIndex(CommonChannel));

        SubscribeLocalEvent<PrototypesReloadedEventArgs>(OnPrototypeReload);
        SubscribeAllEvent<ChatLinkClickedRequestEvent>(OnChatMessageLinkClicked);
        CacheRadios();
        CacheEmotes();

        Subs.CVar(Config, CCVars.ChatNameLinks, v => ChatNameLinks = v, true);
    }

    protected virtual void OnPrototypeReload(PrototypesReloadedEventArgs obj)
    {
        if (obj.WasModified<RadioChannelPrototype>())
            CacheRadios();

        if (obj.WasModified<EmotePrototype>())
            CacheEmotes();
    }

    private void OnChatMessageLinkClicked(ChatLinkClickedRequestEvent msg, EntitySessionEventArgs args)
    {
        if (!ChatNameLinks)
            return;

        if (GetEntity(msg.Target) is not { Valid: true } target || !Exists(target))
            return;

        if (args.SenderSession.AttachedEntity is not { Valid: true } ent)
            return;

        ClickMessageSender(target, ent);
    }

    private void CacheRadios()
    {
        _keyCodes = ProtoMan.EnumeratePrototypes<RadioChannelPrototype>()
            .ToFrozenDictionary(x => x.KeyCode);
    }

    /// <summary>
    ///     Attempts to find an applicable <see cref="SpeechVerbPrototype"/> for a speaking entity's message.
    ///     If one is not found, returns <see cref="DefaultSpeechVerb"/>.
    /// </summary>
    public SpeechVerbPrototype GetSpeechVerb(EntityUid source, string message, SpeechComponent? speech = null)
    {
        if (!Resolve(source, ref speech, false))
            return ProtoMan.Index(DefaultSpeechVerb);

        // check for a suffix-applicable speech verb
        SpeechVerbPrototype? current = null;
        foreach (var (str, id) in speech.SuffixSpeechVerbs)
        {
            var proto = ProtoMan.Index(id);
            if (message.EndsWith(Loc.GetString(str)) && proto.Priority >= (current?.Priority ?? 0))
            {
                current = proto;
            }
        }

        // if no applicable suffix verb return the normal one used by the entity
        return current ?? ProtoMan.Index(speech.SpeechVerb);
    }

    /// <summary>
    /// Splits the input message into a radio prefix part and the rest to preserve it during sanitization.
    /// </summary>
    /// <remarks>
    /// This is primarily for the chat emote sanitizer, which can match against ":b" as an emote, which is a valid radio keycode.
    /// </remarks>
    public void GetRadioKeycodePrefix(EntityUid source,
        string input,
        out string output,
        out string prefix)
    {
        prefix = string.Empty;
        output = input;

        // If the string is less than 2, then it's probably supposed to be an emote.
        // No one is sending empty radio messages!
        if (input.Length <= 2)
            return;

        if (!(input.StartsWith(RadioChannelPrefix) || input.StartsWith(RadioChannelAltPrefix)))
            return;

        if (!_keyCodes.TryGetValue(char.ToLower(input[1]), out _))
            return;

        prefix = input[..2];
        output = input[2..];
    }

    /// <summary>
    ///     Attempts to resolve radio prefixes in chat messages (e.g., remove a leading ":e" and resolve the requested
    ///     channel. Returns true if a radio message was attempted, even if the channel is invalid.
    /// </summary>
    /// <param name="source">Source of the message</param>
    /// <param name="input">The message to be modified</param>
    /// <param name="output">The modified message</param>
    /// <param name="channel">The channel that was requested, if any</param>
    /// <param name="quiet">Whether or not to generate an informative pop-up message.</param>
    /// <returns></returns>
    public bool TryProcessRadioMessage(
        EntityUid source,
        string input,
        out string output,
        out RadioChannelPrototype? channel,
        bool quiet = false)
    {
        output = input.Trim();
        channel = null;

        if (input.Length == 0)
            return false;

        if (input.StartsWith(RadioCommonPrefix))
        {
            output = SanitizeMessageCapital(input[1..].TrimStart());
            channel = ProtoMan.Index(CommonChannel);
            return true;
        }

        if (!(input.StartsWith(RadioChannelPrefix) || input.StartsWith(RadioChannelAltPrefix)))
            return false;

        if (input.Length < 2 || char.IsWhiteSpace(input[1]))
        {
            output = SanitizeMessageCapital(input[1..].TrimStart());
            if (!quiet)
                _popup.PopupEntity(Loc.GetString("chat-manager-no-radio-key"), source, source);
            return true;
        }

        var channelKey = input[1];
        channelKey = char.ToLower(channelKey);
        output = SanitizeMessageCapital(input[2..].TrimStart());

        if (channelKey == DefaultChannelKey)
        {
            var ev = new GetDefaultRadioChannelEvent();
            RaiseLocalEvent(source, ev);

            if (ev.Channel != null)
                ProtoMan.TryIndex(ev.Channel, out channel);
            return true;
        }

        if (!_keyCodes.TryGetValue(channelKey, out channel) && !quiet)
        {
            var msg = Loc.GetString("chat-manager-no-such-channel", ("key", channelKey));
            _popup.PopupEntity(msg, source, source);
        }

        return true;
    }

    public string SanitizeMessageCapital(string message)
    {
        if (string.IsNullOrEmpty(message))
            return message;
        // Capitalize first letter
        message = OopsConcat(char.ToUpper(message[0]).ToString(), message.Remove(0, 1));
        return message;
    }

    private static string OopsConcat(string a, string b)
    {
        // This exists to prevent Roslyn being clever and compiling something that fails sandbox checks.
        return a + b;
    }

    public string SanitizeMessageCapitalizeTheWordI(string message, string theWordI = "i")
    {
        if (string.IsNullOrEmpty(message))
            return message;

        for
        (
            var index = message.IndexOf(theWordI);
            index != -1;
            index = message.IndexOf(theWordI, index + 1)
        )
        {
            // Stops the code If It's tryIng to capItalIze the letter I In the mIddle of words
            // Repeating the code twice is the simplest option
            if (index + 1 < message.Length && char.IsLetter(message[index + 1]))
                continue;
            if (index - 1 >= 0 && char.IsLetter(message[index - 1]))
                continue;

            var beforeTarget = message.Substring(0, index);
            var target = message.Substring(index, theWordI.Length);
            var afterTarget = message.Substring(index + theWordI.Length);

            message = beforeTarget + target.ToUpper() + afterTarget;
        }

        return message;
    }

    public static string SanitizeAnnouncement(string message, int maxLength = 0, int maxNewlines = 2)
    {
        var trimmed = message.Trim();
        if (maxLength > 0 && trimmed.Length > maxLength)
        {
            trimmed = $"{message[..maxLength]}...";
        }

        // No more than max newlines, other replaced to spaces
        if (maxNewlines > 0)
        {
            var chars = trimmed.ToCharArray();
            var newlines = 0;
            for (var i = 0; i < chars.Length; i++)
            {
                if (chars[i] != '\n')
                    continue;

                if (newlines >= maxNewlines)
                    chars[i] = ' ';

                newlines++;
            }

            return new string(chars);
        }

        return trimmed;
    }

    /// <summary>
    /// Injects a tag inside the first found instance of a specific <paramref name="outerTag"/> string in a <see cref="ChatMessage"/>.
    /// </summary>
    public static string InjectTagInsideTag(ChatMessage message, string outerTag, string innerTag, string? tagValue = null, params (string Key, string Value)[]? tagParameters)
    {
        var rawmsg = message.WrappedMessage;
        var tagStart = rawmsg.IndexOf($"[{outerTag}]");
        var tagEnd = rawmsg.IndexOf($"[/{outerTag}]");
        if (tagStart < 0 || tagEnd < 0) //If the outer tag is not found, the injection is not performed
            return rawmsg;
        tagStart += outerTag.Length + 2;

        rawmsg = rawmsg.Insert(tagEnd, $"[/{innerTag}]");
        if (tagValue != null)
            innerTag = $"{innerTag}=\"{FormattedMessage.EscapeText(tagValue)}\"";

        var innerTagProcessed = tagParameters == null
            ? $"[{innerTag}]"
            : $"[{innerTag} {string.Join(" ", tagParameters.Select(t => $"{FormattedMessage.EscapeText(t.Key)}=\"{FormattedMessage.RemoveMarkupPermissive(t.Value)}\""))}]";

        rawmsg = rawmsg.Insert(tagStart, innerTagProcessed);

        return rawmsg;
    }

    /// <summary>
    /// Injects a tag around all found instances of a specific string in a ChatMessage.
    /// Excludes strings inside other tags and brackets.
    /// </summary>
    public static string InjectTagAroundString(ChatMessage message, string targetString, string tag, string? tagParameter)
    {
        var rawmsg = message.WrappedMessage;
        // TODO: Figure out if there's any way we can cache this, and if not then rewrite this to not use regex.
#pragma warning disable RA0026
        rawmsg = Regex.Replace(rawmsg, "(?i)(" + targetString + ")(?-i)(?![^[]*])", $"[{tag}={tagParameter}]$1[/{tag}]");
#pragma warning restore RA0026
        return rawmsg;
    }

    /// <inheritdoc cref="CanClickMessageSender(EntityUid,EntityUid?)"/>
    public bool CanClickMessageSender(NetEntity target, EntityUid? ent = null)
    {
        return CanClickMessageSender(GetEntity(target), ent);
    }

    /// <summary>
    /// Checks whether an entity can click a chat message link.
    /// </summary>
    /// <param name="target">Target of the message link</param>
    /// <param name="ent">Entity that is attempting to click the chat message, defaults to attached player entity if null.</param>
    /// <returns>True if the entity is able to click the link</returns>
    public bool CanClickMessageSender(EntityUid target, EntityUid? ent = null)
    {
        ent ??= _player.LocalEntity;
        if (ent == null)
            return false;

        if (!CanClick(target, ent.Value))
            return false;

        var ev = new ClickEntityLinkEvent(target, true);
        RaiseLocalEvent(ent.Value, ref ev);
        return ev.Handled;
    }

    private bool CanClick(EntityUid target, EntityUid ent)
    {
        if (!ChatNameLinks)
            return false;

        if (ent == target)
            return false;

        return true;
    }

    /// <summary>
    /// Teleports an entity to a target via <see cref="ClickEntityLinkEvent"/>
    /// </summary>
    /// <param name="target">Target we are attempted to teleport to</param>
    /// <param name="ent">Entity that is attempting to warp</param>
    /// <returns>True if warp was successful.</returns>
    public void ClickMessageSender(EntityUid target, EntityUid? ent = null)
    {
        ent ??= _player.LocalEntity;
        if (ent == null)
            return;

        if (!CanClick(target, ent.Value))
            return;

        var ev = new ClickEntityLinkEvent(target, false);
        RaiseLocalEvent(ent.Value, ref ev);
    }

    public static string GetStringInsideTag(ChatMessage message, string tag)
    {
        var rawmsg = message.WrappedMessage;
        var tagStart = rawmsg.IndexOf($"[{tag}]");
        var tagEnd = rawmsg.IndexOf($"[/{tag}]");
        if (tagStart < 0 || tagEnd < 0)
            return "";
        tagStart += tag.Length + 2;
        return rawmsg.Substring(tagStart, tagEnd - tagStart);
    }

    protected virtual void SendEntityEmote(
        EntityUid source,
        string action,
        ChatTransmitRange range,
        string? nameOverride,
        bool hideLog = false,
        bool checkEmote = true,
        bool ignoreActionBlocker = false,
        NetUserId? author = null
        )
    { }

    /// <summary>
    /// Sends an in-character chat message to relevant clients.
    /// </summary>
    /// <param name="source">The entity that is speaking.</param>
    /// <param name="message">The message being spoken or emoted.</param>
    /// <param name="desiredType">The chat type.</param>
    /// <param name="hideChat">Whether or not this message should appear in the chat window.</param>
    /// <param name="hideLog">Whether or not this message should appear in the adminlog window.</param>
    /// <param name="shell"></param>
    /// <param name="player">The player doing the speaking.</param>
    /// <param name="nameOverride">The name to use for the speaking entity. Usually this should just be modified via <see cref="TransformSpeakerNameEvent"/>. If this is set, the event will not get raised.</param>
    /// <param name="checkRadioPrefix">Whether or not <paramref name="message"/> should be parsed with consideration of radio channel prefix text at start the start.</param>
    /// <param name="ignoreActionBlocker">If set to true, action blocker will not be considered for whether an entity can send this message.</param>
    public virtual void TrySendInGameICMessage(
        EntityUid source,
        string message,
        InGameICChatType desiredType,
        bool hideChat,
        bool hideLog = false,
        IConsoleShell? shell = null,
        ICommonSession? player = null,
        string? nameOverride = null,
        bool checkRadioPrefix = true,
        bool ignoreActionBlocker = false)
    { }

    /// <summary>
    /// Sends an in-character chat message to relevant clients.
    /// </summary>
    /// <param name="source">The entity that is speaking.</param>
    /// <param name="message">The message being spoken or emoted.</param>
    /// <param name="desiredType">The chat type.</param>
    /// <param name="range">Conceptual range of transmission, if it shows in the chat window, if it shows to far-away ghosts or ghosts at all...</param>
    /// <param name="hideLog">Disables the admin log for this message if true. Used for entities that are not players, like vendors, cloning, etc.</param>
    /// <param name="shell"></param>
    /// <param name="player">The player doing the speaking.</param>
    /// <param name="nameOverride">The name to use for the speaking entity. Usually this should just be modified via <see cref="TransformSpeakerNameEvent"/>. If this is set, the event will not get raised.</param>
    /// <param name="checkRadioPrefix">Whether or not <paramref name="message"/> should be parsed with consideration of radio channel prefix text at start the start.</param>
    /// <param name="ignoreActionBlocker">If set to true, action blocker will not be considered for whether an entity can send this message.</param>
    public virtual void TrySendInGameICMessage(
        EntityUid source,
        string message,
        InGameICChatType desiredType,
        ChatTransmitRange range,
        bool hideLog = false,
        IConsoleShell? shell = null,
        ICommonSession? player = null,
        string? nameOverride = null,
        bool checkRadioPrefix = true,
        bool ignoreActionBlocker = false
        )
    { }

    /// <summary>
    /// Sends an out-of-character chat message to relevant clients.
    /// </summary>
    /// <param name="source">The entity that is speaking.</param>
    /// <param name="message">The message being spoken or emoted.</param>
    /// <param name="type">The chat type.</param>
    /// <param name="hideChat">Whether or not to show the message in the chat window.</param>
    /// <param name="shell"></param>
    /// <param name="player">The player doing the speaking.</param>
    public virtual void TrySendInGameOOCMessage(
        EntityUid source,
        string message,
        InGameOOCChatType type,
        bool hideChat,
        IConsoleShell? shell = null,
        ICommonSession? player = null
        )
    { }

    /// <summary>
    /// Dispatches an announcement to all.
    /// </summary>
    /// <param name="message">The contents of the message.</param>
    /// <param name="sender">The sender (Communications Console in Communications Console Announcement).</param>
    /// <param name="playSound">Play the announcement sound.</param>
    /// <param name="announcementSound">Sound to play.</param>
    /// <param name="colorOverride">Optional color for the announcement message.</param>
    /// <param name="signature">Optional signature shown below the announcement message.</param>
    public virtual void DispatchGlobalAnnouncement(
        string message,
        string? sender = null,
        bool playSound = true,
        SoundSpecifier? announcementSound = null,
        Color? colorOverride = null,
        string? signature = null
        )
    { }

    /// <summary>
    /// Dispatches an announcement to players selected by filter.
    /// </summary>
    /// <param name="filter">Filter to select players who will recieve the announcement.</param>
    /// <param name="message">The contents of the message.</param>
    /// <param name="source">The entity making the announcement (used to determine the station).</param>
    /// <param name="sender">The sender (Communications Console in Communications Console Announcement).</param>
    /// <param name="playSound">Play the announcement sound.</param>
    /// <param name="announcementSound">Sound to play.</param>
    /// <param name="colorOverride">Optional color for the announcement message.</param>
    /// <param name="signature">Optional signature shown below the announcement message.</param>
    public virtual void DispatchFilteredAnnouncement(
        Filter filter,
        string message,
        EntityUid? source = null,
        string? sender = null,
        bool playSound = true,
        SoundSpecifier? announcementSound = null,
        Color? colorOverride = null,
        string? signature = null)
    { }

    /// <summary>
    /// Dispatches an announcement on a specific station.
    /// </summary>
    /// <param name="source">The entity making the announcement (used to determine the station).</param>
    /// <param name="message">The contents of the message.</param>
    /// <param name="sender">The sender (Communications Console in Communications Console Announcement).</param>
    /// <param name="playDefaultSound">Play the announcement sound.</param>
    /// <param name="announcementSound">Sound to play.</param>
    /// <param name="colorOverride">Optional color for the announcement message.</param>
    /// <param name="signature">Optional signature shown below the announcement message.</param>
    public virtual void DispatchStationAnnouncement(
        EntityUid source,
        string message,
        string? sender = null,
        bool playDefaultSound = true,
        SoundSpecifier? announcementSound = null,
        Color? colorOverride = null,
        string? signature = null)
    { }
}

/// <summary>
/// Controls transmission of chat.
/// </summary>
public enum ChatTransmitRange : byte
{
    /// Acts normal, ghosts can hear across the map, etc.
    Normal,
    /// Normal but ghosts are still range-limited.
    GhostRangeLimit,
    /// Hidden from the chat window.
    HideChat,
    /// Ghosts can't hear or see it at all. Regular players can if in-range.
    NoGhosts
}

/// <summary>
/// InGame IC chat is for chat that is specifically ingame (not lobby) but is also in character, i.e. speaking.
/// </summary>
// ReSharper disable once InconsistentNaming
public enum InGameICChatType : byte
{
    Speak,
    Emote,
    Whisper
}

/// <summary>
/// InGame OOC chat is for chat that is specifically ingame (not lobby) but is OOC, like deadchat or LOOC.
/// </summary>
public enum InGameOOCChatType : byte
{
    Looc,
    Dead
}