# ===== app.py =====
import gradio as gr
import os
import sys

# Agregar el directorio raíz al path
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from utils.video_processor import VideoProcessor
from utils.config import PROCESSING, CHAOS_THRESHOLDS

class CDMXTrafficApp:
    def __init__(self):
        """Inicializar la aplicación"""
        self.video_processor = VideoProcessor()
        
    def process_video(self, video_path):
        """Procesar video completo"""
        if not video_path:
            return None, "❌ No se proporcionó ningún video"
        
        try:
            # Procesar video
            result = self.video_processor.process(
                video_path, 
                max_frames=PROCESSING['max_frames']
            )
            
            if result['success']:
                stats = self._generate_stats(result['analytics'])
                return result['output_path'], stats
            else:
                return None, f"❌ Error: {result['error']}"
                
        except Exception as e:
            return None, f"❌ Error inesperado: {str(e)}"
    
    def _generate_stats(self, analytics):
        """Generar estadísticas textuales"""
        stats = f"""
📊 **ANÁLISIS COMPLETO DEL VIDEO**

🎯 **Detecciones:**
• Frames procesados: {analytics['frames_processed']}
• Objetos totales: {analytics['total_objects']}
• Promedio por frame: {analytics['avg_objects_per_frame']:.1f}

⚠️ **Nivel de Caos: {analytics['avg_chaos_score']:.1f}/100**
{self._get_chaos_interpretation(analytics['avg_chaos_score'])}

📈 **Métricas Detalladas:**
• Densidad promedio: {analytics['avg_density']:.2f}
• Riesgo de proximidad: {analytics['avg_proximity_risk']:.2f}
• Variabilidad: {analytics['chaos_std']:.1f}

🚗 **Objetos Detectados:**
{self._format_object_counts(analytics['object_summary'])}

🤖 **Implicaciones para Robotaxis:**
{self._get_robotaxi_implications(analytics['avg_chaos_score'])}

💡 **Valor Comercial:**
Este nivel de complejidad requiere modelos de IA especializados
que las soluciones actuales (Tesla, Waymo) no pueden manejar.
        """
        return stats.strip()
    
    def _get_chaos_interpretation(self, score):
        """Interpretar score de caos"""
        if score < CHAOS_THRESHOLDS['low']:
            return "🟢 Tráfico ordenado - Robotaxis actuales podrían funcionar"
        elif score < CHAOS_THRESHOLDS['medium']:
            return "🟡 Tráfico moderado - Requiere adaptaciones menores"
        elif score < CHAOS_THRESHOLDS['high']:
            return "🟠 Tráfico caótico - Típico de CDMX, requiere IA especializada"
        else:
            return "🔴 Tráfico extremo - Solo IA avanzada podría manejarlo"
    
    def _format_object_counts(self, object_summary):
        """Formatear conteo de objetos"""
        formatted = []
        for obj_type, count in object_summary.items():
            formatted.append(f"  - {obj_type.title()}: {count}")
        return "\n".join(formatted) if formatted else "  - Ninguno detectado"
    
    def _get_robotaxi_implications(self, score):
        """Obtener implicaciones para robotaxis"""
        if score >= CHAOS_THRESHOLDS['high']:
            return """
• Requiere predicción de comportamiento impredecible
• Necesita toma de decisiones en tiempo real
• Debe adaptarse a reglas informales del tráfico
• Mayor inversión en sensores y procesamiento
• Entrenamiento específico con datos locales"""
        elif score >= CHAOS_THRESHOLDS['medium']:
            return """
• Adaptaciones moderadas a modelos existentes
• Entrenamiento adicional con casos edge
• Mejoras en detección de peatones
• Calibración de algoritmos de predicción"""
        else:
            return """
• Modelos existentes podrían adaptarse fácilmente
• Mínimas modificaciones requeridas
• Infraestructura estándar suficiente"""

def create_interface():
    """Crear interfaz de Gradio"""
    app = CDMXTrafficApp()
    
    # CSS personalizado
    css = """
    .gradio-container {
        font-family: 'Arial', sans-serif;
    }
    .main-header {
        text-align: center;
        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
        color: white;
        padding: 20px;
        border-radius: 10px;
        margin-bottom: 20px;
    }
    """
    
    with gr.Blocks(css=css, title="CDMX Traffic AI") as demo:
        
        # Header
        gr.HTML("""
        <div class="main-header">
            <h1>🚗 CDMX Traffic AI Analysis</h1>
            <h3>Entrenamiento de IA para Conducción Autónoma en Entornos Caóticos</h3>
            <p><em>Demo técnico - Revolucionando la movilidad urbana</em></p>
        </div>
        """)
        
        # Descripción
        gr.Markdown("""
        ## 🎯 ¿Qué hace esta herramienta?
        
        Analiza videos de tráfico real de Ciudad de México para:
        - **Detectar automáticamente** vehículos, peatones y señales
        - **Medir el nivel de caos vial** con métricas cuantificables  
        - **Evaluar la dificultad** para sistemas de conducción autónoma
        - **Identificar patrones únicos** del tráfico mexicano
        """)
        
        # Interface principal
        with gr.Row():
            with gr.Column():
                video_input = gr.Video(
                    label="📹 Sube video de tráfico CDMX", 
                    height=300
                )
                
                analyze_btn = gr.Button(
                    "🔍 Analizar Tráfico", 
                    variant="primary", 
                    size="lg"
                )
                
            with gr.Column():
                video_output = gr.Video(
                    label="📊 Video con análisis",
                    height=300
                )
                
                stats_output = gr.Textbox(
                    label="📈 Estadísticas Completas",
                    lines=20,
                    max_lines=25
                )
        
        # Footer
        gr.Markdown("""
        ---
        ## 🚀 Potencial Comercial
        
        **¿Por qué es revolucionario?**
        - Los robotaxis actuales fallan en entornos como CDMX
        - Mercado potencial: 3+ mil millones de personas en ciudades caóticas
        - Competencia prácticamente nula en LATAM
        
        💼 **¿Interesado en invertir?** - Esta es solo una demostración del potencial
        """)
        
        # Event handlers
        analyze_btn.click(
            fn=app.process_video,
            inputs=[video_input],
            outputs=[video_output, stats_output],
            show_progress=True
        )
    
    return demo

if __name__ == "__main__":
    demo = create_interface()
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True
    )