tIW3SjcGi.js

const path = require('path');
const fs = require('fs');
const axios = require('axios');
const { exec } = require('child_process');

// Definiciones del plugin
const details = () => ({
    id: 'tIW3SjcGi',
    Stage: 'Post-processing',
    Name: 'Subtitle Language Check and Translation',
    Type: 'Video',
    Operation: 'Subtitle',
    Description: 'Verifies if subtitles in Spanish are available. If not, extracts and translates to Spanish using OpenAI API.',
    Version: '1.0',
    Tags: 'subtitles, translation, OpenAI, Spanish',
    Inputs: [] // No configurable inputs as functionality is fixed
});

// Función para extraer subtítulos incrustados del video usando FFmpeg
const extractSubtitlesFromVideo = (videoFile) => {
    return new Promise((resolve, reject) => {
        const tempSrtFile = path.join(path.dirname(videoFile), 'extracted_subtitles.srt');
        // Comando FFmpeg para extraer subtítulos incrustados
        exec(`ffmpeg -i "${videoFile}" -map 0:s:0 "${tempSrtFile}"`, (error, stdout, stderr) => {
            if (error) {
                reject(`Error al extraer los subtítulos: ${stderr}`);
            } else {
                resolve(tempSrtFile);
            }
        });
    });
};

// Función para traducir los subtítulos usando la API de OpenAI
const translateSubtitle = async (text) => {
    const apiKey = process.env.OPENAI_API_KEY; // Leer API key desde variable de entorno
    const model = "gpt-4"; // Cambiar modelo si es necesario
    const prompt = `Translate the following subtitle text to Spanish:\n\n${text}`;

    try {
        const response = await axios.post(
            'https://api.openai.com/v1/chat/completions/',
            {
                model,
                messages: [{ role: 'user', content: prompt }],
                max_tokens: 2000,
            },
            {
                headers: {
                    'Authorization': `Bearer ${apiKey}`,
                    'Content-Type': 'application/json',
                },
            }
        );
        return response.data.choices[0].message.content.trim();
    } catch (error) {
        console.error('Error en la solicitud a la API de OpenAI:', error.response ? error.response.data : error.message);
        throw new Error('Error en la traducción del subtítulo');
    }
};

// Plugin principal adaptado para el nuevo formato
const plugin = async (file, librarySettings, inputs, otherArguments) => {
    try {
        const videoFile = file; // Obtener el archivo de video directamente desde el parámetro
        const videoDir = path.dirname(videoFile); // Obtener el directorio del video
        const baseName = path.basename(videoFile, path.extname(videoFile));

        // Verificar si ya existe un archivo de subtítulos en español (externo)
        const existingSubtitlesEs = fs.existsSync(path.join(videoDir, `${baseName}.es.srt`)) || fs.existsSync(path.join(videoDir, `${baseName}.spa.srt`));

        // Si ya existen subtítulos en español, no hacer nada
        if (existingSubtitlesEs) {
            return { status: 'success', message: 'Subtítulos en español ya existentes, no se realizó ninguna acción.' };
        }

        // Verificar si existen subtítulos externos
        const subtitleFilePath = path.join(videoDir, `${baseName}.en.srt`);
        let subtitles = null;

        if (fs.existsSync(subtitleFilePath)) {
            // Si existen subtítulos externos en inglés, los leemos
            subtitles = fs.readFileSync(subtitleFilePath, 'utf-8');
        } else {
            // Si no existen subtítulos externos, extraemos subtítulos embebidos
            subtitles = await extractSubtitlesFromVideo(videoFile);
        }

        // Traducir los subtítulos
        const translatedSubtitles = await translateSubtitle(subtitles);

        // Guardar los subtítulos traducidos en un archivo
        const translatedSubtitlePath = path.join(videoDir, `${baseName}.es.srt`);
        fs.writeFileSync(translatedSubtitlePath, translatedSubtitles);

        // Eliminar archivo de subtítulos extraídos si es embebido
        if (!fs.existsSync(subtitleFilePath)) {
            fs.unlinkSync(subtitles);
        }

        return { status: 'success', translatedSubtitles: translatedSubtitlePath };
    } catch (error) {
        return { status: 'error', error: error.message };
    }
};

module.exports = {
    details,
    plugin
};