app.py

import os
import asyncio
import logging
import tempfile
import requests
from datetime import datetime
from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
import edge_tts
import gradio as gr
from transformers import GPT2Tokenizer, GPT2LMHeadModel
import torch

# --- Importar la librería de Pexels ---
from pexels_api import API # ¡Asegúrate de instalarla: pip install pexels-api!

# --- Configuración de Logging ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- Clave API de Pexels ---
# IMPORTANTE: No uses tu clave API directamente aquí en un repositorio público.
# Lo ideal es cargarla desde una variable de entorno o un archivo de configuración SEGURO.
# Para Hugging Face Spaces, puedes añadirla como un "Secret" llamado PEXELS_API_KEY.
PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "TU_CLAVE_API_PEXELS_AQUI") # Reemplaza "TU_CLAVE_API_PEXELS_AQUI" con tu clave si pruebas localmente sin variables de entorno
pexels_api = API(PEXELS_API_KEY)

# --- Inicialización de Tokenizer y Modelo GPT-2 ---
MODEL_NAME = "gpt2-small"
try:
    tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
    model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    logger.info(f"Modelo GPT-2 '{MODEL_NAME}' cargado exitosamente.")
except Exception as e:
    logger.error(f"Error al cargar el modelo GPT-2 '{MODEL_NAME}': {e}")
    tokenizer = None
    model = None

# --- Funciones de Utilidad ---

def generate_script(prompt, max_length=250):
    if not tokenizer or not model:
        logger.error("Modelo GPT-2 no disponible para generar guion.")
        return "Lo siento, el generador de guiones no está disponible en este momento."

    logger.info("Generando guion con GPT-2...")
    try:
        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        inputs = {k: v.to(device) for k, v in inputs.items()}
        model.to(device)

        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_length=max_length,
                do_sample=True,
                top_p=0.95,
                top_k=60,
                temperature=0.9,
                pad_token_id=tokenizer.pad_token_id,
                eos_token_id=tokenizer.eos_token_id
            )
        text = tokenizer.decode(outputs[0], skip_special_tokens=True)
        logger.info(f"Guion generado (longitud: {len(text)} caracteres): {text[:200]}...")
        return text
    except Exception as e:
        logger.error(f"Error durante la generación del guion: {e}")
        return "No se pudo generar el guion. Intenta con otro prompt o un guion propio."

async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"):
    logger.info(f"Generando audio TTS para: '{text[:100]}...'")
    try:
        communicate = edge_tts.Communicate(text, voice)
        await communicate.save(output_path)
        logger.info(f"Audio TTS guardado en {output_path}")
    except Exception as e:
        logger.error(f"Error al generar audio TTS: {e}")
        raise

def download_video_sample(url):
    if not url:
        return None
    logger.info(f"Intentando descargar video de: {url}")
    tmp = None
    try:
        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
        response = requests.get(url, stream=True, timeout=20) # Aumentar timeout para videos más grandes
        response.raise_for_status()

        for chunk in response.iter_content(chunk_size=8192):
            if chunk:
                tmp.write(chunk)
        tmp.close()
        logger.info(f"Video descargado a: {tmp.name}")
        return tmp.name
    except requests.exceptions.RequestException as e:
        logger.error(f"Error de red/HTTP al descargar el video {url}: {e}")
        if tmp and os.path.exists(tmp.name):
            os.remove(tmp.name)
        return None
    except Exception as e:
        logger.error(f"Error inesperado al descargar video {url}: {e}")
        if tmp and os.path.exists(tmp.name):
            os.remove(tmp.name)
        return None

def loop_audio_to_length(audio_clip, target_duration):
    if audio_clip.duration >= target_duration:
        return audio_clip.subclip(0, target_duration)
    
    loops = int(target_duration / audio_clip.duration) + 1
    audios = [audio_clip] * loops
    concatenated = concatenate_videoclips(audios)
    return concatenated.subclip(0, target_duration)

