<?php
// discord_bot.php

// Cargar configuración y dependencias
require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/includes/db.php';
require_once __DIR__ . '/includes/logger.php';
require_once __DIR__ . '/discord/DiscordSender.php';
require_once __DIR__ . '/discord/converters/HtmlToDiscordMarkdownConverter.php';
require_once __DIR__ . '/src/Translate.php';

// Importar clases necesarias
use Discord\Discord;
use Discord\WebSockets\Intents;
use Discord\WebSockets\Event;
use Discord\Parts\Channel\Message;
use Discord\Parts\Interactions\Interaction;
use Discord\Parts\WebSockets\MessageReaction;
use Discord\Builders\MessageBuilder;
use Discord\Parts\Embed\Embed;
use Discord\Parts\Guild\Member;
use Discord\Builders\Components\ActionRow;
use Discord\Builders\Components\Button;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$logger = new Logger('DiscordBot');
$logger->pushHandler(new StreamHandler(__DIR__.'/logs/discord_bot.log', Logger::DEBUG));

$logger->info("Iniciando bot de Discord...");

if (!defined('DISCORD_BOT_TOKEN') || empty(DISCORD_BOT_TOKEN)) {
    $logger->error("Error Fatal: La constante DISCORD_BOT_TOKEN no está definida o está vacía.");
    die();
}

