app.py

import os
import asyncio
import logging
import tempfile
import requests
from datetime import datetime
import edge_tts
import gradio as gr
import torch
# Corregir typo: GPT2Tokenizer en lugar de GPTizer
from transformers import GPT2Tokenizer, GPT2LMHeadModel
from keybert import KeyBERT
# Importar concatenate_audioclips específicamente si no está en editor por defecto
from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips
import re
import math
# Pydub ya no parece usarse directamente en las funciones principales,
# pero se mantiene por si acaso o por si se usó en intentos previos.
# from pydub import AudioSegment # Comentado porque no se usa en el flujo principal corregido
from collections import Counter
import shutil
import json

# Configuración de logging MEJORADA
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler('video_generator_full.log', encoding='utf-8')
    ]
)
logger = logging.getLogger(__name__)
logger.info("="*80)
logger.info("INICIO DE EJECUCIÓN - GENERADOR DE VIDEOS")
logger.info("="*80)

# Clave API de Pexels (configuración segura)
# Asegúrate de que esta variable de entorno esté configurada en tu entorno.
PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
if not PEXELS_API_KEY:
    logger.critical("NO SE ENCONTRÓ PEXELS_API_KEY EN VARIABLES DE ENTORNO")
    # Permite que continúe en desarrollo/test pero registra el problema
    # raise ValueError("API key de Pexels no configurada") # Descomentar para forzar fallo si no está
    logger.warning("Continuando sin PEXELS_API_KEY. La búsqueda de videos fallará.")
else:
    logger.info("API key de Pexels configurada correctamente")

# Inicialización de modelos CON LOGS DETALLADOS
MODEL_NAME = "datificate/gpt2-small-spanish"
logger.info(f"Inicializando modelo GPT-2: {MODEL_NAME}")
tokenizer = None # Inicializar a None por si falla
model = None   # Inicializar a None por si falla
try:
    # CORRECCIÓN: Usar GPT2Tokenizer
    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 cargado | Vocabulario: {len(tokenizer)} tokens")
except Exception as e:
    logger.error(f"FALLA CRÍTICA al cargar GPT-2: {str(e)}", exc_info=True)
    tokenizer = model = None # Asegurar que queden como None

logger.info("Cargando modelo KeyBERT...")
kw_model = None # Inicializar a None por si falla
try:
    kw_model = KeyBERT('distilbert-base-multilingual-cased')
    logger.info("KeyBERT inicializado correctamente")
except Exception as e:
    logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
    kw_model = None # Asegurar que quede como None

# [FUNCIÓN BUSCAR_VIDEOS_PEXELS ORIGINAL CON LOGS AÑADIDOS]
def buscar_videos_pexels(query, api_key, per_page=5):
    if not api_key:
        logger.warning("No se puede buscar en Pexels: API Key no configurada.")
        return []

    logger.debug(f"Buscando en Pexels: '{query}' | Resultados: {per_page}")
    headers = {"Authorization": api_key}
    try:
        params = {
            "query": query,
            "per_page": per_page,
            "orientation": "landscape",
            "size": "medium"
        }
        
        logger.debug(f"Params: {params}")
        response = requests.get(
            "https://api.pexels.com/videos/search",
            headers=headers,
            params=params,
            timeout=20
        )
        response.raise_for_status() # Lanza una excepción para códigos de estado de error HTTP

        try:
            data = response.json()
            videos = data.get('videos', [])
            logger.info(f"Pexels: {len(videos)} videos encontrados para '{query}'")
            return videos
        except json.JSONDecodeError:
            logger.error(f"Pexels: JSON inválido recibido | Status: {response.status_code} | Respuesta: {response.text[:200]}...")
            return []
            
    except requests.exceptions.RequestException as e:
        logger.error(f"Error de conexión Pexels para '{query}': {str(e)}")
    except Exception as e:
        logger.error(f"Error inesperado Pexels para '{query}': {str(e)}", exc_info=True)
    
    return []