# --- NUEVA FUNCIÓN: Búsqueda de videos en Pexels ---
def search_pexels_videos(query, num_videos=3, min_duration_sec=5):
    """
    Busca videos en Pexels basados en una query y devuelve una lista de URLs de descarga.
    """
    if not PEXELS_API_KEY or PEXELS_API_KEY == "TU_CLAVE_API_PEXELS_AQUI":
        logger.warning("PEXELS_API_KEY no configurada. No se buscarán videos en Pexels.")
        return []

    logger.info(f"Buscando {num_videos} videos en Pexels para la query: '{query}'")
    video_urls = []
    try:
        # Pexels API para videos: search_videos(query, orientation, size, per_page, page)
        # La API de Pexels no permite filtrar directamente por duración mínima.
        # Tendremos que filtrar después de obtener los resultados.
        pexels_api.search_videos(query, per_page=num_videos * 3) # Pedimos más por si algunos no cumplen duración
        videos = pexels_api.get_videos()

        if not videos:
            logger.warning(f"No se encontraron videos en Pexels para la query: '{query}'")
            return []

        for video in videos:
            # Pexels devuelve diferentes archivos de video (quality). Buscamos la más adecuada (p.ej., medium o large).
            # También verificamos la duración si está disponible en los metadatos de Pexels.
            if video.get('duration') and video['duration'] < min_duration_sec:
                logger.info(f"Saltando video {video['id']} de Pexels por duración ({video['duration']}s < {min_duration_sec}s).")
                continue

            # Buscar la URL de descarga del video de mayor calidad disponible o una calidad aceptable.
            # Los archivos vienen en una lista 'video_files'.
            best_quality_url = None
            for file in video.get('video_files', []):
                # Preferir calidades como 'hd', 'sd', 'medium', 'large'
                if file.get('quality') in ['hd', 'sd', 'medium', 'large'] and file.get('link'):
                    best_quality_url = file['link']
                    break # Tomar el primero que cumpla
                elif file.get('link'): # Si no hay calidad específica, tomar cualquier enlace válido
                    best_quality_url = file['link']

            if best_quality_url:
                video_urls.append(best_quality_url)
                if len(video_urls) >= num_videos:
                    break # Suficientes videos
            else:
                logger.warning(f"No se encontró URL de descarga válida para el video Pexels ID: {video.get('id')}")

        logger.info(f"Encontrados {len(video_urls)} URLs de video de Pexels para '{query}'.")
        return video_urls

    except Exception as e:
        logger.error(f"Error al buscar videos en Pexels para '{query}': {e}")
        return []

# --- Función Principal de Creación de Video ---