try {
    $discord = new Discord([
        'token' => DISCORD_BOT_TOKEN,
        'intents' => Intents::GUILDS | Intents::GUILD_MESSAGES | Intents::DIRECT_MESSAGES | Intents::GUILD_MEMBERS | Intents::GUILD_MESSAGE_REACTIONS | Intents::MESSAGE_CONTENT,
        'logger' => $logger
    ]);

    $discord->on('ready', function (Discord $discord) {
        $discord->getLogger()->info("==================================================");
        $discord->getLogger()->info("Bot conectado y listo para escuchar!");
        $discord->getLogger()->info("Usuario: {$discord->user->username}#{$discord->user->discriminator}");
        $discord->getLogger()->info("==================================================");
    });

    // Evento para nuevos miembros en el servidor
    $discord->on(Event::GUILD_MEMBER_ADD, function (Member $member, Discord $discord) use ($pdo, $logger) {
        $logger->info("[NUEVO MIEMBRO] Usuario {$member->user->username} ({$member->id}) se ha unido al servidor.");
        try {
            $stmt = $pdo->prepare(
                "INSERT INTO recipients (platform_id, name, type, platform, language_code) 
                 VALUES (?, ?, 'user', 'discord', 'es') 
                 ON DUPLICATE KEY UPDATE name = VALUES(name)"
            );
            $stmt->execute([$member->id, $member->user->username]);
            $logger->info("[NUEVO MIEMBRO] Usuario {$member->user->username} registrado/actualizado en la base de datos.");
        } catch (Throwable $e) {
            $logger->error("[NUEVO MIEMBRO] Error al registrar al usuario.", ['error' => $e->getMessage()]);
        }
    });

    // Evento para manejar interacciones (clics en botones)
    $discord->on(Event::INTERACTION_CREATE, function (Interaction $interaction, Discord $discord) use ($pdo, $logger) {
        // DiscordPHP v7: No existe isButton(). Botones llegan como MESSAGE_COMPONENT (type = 3) y component_type = 2
        $type = (int) ($interaction->type ?? 0); // 3 = MESSAGE_COMPONENT
        $componentType = (int) ($interaction->data->component_type ?? 0); // 2 = BUTTON
        if ($type !== 3 || $componentType !== 2) return;

        $customId = $interaction->data->custom_id;
        $userId = $interaction->user->id;
        $logger->info("[INTERACCION] Usuario $userId hizo clic en el botón: $customId");

        try {
            if (strpos($customId, 'translate_manual:') === 0) {
                $targetLang = substr($customId, strlen('translate_manual:'));
                $originalMessage = $interaction->message;
                $channelId = $originalMessage->channel_id;
                
                // Responder de inmediato para evitar timeout de interacción
                $interaction->respondWithMessage(MessageBuilder::new()->setContent('⌛ Procesando traducción...'), true);

                // Extraer contenido del mensaje: primero content plano, luego embeds como fallback
                $originalContent = trim((string) ($originalMessage->content ?? ''));
                if ($originalContent === '' && count($originalMessage->embeds) > 0) {
                    foreach ($originalMessage->embeds as $embed) {
                        $originalContent .= trim((string) ($embed->description ?? '')) . "\n";
                    }
                    $originalContent = trim($originalContent);
                }

                if (!empty($originalContent)) {
                    try {
                        $translator = new Translate(LIBRETRANSLATE_URL);
                        $sourceLang = $translator->detectLanguage($originalContent) ?? 'es';
                        if ($sourceLang === $targetLang) {
                            // Fallback: muchas plantillas están en ES; intenta forzar ES como origen
                            $fallbackSrc = 'es';
                            if ($fallbackSrc !== $targetLang) {
                                $translatedText = $translator->translateText($originalContent, $fallbackSrc, $targetLang);
                                $sourceLang = $fallbackSrc;
                            } else {
                                $translatedText = null;
                            }
                        } else {
                            $translatedText = $translator->translateText($originalContent, $sourceLang, $targetLang);
                        }

                            // Obtener bandera desde supported_languages
                            $flag = '';
                            try {
                                $stmt = $pdo->prepare("SELECT flag_emoji FROM supported_languages WHERE language_code = ? AND is_active = 1");
                                $stmt->execute([$targetLang]);
                                $flag = $stmt->fetchColumn() ?: '';
                            } catch (\Throwable $e) { /* noop */ }

                            $flag = $flag !== '' ? $flag : '🏳️';

                            // Enviar resultado como mensaje normal al canal, mencionando al usuario
                            $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                            $mention = '<@' . $userId . '>';
                            $content = "{$mention} {$flag} Traducción ({$sourceLang} → {$targetLang}):\n> " . $translatedText;
                            // Pequeña espera para que el mensaje efímero aparezca primero
                            usleep(300000);
                            $sender->sendRawMessage($channelId, $content);
                        if (empty($translatedText)) {
                            $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                            $sender->sendRawMessage($channelId, '<@' . $userId . '> El mensaje ya está en este idioma.');
                        }
                    } catch (\Throwable $e) {
                        $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                        $sender->sendRawMessage($channelId, '<@' . $userId . "> Error al traducir: " . $e->getMessage());
                    }
                } else {
                    $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                    $sender->sendRawMessage($channelId, '<@' . $userId . '> No se encontró contenido para traducir.');
                }
                return; // Salir después de manejar la interacción
            }

            // MANEJAR TRADUCCIÓN A IDIOMA ESPECÍFICO (desde botones de idiomas)
            if (strpos($customId, 'translate_to_lang:') === 0) {
                // Extraer el ID del mensaje original y el idioma destino del custom_id
                $parts = explode(':', $customId);
                if (count($parts) < 3) {
                    $interaction->respondWithMessage(MessageBuilder::new()->setContent("❌ Error: Formato de botón de traducción inválido."), true);
                    return;
                }
                $originalMessageId = $parts[1];
                $targetLang = $parts[2];
                
                // 1. Deferir la respuesta de forma efímera para que el usuario sepa que se está procesando
                $interaction->acknowledge(true)->done(function() use ($originalMessageId, $targetLang, $interaction, $discord, $pdo, $logger, $userId) {
                    // 2. Obtener el mensaje original usando su ID
                    $interaction->channel->messages->fetch($originalMessageId)->done(function ($originalMessage) use ($originalMessageId, $interaction, $discord, $pdo, $logger, $userId, $targetLang) {
                        $originalContent = (string) ($originalMessage->content ?? '');
                        
                        $emojiMap = [];
                        preg_match_all('/<a?:(\w+):(\d+)>/', $originalContent, $matches, PREG_OFFSET_CAPTURE);
                        foreach ($matches[0] as $match) {
                            $emojiMap[$match[1]] = $match[0];
                        }
                        $contentForTranslation = preg_replace('/<a?:(\w+):(\d+)>/', '', $originalContent);
                        $contentForTranslation = trim($contentForTranslation);
                        
                        if (empty($contentForTranslation)) {
                            $interaction->editOriginalResponse(MessageBuilder::new()->setContent("⚠️ El mensaje no contiene texto traducible."));
                            return;
                        }
                        
                        try {
                            $translator = new Translate(LIBRETRANSLATE_URL);
                            $detectionResultForSource = $translator->detectLanguage($contentForTranslation);
                            $sourceLang = $detectionResultForSource[0]['language'] ?? 'es';
                            
                            if ($sourceLang === $targetLang) {
                                $interaction->editOriginalResponse(MessageBuilder::new()->setContent("⚠️ El mensaje ya está en el idioma seleccionado ({$targetLang})."));
                                return;
                            }
                            
                            $translatedText = $translator->translateText($contentForTranslation, $sourceLang, $targetLang);
                    
                            if (!empty($translatedText)) {
                                foreach ($emojiMap as $emojiTag) {
                                    $translatedText .= ' ' . $emojiTag;
                                }
                                $translatedText = trim($translatedText);
                    
                                $stmt = $pdo->prepare("SELECT flag_emoji, language_name FROM supported_languages WHERE language_code = ? AND is_active = 1");
                                $stmt->execute([$targetLang]);
                                $langInfo = $stmt->fetch(PDO::FETCH_ASSOC);
                                $flag = $langInfo['flag_emoji'] ?? '🏳️';
                                $langName = $langInfo['language_name'] ?? strtoupper($targetLang);
                                
                                $embed = new Embed($discord);
                                $embed->setTitle("{$flag} Traducción a {$langName}");
                                $embed->setDescription($translatedText);
                                $embed->setColor("#5865F2");
                                $embed->setFooter("Traducido de {$sourceLang} • Solo tú puedes ver esto");
                                
                                $imageUrl = null;
                                if ($originalMessage->attachments !== null && count($originalMessage->attachments) > 0) {
                                    $firstAttachment = $originalMessage->attachments->first();
                                    if ($firstAttachment && isset($firstAttachment->url)) {
                                        $contentType = $firstAttachment->content_type ?? '';
                                        if (strpos($contentType, 'image/') === 0 || strpos($contentType, 'video/') === 0) {
                                            $imageUrl = $firstAttachment->url;
                                        }
                                    }
                                }
                                
                                if (!$imageUrl && $originalMessage->stickers !== null && count($originalMessage->stickers) > 0) {
                                    $firstSticker = $originalMessage->stickers->first();
                                    if ($firstSticker && isset($firstSticker->image_url)) {
                                        $imageUrl = $firstSticker->image_url;
                                    }
                                }
                                
                                if ($imageUrl) {
                                    $embed->setImage($imageUrl);
                                }
                                
                                // 3. Editar la respuesta original con el resultado
                                $builder = MessageBuilder::new()->addEmbed($embed);
                                $interaction->sendFollowUpMessage($builder, true);
                                
                                $logger->info("[TRANSLATION_BUTTON] Usuario {$userId} tradujo mensaje #{$originalMessageId} de {$sourceLang} a {$targetLang}");
                            } else {
                                $interaction->editOriginalResponse(MessageBuilder::new()->setContent("⚠️ No se pudo traducir el mensaje."));
                            }
                        } catch (\Throwable $e) {
                            $logger->error("[TRANSLATION_BUTTON] Error al traducir", ['error' => $e->getMessage(), 'trace' => $e->getTraceAsString()]);
                            $interaction->editOriginalResponse(MessageBuilder::new()->setContent("❌ Error al traducir: " . $e->getMessage()));
                        }
                    }, function ($error) use ($interaction, $logger) {
                        $logger->error("[TRANSLATION_BUTTON] Error al obtener mensaje original", ['error' => $error->getMessage()]);
                        $interaction->editOriginalResponse(MessageBuilder::new()->setContent("❌ No se pudo obtener el mensaje original."));
                    });
                }, function ($error) use ($logger, $interaction) {
                    $logger->error("[TRANSLATION_BUTTON] Error al reconocer (defer) la interacción.", ['error' => $error->getMessage()]);
                    // If even deferring fails, we can't edit the response.
                });
                return; // Finalizar para no procesar otros ifs
            }

            // Traducción de plantillas completas (comandos #)
            if (strpos($customId, 'translate_template:') === 0) {
                $payload = substr($customId, strlen('translate_template:'));
                $parts = explode(':', $payload, 2);
                if (count($parts) !== 2) {
                    $interaction->respondWithMessage(MessageBuilder::new()->setContent('Formato de botón inválido.'), true);
                    return;
                }
                [$commandKey, $targetLang] = $parts;
                $interaction->respondWithMessage(MessageBuilder::new()->setContent('⌛ Traduciendo plantilla...'), true);

                try {
                    // Obtener contenido HTML original de la plantilla
                    $stmt = $pdo->prepare("SELECT message_content FROM recurrent_messages WHERE telegram_command = ?");
                    $stmt->execute([$commandKey]);
                    $template = $stmt->fetch(PDO::FETCH_ASSOC);
                    if (!$template) {
                        $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                        $sender->sendRawMessage($interaction->channel_id, '<@' . $userId . '> No se encontró la plantilla.');
                        return;
                    }

                    $originalHtml = $template['message_content'] ?? '';
                    $converter = new HtmlToDiscordMarkdownConverter();
                    $partsArr = $converter->convertToArray($originalHtml);

                    // Unir todos los segmentos de texto (las imágenes no se traducen)
                    $fullText = '';
                    foreach ($partsArr as $p) {
                        if (($p['type'] ?? '') === 'text') {
                            $fullText .= ($fullText === '' ? '' : "\n\n") . trim((string)$p['content']);
                        }
                    }

                    if ($fullText === '') {
                        $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                        $sender->sendRawMessage($interaction->channel_id, '<@' . $userId . '> No hay contenido de texto para traducir en la plantilla.');
                        return;
                    }

                    $translator = new Translate(LIBRETRANSLATE_URL);
                    $sourceLang = $translator->detectLanguage($fullText) ?? 'es';
                    if ($sourceLang === $targetLang) {
                        // Fallback: fuerza ES como origen si coincide con el destino (común en nuestras plantillas)
                        $fallbackSrc = 'es';
                        if ($fallbackSrc !== $targetLang) {
                            $translated = $translator->translateText($fullText, $fallbackSrc, $targetLang);
                            $sourceLang = $fallbackSrc;
                        } else {
                            $translated = '';
                        }
                    } else {
                        $translated = $translator->translateText($fullText, $sourceLang, $targetLang);
                    }
                    if ($translated === '') {
                        $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                        $sender->sendRawMessage($interaction->channel_id, '<@' . $userId . '> El contenido ya está en este idioma.');
                        return;
                    }

                    // Bandera
                    $flag = '';
                    try {
                        $stmt = $pdo->prepare("SELECT flag_emoji FROM supported_languages WHERE language_code = ? AND is_active = 1");
                        $stmt->execute([$targetLang]);
                        $flag = $stmt->fetchColumn() ?: '';
                    } catch (\Throwable $e) { /* noop */ }
                    $flag = $flag !== '' ? $flag : '🏳️';

                    $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                    // Pequeña espera para que el mensaje efímero aparezca primero
                    usleep(300000);
                    $sender->sendRawMessage($interaction->channel_id, '<@' . $userId . "> {$flag} Traducción plantilla ({$sourceLang} → {$targetLang}):\n" . $translated);
                } catch (\Throwable $e) {
                    $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                    $sender->sendRawMessage($interaction->channel_id, '<@' . $userId . "> Error al traducir plantilla: " . $e->getMessage());
                }
                return;
            }

            if ($customId === 'platicar_bot' || $customId === 'usar_ia') {
                $newMode = ($customId === 'platicar_bot') ? 'bot' : 'ia';
                
                $stmt = $pdo->prepare("UPDATE recipients SET chat_mode = ? WHERE platform_id = ? AND platform = 'discord'");
                $stmt->execute([$newMode, $userId]);
                
                $responseText = $newMode === 'bot' 
                    ? "🤖 Modo cambiado a 'Platicar con bot'. Ahora puedes usar los comandos normales como `/comandos`."
                    : "🧠 Modo cambiado a 'Usar IA'. Todo lo que escribas será procesado por la IA.\n\nEscribe `/agente` para volver a este menú.";
                
                $interaction->respondWithMessage(MessageBuilder::new()->setContent($responseText), true);
                $logger->info("[MODO AGENTE] Usuario $userId cambió al modo: $newMode");
            }
        } catch (Throwable $e) {
            $logger->error("[INTERACCION] Error al procesar el botón.", ['error' => $e->getMessage()]);
            $interaction->respondWithMessage(MessageBuilder::new()->setContent("Hubo un error al cambiar de modo."), true);
        }
    });


    // Evento para manejar mensajes
    $discord->on(Event::MESSAGE_CREATE, function (Message $message, Discord $discord) use ($pdo, $logger) {
        if ($message->author->bot) return;

        $logger->info("[Mensaje Recibido] En canal '{$message->channel->name}' de @{$message->author->username}: {$message->content}");
        
        $isPrivateChat = $message->channel->is_private;
        $userId = $message->author->id;
        $content = $message->content;

        try {
            if ($isPrivateChat) {
                // --- LÓGICA DE CHAT PRIVADO (AGENTE/IA/BOT) ---
                $logger->info("[MODO AGENTE] Mensaje en chat privado de $userId.");

                $stmt = $pdo->prepare("SELECT chat_mode FROM recipients WHERE platform_id = ? AND platform = 'discord'");
                $stmt->execute([$userId]);
                $userChatMode = $stmt->fetchColumn();

                if ($userChatMode === false) {
                    // --- Nuevo Usuario en DM ---
                    $logger->info("[NUEVO USUARIO DM] Usuario $userId no encontrado. Registrando...");
                    $userName = $message->author->username;
                    
                    $insertStmt = $pdo->prepare(
                        "INSERT INTO recipients (platform_id, name, type, platform, language_code, chat_mode) 
                         VALUES (?, ?, 'user', 'discord', 'es', 'agent') 
                         ON DUPLICATE KEY UPDATE name = VALUES(name)"
                    );
                    $insertStmt->execute([$userId, $userName]);
                    $logger->info("[NUEVO USUARIO DM] Usuario $userId ($userName) registrado con modo 'agent'.");
                    $userChatMode = 'agent'; // Forzar modo agente para la primera interacción
                }

                if (trim($content) === '/agente') {
                    $stmt = $pdo->prepare("UPDATE recipients SET chat_mode = 'agent' WHERE platform_id = ? AND platform = 'discord'");
                    $stmt->execute([$userId]);
                    $userChatMode = 'agent';
                    $logger->info("[MODO AGENTE] Usuario $userId usó /agente. Reseteando a modo 'agent'.");
                }

                switch ($userChatMode) {
                    case 'agent':
                        $builder = MessageBuilder::new()->setContent("👋 Hola! ¿Cómo quieres interactuar?");
                        $actionRow = ActionRow::new()
                            ->addComponent(Button::new(Button::STYLE_PRIMARY, 'platicar_bot')->setLabel('🤖 Platicar con bot'))
                            ->addComponent(Button::new(Button::STYLE_SUCCESS, 'usar_ia')->setLabel('🧠 Usar IA'));
                        $builder->addComponent($actionRow);
                        $message->channel->sendMessage($builder);
                        return;

                    case 'ia':
                        $logger->info("[MODO IA] Mensaje de $userId para la IA: $content");
                        $n8nWebhookUrl = $_ENV['N8N_IA_WEBHOOK_URL_DISCORD'] ?? null;
                        if ($n8nWebhookUrl) {
                            $postData = [
                                'chat_id' => $message->channel_id,
                                'user_id' => $userId,
                                'message' => $content,
                                'name' => $message->author->username
                            ];
                            $ch = curl_init($n8nWebhookUrl);
                            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                            curl_setopt($ch, CURLOPT_POST, true);
                            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($postData));
                            curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
                            curl_setopt($ch, CURLOPT_TIMEOUT, 10);
                            curl_exec($ch);
                            curl_close($ch);
                            $logger->info("[MODO IA] Mensaje reenviado a n8n.");
                        } else {
                            $logger->error("[MODO IA] La variable N8N_IA_WEBHOOK_URL no está configurada.");
                        }
                        return;

                    case 'bot':
                        // Continuar con la lógica normal de bot abajo
                        break;
                }
            }

            // --- LÓGICA DE BOT NORMAL (CHATS PÚBLICOS O MODO 'bot') ---
            if (strpos($content, '/') === 0 || strpos($content, '#') === 0) {
                handleDiscordCommand($message, $pdo, $logger);
            } else if (strtolower($content) === '!ping') {
                $message->reply('pong!');
            } else {
                handleDiscordTranslation($message, $pdo, $logger);
            }

        } catch (Throwable $e) {
            $logger->error("!!!!!!!!!! ERROR FATAL CAPTURADO !!!!!!!!!!", [
                'error' => $e->getMessage(), 'file' => $e->getFile(), 'line' => $e->getLine(), 'trace' => $e->getTraceAsString()
            ]);
        }
    });

    $discord->run();

} catch (Throwable $e) {
    $logger->critical("!!!!!!!!!! ERROR FATAL AL INICIAR !!!!!!!!!!", [
        'error' => $e->getMessage(), 'file' => $e->getFile(), 'line' => $e->getLine()
    ]);
    die();
}

