using System.Net.Sockets;
using System.Reflection;
using System.Text.Json;
using DX86;
using Server.Commands;

namespace Server;

public class CommandManager
{
    private readonly Dictionary<string, MethodInfo> _commands = new();

    public CommandManager()
    {
        LoadCommands();
    }

    private void LoadCommands()
    {
        var methods = Assembly.GetExecutingAssembly()
            .GetTypes()
            .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Static))
            .Where(m => m.GetCustomAttribute<CommandAttribute>() != null);

        foreach (var method in methods)
        {
            var attr = method.GetCustomAttribute<CommandAttribute>()!;
            _commands[attr.Name.ToLower()] = method;
            Program.messageSender.Log($"[COMMANDMANAGER] Registered command: {attr.Name}");
        }
    }
    public void ExecuteCommand(string executor, TcpClient? client = null, TcpServer? clientSocket = null, string cid = "", params string[] args)
{
    if (_commands.TryGetValue(executor.ToLower(), out var method))
    {
        try
        {
            var parameters = method.GetParameters();
            var arguments = new object?[parameters.Length];

            for (int i = 0; i < parameters.Length; i++)
            {
                var param = parameters[i];

                if (param.ParameterType == typeof(string[]))
                    arguments[i] = args;
                else if (param.ParameterType == typeof(TcpClient))
                    arguments[i] = client;
                else if (param.ParameterType == typeof(TcpServer))
                    arguments[i] = clientSocket;
                else
                {
                    Program.messageSender.Warn($"[COMMANDMANAGER] Unknown parameter type '{param.ParameterType.Name}' in command '{executor}'. Defaulting to null.");
                    arguments[i] = null;
                }
            }

            Program.messageSender.Debug($"[COMMANDMANAGER] Executing command '{executor}'...");
            string result = method.Invoke(null, arguments)?.ToString() ?? "";

            var returnMessage = new JsonMessage
            {
                cid = cid,
                cmd = result
            };

            var sendClientMessage = JsonSerializer.Serialize(returnMessage);
            clientSocket?.SendMessageAsync(client, sendClientMessage + "\n");
            Program.messageSender.Debug($"[COMMANDMANAGER] Response sent to client.");
        }
        catch (TargetInvocationException ex) when (ex.InnerException is CommandException cmdEx)
        {
            Program.messageSender.Warn($"[COMMANDMANAGER] Command '{executor}' failed: {cmdEx.Message}");

            var returnMessage = new JsonMessage
            {
                cid = cid,
                cmd = $"Error: {cmdEx.Message}"
            };

            var sendClientMessage = JsonSerializer.Serialize(returnMessage);
            clientSocket?.SendMessageAsync(client, sendClientMessage + "\n");
        }
        catch (TargetInvocationException ex)
        {
            var actualError = ex.InnerException?.Message ?? ex.Message;
            Program.messageSender.Error($"[COMMANDMANAGER] Unexpected error in command '{executor}': {actualError}");
            Program.messageSender.Debug($"[COMMANDMANAGER] Stack Trace: {ex.InnerException?.StackTrace ?? ex.StackTrace}");
        }
        catch (Exception ex)
        {
            Program.messageSender.Error($"[COMMANDMANAGER] Failed to invoke command '{executor}': {ex.Message}");
        }
    }
    else
    {
        Program.messageSender.Warn($"[COMMANDMANAGER] Unknown command '{executor}' received.");
    }
}
}