# [FUNCIÓN GENERATE_SCRIPT ORIGINAL CON LOGS]
def generate_script(prompt, max_length=150):
    logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Longitud máxima: {max_length}")
    if not tokenizer or not model:
        logger.warning("Modelos GPT-2 no disponibles - Usando prompt original como guion.")
        return prompt
    
    try:
        # Intenta mejorar el prompt para la IA si se detecta que es muy corto o no es una pregunta
        # (Esto es una heurística simple, podrías mejorarlo)
        if len(prompt.split()) < 5 or not re.search(r'[¿?.]', prompt):
             enhanced_prompt = f"Escribe un guion corto, interesante y coherente sobre: {prompt}"
        else:
             enhanced_prompt = prompt # Si parece ya un guion o pregunta, úsalo directamente
             logger.debug("Usando prompt original como base para la generación.")

        inputs = tokenizer(enhanced_prompt, return_tensors="pt", truncation=True, max_length=512)
        
        logger.debug("Generando texto con GPT-2...")
        # Asegurar que el modelo esté en modo evaluación y en la CPU si no hay GPU
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        model.to(device)
        inputs = {k: v.to(device) for k, v in inputs.items()}


        outputs = model.generate(
            **inputs,
            max_length=max_length,
            do_sample=True, # Permite creatividad
            top_p=0.9,
            top_k=40,
            temperature=0.7,
            repetition_penalty=1.2, # Reducido un poco para menos repetición agresiva
            pad_token_id=tokenizer.pad_token_id,
            eos_token_id=tokenizer.eos_token_id,
            no_repeat_ngram_size=3 # Ayuda a evitar repeticiones de frases cortas
        )
        
        text = tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # Limpieza del texto
        text = re.sub(r'<[^>]+>', '', text) # Elimina posibles tags HTML/XML si los hay
        text = text.strip()
        
        # Intenta obtener al menos una oración completa si es posible
        sentences = text.split('.')
        if sentences and sentences[0].strip():
            final_text = sentences[0].strip() + '.'
            # Añadir la segunda oración si existe y es razonable
            if len(sentences) > 1 and sentences[1].strip() and len(final_text.split()) < max_length * 0.5: # Si la primera es corta y el guion no muy largo aún
                 final_text += " " + sentences[1].strip() + "."
                 final_text = final_text.replace("..", ".") # Limpiar doble punto

            logger.info(f"Guion generado (Truncado a 100 chars): '{final_text[:100]}...'")
            return final_text.strip() # Asegurar que no haya espacios al inicio/fin
        
        logger.info(f"Guion generado (sin oraciones completas detectadas): '{text[:100]}...'")
        return text.strip() # Si no se puede formar una oración, devolver el texto tal cual
    except Exception as e:
        logger.error(f"Error generando guion con GPT-2: {str(e)}", exc_info=True)
        logger.warning("Usando prompt original como guion debido al error de generación.")
        return prompt.strip() # En caso de error, devolver el prompt original limpio

