<?php
// Habilitar reporte de errores para depuración
error_reporting(E_ALL);
ini_set('display_errors', 1);

// Cargar el autoloader de Composer para las dependencias
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/includes/db.php'; // Conexión a la base de datos

// Configurar cabeceras CORS
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, OPTIONS');
header('Access-Control-Allow-Headers: Content-Type, Authorization');
header('Content-Type: application/json');

// Manejar solicitudes OPTIONS para CORS
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
    http_response_code(200);
    exit();
}

// Cargar las variables de entorno
try {
    // Determinar el entorno desde la variable de entorno del servidor
    $environment = $_SERVER['APP_ENVIRONMENT'] ?? 'pruebas'; // Usar 'pruebas' como fallback
    $envFile = '.env.' . $environment;

    // Verificar si el archivo de entorno existe
    if (!file_exists(__DIR__ . '/' . $envFile)) {
        throw new \Dotenv\Exception\InvalidPathException("El archivo de entorno '{$envFile}' no se encuentra.");
    }

    // Cargar el archivo de entorno correspondiente
    $dotenv = Dotenv\Dotenv::createImmutable(__DIR__, $envFile);
    $dotenv->load();
} catch (\Dotenv\Exception\InvalidPathException $e) {
    http_response_code(500);
    $errorMessage = "Error al cargar la configuración del entorno: " . $e->getMessage();
    // No mostrar detalles sensibles en producción, pero sí en logs
    error_log($errorMessage);
    echo json_encode(["error" => "No se pudo cargar la configuración del entorno."]);
    exit;
}

// Para depuración: registrar qué entorno y URL se están usando
$logEnvData = [
    'timestamp' => date('Y-m-d H:i:s'),
    'message' => 'Environment check',
    'loaded_environment' => $environment,
    'loaded_env_file' => $envFile,
    'libretranslate_url_loaded' => $_ENV['LIBRETRANSLATE_URL'] ?? 'NOT SET'
];

file_put_contents(
    '/var/www/html/bot/logs/translate_proxy.log',
    json_encode($logEnvData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n\n",
    FILE_APPEND
);

// Obtener la URL de LibreTranslate desde las variables de entorno
$libreTranslateUrl = $_ENV['LIBRETRANSLATE_URL'] ?? '';

if (empty($libreTranslateUrl)) {
    http_response_code(500);
    echo json_encode(["error" => "La variable LIBRETRANSLATE_URL no está configurada."]);
    exit;
}

// Asegurarse de que la URL termine con /
$libreTranslateUrl = rtrim($libreTranslateUrl, '/') . '/';

// Función para hacer solicitudes a la API de LibreTranslate
function make_request($url, $method = 'GET', $data = null) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    curl_setopt($ch, CURLOPT_MAXREDIRS, 10);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);

    if ($method === 'POST' && $data) {
        $payload = json_encode($data);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json',
            'Content-Length: ' . strlen($payload)
        ]);
    }

    $response = curl_exec($ch);
    $err = curl_error($ch);
    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($err) {
        return ["error" => "cURL Error: " . $err];
    }
    if ($http_code >= 400) {
        return ["error" => "La API de LibreTranslate devolvió un error: " . $http_code, "response" => json_decode($response, true)];
    }

    return json_decode($response, true);
}

// Obtener el método de la solicitud
$method = $_SERVER['REQUEST_METHOD'];

// Inicializar variables
$jsonData = [];
$action = '';

// Obtener el contenido JSON del cuerpo de la solicitud
$input = file_get_contents('php://input');
if (!empty($input)) {
    $jsonData = json_decode($input, true) ?? [];
}

// Determinar la acción basada en la petición
$action = '';

// Si es una petición GET, buscar el parámetro action
if ($method === 'GET' && isset($_GET['action'])) {
    $action = $_GET['action'];
}
// Si es una petición POST, verificar si es una traducción
elseif ($method === 'POST') {
    // Si hay un parámetro 'action' en el JSON, usarlo
    if (isset($jsonData['action'])) {
        $action = $jsonData['action'];
    }
    // Si no hay 'action' pero hay 'text', 'source' y 'target', asumir que es una traducción
    elseif (isset($jsonData['text'], $jsonData['source'], $jsonData['target'])) {
        $action = 'translate';
    }
}

// Para depuración
$logData = [
    'timestamp' => date('Y-m-d H:i:s'),
    'method' => $method,
    'action' => $action,
    'get_params' => $_GET,
    'post_data' => $_POST,
    'json_data' => $jsonData,
    'raw_input' => $input
];

file_put_contents(
    '/var/www/html/bot/logs/translate_proxy.log', 
    json_encode($logData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n\n",
    FILE_APPEND
);

// Aceptar tanto 'languages' como 'get_languages' para compatibilidad
if ($action === 'get_languages' || $action === 'languages') {
    // 1. Get all supported languages from LibreTranslate
    $libreLanguages = make_request($libreTranslateUrl . '/languages');
    if (isset($libreLanguages['error'])) {
        http_response_code(500);
        echo json_encode($libreLanguages);
        exit;
    }

    // 2. Get all active languages from the local database
    try {
        $stmt = $pdo->query("SELECT * FROM languages WHERE is_active = 1");
        $localLanguages = $stmt->fetchAll(PDO::FETCH_ASSOC);
    } catch (PDOException $e) {
        http_response_code(500);
        error_log("Database error in translate_proxy: " . $e->getMessage());
        echo json_encode(["error" => "Could not retrieve languages from local database."]);
        exit;
    }

    // 3. Create a map of active local languages with their flags
    $activeLanguagesMap = [];
    foreach ($localLanguages as $lang) {
        $activeLanguagesMap[$lang['code']] = $lang;
    }

    // 4. Filter LibreTranslate languages and enrich them with local data
    $enrichedLanguages = [];
    foreach ($libreLanguages as $libreLang) {
        if (isset($activeLanguagesMap[$libreLang['code']])) {
            $localLang = $activeLanguagesMap[$libreLang['code']];
            $enrichedLanguages[] = [
                'code' => $libreLang['code'],
                'name' => $localLang['native_name'], // Use native_name for display
                'flag_emoji' => $localLang['flag_emoji']
            ];
        }
    }

    // 5. Return the enriched list
    header('Content-Type: application/json');
    echo json_encode($enrichedLanguages);

} elseif ($action === 'translate' && $method === 'POST') {
    // Usar los datos del JSON o de $_POST
    $text = trim($jsonData['text'] ?? '');
    $targetLang = $jsonData['target'] ?? 'en';
    $sourceLang = $jsonData['source'] ?? 'es';

    $translationData = [
        'q' => $text,
        'source' => $sourceLang,
        'target' => $targetLang,
        'format' => 'text'
    ];

    $translationResult = make_request($libreTranslateUrl . 'translate', 'POST', $translationData);

    if (isset($translationResult['error'])) {
        http_response_code(500);
    }
    
    // Registrar la respuesta para depuración
    file_put_contents('/var/www/html/bot/logs/translate_proxy.log', 
        date('Y-m-d H:i:s') . " - Translation Result: " . print_r($translationResult, true) . "\n", 
        FILE_APPEND
    );
    
    echo json_encode($translationResult);

} else {
    header("HTTP/1.1 400 Bad Request");
    echo json_encode(["error" => "Acción no válida o no especificada. Se recibió: '" . htmlspecialchars($action) . "'"]);
}