using axXez.TS3.Protocol;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace axXez.TS3.Bot
{
    /// <summary>
    /// Provides context for a command invocation, including the invoker, parsed arguments, reply helpers, and the command's result.
    /// </summary>
    public class CommandContext
    {
        private readonly BotContext _bot;
        private readonly Dictionary<MessageTargetMode, StringBuilder> _replies = new();
        private readonly Dictionary<MessageTargetMode, StringBuilder> _allReplies = new();

        /// <summary>The connection the command arrived on. Cast to <see cref="VoiceConnection"/> for voice channel commands or <see cref="QueryClient"/> for server-query commands.</summary>
        public ITeamspeakClient Source { get; }

        /// <summary>The client who invoked the command. This is the bot's own query client when the command is executed internally.</summary>
        public Client Invoker { get; }

        /// <summary>The scope in which the command was received.</summary>
        public MessageTargetMode TargetMode { get; }

        /// <summary>The full raw message text, including the command keyword and prefix.</summary>
        public string Message { get; }

        /// <summary>The raw argument string passed after the command keyword.</summary>
        public string ParameterString { get; }

        /// <summary>The arguments passed to the command, split by whitespace.</summary>
        public string[] Args { get; }

        /// <summary>The result set by the command via <see cref="Ok()"/>, <see cref="Ok(string)"/>, or <see cref="Error(string)"/>.</summary>
        public CommandResponse Response { get; private set; }

        /// <summary>All replies ever added via <see cref="Reply(string, bool)"/>, keyed by scope. Preserved across <see cref="Flush"/> calls.</summary>
        public IReadOnlyDictionary<MessageTargetMode, string> Replies
            => _allReplies.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToString());

        /// <summary>Whether the command was invoked internally by the bot itself rather than by a real client.</summary>
        public bool IsInternalInvocation => Invoker == _bot.Server.QueryClient;

        /// <summary>Whether the invoker has the <see cref="CommandRole.Admin"/> role. Always <c>true</c> for internal invocations.</summary>
        public bool IsInvokerAdmin => _bot.IsAdmin(Invoker);
        /// <summary>Whether the invoker has the <see cref="CommandRole.Moderator"/> role or higher. Always <c>true</c> for internal invocations.</summary>
        public bool IsInvokerModerator => _bot.IsModerator(Invoker);
        /// <summary>Whether the invoker has the <see cref="CommandRole.User"/> role or higher. Always <c>true</c> for internal invocations.</summary>
        public bool IsInvokerUser => _bot.IsUser(Invoker);
        /// <summary>Whether the invoker has the <see cref="CommandRole.Guest"/> role (i.e. is in the server's default group). Always <c>true</c> for internal invocations.</summary>
        public bool IsInvokerGuest => _bot.IsGuest(Invoker);

        internal CommandContext(BotContext bot, ITeamspeakClient source, Client invoker, MessageTargetMode targetMode, string message, string paramStr, string[] args)
        {
            _bot = bot;
            Source = source;
            Invoker = invoker;
            TargetMode = targetMode;
            Message = message;
            ParameterString = paramStr;
            Args = args;
        }

        /// <summary>
        /// Buffers a reply in the same scope the command was received in, sent all at once when the command completes.
        /// Pass <paramref name="flush"/> to send immediately instead.
        /// </summary>
        public void Reply(string message, bool flush = false)
            => Reply(message, TargetMode, flush);

        /// <summary>
        /// Buffers a reply in the specified scope, sent all at once when the command completes.
        /// Pass <paramref name="flush"/> to send immediately instead.
        /// </summary>
        public void Reply(string message, MessageTargetMode targetMode, bool flush = false)
        {
            if (!_replies.TryGetValue(targetMode, out var sb))
                _replies[targetMode] = sb = new StringBuilder();
            if (!_allReplies.TryGetValue(targetMode, out var all))
                _allReplies[targetMode] = all = new StringBuilder();

            if (sb.Length > 0)
                sb.AppendLine();
            if (all.Length > 0)
                all.AppendLine();

            sb.Append(message);
            all.Append(message);

            if (flush)
                Flush();
        }

        /// <summary>
        /// Buffers a private reply directly to the invoker, sent all at once when the command completes.
        /// Pass <paramref name="flush"/> to send immediately instead.
        /// </summary>
        public void ReplyPrivate(string message, bool flush = false)
            => Reply(message, MessageTargetMode.Private, flush);

        /// <summary>
        /// Signals the command completed successfully with no message.
        /// Use as <c>return ctx.Ok();</c> in a command method.
        /// </summary>
        public CommandResponse Ok()
            => Response = new(true);

        /// <summary>
        /// Buffers <paramref name="message"/> as a reply and signals success. Shorthand for <c>ctx.Reply(message); return ctx.Ok();</c>
        /// Use as <c>return ctx.Ok("message");</c> in a command method.
        /// </summary>
        public CommandResponse Ok(string message)
        {
            Reply(message);
            return Response = new(true);
        }

        /// <summary>
        /// Buffers <paramref name="message"/> as a reply in the specified scope and signals success.
        /// Use as <c>return ctx.Ok("message", MessageTargetMode.Private);</c> in a command method.
        /// </summary>
        public CommandResponse Ok(string message, MessageTargetMode targetMode)
        {
            Reply(message, targetMode);
            return Response = new(true);
        }

        /// <summary>
        /// Signals the command failed with an optional reason. The framework sends the message privately to the invoker and appends the command's help text.
        /// Use as <c>return ctx.Error("reason");</c> in a command method.
        /// </summary>
        public CommandResponse Error(string message = null)
            => Response = new(false, message);

        /// <summary>Signals the command failed because the invoker lacks the required role.</summary>
        public CommandResponse ErrorNoPermission()
            => Error("You don't have permission to use that command!");

        /// <summary>
        /// Immediately sends all buffered replies and clears the buffer.
        /// Use when a reply must be delivered before a blocking operation (e.g. reconnect).
        /// Has no effect on internal invocations.
        /// </summary>
        public void Flush()
        {
            if (IsInternalInvocation || _replies.Count == 0)
                return;

            foreach (var (mode, sb) in _replies)
            {
                var client = mode == MessageTargetMode.Server ? _bot.Server.Query : Source;
                client.SendTextMessage(mode, mode == MessageTargetMode.Private ? Invoker.ID : 0, sb.ToString());
            }

            _replies.Clear();
        }

        /// <summary>Returns all reply text for the given scope (including already-flushed replies), or <c>null</c> if nothing was replied in that scope.</summary>
        public string GetReply(MessageTargetMode mode)
            => _allReplies.TryGetValue(mode, out var sb) ? sb.ToString() : null;
    }
}