function handleDiscordCommand(Message $message, PDO $pdo, Logger $logger)
{
    $text = trim($message->content);
    $userId = $message->author->id;

    if (strpos($text, '#') === 0) {
        $command = ltrim($text, '#');
        $logger->info("[Comando] Usuario @{$message->author->username} solicitó: #{$command}");
        try {
            $stmt = $pdo->prepare("SELECT message_content FROM recurrent_messages WHERE telegram_command = ?");
            $stmt->execute([$command]);
            $template = $stmt->fetch(PDO::FETCH_ASSOC);

            if ($template) {
                $logger->info("[Comando] Plantilla encontrada para #{$command}.");
                $originalHtml = $template['message_content'];

                $sender = new DiscordSender(DISCORD_BOT_TOKEN);
                $sentMessageIds = $sender->sendMessage($message->channel_id, $originalHtml);

                if ($sentMessageIds && !empty($sentMessageIds)) {
                    $firstMessageId = $sentMessageIds[0];
                    $logger->info("Mensajes enviados, primer ID: {$firstMessageId}");

                    // Añadir botones de traducción dinámicos
                    $message->channel->messages->fetch($firstMessageId)->done(function (Message $sentMessage) use ($pdo, $logger, $command) {
                        $langStmt = $pdo->query("SELECT language_code, language_name, flag_emoji FROM supported_languages WHERE is_active = 1");
                        $activeLangs = $langStmt->fetchAll(PDO::FETCH_ASSOC);

                        if (count($activeLangs) > 1) {
                            $components = [];
                            $actionRow = ActionRow::new();
                            $buttonCount = 0;

                            foreach ($activeLangs as $lang) {
                                // Para plantillas, incluir el comando en el custom_id para traducir el contenido completo original
                                $button = Button::new(Button::STYLE_SECONDARY, 'translate_template:' . $command . ':' . $lang['language_code'])
                                    ->setLabel($lang['language_name']);
                                if (!empty($lang['flag_emoji'])) {
                                    $button->setEmoji($lang['flag_emoji']);
                                }
                                $actionRow->addComponent($button);
                                $buttonCount++;

                                // Discord permite máximo 5 botones por ActionRow
                                if ($buttonCount % 5 === 0) {
                                    $components[] = $actionRow;
                                    $actionRow = ActionRow::new();
                                }
                            }
                            if ($buttonCount % 5 !== 0) {
                                $components[] = $actionRow;
                            }

                            $builder = MessageBuilder::new()->setComponents($components);
                            $sentMessage->edit($builder);
                            $logger->info("Botones de traducción añadidos al mensaje {$sentMessage->id}");
                        }
                    });
                }

            } else {
                $message->reply("El comando `#{$command}` no fue encontrado.");
            }
        } catch (Throwable $e) {
            $logger->error("[Error Comando] Procesando #{$command}", ['error' => $e->getMessage()]);
            $message->reply("Ocurrió un error inesperado al procesar tu comando.");
        }
    } elseif (strpos($text, '/setlang') === 0) {
        $parts = explode(' ', $text, 2);
        if (count($parts) < 2 || strlen(trim($parts[1])) !== 2) {
            $message->reply("❌ Formato incorrecto. Usa: `/setlang es`");
            return;
        }
        $newLangCode = strtolower(trim($parts[1]));
        $stmt = $pdo->prepare("UPDATE recipients SET language_code = ? WHERE platform_id = ? AND platform = 'discord'");
        $stmt->execute([$newLangCode, $userId]);
        $message->reply("✅ Tu idioma ha sido establecido a '" . strtoupper($newLangCode) . "'.");

    } elseif (strpos($text, '/bienvenida') === 0) {
        $configStmt = $pdo->query("SELECT * FROM telegram_bot_messages WHERE id = 1");
        $welcomeConfig = $configStmt->fetch(PDO::FETCH_ASSOC);
        if ($welcomeConfig && $welcomeConfig['is_active']) {
            $messageText = str_replace('{user_name}', $message->author->username, $welcomeConfig['message_text']);
            $converter = new HtmlToDiscordMarkdownConverter();
            $markdownText = $converter->convert($messageText);
            $builder = MessageBuilder::new()->setContent($markdownText);
            $actionRow = ActionRow::new()
                ->addComponent(Button::new(Button::STYLE_LINK, $welcomeConfig['group_invite_link'])->setLabel($welcomeConfig['button_text']));
            $builder->addComponent($actionRow);
            $message->channel->sendMessage($builder);
        } else {
            $message->reply("ℹ️ La función de bienvenida no está activa.");
        }

    } elseif (strpos($text, '/comandos') === 0) {
        $stmt = $pdo->query("SELECT telegram_command, name FROM recurrent_messages WHERE telegram_command IS NOT NULL AND telegram_command != '' ORDER BY name ASC");
        $commands = $stmt->fetchAll(PDO::FETCH_ASSOC);
        if (empty($commands)) {
            $message->reply("ℹ️ No hay comandos personalizados disponibles.");
        } else {
            $response = "**LISTA DE COMANDOS DISPONIBLES**\n\n";
            foreach ($commands as $cmd) {
                $command = trim($cmd['telegram_command']);
                if (strpos($command, '#') !== 0) $command = '#' . $command;
                $name = trim($cmd['name']);
                $response .= "`" . $command . "` - " . $name . "\n";
            }
            $response .= "\nℹ️ Escribe el comando para usarlo.";
            $message->channel->sendMessage($response);
        }

    } elseif (strpos($text, '/agente') === 0) {
        $prompt = trim(substr($text, strlen('/agente')));
        $logger->info("[Comando] Usuario @{$message->author->username} solicitó: /agente con prompt: '{$prompt}'");

        if (empty($prompt)) {
            $message->reply("Por favor, escribe tu consulta después de /agente.");
            return;
        }

        $n8nWebhookUrl = $_ENV['N8N_IA_WEBHOOK_URL_DISCORD'] ?? null;
        if ($n8nWebhookUrl) {
            $postData = [
                'chat_id' => $message->channel_id,
                'user_id' => $message->author->id,
                'message' => $prompt,
                'name' => $message->author->username
            ];
            $ch = curl_init($n8nWebhookUrl);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($postData));
            curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
            curl_setopt($ch, CURLOPT_TIMEOUT, 10);
            curl_exec($ch);
            curl_close($ch);
            
            $logger->info("[Comando /agente] Prompt reenviado a n8n.");
            $message->reply("Tu solicitud ha sido enviada al agente. Recibirás una respuesta en breve.");
        } else {
            $logger->error("[Comando /agente] La variable N8N_IA_WEBHOOK_URL no está configurada.");
            $message->reply("No se pudo procesar tu solicitud. El servicio de agente no está configurado.");
        }
    }
}

