using axXez.TS3.Protocol;
using axXez.Utils;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text.Json.Serialization;

namespace axXez.TS3.Bot
{
    /// <summary>Base class for all bot modules. Provides lifecycle hooks, event callbacks, and access to the server connection.</summary>
    public abstract class Module : ConfigFile
    {
        private List<Command> _commands;
        private readonly List<VoiceConnection> _voiceConnections = new();

        /// <summary>Short name of the module type (class name).</summary>
        [JsonIgnore]
        public string Name => Type.Name;

        /// <summary>Fully qualified name of the module type (namespace + class name).</summary>
        [JsonIgnore]
        public string FullName => Type.FullName;

        /// <summary>Human-readable display name of the module, as set in the <see cref="ModuleAttribute"/>.</summary>
        [JsonIgnore]
        public string DisplayName => Type.DisplayName;

        /// <summary>Whether the module is currently running.</summary>
        [JsonIgnore]
        public bool Running { get; private set; } = false;

        /// <summary>Whether the module has stopped due to an unhandled exception.</summary>
        [JsonIgnore]
        public bool HasError => LastException != null;

        /// <summary>The last unhandled exception that caused the module to stop, or <c>null</c> if no error has occurred.</summary>
        [JsonIgnore]
        public Exception LastException { get; private set; }

        /// <summary>Metadata descriptor for this module's type.</summary>
        [JsonIgnore]
        public ModuleType Type { get; private set; }

        /// <summary>The bot context this module is loaded into.</summary>
        protected BotContext Bot { get; private set; }

        /// <summary>The active server connection.</summary>
        protected ServerConnection Server => Bot.Server;

        /// <summary>The raw ServerQuery API client.</summary>
        protected QueryClient Query => Server.Query;

        /// <summary>Snapshot of all server groups currently tracked by the connection.</summary>
        protected IReadOnlyDictionary<int, ServerGroupInfo> ServerGroups => Server.ServerGroups;

        /// <summary>Snapshot of all channel groups currently tracked by the connection.</summary>
        protected IReadOnlyDictionary<int, ChannelGroupInfo> ChannelGroups => Server.ChannelGroups;

        /// <summary>Snapshot of all channels currently tracked by the connection.</summary>
        protected IReadOnlyDictionary<int, Channel> Channels => Server.Channels;

        /// <summary>Snapshot of all connected clients currently tracked by the connection.</summary>
        protected IReadOnlyDictionary<int, Client> Clients => Server.Clients;

        /// <summary>All voice connections currently owned by this module.</summary>
        protected IReadOnlyList<VoiceConnection> VoiceConnections => _voiceConnections.AsReadOnly();

        /// <summary>Writes a message to the global logger using this module's name as the source.</summary>
        protected void Log(string message, LogType type = LogType.Info)
            => GlobalLogger.Log(this.Name, message, type);

        internal List<Command> GetCommands() => _commands;

        internal void Initialize(ModuleType type, BotContext bot)
        {
            Type = type;
            Bot = bot;
            _commands = new List<Command>();
            foreach (var x in type.CommandMethods)
            {
                try
                {
                    var methodParams = x.Method.GetParameters();

                    if (methodParams.Length == 0 || methodParams[0].ParameterType != typeof(CommandContext))
                        throw new InvalidOperationException("First parameter must be CommandContext.");
                    if (x.Method.ReturnType != typeof(CommandResponse))
                        throw new InvalidOperationException("Return type must be CommandResponse.");

                    CommandLineParser parser = null;
                    Func<CommandContext, CommandResponse> callback;

                    if (methodParams.Length == 1)
                    {
                        // no extra params — fast delegate binding
                        callback = (Func<CommandContext, CommandResponse>)Delegate.CreateDelegate(
                            typeof(Func<CommandContext, CommandResponse>), this, x.Method);
                    }
                    else
                    {
                        // typed params — build parser and binding callback
                        parser = new CommandLineParser(p =>
                        {
                            for (int j = 1; j < methodParams.Length; j++)
                            {
                                var param = methodParams[j];
                                p.Register(
                                    param.GetCustomAttribute<CommandParamAttribute>()?.Name ?? param.Name,
                                    j - 1, param.ParameterType, !param.HasDefaultValue,
                                    param.HasDefaultValue ? param.DefaultValue : null);
                            }
                        });
                        callback = ctx =>
                        {
                            var result = parser.Process(ctx.Args);
                            if (!result.IsValid)
                                return ctx.Error();

                            var invokeArgs = new object[result.Values.Count + 1];
                            invokeArgs[0] = ctx;
                            result.Values.CopyTo(invokeArgs, 1);

                            return (CommandResponse)x.Method.Invoke(this, invokeArgs);
                        };
                    }

                    _commands.Add(new Command(x.Attr, x.Method, this, callback, parser));
                }
                catch (Exception ex)
                {
                    GlobalLogger.Log(type.Name, $"Command '{x.Attr.Keyword}' on method '{x.Method.Name}' could not be registered: {ex.Message}", LogType.Warning);
                }
            }

            OnLoad();
        }

