app.py

import math
import tempfile
import logging
import os
import asyncio
import time
from threading import Timer
from moviepy.editor import *
import edge_tts
import gradio as gr
from pydub import AudioSegment

# Configuración de Logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# CONSTANTES DE ARCHIVOS
INTRO_VIDEO = "introvideo.mp4"
OUTRO_VIDEO = "outrovideo.mp4"
MUSIC_BG = "musicafondo.mp3"
FX_SOUND = "fxsound.mp3"
WATERMARK = "watermark.png"
EJEMPLO_VIDEO = "ejemplo.mp4"

# Validar existencia de archivos
for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK, EJEMPLO_VIDEO]:
    if not os.path.exists(file):
        logging.error(f"Falta archivo necesario: {file}")
        raise FileNotFoundError(f"Falta: {file}")

def eliminar_archivo_tiempo(ruta, delay=1800):
    """Elimina archivos después de 30 minutos"""
    def eliminar():
        try:
            if os.path.exists(ruta):
                os.remove(ruta)
                logging.info(f"Archivo eliminado: {ruta}")
        except Exception as e:
            logging.error(f"Error al eliminar {ruta}: {e}")
    Timer(delay, eliminar).start()

async def procesar_audio(texto, voz, duracion_total, duracion_intro):
    """Genera TTS y mezcla con música"""
    temp_files = []
    try:
        # Generar TTS
        communicate = edge_tts.Communicate(texto, voz)
        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
            await communicate.save(tmp.name)
            tts_audio = AudioFileClip(tmp.name)
            temp_files.append(tmp.name)
        
        # Preparar música de fondo en loop
        bg_music = AudioSegment.from_mp3(MUSIC_BG)
        bg_music = bg_music * (duracion_total // len(bg_music) + 1)
        bg_music = bg_music[:duracion_total * 1000].fade_out(5000)
        
        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
            bg_music.export(tmp.name, format="mp3")
            bg_audio = AudioFileClip(tmp.name).volumex(0.15)
            temp_files.append(tmp.name)
        
        # Combinar audios
        audio_final = CompositeAudioClip([
            bg_audio,
            tts_audio.volumex(0.85).set_start(duracion_intro)
        ])
        return audio_final
    finally:
        for file in temp_files:
            try:
                os.remove(file)
            except: pass

def agregar_transiciones(clips):
    """Transiciones suaves cada 40 segundos"""
    try:
        transicion_fx = AudioFileClip(FX_SOUND).subclip(0, 0.5)
        watermark = (ImageClip(WATERMARK)
                    .set_duration(0.5)
                    .resize(height=50)
                    .margin(right=10, bottom=10, opacity=0)
                    .set_pos(("right", "bottom")))
        
        clips_finales = []
        for i, clip in enumerate(clips):
            # Añadir watermark al clip principal
            clip_watermarked = CompositeVideoClip([clip, watermark])
            
            # Agregar transición cada 40 segundos
            if i > 0 and i % 40 == 0:
                transicion = CompositeVideoClip([watermark.set_duration(0.5)]).set_audio(transicion_fx)
                clips_finales.append(transicion)
            
            clips_finales.append(clip_watermarked)
        
        return concatenate_videoclips(clips_finales, method="compose")
    except Exception as e:
        logging.error(f"Error en transiciones: {e}")
        return concatenate_videoclips(clips)

async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte):
    try:
        # Cargar video original con su audio
        video_original = VideoFileClip(video_input)
        audio_original = video_original.audio.volumex(0.7)  # Conservar audio original al 70%
        
        # Cortar video según método
        clips = []
        if metodo_corte == "manual":
            for i in range(math.ceil(video_original.duration / duracion_corte)):
                clips.append(video_original.subclip(i*duracion_corte, (i+1)*duracion_corte))
        else:
            # Cortes automáticos cada 40 segundos para transiciones
            clips = [video_original.subclip(i, i+40) for i in range(0, math.ceil(video_original.duration), 40)]
        
        # Procesar transiciones
        video_editado = agregar_transiciones(clips)
        
        # Combinar con intro/outro
        intro = VideoFileClip(INTRO_VIDEO)
        outro = VideoFileClip(OUTRO_VIDEO)
        video_final = concatenate_videoclips([intro, video_editado, outro])
        
        # Procesar audio completo
        duracion_total = video_final.duration
        audio_tts_bg = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, intro.duration)
        
        # Combinar TODOS los audios
        audio_final = CompositeAudioClip([
            audio_original.set_duration(video_final.duration),
            audio_tts_bg
        ])
        
        # Renderizar video final
        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
            video_final.set_audio(audio_final).write_videofile(
                tmp.name,
                codec="libx264",
                audio_codec="aac",
                fps=24,
                threads=4
            )
            eliminar_archivo_tiempo(tmp.name)
            return tmp.name
    except Exception as e:
        logging.error(f"Error procesando video: {e}")
        raise

# Interfaz Gradio
with gr.Blocks() as demo:
    gr.Markdown("# Editor de Video con IA")
    
    with gr.Tab("Principal"):
        video_input = gr.Video(label="Subir video", value=EJEMPLO_VIDEO)
        texto_tts = gr.Textbox(
            label="Texto para TTS",
            lines=3,
            value="¡Hola! Esto es una prueba. Suscríbete al canal y activa la campanita."
        )
        voz_seleccionada = gr.Dropdown(
            label="Voz",
            choices=["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"],
            value="es-ES-AlvaroNeural"
        )
        procesar_btn = gr.Button("Generar Video")
        video_output = gr.Video(label="Video Procesado")
    
    with gr.Tab("Ajustes"):
        metodo_corte = gr.Radio(
            ["inteligente", "manual"],
            label="Método de corte",
            value="inteligente"
        )
        duracion_corte = gr.Slider(
            1, 60, 10,
            label="Segundos por corte (manual)"
        )

    procesar_btn.click(
        procesar_video,
        inputs=[video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte],
        outputs=video_output
    )

if __name__ == "__main__":
    demo.queue().launch()