import gradio as gr
import os
import subprocess
import time
import logging
import psutil
from pathlib import Path

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

# Configuración de rutas
FFMPEG_PATH = os.path.join(os.getcwd(), "ffmpeg.exe")
UPLOADS_DIR = os.path.join(os.getcwd(), "uploads")

# Crear directorio de uploads si no existe
os.makedirs(UPLOADS_DIR, exist_ok=True)

# Formatos soportados
VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm', '.m4v']
AUDIO_FORMATS = ['.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a', '.wma']
SUPPORTED_FORMATS = VIDEO_FORMATS + AUDIO_FORMATS

# Presets de compresión
COMPRESSION_PRESETS = {
    "Compresión Rápida": {
        "video": "-c:v libx264 -preset ultrafast -crf 28",
        "audio": "-c:a aac -b:a 128k"
    },
    "Compresión Media": {
        "video": "-c:v libx264 -preset medium -crf 23",
        "audio": "-c:a aac -b:a 128k"
    },
    "Compresión Alta": {
        "video": "-c:v libx264 -preset slow -crf 20",
        "audio": "-c:a aac -b:a 192k"
    },
    "Compresión Máxima": {
        "video": "-c:v libx264 -preset veryslow -crf 18",
        "audio": "-c:a aac -b:a 256k"
    }
}

def compress_media(file_path, preset="Compresión Alta", progress=gr.Progress()):
    """Comprimir archivo de media usando FFmpeg"""
    try:
        if not os.path.exists(file_path):
            return None, "Error: Archivo no encontrado"
        
        file_ext = Path(file_path).suffix.lower()
        if file_ext not in SUPPORTED_FORMATS:
            return None, f"Error: Formato {file_ext} no soportado"
        
        # Generar nombre de archivo de salida
        base_name = Path(file_path).stem
        output_path = os.path.join(UPLOADS_DIR, f"{base_name}_compressed{file_ext}")
        
        # Obtener configuración del preset
        preset_config = COMPRESSION_PRESETS.get(preset, COMPRESSION_PRESETS["Compresión Alta"])
        
        # Construir comando FFmpeg
        cmd = [
            FFMPEG_PATH,
            "-i", file_path,
            "-y",  # Sobrescribir archivo de salida
        ]
        
        # Agregar configuración según el tipo de archivo
        if file_ext in VIDEO_FORMATS:
            cmd.extend(preset_config["video"].split())
            cmd.extend(preset_config["audio"].split())
        else:  # Audio
            cmd.extend(preset_config["audio"].split())
        
        cmd.append(output_path)
        
        logger.info(f"Ejecutando comando: {' '.join(cmd)}")
        
        # Ejecutar FFmpeg
        process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        
        # Simular progreso
        for i in progress.tqdm(range(100), desc="Comprimiendo..."):
            time.sleep(0.1)
            if process.poll() is not None:
                break
        
        stdout, stderr = process.communicate()
        
        if process.returncode != 0:
            logger.error(f"Error en FFmpeg: {stderr}")
            return None, f"Error durante compresión: {stderr[:200]}"
        
        if not os.path.exists(output_path):
            return None, "Error: No se pudo crear el archivo comprimido"
        
        # Calcular ratio de compresión
        original_size = os.path.getsize(file_path)
        compressed_size = os.path.getsize(output_path)
        compression_ratio = (1 - compressed_size / original_size) * 100
        
        logger.info(f"Compresión completada. Ratio: {compression_ratio:.1f}%")
        
        return output_path, f"Compresión exitosa! Reducción: {compression_ratio:.1f}%"
        
    except Exception as e:
        logger.error(f"Error en compress_media: {str(e)}")
        return None, f"Error durante compresión: {str(e)}"

def run_app():
    """Ejecutar la aplicación Gradio"""
    
    # Verificar que FFmpeg existe
    if not os.path.exists(FFMPEG_PATH):
        print(f"Error: FFmpeg no encontrado en {FFMPEG_PATH}")
        return
    
    with gr.Blocks(title="Compresor de Video y Audio", theme=gr.themes.Soft()) as iface:
        gr.Markdown("# 🎬 Compresor de Video y Audio")
        gr.Markdown("Comprime tus archivos de video y audio de forma eficiente")
        
        with gr.Row():
            with gr.Column():
                file_input = gr.File(
                    label="Seleccionar archivo",
                    file_types=SUPPORTED_FORMATS
                )
                
                preset_dropdown = gr.Dropdown(
                    choices=list(COMPRESSION_PRESETS.keys()),
                    value="Compresión Alta",
                    label="Nivel de compresión"
                )
                
                compress_btn = gr.Button("🚀 Comprimir", variant="primary")
            
            with gr.Column():
                output_file = gr.File(label="Archivo comprimido")
                status_text = gr.Textbox(label="Estado", interactive=False)
        
        # Información sobre formatos soportados
        gr.Markdown(
            f"**Formatos soportados:**\n"
            f"- Video: {', '.join(VIDEO_FORMATS)}\n"
            f"- Audio: {', '.join(AUDIO_FORMATS)}"
        )
        
        # Evento de compresión
        compress_btn.click(
            fn=compress_media,
            inputs=[file_input, preset_dropdown],
            outputs=[output_file, status_text]
        )
    
    # Lanzar interfaz
    iface.launch(
        share=False,
        server_name="127.0.0.1",
        server_port=7862,
        show_error=True,
        inbrowser=True
    )

if __name__ == "__main__":
    run_app()