# [FUNCIÓN TEXT_TO_SPEECH ORIGINAL CON LOGS]
async def text_to_speech(text, output_path, voice="es-ES-ElviraNeural"):
    logger.info(f"Convirtiendo texto a voz | Caracteres: {len(text)} | Voz: {voice} | Salida: {output_path}")
    if not text or not text.strip():
        logger.warning("Texto vacío para TTS")
        return False
        
    try:
        communicate = edge_tts.Communicate(text, voice)
        await communicate.save(output_path)
        
        if os.path.exists(output_path) and os.path.getsize(output_path) > 100: # Check for minimum size
            logger.info(f"Audio guardado exitosamente en: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
            return True
        else:
            logger.error(f"TTS guardó un archivo pequeño o vacío en: {output_path}")
            return False
            
    except Exception as e:
        logger.error(f"Error en TTS: {str(e)}", exc_info=True)
        return False

# [FUNCIÓN DOWNLOAD_VIDEO_FILE ORIGINAL CON LOGS]
def download_video_file(url, temp_dir):
    if not url:
        logger.warning("URL de video no proporcionada para descargar")
        return None
    
    try:
        logger.info(f"Descargando video desde: {url[:80]}...")
        # Usar un nombre más robusto y asegurar que el directorio exista
        os.makedirs(temp_dir, exist_ok=True)
        file_name = f"video_dl_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}.mp4"
        output_path = os.path.join(temp_dir, file_name)
        
        # Aumentar timeout para descargas grandes
        with requests.get(url, stream=True, timeout=60) as r: 
            r.raise_for_status()
            total_size = int(r.headers.get('content-length', 0))
            downloaded_size = 0
            logger.debug(f"Tamaño esperado: {total_size} bytes")

            with open(output_path, 'wb') as f:
                for chunk in r.iter_content(chunk_size=8192):
                    f.write(chunk)
                    downloaded_size += len(chunk)
                    # Opcional: loguear progreso si es muy lento

        # Verificar si el archivo descargado tiene un tamaño razonable
        if os.path.exists(output_path) and os.path.getsize(output_path) > 1000: # Mínimo 1KB
             logger.info(f"Video descargado exitosamente: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
             return output_path
        else:
             logger.warning(f"Descarga parece incompleta o vacía para {url[:80]}... Archivo: {output_path} Tamaño: {os.path.getsize(output_path) if os.path.exists(output_path) else 'N/A'} bytes")
             if os.path.exists(output_path):
                 os.remove(output_path) # Eliminar archivo inválido
             return None

    except requests.exceptions.RequestException as e:
        logger.error(f"Error de descarga para {url[:80]}... : {str(e)}")
    except Exception as e:
        logger.error(f"Error inesperado descargando {url[:80]}... : {str(e)}", exc_info=True)
    
    return None

# [FUNCIÓN LOOP_AUDIO_TO_LENGTH ORIGINAL CON LOGS]
def loop_audio_to_length(audio_clip, target_duration):
    logger.debug(f"Ajustando audio | Duración actual: {audio_clip.duration:.2f}s | Objetivo: {target_duration:.2f}s")
    if audio_clip.duration <= 0:
        logger.warning("Clip de audio de duración cero o negativa, no se puede ajustar.")
        return AudioFileClip(filename="") # Devuelve clip de audio vacío

    if audio_clip.duration >= target_duration:
        logger.debug("Clip de audio ya es más largo o igual al objetivo.")
        return audio_clip.subclip(0, target_duration)
    
    # CORRECCIÓN: Usar concatenate_audioclips para audio
    loops = math.ceil(target_duration / audio_clip.duration)
    logger.debug(f"Creando {loops} loops de audio")
    
    # Crear una lista de clips de audio
    audio_segments = [audio_clip] * loops
    
    # Concatenar los clips de audio
    looped_audio = concatenate_audioclips(audio_segments)
    
    # Recortar al target_duration exacto
    return looped_audio.subclip(0, target_duration)

# [FUNCIÓN EXTRACT_VISUAL_KEYWORDS_FROM_SCRIPT ORIGINAL CON LOGS]
def extract_visual_keywords_from_script(script_text):
    logger.info("Extrayendo palabras clave del guion")
    if not script_text or not script_text.strip():
        logger.warning("Guion vacío, no se pueden extraer palabras clave.")
        return ["naturaleza", "ciudad", "paisaje"] # Keywords por defecto

    # Limpieza de texto más robusta, manteniendo espacios para keyphrases
    clean_text = re.sub(r'[^\w\sáéíóúñÁÉÍÓÚÑ]', '', script_text)
    
    keywords_list = []

    if kw_model:
        try:
            logger.debug("Intentando extraer keywords con KeyBERT...")
            # Intentar con ngrams 1 y 2
            keywords1 = kw_model.extract_keywords(
                clean_text,
                keyphrase_ngram_range=(1, 1),
                stop_words='spanish',
                top_n=5
            )
            keywords2 = kw_model.extract_keywords(
                clean_text,
                keyphrase_ngram_range=(2, 2),
                stop_words='spanish',
                top_n=3
            )
            
            # Combinar y priorizar palabras clave (ngram 1) y frases clave (ngram 2)
            all_keywords = keywords1 + keywords2
            # Ordenar por score descendente
            all_keywords.sort(key=lambda item: item[1], reverse=True)
            
            # Tomar los top N únicos
            seen_keywords = set()
            for keyword, score in all_keywords:
                # Convertir a minúsculas y reemplazar espacios por + para URL
                formatted_keyword = keyword.lower().replace(" ", "+")
                if formatted_keyword not in seen_keywords:
                    keywords_list.append(formatted_keyword)
                    seen_keywords.add(formatted_keyword)
                if len(keywords_list) >= 5: # Limitar el número total de keywords
                    break

            if keywords_list:
                logger.debug(f"KeyBERT keywords extraídas: {keywords_list}")
                return keywords_list

        except Exception as e:
            logger.warning(f"KeyBERT falló durante la extracción: {str(e)}. Intentando método simple.")
            # Continúa al método simple si KeyBERT falla
    
    # Método simple de extracción si KeyBERT no está disponible o falló
    logger.debug("Extrayendo keywords con método simple...")
    words = clean_text.lower().split()
    # Conjunto de stop words más amplio y eficiente
    stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "un", "una", "con", "para", "del", "al", "por", "su", "sus", "se", "lo", "le", "me", "te", "nos", "os", "les", "mi", "tu", "nuestro", "vuestro", "este", "ese", "aquel", "esta", "esa", "aquella", "esto", "eso", "aquello", "mis", "tus", "nuestros", "vuestros", "estas", "esas", "aquellas", "si", "no", "más", "menos", "sin", "sobre", "bajo", "entre", "hasta", "desde", "durante", "mediante", "según", "versus", "via", "cada", "todo", "todos", "toda", "todas", "poco", "pocos", "poca", "pocas", "mucho", "muchos", "mucha", "muchas", "varios", "varias", "otro", "otros", "otra", "otras", "mismo", "misma", "mismos", "mismas", "tan", "tanto", "tanta", "tantos", "tantas", "tal", "tales", "cual", "cuales", "cuyo", "cuya", "cuyos", "cuyas", "quien", "quienes", "cuan", "cuanto", "cuanta", "cuantos", "cuantas", "como", "donde", "cuando", "que", "porque", "si", "aunque", "mientras", "cuando", "como", "donde", "siempre", "nunca", "jamás", "muy", "más", "menos", "tan", "tanto", "casi", "solo", "solamente", "incluso", "apenas", "quizás", "tal vez", "acaso", "claro", "cierto", "obvio", "evidentemente", "realmente", "simplemente", "generalmente", "especialmente", "principalmente", "posiblemente", "probablemente", "difícilmente", "fácilmente", "rápidamente", "lentamente", "bien", "mal", "mejor", "peor", "arriba", "abajo", "adelante", "atrás", "cerca", "lejos", "dentro", "fuera", "encima", "debajo", "frente", "detrás", "antes", "después", "luego", "pronto", "tarde", "todavía", "ya", "aun", "aún", "siempre", "nunca", "jamás", "quizá", "acaso", "tal vez"}

    # Filtrar palabras, eliminar stop words y palabras cortas
    valid_words = [word for word in words if len(word) > 3 and word not in stop_words]
    
    if not valid_words:
        logger.warning("No se encontraron palabras clave válidas con método simple. Usando palabras clave predeterminadas.")
        return ["naturaleza", "ciudad", "paisaje"]
    
    # Contar frecuencia y tomar las más comunes
    word_counts = Counter(valid_words)
    # Tomar hasta 5 palabras clave más comunes
    top_keywords = [word.replace(" ", "+") for word, _ in word_counts.most_common(5)]
    
    if not top_keywords:
         logger.warning("El método simple no produjo keywords. Usando palabras clave predeterminadas.")
         return ["naturaleza", "ciudad", "paisaje"]

    logger.info(f"Palabras clave finales: {top_keywords}")
    return top_keywords

# [FUNCIÓN CREAR_VIDEO CORREGIDA]
def crear_video(prompt_type, input_text, musica_file=None):
    logger.info("="*80)
    logger.info(f"INICIANDO CREACIÓN DE VIDEO | Tipo: {prompt_type}")
    logger.debug(f"Input: '{input_text[:100]}...'")
    
    start_time = datetime.now()
    temp_dir_intermediate = None # Directorio para archivos temporales intermedios
    output_video_path = None # Path para el video final fuera del directorio intermedio

    try:
        # 1. Generar o usar guion
        if prompt_type == "Generar Guion con IA":
            logger.info("Generando guion con IA...")
            guion = generate_script(input_text)
        else:
            logger.info("Usando guion proporcionado")
            guion = input_text.strip() # Asegurar que el guion manual no tenga espacios al inicio/fin

        logger.info(f"Guion final ({len(guion)} caracteres): '{guion[:100]}...'")
        
        if not guion.strip():
            logger.error("El guion resultante está vacío o solo contiene espacios.")
            raise ValueError("El guion está vacío.")
        
        # Crear directorio temporal para archivos intermedios (audio TTS, videos descargados)
        temp_dir_intermediate = tempfile.mkdtemp(prefix="video_gen_intermediate_")
        logger.info(f"Directorio temporal intermedio creado: {temp_dir_intermediate}")
        temp_intermediate_files = [] # Lista para seguir los archivos que hay que limpiar

        # 2. Generar audio de voz
        logger.info("Generando audio de voz...")
        voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
        # No añadimos voz_path a temp_intermediate_files *antes* de la generación,
        # solo si la generación es exitosa.
        if not asyncio.run(text_to_speech(guion, voz_path)):
            logger.error("Fallo en generación de voz.")
            raise ValueError("Error generando voz a partir del guion.")
        temp_intermediate_files.append(voz_path) # Añadir para limpieza si la generación tuvo éxito

        audio_tts = AudioFileClip(voz_path)
        audio_duration = audio_tts.duration
        logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")

        if audio_duration < 1.0:
             logger.warning(f"Duración del audio de voz ({audio_duration:.2f}s) es muy corta. El video podría ser muy breve o fallar.")
             # Podrías añadir un mínimo o generar un guion/voz alternativo

        # 3. Extraer palabras clave
        logger.info("Extrayendo palabras clave...")
        try:
            keywords = extract_visual_keywords_from_script(guion)
            logger.info(f"Palabras clave identificadas: {keywords}")
        except Exception as e:
            logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
            keywords = ["naturaleza", "paisaje"] # Fallback si la extracción falla

        if not keywords:
             logger.warning("Lista de palabras clave vacía después de extracción y fallback.")
             keywords = ["video", "background"] # Fallback final

        # 4. Buscar y descargar videos
        logger.info("Buscando videos en Pexels...")
        videos_data = []
        # Buscar con todas las keywords, intentando obtener más resultados al principio
        total_desired_videos = 10 # Intentar descargar hasta 10 videos en total
        per_page_per_keyword = max(1, total_desired_videos // len(keywords)) # Distribuir la búsqueda

        for keyword in keywords:
            if len(videos_data) >= total_desired_videos: break # Dejar de buscar si ya tenemos suficientes
            try:
                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=per_page_per_keyword)
                if videos:
                    videos_data.extend(videos)
                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'. Total data: {len(videos_data)}")
            except Exception as e:
                logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")

        # Si no se encontraron suficientes videos con keywords específicas, intentar genéricas
        if len(videos_data) < total_desired_videos / 2: # Si tenemos menos de la mitad de los deseados
            logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
            generic_keywords = ["nature", "city", "background", "abstract"] # Palabras clave genéricas en inglés para Pexels
            for keyword in generic_keywords:
                 if len(videos_data) >= total_desired_videos: break
                 try:
                    # Buscar menos por cada genérica para no saturar
                    videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2) 
                    if videos:
                        videos_data.extend(videos)
                        logger.info(f"Encontrados {len(videos)} videos para '{keyword}' (genérico). Total data: {len(videos_data)}")
                 except Exception as e:
                    logger.warning(f"Error buscando videos genéricos para '{keyword}': {str(e)}")


        if not videos_data:
            logger.error("No se encontraron videos en Pexels para ninguna palabra clave.")
            raise ValueError("No se encontraron videos adecuados en Pexels.")
        
        video_paths = []
        logger.info(f"Intentando descargar {len(videos_data)} videos encontrados...")
        for video in videos_data:
            if 'video_files' not in video or not video['video_files']:
                logger.debug(f"Saltando video sin archivos de video: {video.get('id')}")
                continue
                
            try:
                # Encontrar la mejor calidad disponible con un enlace de descarga
                best_quality = None
                for vf in sorted(video['video_files'], key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True):
                    if 'link' in vf:
                        best_quality = vf
                        break

                if best_quality and 'link' in best_quality:
                    path = download_video_file(best_quality['link'], temp_dir_intermediate)
                    if path:
                        video_paths.append(path)
                        temp_intermediate_files.append(path) # Añadir para limpieza
                        logger.info(f"Video descargado OK desde {best_quality['link'][:50]}...")
                    else:
                         logger.warning(f"No se pudo descargar video desde {best_quality['link'][:50]}...")
                else:
                    logger.warning(f"No se encontró enlace de descarga válido para video {video.get('id')}.")

            except Exception as e:
                logger.warning(f"Error procesando/descargando video {video.get('id')}: {str(e)}")

        logger.info(f"Descargados {len(video_paths)} archivos de video utilizables.")
        if not video_paths:
            logger.error("No se pudo descargar ningún archivo de video utilizable.")
            raise ValueError("No se pudo descargar ningún video utilizable de Pexels.")
        
        # 5. Procesar y concatenar clips de video
        logger.info("Procesando y concatenando videos descargados...")
        clips = []
        current_duration = 0
        min_clip_duration = 1.0 # Duración mínima para un clip
        max_clip_segment = 8.0 # Segmento máximo a tomar de un clip fuente

        # Ordenar clips descargados por tamaño o duración si se desea, o usar el orden de descarga
        # Por ahora, usamos el orden de descarga

        for path in video_paths:
            # Dejar de añadir clips si ya tenemos suficiente duración o estamos cerca
            # Añadimos un buffer para no cortar bruscamente el último clip
            if current_duration >= audio_duration + max_clip_segment: 
                break

            try:
                logger.debug(f"Abriendo clip: {path}")
                clip = VideoFileClip(path)
                
                # Calcular duración útil: min(duración_restante_necesaria, duración_total_clip, segmento_máximo)
                remaining_needed = audio_duration - current_duration
                usable_duration = min(clip.duration, max_clip_segment)
                
                # Si necesitamos más duración, tomamos hasta el final del clip o el max_clip_segment
                if remaining_needed > 0:
                    usable_duration = min(usable_duration, remaining_needed + min_clip_duration) # Añadir un poco extra si el último clip nos deja justos
                    usable_duration = max(min_clip_duration, usable_duration) # Asegurar duración mínima si es posible

                if usable_duration > min_clip_duration:
                    # Asegurar que no excedemos la duración del clip fuente
                    segment_duration = min(usable_duration, clip.duration)
                    if segment_duration > min_clip_duration:
                         clips.append(clip.subclip(0, segment_duration))
                         current_duration += segment_duration
                         logger.debug(f"Clip añadido: {segment_duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
                    else:
                         logger.debug(f"Clip {path} es demasiado corto ({clip.duration:.1f}s) para añadir un segmento útil.")
                else:
                    logger.debug(f"Clip {path} demasiado corto ({clip.duration:.1f}s) o no necesita más duración.")
                
                # Cerrar clip para liberar recursos
                clip.close() 

            except Exception as e:
                logger.warning(f"Error procesando video clip {path}: {str(e)}", exc_info=True)
                # Continuar con el siguiente clip si hay un error con este
                continue

        if not clips:
            logger.error("No hay clips de video válidos para crear la secuencia.")
            raise ValueError("No hay clips de video válidos para crear el video.")
        
        logger.info(f"Concatenando {len(clips)} clips de video.")
        video_base = concatenate_videoclips(clips, method="compose")
        logger.info(f"Duración base del video concatenado: {video_base.duration:.2f}s")
        
        # Asegurar que el video base tenga al menos la duración del audio
        if video_base.duration < audio_duration:
            # Calcular cuántas veces se necesita repetir el video base o parte de él
            # Un método simple es repetir el video base completo
            num_repeats = math.ceil(audio_duration / video_base.duration)
            logger.info(f"Repitiendo video base ({video_base.duration:.2f}s) {num_repeats} veces para alcanzar {audio_duration:.2f}s.")
            repeated_clips = [video_base] * num_repeats
            video_base = concatenate_videoclips(repeated_clips, method="compose").subclip(0, audio_duration)
            logger.info(f"Duración del video base ajustada: {video_base.duration:.2f}s")

        # Si el video base es más largo que el audio (puede pasar si el último clip añadido fue largo)
        # Recortarlo exactamente a la duración del audio
        if video_base.duration > audio_duration:
             logger.info(f"Recortando video base ({video_base.duration:.2f}s) a la duración del audio ({audio_duration:.2f}s).")
             video_base = video_base.subclip(0, audio_duration)
             logger.info(f"Duración final del video base: {video_base.duration:.2f}s")


        # 6. Manejar música de fondo
        logger.info("Procesando audio...")
        final_audio = audio_tts # El audio base es la voz TTS
        
        if musica_file:
            try:
                # Copiar archivo de música a un lugar temporal seguro
                music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
                shutil.copyfile(musica_file, music_path)
                temp_intermediate_files.append(music_path) # Añadir para limpieza
                logger.info(f"Música de fondo copiada a: {music_path}")
                
                musica_audio = AudioFileClip(music_path)
                logger.debug(f"Duración música original: {musica_audio.duration:.2f}s")
                
                # Ajustar duración de la música al video final (que ya tiene la duración del audio TTS)
                musica_audio = loop_audio_to_length(musica_audio, video_base.duration)
                logger.debug(f"Música ajustada a duración del video: {musica_audio.duration:.2f}s")
                
                # Mezclar voz y música. Ajusta los volúmenes según prefieras.
                final_audio = CompositeAudioClip([
                    musica_audio.volumex(0.2), # Volumen bajo para la música
                    audio_tts.volumex(1.0)     # Volumen normal para la voz
                ])
                logger.info("Mezcla de audio completada (voz + música).")
            except Exception as e:
                logger.warning(f"Error procesando música de fondo: {str(e)}", exc_info=True)
                # Si falla la música, simplemente usamos el audio TTS
                final_audio = audio_tts
                logger.warning("Usando solo audio de voz debido a un error con la música.")

        # Asegurar que el audio final tenga exactamente la misma duración que el video base
        if final_audio.duration > video_base.duration:
             final_audio = final_audio.subclip(0, video_base.duration)
        elif final_audio.duration < video_base.duration:
             # Esto no debería pasar si loop_audio_to_length funciona, pero como seguridad
             logger.warning("La duración del audio final es menor que la del video base. Intentando ajustar.")
             # Podría re-ajustar o logear error más severo
             # Para evitar errores en write_videofile, es mejor que el audio no sea más corto
             # Si es más corto, moviepy suele extender el último frame de audio, lo cual es feo pero funciona.
             # No intentaremos extenderlo aquí automáticamente para evitar complejidad, MoviePy lo manejará.
             pass # MoviePy manejará la diferencia de duración

        # 7. Crear video final
        logger.info("Renderizando video final...")
        video_final = video_base.set_audio(final_audio)
        
        # Gradio maneja directorios temporales para los outputs.
        # Podemos escribir directamente en un archivo temporal dentro de la carpeta temporal de Gradio.
        # Si no estamos en un entorno Gradio, podríamos usar un tempfile normal.
        # Por simplicidad y compatibilidad con Gradio, devolveremos el path absoluto.
        # El directorio temporal creado por tempfile.mkdtemp() EXISTIRÁ cuando la función retorne
        # porque hemos eliminado la línea que lo borraba. Gradio debería poder leerlo.
        # Si queremos un archivo temporal más "formal" de Gradio, necesitaríamos que Gradio
        # nos pasara un path temporal. La forma actual de retornar el path debería funcionar
        # ahora que no borramos el directorio.

        # Asegurar que el directorio para el output existe si no es temp_dir_intermediate
        # output_filename = f"final_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
        # # Si queremos que el archivo no esté en temp_dir_intermediate, podríamos usar otro temp_dir
        # # o un path fijo para prueba. Para Gradio, devolver el path en temp_dir_intermediate
        # # FUNCIONARÁ si temp_dir_intermediate NO SE BORRA.
        # output_path = os.path.join(temp_dir_intermediate, output_filename)

        # Dejar el nombre y path original dentro del temp_dir_intermediate,
        # pero ASEGURARSE de que el rmtree del finally está COMENTADO/ELIMINADO.
        output_filename = "final_video.mp4"
        output_path = os.path.join(temp_dir_intermediate, output_filename)
        logger.info(f"Escribiendo video final a: {output_path}")

        video_final.write_videofile(
            output_path,
            fps=24,
            threads=4, # Usa un número razonable de hilos
            codec="libx264", # Codec estándar compatible
            audio_codec="aac", # Codec de audio estándar
            preset="medium", # Balance entre velocidad y tamaño/calidad
            # CORRECCIÓN: Mostrar log de MoviePy para debugging
            logger='bar' # Muestra una barra de progreso y mensajes de FFmpeg
            # logger='log' # Muestra mensajes detallados de FFmpeg
        )
        
        total_time = (datetime.now() - start_time).total_seconds()
        logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
        
        # Cerrar clips para liberar recursos
        video_base.close()
        audio_tts.close()
        if musica_file: musica_audio.close()
        video_final.close()

        return output_path # Retornar el path del archivo generado

    except ValueError as ve:
         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
         # Asegurar que se cierran los clips abiertos antes de relanzar
         # (Esto es mejor hacerlo en el finally, pero aquí es una capa extra)
         try:
             if 'video_base' in locals() and video_base is not None: video_base.close()
             if 'audio_tts' in locals() and audio_tts is not None: audio_tts.close()
             if 'musica_audio' in locals() and musica_audio is not None: musica_audio.close()
             if 'video_final' in locals() and video_final is not None: video_final.close()
         except: pass # Ignore errors during cleanup before re-raise
         raise ve # Rellenar la excepción para que la atrape run_app

    except Exception as e:
        logger.critical(f"ERROR CRÍTICO NO CONTROLADO en crear_video: {str(e)}", exc_info=True)
        # Asegurar que se cierran los clips abiertos antes de relanzar
        try:
            if 'video_base' in locals() and video_base is not None: video_base.close()
            if 'audio_tts' in locals() and audio_tts is not None: audio_tts.close()
            if 'musica_audio' in locals() and musica_audio is not None: musica_audio.close()
            if 'video_final' in locals() and video_final is not None: video_final.close()
        except: pass # Ignore errors during cleanup before re-raise
        raise e # Rellenar la excepción

    finally:
        logger.info("Iniciando limpieza de archivos temporales intermedios...")
        # Limpiar solo los archivos listados como temporales intermedios
        if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
             # Asegurarse de que el archivo de video final *no* sea borrado si está en esta lista por error
             final_output_in_temp = os.path.join(temp_dir_intermediate, "final_video.mp4")
             
             for path in temp_intermediate_files:
                 try:
                     if os.path.isfile(path) and path != final_output_in_temp: # No borrar el archivo final
                         logger.debug(f"Eliminando archivo temporal: {path}")
                         os.remove(path)
                     elif os.path.isdir(path): # Limpieza defensiva, aunque no deberíamos tener directorios aquí
                         logger.warning(f"Intentando eliminar directorio listado como archivo temporal: {path}")
                         shutil.rmtree(path, ignore_errors=True)
                 except Exception as e:
                     logger.warning(f"No se pudo eliminar archivo temporal {path}: {str(e)}")
            
             # CORRECCIÓN CRÍTICA: NO eliminar el directorio temporal completo con rmtree.
             # Este directorio contiene el video final que Gradio necesita leer.
             # El sistema operativo se encargará de limpiar los directorios temporales abandonados
             # con el tiempo, o puedes implementar una limpieza más sofisticada si es necesario
             # para archivos *muy* viejos, pero NO lo hagas inmediatamente después de crear el archivo.
             # shutil.rmtree(temp_dir_intermediate, ignore_errors=True) # COMENTADO/ELIMINADO intencionadamente
             logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")


# [FUNCIÓN RUN_APP ORIGINAL CON LOGS]
def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
    logger.info("="*80)
    logger.info("SOLICITUD RECIBIDA EN INTERFAZ")
    
    input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
    
    if not input_text or not input_text.strip():
        logger.warning("Texto de entrada vacío.")
        # Asegurarse de devolver None para el video y un mensaje de error
        return None, gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.")

    # Gradio actualiza la interfaz, no necesitamos un primer return para "Procesando..." aquí,
    # el .then() encadenado en la interfaz ya maneja eso.
    logger.info(f"Tipo de entrada: {prompt_type}")
    logger.debug(f"Texto de entrada: '{input_text[:100]}...'")
    if musica_file:
        logger.info(f"Archivo de música recibido: {musica_file}")
    else:
        logger.info("No se proporcionó archivo de música.")

    try:
        logger.info("Llamando a crear_video...")
        video_path = crear_video(prompt_type, input_text, musica_file)
        
        if video_path and os.path.exists(video_path):
            logger.info(f"Función crear_video retornó path: {video_path}")
            logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
            return video_path, gr.update(value="✅ Video generado exitosamente.", interactive=False)
        else:
            logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
            return None, gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)

    except ValueError as ve:
        logger.warning(f"Error de validación durante la creación del video: {str(ve)}")
        return None, gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
    except Exception as e:
        logger.critical(f"Error crítico durante la creación del video: {str(e)}", exc_info=True)
        return None, gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
    finally:
        logger.info("Fin del handler run_app.")