        internal void Start()
        {
            if (Running)
                return;

            if (!Type.IsCompatibleWith(Server.Version))
                throw new InvalidOperationException($"Module is not compatible with server version {Server.Version}.");

            LastException = null;

            OnStart();

            Running = true; // after OnStart so events aren't dispatched before the module is fully started
        }

        internal void Stop()
        {
            if (!Running)
                return;

            Running = false;

            OnStop(Query.Connected);
        }

        internal void ThrowException(Exception exception)
        {
            Running = false;
            LastException = exception;
            OnException(exception);
        }

        internal void Unload()
        {
            if (HasError)
                return;

            OnUnload();
        }

        internal void InternalCleanup()
        {
            foreach (var conn in _voiceConnections)
                Bot.Server.RemoveVoiceConnection(conn);
            _voiceConnections.Clear();
        }

        /// <summary>Overrides the minimum role required to invoke a command registered by this module.</summary>
        protected void SetCommandRole(string keyword, CommandRole role)
        {
            var cmd = _commands?.Find(c => c.Keyword.Equals(keyword, StringComparison.OrdinalIgnoreCase));
            if (cmd != null) cmd.Role = role;
        }

        /// <summary>Overrides the scope in which a command registered by this module responds.</summary>
        protected void SetCommandScope(string keyword, CommandScope scope)
        {
            var cmd = _commands?.Find(c => c.Keyword.Equals(keyword, StringComparison.OrdinalIgnoreCase));
            if (cmd != null) cmd.Scope = scope;
        }

        /// <summary>Creates a new <see cref="VoiceConnection"/> targeting the active server and registers it under this module.</summary>
        protected VoiceConnection CreateVoiceConnection(string nickname, VoiceIdentity identity = null, VoiceClientOptions options = null)
        {
            var conn = Bot.Server.CreateVoiceConnection(nickname, identity, options);
            _voiceConnections.Add(conn);
            return conn;
        }

        /// <summary>Disposes and deregisters a <see cref="VoiceConnection"/> previously created by this module.</summary>
        protected void RemoveVoiceConnection(VoiceConnection conn)
        {
            _voiceConnections.Remove(conn);
            Bot.Server.RemoveVoiceConnection(conn);
        }

        /// <summary>Called once when the module is loaded, either on bot start or while the bot is already running. Override to perform one-time initialization such as dependency checks.</summary>
        protected virtual void OnLoad() { }

        /// <summary>Called when the server connection is established. Raised on initial load if already connected, and on every subsequent reconnect. Override to set up connection-dependent state.</summary>
        protected virtual void OnStart() { }

        /// <summary>Called when the server connection is lost. Override to react to disconnects — do not perform full teardown here, as the connection may reconnect and <see cref="OnStart"/> will be called again.</summary>
        protected virtual void OnStop(bool queryConnected) { }

        /// <summary>Called when the module is unloaded, either on bot stop or while the bot is still running. Override to release resources and perform full teardown. Base implementation saves the module config — call <c>base.OnUnload()</c> to preserve this behavior.</summary>
        protected virtual void OnUnload()
        {
            Save();
        }

        /// <summary>Called when the module throws an unhandled exception inside an event handler. The module is stopped before this is called. Override to react to crashes (e.g. notify admins or reset state).</summary>
        /// <param name="exception">The exception that was thrown.</param>
        protected virtual void OnException(Exception exception) { }

        /// <summary>Called when a new channel is created on the server.</summary>
        /// <param name="channel">The newly created channel.</param>
        /// <param name="parent">The parent channel, or <c>null</c> if it has no parent.</param>
        /// <param name="invoker">The client who created the channel, or <c>null</c> if unknown.</param>
        public virtual void OnChannelCreated(Channel channel, Channel parent, Client invoker) { }

        /// <summary>Called when a channel is deleted from the server.</summary>
        /// <param name="channel">The channel that was deleted.</param>
        /// <param name="invoker">The client who deleted the channel, or <c>null</c> if unknown.</param>
        public virtual void OnChannelDeleted(Channel channel, Client invoker) { }