def crear_video(prompt_type, input_text, musica_url=None):
    logger.info(f"Iniciando creación de video. Tipo de prompt: {prompt_type}")
    guion = ""
    if prompt_type == "Generar Guion con IA":
        guion = generate_script(input_text)
        if not guion or guion == "No se pudo generar el guion. Intenta con otro prompt o un guion propio.":
            raise ValueError(guion)
    else: # prompt_type == "Usar Mi Guion"
        guion = input_text
        if not guion.strip():
            raise ValueError("Por favor, introduce tu guion.")

    if not guion.strip():
        raise ValueError("El guion está vacío. No se puede proceder.")

    temp_files = []
    clips = []

    try:
        # 1. Generar audio TTS
        voz_archivo = os.path.join(tempfile.gettempdir(), f"voz_temp_{os.getpid()}.mp3")
        temp_files.append(voz_archivo)
        asyncio.run(text_to_speech(guion, output_path=voz_archivo))
        audio_tts = AudioFileClip(voz_archivo)

        # 2. Búsqueda y descarga de videos con Pexels
        # Usamos el guion o el prompt inicial para la búsqueda en Pexels
        search_query = input_text if prompt_type == "Generar Guion con IA" else guion.split('.')[0] # Usar primera frase del guion
        pexels_video_urls = search_pexels_videos(search_query, num_videos=4, min_duration_sec=7) # Pedimos 4, min 7s

        # Si Pexels no devuelve nada o falla, podemos tener unas URLs de fallback
        if not pexels_video_urls:
            logger.warning("Pexels no devolvió videos. Usando videos de ejemplo de fallback.")
            pexels_video_urls = [
                "https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-mp4-file.mp4",
                "https://file-examples.com/storage/fe2c91b5c46522c0734a74a/2017/04/file_example_MP4_480_1_5MG.mp4",
                "https://sample-videos.com/video123/mp4/720/big_buck_bunny_720p_1mb.mp4",
                "https://test-videos.co.uk/vids/bigbuckbunny/mp4/720/big_buck_bunny_720p_1mb.mp4"
            ]

        valid_clip_found = False
        for url in pexels_video_urls:
            video_path = download_video_sample(url)
            if video_path:
                temp_files.append(video_path)
                try:
                    clip = VideoFileClip(video_path).subclip(0, min(15, VideoFileClip(video_path).duration))
                    if clip.duration > 1:
                        clips.append(clip)
                        valid_clip_found = True
                    else:
                        logger.warning(f"Clip de video muy corto ({clip.duration:.2f}s) de {url}, omitiendo.")
                        clip.close()
                except Exception as e:
                    logger.warning(f"No se pudo cargar o procesar el clip de video {video_path} de {url}: {e}")
            else:
                logger.warning(f"No se pudo descargar el video de la URL: {url}")
        
        if not valid_clip_found or not clips:
            logger.error("No se pudieron obtener clips de video válidos. Abortando creación de video.")
            raise ValueError("No se encontraron clips de video válidos. Asegúrate de que las URLs de Pexels o fallback sean correctas y accesibles.")

        # 3. Concatenar videos
        video_base = concatenate_videoclips(clips, method="compose")
        logger.info(f"Video base concatenado, duración: {video_base.duration:.2f}s")

        if video_base.duration < audio_tts.duration:
            logger.info(f"Duración del video ({video_base.duration:.2f}s) es menor que la del audio TTS ({audio_tts.duration:.2f}s). Repitiendo video.")
            num_repeats = int(audio_tts.duration / video_base.duration) + 1
            repeated_clips = [video_base] * num_repeats
            video_base = concatenate_videoclips(repeated_clips, method="compose")

        final_video_duration = audio_tts.duration

        # 4. Música de fondo en loop
        mezcla_audio = audio_tts
        if musica_url and musica_url.strip():
            musica_path = download_video_sample(musica_url)
            if musica_path:
                temp_files.append(musica_path)
                try:
                    musica_audio = AudioFileClip(musica_path)
                    musica_loop = loop_audio_to_length(musica_audio, final_video_duration)
                    mezcla_audio = CompositeAudioClip([musica_loop.volumex(0.3), audio_tts.set_duration(final_video_duration).volumex(1.0)])
                    logger.info("Música de fondo añadida y mezclada.")
                except Exception as e:
                    logger.warning(f"No se pudo procesar la música de fondo de {musica_url}: {e}. Se usará solo la voz.")
            else:
                logger.warning(f"No se pudo descargar la música de {musica_url}. Se usará solo la voz.")
        
        # 5. Asignar audio al video y ajustar duración
        video_final = video_base.set_audio(mezcla_audio).subclip(0, final_video_duration)
        logger.info(f"Video final configurado con audio. Duración final: {video_final.duration:.2f}s")

        # 6. Guardar video final
        output_dir = "generated_videos"
        os.makedirs(output_dir, exist_ok=True)
        output_path = os.path.join(output_dir, f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4")
        logger.info(f"Escribiendo video final a: {output_path}")
        video_final.write_videofile(output_path, fps=24, threads=4, logger=None, preset="medium", codec="libx264")

        logger.info(f"Video generado exitosamente en: {output_path}")
        return output_path

    except Exception as e:
        logger.error(f"Error general en la creación del video: {e}", exc_info=True)
        raise e
    finally:
        for f in temp_files:
            if os.path.exists(f):
                try:
                    os.remove(f)
                    logger.info(f"Archivo temporal eliminado: {f}")
                except Exception as e:
                    logger.warning(f"No se pudo eliminar el archivo temporal {f}: {e}")
        for clip in clips:
            if clip:
                clip.close()
        if 'audio_tts' in locals() and audio_tts:
            audio_tts.close()
        if 'musica_audio' in locals() and musica_audio:
            musica_audio.close()
        if 'video_final' in locals() and video_final:
            video_final.close()
        if 'video_base' in locals() and video_base:
            video_base.close()


def run_app(prompt_type, prompt_ia, prompt_manual, musica_url):
    input_text = ""
    if prompt_type == "Generar Guion con IA":
        input_text = prompt_ia
        if not input_text.strip():
            raise gr.Error("Por favor, introduce un tema para generar el guion.")
    else:
        input_text = prompt_manual
        if not input_text.strip():
            raise gr.Error("Por favor, introduce tu guion.")

    logger.info(f"Solicitud recibida: Tipo='{prompt_type}', Input='{input_text[:50]}...', Música='{musica_url}'")

    try:
        video_path = crear_video(prompt_type, input_text, musica_url if musica_url.strip() else None)
        if video_path:
            logger.info(f"Proceso completado. Video disponible en: {video_path}")
            return video_path, gr.update(value="¡Video generado exitosamente!")
        else:
            raise gr.Error("Hubo un problema desconocido al generar el video. Revisa los logs.")
    except ValueError as ve:
        logger.error(f"Error de validación: {ve}")
        return None, gr.update(value=f"Error: {ve}", text_color="red")
    except Exception as e:
        logger.error(f"Error inesperado al ejecutar la aplicación: {e}", exc_info=True)
        return None, gr.update(value=f"Ocurrió un error grave: {e}. Por favor, inténtalo de nuevo.", text_color="red")

# --- Interfaz de Gradio ---
with gr.Blocks() as app:
    gr.Markdown("""
    ### 🎬 Generador de Video Inteligente con Pexels 🚀
    Crea videos con guiones generados por IA o propios, voz automática y videos de stock relevantes de Pexels.
    """)
    
    with gr.Tab("Generar Video"):
        with gr.Row():
            prompt_type = gr.Radio(
                ["Generar Guion con IA", "Usar Mi Guion"], 
                label="Método de Guion", 
                value="Generar Guion con IA"
            )
        
        with gr.Column(visible=True) as ia_guion_column:
            prompt_ia = gr.Textbox(
                label="Tema para Generar Guion (con IA)", 
                lines=2, 
                placeholder="Ej: Las maravillas del universo y las estrellas."
            )
        
        with gr.Column(visible=False) as manual_guion_column:
            prompt_manual = gr.Textbox(
                label="Introduce Tu Guion Propio", 
                lines=5, 
                placeholder="Ej: Hola a todos, hoy hablaremos de un tema fascinante..."
            )
        
        musica_input = gr.Textbox(
            label="URL de Música de Fondo (opcional, MP3 recomendado)", 
            placeholder="Ej: https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"
        )
        
        boton = gr.Button("✨ Generar Video")
        
        with gr.Column():
            salida_video = gr.Video(label="Video Generado", interactive=False)
            estado_mensaje = gr.Textbox(label="Estado del Proceso", interactive=False, value="")

    prompt_type.change(
        fn=lambda value: (gr.update(visible=value == "Generar Guion con IA"), 
                          gr.update(visible=value == "Usar Mi Guion")),
        inputs=prompt_type,
        outputs=[ia_guion_column, manual_guion_column]
    )

    boton.click(
        fn=lambda: (None, gr.update(value="Iniciando generación... Esto puede tardar varios minutos (descarga de videos).")),
        outputs=[salida_video, estado_mensaje],
        queue=False
    ).then(
        fn=run_app,
        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
        outputs=[salida_video, estado_mensaje]
    )

    prompt_ia.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
    prompt_manual.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
    musica_input.change(fn=lambda: gr.update(value=""), outputs=estado_mensaje, queue=False)
    
if __name__ == "__main__":
    logger.info("Iniciando aplicación Gradio para Hugging Face Spaces...")
    app.launch(server_name="0.0.0.0", server_port=7860, share=False)