# [INTERFAZ DE GRADIO ORIGINAL COMPLETA]
with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
    .gradio-container {max-width: 800px; margin: auto;}
    h1 {text-align: center;}
    """) as app:
    
    gr.Markdown("# 🎬 Generador Automático de Videos con IA")
    gr.Markdown("Genera videos cortos a partir de un tema o guion, usando imágenes de archivo de Pexels y voz generada.")
    
    with gr.Row():
        with gr.Column():
            prompt_type = gr.Radio(
                ["Generar Guion con IA", "Usar Mi Guion"],
                label="Método de Entrada",
                value="Generar Guion con IA" # Valor por defecto
            )
            
            with gr.Column(visible=True) as ia_guion_column:
                prompt_ia = gr.Textbox(
                    label="Tema para IA", 
                    lines=2,
                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer, mostrando la belleza de la naturaleza...",
                    max_lines=4,
                    value="" # Inicializar vacío
                )
            
            with gr.Column(visible=False) as manual_guion_column:
                prompt_manual = gr.Textbox(
                    label="Tu Guion Completo", 
                    lines=5,
                    placeholder="Ej: En este video exploraremos los misterios del océano. Veremos la vida marina fascinante y los arrecifes de coral vibrantes. ¡Acompáñanos en esta aventura subacuática!",
                    max_lines=10,
                    value="" # Inicializar vacío
                )
            
            musica_input = gr.Audio(
                label="Música de fondo (opcional)",
                type="filepath",
                interactive=True,
                value=None # Inicializar vacío
            )
            
            generate_btn = gr.Button("✨ Generar Video", variant="primary")
        
        with gr.Column():
            video_output = gr.Video(
                label="Video Generado", 
                interactive=False, # No interactivo para el usuario
                height=400 # Altura fija
            )
            status_output = gr.Textbox(
                label="Estado", 
                interactive=False, # Solo lectura
                show_label=False, # No mostrar la etiqueta "Estado"
                placeholder="Esperando acción...",
                value="Esperando entrada..." # Estado inicial
            )

    # Lógica para mostrar/ocultar campos de texto según el tipo de prompt
    prompt_type.change(
        lambda x: (gr.update(visible=x == "Generar Guion con IA"), 
                   gr.update(visible=x == "Usar Mi Guion")),
        inputs=prompt_type,
        outputs=[ia_guion_column, manual_guion_column]
    )

    # Lógica para el botón de generar video
    # Primero, actualizar el estado a "Procesando..."
    # Luego, llamar a la función run_app
    generate_btn.click(
        # La primera acción (sincrona) actualiza el estado y limpia el video anterior
        lambda: (None, gr.update(value="⏳ Procesando... Esto puede tomar 2-5 minutos dependiendo de la longitud y recursos.", interactive=False)),
        outputs=[video_output, status_output],
        queue=True, # Poner en cola si hay varias peticiones
        # preprocess=False, # No pre-procesar para esta primera acción
    ).then(
        # La segunda acción (asincrona) ejecuta la función principal de generación
        run_app,
        inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
        outputs=[video_output, status_output]
    )

    gr.Markdown("### Instrucciones:")
    gr.Markdown("""
    1.  **Clave API de Pexels:** Asegúrate de haber configurado la variable de entorno `PEXELS_API_KEY` con tu clave.
    2.  **Selecciona el tipo de entrada**:
        -   "Generar Guion con IA": Describe brevemente un tema (ej. "La belleza de las montañas"). La IA generará un guion corto.
        -   "Usar Mi Guion": Escribe el guion completo que quieres para el video.
    3.  **Sube música** (opcional): Selecciona un archivo de audio (MP3, WAV, etc.) para usar como música de fondo.
    4.  **Haz clic en "✨ Generar Video"**.
    5.  Espera a que se procese el video. El tiempo de espera puede variar. Verás el estado en el cuadro de texto.
    6.  Si hay errores, revisa el log `video_generator_full.log` para más detalles.
    """)
    gr.Markdown("---")
    gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]") # Añade tu nombre o un alias si quieres

if __name__ == "__main__":
    # Verificar si FFmpeg está instalado (MoviePy lo requiere)
    # Puedes añadir esta verificación aquí
    logger.info("Verificando dependencias críticas...")
    try:
        # moviepy intenta encontrar ffmpeg, si falla, lanzar error
        # from moviepy.config import get_setting
        # ffmpeg_path = get_setting("FFMPEG_BINARY")
        # if not os.path.exists(ffmpeg_path):
        #      logger.critical(f"FFmpeg no encontrado en {ffmpeg_path}. Instálalo y/o configura la variable FFMPEG_BINARY.")
        #      # raise RuntimeError("FFmpeg no está instalado o configurado correctamente.")
        # else:
        #     logger.info(f"FFmpeg encontrado en {ffmpeg_path}")
        
        # Una forma más simple es intentar importar algo que use FFmpeg
        try:
            from moviepy.editor import VideoFileClip
            # No cargamos un archivo real, solo verificamos que el import no falle por FFmpeg
            logger.info("MoviePy importado correctamente. FFmpeg parece accesible.")
        except Exception as e:
             logger.critical(f"Fallo al importar MoviePy, a menudo indica problemas con FFmpeg. Asegúrate de tenerlo instalado y en el PATH. Error: {e}")
             # raise RuntimeError("MoviePy/FFmpeg dependency issue.")

    except Exception as e:
         logger.warning(f"No se pudo verificar FFmpeg automáticamente: {e}") # Esto no debería detener el script, solo advertir

    logger.info("Iniciando aplicación Gradio...")
    try:
        # Usa share=True para obtener un enlace público si lo necesitas para probar fuera de localhost
        # No uses share=True en producción sin medidas de seguridad adecuadas
        app.launch(server_name="0.0.0.0", server_port=7860, share=False)
    except Exception as e:
        logger.critical(f"No se pudo iniciar la app: {str(e)}", exc_info=True)
        raise # Relanzar la excepción para ver el traceback completo si falla al iniciar