function handleDiscordTranslation(Message $message, PDO $pdo, Logger $logger)
{
    try {
        $translator = new Translate(LIBRETRANSLATE_URL); // Instanciar al inicio

        $messageContentOriginal = trim($message->content);
        
        // Determine if there is translatable text content based on LibreTranslate confidence
        $hasTranslatableText = false;
        $contentForDetection = ''; // Initialize outside if block for broader scope

        if (!empty($messageContentOriginal)) { // Only try to detect if message has any content
            // Prepare content for language detection: remove custom Discord emojis
            $contentForDetection = preg_replace('/<a?:(\w+):(\d+)>/u', '', $messageContentOriginal);
            // Removed: $contentForDetection = strip_tags($contentForDetection); // This was the culprit
            $contentForDetection = trim($contentForDetection);

            if (!empty($contentForDetection)) { // Only if there's something left to detect
                $detectionResult = $translator->detectLanguage($contentForDetection);
                $confidence = $detectionResult[0]['confidence'] ?? 0.0;
                if ($confidence > 0.0) {
                    $hasTranslatableText = true;
                }
            }
        }
        
        // If no translatable text is found, do not send buttons.
        if (!$hasTranslatableText) {
            $logger->info("[TRANSLATION_BUTTONS] Mensaje de Discord #{$message->id} sin contenido de texto traducible, no se envían botones de traducción.");
            return;
        }

        // 1. Detectar idioma original (using the content prepared for detection, which we know has text)
        $finalDetectionResult = $translator->detectLanguage($contentForDetection); // This will be the full array or null
        $detectedLang = $finalDetectionResult[0]['language'] ?? 'es'; // Correctly extract language
        
        // 2. Obtener todos los idiomas activos con información completa
        $langStmt = $pdo->query("SELECT language_code, language_name, flag_emoji FROM supported_languages WHERE is_active = 1 ORDER BY language_name ASC");
        $activeLangs = $langStmt->fetchAll(PDO::FETCH_ASSOC);

        // 3. Filtrar los idiomas de destino (todos los activos menos el original)
        $targetLangs = array_filter($activeLangs, function($lang) use ($detectedLang) {
            return $lang['language_code'] !== $detectedLang;
        });

        // 4. Si no hay idiomas a los que traducir, no hacer nada
        if (empty($targetLangs)) {
            $logger->info("[TRANSLATION_BUTTONS] No se requieren botones de traducción para el mensaje de Discord #{$message->id} desde '$detectedLang'.");
            return;
        }

        // 5. Crear botones de traducción para cada idioma destino
        $components = [];
        $actionRow = ActionRow::new();
        $buttonCount = 0;

        foreach ($targetLangs as $lang) {
            $button = Button::new(Button::STYLE_SECONDARY, 'translate_to_lang:' . $message->id . ':' . $lang['language_code'])
                ->setLabel($lang['language_name']);
            if (!empty($lang['flag_emoji'])) {
                $button->setEmoji($lang['flag_emoji']);
            }
            $actionRow->addComponent($button);
            $buttonCount++;

            if ($buttonCount % 5 === 0) {
                $components[] = $actionRow;
                $actionRow = ActionRow::new();
            }
        }
        if ($buttonCount % 5 !== 0) {
            $components[] = $actionRow;
        }

        // 6. Enviar mensaje del bot con botones como respuesta al mensaje original
        $builder = MessageBuilder::new()
            ->setContent('🌐 Select a language to translate to:')
            ->setComponents($components);
        
        $message->reply($builder)->done(function () use ($logger, $message, $detectedLang) {
            $logger->info("[TRANSLATION_BUTTONS] Botones de traducción enviados para mensaje #{$message->id} (idioma detectado: $detectedLang)");
        }, function ($error) use ($logger, $message) {
            $logger->error("[TRANSLATION_BUTTONS] Error al enviar botones para mensaje #{$message->id}", ['error' => $error->getMessage()]);
        });

    } catch (Throwable $e) {
        $logger->error("[TRANSLATION_BUTTONS] Error al procesar mensaje para botones de traducción", ['error' => $e->getMessage(), 'trace' => $e->getTraceAsString()]);
    }
}