        /// <summary>Called when a channel's properties are edited by a client.</summary>
        /// <param name="channel">The channel that was edited, already updated with the new values.</param>
        /// <param name="changes">The set of properties that changed.</param>
        /// <param name="invoker">The client who edited the channel, or <c>null</c> if unknown.</param>
        public virtual void OnChannelEdited(Channel channel, TsEntityChangeInfo changes, Client invoker) { }

        /// <summary>Called when a channel's properties are updated by the periodic channel watcher or a description change.</summary>
        /// <param name="channel">The channel that was updated, already updated with the new values.</param>
        /// <param name="changes">The set of properties that changed.</param>
        public virtual void OnChannelUpdated(Channel channel, TsEntityChangeInfo changes) { }

        /// <summary>Called when a client connects to the server and enters view.</summary>
        /// <param name="client">The client who joined.</param>
        /// <param name="source">The channel the client came from, or <c>null</c> if connecting fresh.</param>
        /// <param name="target">The channel the client joined.</param>
        /// <param name="reason">The reason ID for the join.</param>
        public virtual void OnClientJoined(Client client, Channel source, Channel target, EventReason reason) { }

        /// <summary>Called when a client disconnects or leaves view.</summary>
        /// <param name="client">The client who left.</param>
        /// <param name="source">The channel the client was in.</param>
        /// <param name="target">The target channel (relevant for kicks/bans).</param>
        /// <param name="reason">The reason ID (e.g. 3 = timeout, 5 = kicked, 6 = banned).</param>
        /// <param name="invoker">The client who performed the kick/ban, or <c>null</c> if not applicable.</param>
        /// <param name="reasonMsg">The reason message provided by the invoker.</param>
        /// <param name="banTime">The ban duration; <see cref="TimeSpan.Zero"/> if not a ban.</param>
        public virtual void OnClientLeaved(Client client, Channel source, Channel target, EventReason reason, Client invoker, string reasonMsg, TimeSpan banTime) { }

        /// <summary>Called when a client is moved to a different channel.</summary>
        /// <param name="client">The client who was moved, already updated with the new channel.</param>
        /// <param name="target">The channel the client was moved into.</param>
        /// <param name="reason">The reason ID for the move.</param>
        /// <param name="invoker">The client who initiated the move, or <c>null</c> if the client moved themselves.</param>
        public virtual void OnClientMoved(Client client, Channel target, EventReason reason, Client invoker) { }

        /// <summary>Called when a client's properties are updated by the periodic client watcher.</summary>
        /// <param name="client">The client that was updated, already updated with the new values.</param>
        /// <param name="changes">The set of properties that changed.</param>
        public virtual void OnClientUpdated(Client client, TsEntityChangeInfo changes) { }

        /// <summary>Called when a text message is received in any registered scope (server, channel, or private).</summary>
        /// <param name="source">The connection the message arrived on — cast to <see cref="VoiceConnection"/> for voice channel messages or <see cref="QueryClient"/> for server-query messages.</param>
        /// <param name="message">The message text.</param>
        /// <param name="invoker">The client who sent the message.</param>
        /// <param name="targetMode">Scope of the message: 1 = private, 2 = channel, 3 = server.</param>
        /// <param name="target">The recipient client when <paramref name="targetMode"/> is 1; otherwise <c>null</c>.</param>
        public virtual void OnTextMessage(ITeamspeakClient source, string message, Client invoker, MessageTargetMode targetMode, Client target) { }

        /// <summary>Called when a registered command keyword is received in a text message.</summary>
        /// <param name="keyword">The command keyword without the leading <c>!</c> or <c>?</c>.</param>
        /// <param name="command">The full text message args that triggered the command.</param>
        public virtual void OnCommandReceived(string keyword, TextMessageArgs command) { }

        /// <summary>Called when the virtual server's properties are edited.</summary>
        /// <param name="serverInfo">The server info object, already updated with the new values.</param>
        /// <param name="changes">The set of properties that changed.</param>
        /// <param name="reason">The reason ID for the edit.</param>
        /// <param name="invoker">The client who edited the server, or <c>null</c> if unknown.</param>
        public virtual void OnServerEdited(ServerInfo serverInfo, TsEntityChangeInfo changes, EventReason reason, Client invoker) { }

        /// <inheritdoc/>
        public override string ToString() => Name;
        /// <inheritdoc/>
        public override int GetHashCode() => Type.GetHashCode();
        /// <inheritdoc/>
        public override bool Equals(object obj)
            => typeof(Module).IsAssignableFrom(obj.GetType()) && (obj as Module).Type.Equals(Type);
    }
}