import logging
from typing import Dict, List, Any
from datetime import datetime
import sys
import os

# Usar la misma configuración de conexión que contactabilidad.py
sys.path.append('/var/www/html/config')
from cnxpdo import get_connection

def get_inscripciones_voluntarios_stats() -> Dict:
    """Obtener estadísticas de Inscripciones Voluntarios"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        # Total de contactos
        total_query = "SELECT COUNT(*) as total FROM inscripciones_voluntarios"
        cursor.execute(total_query)
        total_result = cursor.fetchone()
        total_contactos = total_result['total'] if total_result else 0
        
        # Contactos exitosos (estado_etapa = 2)
        exitosos_query = """
        SELECT COUNT(*) as exitosos 
        FROM inscripciones_voluntarios 
        WHERE estado_etapa = 2
        """
        cursor.execute(exitosos_query)
        exitosos_result = cursor.fetchone()
        exitosos = exitosos_result['exitosos'] if exitosos_result else 0
        
        # Contactos rechazados (estado_etapa = 5)
        rechazados_query = """
        SELECT COUNT(*) as rechazados 
        FROM inscripciones_voluntarios 
        WHERE estado_etapa = 5
        """
        cursor.execute(rechazados_query)
        rechazados_result = cursor.fetchone()
        rechazados = rechazados_result['rechazados'] if rechazados_result else 0
        
        cursor.close()
        conexionBD.close()
        
        # Calcular porcentajes con decimales
        porcentaje_exitosos = round((exitosos / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        porcentaje_rechazados = round((rechazados / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        
        return {
            "success": True,
            "tabla": "inscripciones_voluntarios",
            "titulo": "Resultados de Inscripciones Voluntarios",
            "total_contactos": total_contactos,
            "exitosos": exitosos,
            "rechazados": rechazados,
            "porcentaje_exitosos": porcentaje_exitosos,
            "porcentaje_rechazados": porcentaje_rechazados
        }
    except Exception as e:
        logging.error(f"Error obteniendo estadísticas de inscripciones_voluntarios: {e}")
        return {"success": False, "error": str(e)}

def get_registros_crm_antiguo_stats() -> Dict:
    """Obtener estadísticas de Registros CRM Antiguo"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        # Total de contactos
        total_query = "SELECT COUNT(*) as total FROM registros_crm_antiguo"
        cursor.execute(total_query)
        total_result = cursor.fetchone()
        total_contactos = total_result['total'] if total_result else 0
        
        # Contactos exitosos (estado_etapa = 2)
        exitosos_query = """
        SELECT COUNT(*) as exitosos 
        FROM registros_crm_antiguo 
        WHERE estado_etapa = 2
        """
        cursor.execute(exitosos_query)
        exitosos_result = cursor.fetchone()
        exitosos = exitosos_result['exitosos'] if exitosos_result else 0
        
        # Contactos rechazados (estado_etapa = 5)
        rechazados_query = """
        SELECT COUNT(*) as rechazados 
        FROM registros_crm_antiguo 
        WHERE estado_etapa = 5
        """
        cursor.execute(rechazados_query)
        rechazados_result = cursor.fetchone()
        rechazados = rechazados_result['rechazados'] if rechazados_result else 0
        
        cursor.close()
        conexionBD.close()
        
        # Calcular porcentajes con decimales
        porcentaje_exitosos = round((exitosos / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        porcentaje_rechazados = round((rechazados / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        
        return {
            "success": True,
            "tabla": "registros_crm_antiguo",
            "titulo": "Resultados de Registros CRM Antiguo",
            "total_contactos": total_contactos,
            "exitosos": exitosos,
            "rechazados": rechazados,
            "porcentaje_exitosos": porcentaje_exitosos,
            "porcentaje_rechazados": porcentaje_rechazados
        }
    except Exception as e:
        logging.error(f"Error obteniendo estadísticas de registros_crm_antiguo: {e}")
        return {"success": False, "error": str(e)}

def get_base_datos_10k_stats() -> Dict:
    """Obtener estadísticas de Base de Datos 10k"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        # Total de contactos
        total_query = "SELECT COUNT(*) as total FROM base_datos_10k"
        cursor.execute(total_query)
        total_result = cursor.fetchone()
        total_contactos = total_result['total'] if total_result else 0
        
        # Contactos exitosos (estado_etapa = 2)
        exitosos_query = """
        SELECT COUNT(*) as exitosos 
        FROM base_datos_10k 
        WHERE estado_etapa = 2
        """
        cursor.execute(exitosos_query)
        exitosos_result = cursor.fetchone()
        exitosos = exitosos_result['exitosos'] if exitosos_result else 0
        
        # Contactos rechazados (estado_etapa = 5)
        rechazados_query = """
        SELECT COUNT(*) as rechazados 
        FROM base_datos_10k 
        WHERE estado_etapa = 5
        """
        cursor.execute(rechazados_query)
        rechazados_result = cursor.fetchone()
        rechazados = rechazados_result['rechazados'] if rechazados_result else 0
        
        cursor.close()
        conexionBD.close()
        
        # Calcular porcentajes con decimales
        porcentaje_exitosos = round((exitosos / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        porcentaje_rechazados = round((rechazados / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        
        return {
            "success": True,
            "tabla": "base_datos_10k",
            "titulo": "Resultados de Base de Datos 10k",
            "total_contactos": total_contactos,
            "exitosos": exitosos,
            "rechazados": rechazados,
            "porcentaje_exitosos": porcentaje_exitosos,
            "porcentaje_rechazados": porcentaje_rechazados
        }
    except Exception as e:
        logging.error(f"Error obteniendo estadísticas de base_datos_10k: {e}")
        return {"success": False, "error": str(e)}

def get_prospectos_manual_stats() -> Dict:
    """Obtener estadísticas de Prospectos Manual"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        # Total de contactos
        total_query = "SELECT COUNT(*) as total FROM prospectos_manual"
        cursor.execute(total_query)
        total_result = cursor.fetchone()
        total_contactos = total_result['total'] if total_result else 0
        
        # Contactos exitosos (estado_etapa = 2)
        exitosos_query = """
        SELECT COUNT(*) as exitosos 
        FROM prospectos_manual 
        WHERE estado_etapa = 2
        """
        cursor.execute(exitosos_query)
        exitosos_result = cursor.fetchone()
        exitosos = exitosos_result['exitosos'] if exitosos_result else 0
        
        # Contactos rechazados (estado_etapa = 5)
        rechazados_query = """
        SELECT COUNT(*) as rechazados 
        FROM prospectos_manual 
        WHERE estado_etapa = 5
        """
        cursor.execute(rechazados_query)
        rechazados_result = cursor.fetchone()
        rechazados = rechazados_result['rechazados'] if rechazados_result else 0
        
        cursor.close()
        conexionBD.close()
        
        # Calcular porcentajes con decimales
        porcentaje_exitosos = round((exitosos / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        porcentaje_rechazados = round((rechazados / total_contactos * 100), 2) if total_contactos > 0 else 0.00
        
        return {
            "success": True,
            "tabla": "prospectos_manual",
            "titulo": "Resultados de Prospectos Manual",
            "total_contactos": total_contactos,
            "exitosos": exitosos,
            "rechazados": rechazados,
            "porcentaje_exitosos": porcentaje_exitosos,
            "porcentaje_rechazados": porcentaje_rechazados
        }
    except Exception as e:
        logging.error(f"Error obteniendo estadísticas de prospectos_manual: {e}")
        return {"success": False, "error": str(e)}

def get_all_contactability_stats() -> Dict:
    """Obtener todas las estadísticas de contactabilidad para el dashboard - OPTIMIZADO"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": False, "message": "Error de conexión"}

        cursor = conexionBD.cursor(dictionary=True)
        
        # Consulta optimizada que trae todo de una vez
        query = """
        SELECT 
            'inscripciones_voluntarios' as tabla,
            'Resultados de Inscripciones Voluntarios' as titulo,
            COUNT(*) as total_contactos,
            SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END) as exitosos,
            SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END) as rechazados
        FROM inscripciones_voluntarios
        UNION ALL
        SELECT 'registros_crm_antiguo', 'Resultados de Registros CRM Antiguo', COUNT(*), 
               SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END), 
               SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END)
        FROM registros_crm_antiguo
        UNION ALL
        SELECT 'base_datos_10k', 'Resultados de Base de Datos 10k', COUNT(*), 
               SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END), 
               SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END)
        FROM base_datos_10k
        UNION ALL
        SELECT 'prospectos_manual', 'Resultados de Prospectos Manual', COUNT(*), 
               SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END), 
               SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END)
        FROM prospectos_manual
        """
        
        cursor.execute(query)
        resultados = cursor.fetchall()
        
        # Construir respuesta
        stats = {
            "success": True,
            "generated_at": datetime.now().isoformat()
        }
        
        for resultado in resultados:
            tabla = resultado['tabla']
            total_contactos = resultado['total_contactos']
            exitosos = resultado['exitosos']
            rechazados = resultado['rechazados']
            
            porcentaje_exitosos = round((exitosos / total_contactos * 100), 2) if total_contactos > 0 else 0.00
            porcentaje_rechazados = round((rechazados / total_contactos * 100), 2) if total_contactos > 0 else 0.00
            
            stats[tabla] = {
                "success": True,
                "tabla": tabla,
                "titulo": resultado['titulo'],
                "total_contactos": total_contactos,
                "exitosos": exitosos,
                "rechazados": rechazados,
                "porcentaje_exitosos": porcentaje_exitosos,
                "porcentaje_rechazados": porcentaje_rechazados
            }
        
        cursor.close()
        conexionBD.close()
        
        return stats
        
    except Exception as e:
        logging.error(f"Error obteniendo todas las estadísticas: {e}")
        return {"success": False, "error": str(e)}

def get_contactability_summary() -> Dict:
    """Obtener resumen consolidado de todas las estadísticas - VERSIÓN OPTIMIZADA"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": False, "message": "Error de conexión"}

        cursor = conexionBD.cursor(dictionary=True)
        
        # UNA SOLA CONSULTA para obtener todas las estadísticas en lugar de 4 consultas separadas
        query_optimizada = """
        SELECT 
            'inscripciones_voluntarios' as tabla,
            'Resultados de Inscripciones Voluntarios' as titulo,
            COUNT(*) as total_contactos,
            SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END) as exitosos,
            SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END) as rechazados
        FROM inscripciones_voluntarios
        
        UNION ALL
        
        SELECT 
            'registros_crm_antiguo' as tabla,
            'Resultados de Registros CRM Antiguo' as titulo,
            COUNT(*) as total_contactos,
            SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END) as exitosos,
            SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END) as rechazados
        FROM registros_crm_antiguo
        
        UNION ALL
        
        SELECT 
            'base_datos_10k' as tabla,
            'Resultados de Base de Datos 10k' as titulo,
            COUNT(*) as total_contactos,
            SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END) as exitosos,
            SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END) as rechazados
        FROM base_datos_10k
        
        UNION ALL
        
        SELECT 
            'prospectos_manual' as tabla,
            'Resultados de Prospectos Manual' as titulo,
            COUNT(*) as total_contactos,
            SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END) as exitosos,
            SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END) as rechazados
        FROM prospectos_manual
        """
        
        cursor.execute(query_optimizada)
        resultados = cursor.fetchall()
        
        # Procesar resultados una sola vez
        total_general = 0
        total_exitosos_general = 0
        total_rechazados_general = 0
        tablas_data = []
        
        for resultado in resultados:
            total_contactos = resultado['total_contactos']
            exitosos = resultado['exitosos']
            rechazados = resultado['rechazados']
            
            total_general += total_contactos
            total_exitosos_general += exitosos
            total_rechazados_general += rechazados
            
            porcentaje_exitosos = round((exitosos / total_contactos * 100), 2) if total_contactos > 0 else 0.00
            porcentaje_rechazados = round((rechazados / total_contactos * 100), 2) if total_contactos > 0 else 0.00
            
            tablas_data.append({
                "tabla": resultado['tabla'],
                "titulo": resultado['titulo'],
                "total_contactos": total_contactos,
                "exitosos": exitosos,
                "rechazados": rechazados,
                "porcentaje_exitosos": porcentaje_exitosos,
                "porcentaje_rechazados": porcentaje_rechazados
            })
        
        cursor.close()
        conexionBD.close()
        
        porcentaje_exitosos_general = round((total_exitosos_general / total_general * 100), 2) if total_general > 0 else 0.00
        porcentaje_rechazados_general = round((total_rechazados_general / total_general * 100), 2) if total_general > 0 else 0.00
        
        return {
            "success": True,
            "generated_at": datetime.now().isoformat(),
            "resumen_general": {
                "total_contactos": total_general,
                "total_exitosos": total_exitosos_general,
                "total_rechazados": total_rechazados_general,
                "porcentaje_exitosos": porcentaje_exitosos_general,
                "porcentaje_rechazados": porcentaje_rechazados_general
            },
            "detalle_por_tabla": tablas_data
        }
        
    except Exception as e:
        logging.error(f"Error generando resumen consolidado: {e}")
        return {"success": False, "error": str(e)}

def get_prospectos_por_ciudad() -> Dict:
    """Obtener estadísticas de prospectos por ciudad - OPTIMIZADO"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": False, "message": "Error de conexión"}

        cursor = conexionBD.cursor(dictionary=True)
        
        # Consulta optimizada con cálculo de porcentajes en SQL
        query = """
        WITH total_prospectos AS (
            SELECT COUNT(*) as total FROM (
                SELECT 1 FROM inscripciones_voluntarios WHERE estado_etapa = 1
                UNION ALL SELECT 1 FROM registros_crm_antiguo WHERE estado_etapa = 1
                UNION ALL SELECT 1 FROM base_datos_10k WHERE estado_etapa = 1
                UNION ALL SELECT 1 FROM prospectos_manual WHERE estado_etapa = 1
            ) t
        )
        SELECT 
            ciudad,
            COUNT(*) as total_prospectos,
            ROUND((COUNT(*) * 100.0 / (SELECT total FROM total_prospectos)), 2) as porcentaje
        FROM (
            SELECT ciudad FROM inscripciones_voluntarios 
            WHERE estado_etapa = 1 AND ciudad IS NOT NULL AND ciudad != ''
            UNION ALL
            SELECT ciudad FROM registros_crm_antiguo 
            WHERE estado_etapa = 1 AND ciudad IS NOT NULL AND ciudad != ''
            UNION ALL
            SELECT ciudad FROM base_datos_10k 
            WHERE estado_etapa = 1 AND ciudad IS NOT NULL AND ciudad != ''
            UNION ALL
            SELECT ciudad FROM prospectos_manual 
            WHERE estado_etapa = 1 AND ciudad IS NOT NULL AND ciudad != ''
        ) AS todas_ciudades
        GROUP BY ciudad
        ORDER BY total_prospectos DESC
        LIMIT 100
        """
        
        cursor.execute(query)
        resultados = cursor.fetchall()
        
        # Obtener total por separado
        total_query = """
        SELECT COUNT(*) as total FROM (
            SELECT 1 FROM inscripciones_voluntarios WHERE estado_etapa = 1
            UNION ALL SELECT 1 FROM registros_crm_antiguo WHERE estado_etapa = 1
            UNION ALL SELECT 1 FROM base_datos_10k WHERE estado_etapa = 1
            UNION ALL SELECT 1 FROM prospectos_manual WHERE estado_etapa = 1
        ) AS todos_prospectos
        """
        cursor.execute(total_query)
        total_result = cursor.fetchone()
        total_prospectos = total_result['total'] if total_result else 0
        
        cursor.close()
        conexionBD.close()
        
        ciudades_data = []
        for resultado in resultados:
            ciudades_data.append({
                "ciudad": resultado['ciudad'],
                "total_prospectos": resultado['total_prospectos'],
                "porcentaje": float(resultado['porcentaje'])
            })
        
        return {
            "success": True,
            "titulo": "Prospectos por Ciudad",
            "total_prospectos_general": total_prospectos,
            "ciudades": ciudades_data,
            "total_ciudades": len(ciudades_data)
        }
        
    except Exception as e:
        logging.error(f"Error obteniendo prospectos por ciudad: {e}")
        return {"success": False, "error": str(e)}

def get_prospectos_detalle_por_tabla() -> Dict:
    """Obtener detalle de prospectos por tabla individual"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        tablas_detalle = []
        
        # Lista de tablas a consultar
        tablas = [
            {"nombre": "inscripciones_voluntarios", "titulo": "Inscripciones Voluntarios"},
            {"nombre": "registros_crm_antiguo", "titulo": "Registros CRM Antiguo"},
            {"nombre": "base_datos_10k", "titulo": "Base de Datos 10k"},
            {"nombre": "prospectos_manual", "titulo": "Prospectos Manual"}
        ]
        
        for tabla_info in tablas:
            tabla_nombre = tabla_info["nombre"]
            tabla_titulo = tabla_info["titulo"]
            
            # Total de prospectos por tabla
            total_query = f"SELECT COUNT(*) as total FROM {tabla_nombre} WHERE estado_etapa = 1"
            cursor.execute(total_query)
            total_result = cursor.fetchone()
            total_prospectos_tabla = total_result['total'] if total_result else 0
            
            # Prospectos por ciudad en esta tabla
            ciudad_query = f"""
            SELECT ciudad, COUNT(*) as total_prospectos
            FROM {tabla_nombre}
            WHERE estado_etapa = 1 AND ciudad IS NOT NULL AND ciudad != ''
            GROUP BY ciudad
            ORDER BY total_prospectos DESC
            """
            cursor.execute(ciudad_query)
            ciudades_tabla = cursor.fetchall()
            
            # Calcular porcentajes para esta tabla
            ciudades_con_porcentaje = []
            for ciudad_data in ciudades_tabla:
                porcentaje = round((ciudad_data['total_prospectos'] / total_prospectos_tabla * 100), 2) if total_prospectos_tabla > 0 else 0.00
                ciudades_con_porcentaje.append({
                    "ciudad": ciudad_data['ciudad'],
                    "total_prospectos": ciudad_data['total_prospectos'],
                    "porcentaje": porcentaje
                })
            
            tablas_detalle.append({
                "tabla": tabla_nombre,
                "titulo": tabla_titulo,
                "total_prospectos": total_prospectos_tabla,
                "ciudades": ciudades_con_porcentaje,
                "total_ciudades": len(ciudades_con_porcentaje)
            })
        
        cursor.close()
        conexionBD.close()
        
        return {
            "success": True,
            "titulo": "Detalle de Prospectos por Tabla y Ciudad",
            "generated_at": datetime.now().isoformat(),
            "detalle_por_tabla": tablas_detalle
        }
        
    except Exception as e:
        logging.error(f"Error obteniendo detalle de prospectos por tabla: {e}")
        return {"success": False, "error": str(e)}

def get_top_ciudades_prospectos(limite: int = 10) -> Dict:
    """Obtener el top de ciudades con más prospectos"""
    try:
        prospectos_data = get_prospectos_por_ciudad()
        
        if not prospectos_data["success"]:
            return prospectos_data
        
        # Obtener top ciudades limitado
        top_ciudades = prospectos_data["ciudades"][:limite]
        
        return {
            "success": True,
            "titulo": f"Top {limite} Ciudades con Más Prospectos",
            "total_prospectos_general": prospectos_data["total_prospectos_general"],
            "top_ciudades": top_ciudades,
            "limite_aplicado": limite
        }
        
    except Exception as e:
        logging.error(f"Error obteniendo top ciudades: {e}")
        return {"success": False, "error": str(e)}

def get_union_contacto_personas_stats() -> Dict:
    """Obtener estadísticas de personas por estado de etapa - OPTIMIZADO"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": False, "message": "Error de conexión"}

        cursor = conexionBD.cursor(dictionary=True)
        
        # Una sola consulta para obtener todo
        query = """
        SELECT 
            COUNT(*) as total_personas,
            SUM(CASE WHEN estado_etapa = 1 THEN 1 ELSE 0 END) as prospectos,
            SUM(CASE WHEN estado_etapa = 2 THEN 1 ELSE 0 END) as primer_contacto,
            SUM(CASE WHEN estado_etapa = 3 THEN 1 ELSE 0 END) as consolidacion,
            SUM(CASE WHEN estado_etapa = 4 THEN 1 ELSE 0 END) as fidelizacion,
            SUM(CASE WHEN estado_etapa = 5 THEN 1 ELSE 0 END) as rechazados
        FROM union_contactos_personas
        """
        
        cursor.execute(query)
        resultado = cursor.fetchone()
        
        cursor.close()
        conexionBD.close()
        
        if not resultado:
            return {"success": False, "message": "No se encontraron datos"}
        
        total_personas = resultado['total_personas']
        
        # Definir los estados de etapa
        estados_data = [
            {"id": 1, "nombre": "Prospecto", "total": resultado['prospectos']},
            {"id": 2, "nombre": "Primer contacto", "total": resultado['primer_contacto']},
            {"id": 3, "nombre": "Consolidación", "total": resultado['consolidacion']},
            {"id": 4, "nombre": "Fidelización", "total": resultado['fidelizacion']},
            {"id": 5, "nombre": "Rechazado", "total": resultado['rechazados']}
        ]
        
        # Calcular porcentajes
        estadisticas_por_etapa = []
        for estado in estados_data:
            porcentaje = round((estado['total'] / total_personas * 100), 2) if total_personas > 0 else 0.00
            estadisticas_por_etapa.append({
                "estado_etapa_id": estado['id'],
                "estado_etapa_nombre": estado['nombre'],
                "total_personas": estado['total'],
                "porcentaje": porcentaje
            })
        
        return {
            "success": True,
            "titulo": "Estadísticas por Estado de Etapa - Union Contacto Personas",
            "tabla": "union_contactos_personas",
            "total_personas_general": total_personas,
            "estadisticas_por_etapa": estadisticas_por_etapa,
            "generated_at": datetime.now().isoformat()
        }
        
    except Exception as e:
        logging.error(f"Error obteniendo estadísticas de union_contactos_personas: {e}")
        return {"success": False, "error": str(e)}

def get_union_contacto_personas_resumen() -> Dict:
    """Obtener resumen consolidado de union_contactos_personas con métricas clave"""
    try:
        stats_data = get_union_contacto_personas_stats()
        
        if not stats_data["success"]:
            return stats_data
        
        # Extraer métricas específicas
        metricas = {}
        for etapa in stats_data["estadisticas_por_etapa"]:
            estado_id = etapa["estado_etapa_id"]
            if estado_id == 1:  # Prospecto
                metricas["prospectos"] = {
                    "total": etapa["total_personas"],
                    "porcentaje": etapa["porcentaje"]
                }
            elif estado_id == 2:  # Primer contacto
                metricas["primer_contacto"] = {
                    "total": etapa["total_personas"],
                    "porcentaje": etapa["porcentaje"]
                }
            elif estado_id == 3:  # Consolidación
                metricas["consolidacion"] = {
                    "total": etapa["total_personas"],
                    "porcentaje": etapa["porcentaje"]
                }
            elif estado_id == 4:  # Fidelización
                metricas["fidelizacion"] = {
                    "total": etapa["total_personas"],
                    "porcentaje": etapa["porcentaje"]
                }
            elif estado_id == 5:  # Rechazado
                metricas["rechazados"] = {
                    "total": etapa["total_personas"],
                    "porcentaje": etapa["porcentaje"]
                }
        
        # Calcular métricas adicionales
        total_activos = (metricas.get("prospectos", {}).get("total", 0) + 
                        metricas.get("primer_contacto", {}).get("total", 0) + 
                        metricas.get("consolidacion", {}).get("total", 0) + 
                        metricas.get("fidelizacion", {}).get("total", 0))
        
        total_rechazados = metricas.get("rechazados", {}).get("total", 0)
        total_general = stats_data["total_personas_general"]
        
        porcentaje_activos = round((total_activos / total_general * 100), 2) if total_general > 0 else 0.00
        porcentaje_rechazados = round((total_rechazados / total_general * 100), 2) if total_general > 0 else 0.00
        
        return {
            "success": True,
            "titulo": "Resumen Union Contacto Personas",
            "tabla": "union_contactos_personas",
            "total_general": total_general,
            "metricas_clave": {
                "total_activos": total_activos,
                "total_rechazados": total_rechazados,
                "porcentaje_activos": porcentaje_activos,
                "porcentaje_rechazados": porcentaje_rechazados
            },
            "detalle_por_etapa": metricas,
            "estadisticas_completas": stats_data["estadisticas_por_etapa"],
            "generated_at": datetime.now().isoformat()
        }
        
    except Exception as e:
        logging.error(f"Error generando resumen de union_contactos_personas: {e}")
        return {"success": False, "error": str(e)}

def get_estadisticas_descriptivas_consolidadas() -> Dict:
    """Obtener estadísticas descriptivas - VERSIÓN SIMPLIFICADA"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": False, "message": "Error de conexión"}

        cursor = conexionBD.cursor(dictionary=True)
        
        # Consulta más simple y rápida
        query = """
        SELECT 
            estado_etapa,
            COUNT(*) as frecuencia
        FROM (
            SELECT CAST(estado_etapa AS SIGNED) as estado_etapa FROM inscripciones_voluntarios 
            WHERE estado_etapa REGEXP '^[1-5]$'
            UNION ALL
            SELECT CAST(estado_etapa AS SIGNED) FROM registros_crm_antiguo 
            WHERE estado_etapa REGEXP '^[1-5]$'
            UNION ALL
            SELECT CAST(estado_etapa AS SIGNED) FROM base_datos_10k 
            WHERE estado_etapa REGEXP '^[1-5]$'
            UNION ALL
            SELECT CAST(estado_etapa AS SIGNED) FROM prospectos_manual 
            WHERE estado_etapa REGEXP '^[1-5]$'
        ) AS todos_estados
        GROUP BY estado_etapa
        ORDER BY estado_etapa
        """
        
        cursor.execute(query)
        resultados = cursor.fetchall()
        
        cursor.close()
        conexionBD.close()
        
        if not resultados:
            return {"success": False, "message": "No se encontraron datos válidos"}
        
        # Procesamiento simplificado
        estados_nombres = {1: "Prospecto", 2: "Primer contacto", 3: "Consolidación", 4: "Fidelización", 5: "Rechazado"}
        
        total_registros = sum(r['frecuencia'] for r in resultados)
        estados = [r['estado_etapa'] for r in resultados for _ in range(r['frecuencia'])]
        
        import statistics
        media = round(statistics.mean(estados), 4)
        mediana = statistics.median(estados)
        
        from collections import Counter
        contador = Counter(estados)
        moda = contador.most_common(1)[0][0]
        
        distribucion_detallada = []
        for resultado in resultados:
            estado_id = resultado['estado_etapa']
            frecuencia = resultado['frecuencia']
            porcentaje_sin_redondear = (frecuencia / total_registros * 100) if total_registros > 0 else 0.0
            porcentaje = round((frecuencia / total_registros * 100), 2)
            
            distribucion_detallada.append({
                "estado_etapa_id": estado_id,
                "estado_etapa_nombre": estados_nombres.get(estado_id, f"Estado {estado_id}"),
                "frecuencia": frecuencia,
                "porcentaje": porcentaje,
                "porcentaje_sin_redondear": porcentaje_sin_redondear
            })
        
        return {
            "success": True,
            "titulo": "Estadísticas Descriptivas Recopiladas - Estado de Etapa",
            "muestra_consolidada": {
                "total_registros": total_registros,
                "variable_analizada": "estado_etapa"
            },
            "estadisticas_descriptivas": {
                "medidas_centrales": {
                    "media": media,
                    "mediana": mediana,
                    "moda": moda,
                    "moda_nombre": estados_nombres.get(moda, f"Estado {moda}")
                }
            },
            "distribucion_frecuencias": {
                "por_estado_etapa": distribucion_detallada
            },
            "generated_at": datetime.now().isoformat()
        }
        
    except Exception as e:
        logging.error(f"Error calculando estadísticas descriptivas: {e}")
        return {"success": False, "error": str(e)}

def get_estadisticas_descriptivas_por_tabla() -> Dict:
    """Obtener estadísticas descriptivas de cada tabla por separado para comparación"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        # Lista de tablas a analizar
        tablas = [
            {"nombre": "inscripciones_voluntarios", "titulo": "Inscripciones Voluntarios"},
            {"nombre": "registros_crm_antiguo", "titulo": "Registros CRM Antiguo"},
            {"nombre": "base_datos_10k", "titulo": "Base de Datos 10k"},
            {"nombre": "prospectos_manual", "titulo": "Prospectos Manual"}
        ]
        
        resultados_por_tabla = []
        
        import statistics
        
        for tabla_info in tablas:
            tabla_nombre = tabla_info["nombre"]
            tabla_titulo = tabla_info["titulo"]
            
            # Obtener estados de etapa de esta tabla con validación
            query = f"""
            SELECT CAST(estado_etapa AS SIGNED) as estado_etapa 
            FROM {tabla_nombre} 
            WHERE estado_etapa IS NOT NULL 
            AND estado_etapa != '' 
            AND estado_etapa REGEXP '^[0-9]+$'
            """
            cursor.execute(query)
            registros_tabla = cursor.fetchall()
            
            if not registros_tabla:
                continue
            
            # Filtrar y convertir estados válidos
            estados_etapa = []
            for registro in registros_tabla:
                try:
                    estado = int(registro['estado_etapa'])
                    if 1 <= estado <= 5:  # Solo estados válidos
                        estados_etapa.append(estado)
                except (ValueError, TypeError):
                    continue
            
            if not estados_etapa:
                continue
                
            n_tabla = len(estados_etapa)
            
            # Cálculos estadísticos para esta tabla
            media_tabla = round(statistics.mean(estados_etapa), 4)
            mediana_tabla = statistics.median(estados_etapa)
            
            try:
                moda_tabla = statistics.mode(estados_etapa)
            except statistics.StatisticsError:
                from collections import Counter
                contador = Counter(estados_etapa)
                moda_tabla = contador.most_common(1)[0][0]
            
            try:
                desviacion_tabla = round(statistics.stdev(estados_etapa), 4) if len(estados_etapa) > 1 else 0.0
            except statistics.StatisticsError:
                desviacion_tabla = 0.0
            
            try:
                varianza_tabla = round(statistics.variance(estados_etapa), 4) if len(estados_etapa) > 1 else 0.0
            except statistics.StatisticsError:
                varianza_tabla = 0.0
            
            min_tabla = min(estados_etapa)
            max_tabla = max(estados_etapa)
            
            resultados_por_tabla.append({
                "tabla": tabla_nombre,
                "titulo": tabla_titulo,
                "total_registros": n_tabla,
                "estadisticas": {
                    "media": media_tabla,
                    "mediana": mediana_tabla,
                    "moda": moda_tabla,
                    "desviacion_estandar": desviacion_tabla,
                    "varianza": varianza_tabla,
                    "minimo": min_tabla,
                    "maximo": max_tabla,
                    "rango": max_tabla - min_tabla
                }
            })
        
        cursor.close()
        conexionBD.close()
        
        return {
            "success": True,
            "titulo": "Estadísticas Descriptivas por Tabla Individual",
            "estadisticas_por_tabla": resultados_por_tabla,
            "generated_at": datetime.now().isoformat()
        }
        
    except Exception as e:
        logging.error(f"Error calculando estadísticas por tabla: {e}")
        return {"success": False, "error": str(e)}



# Reportes de los logs de primer contacto
def get_logs_primer_contacto_summary() -> Dict:
    """Obtener logs de primer contacto con nombres de tablas relacionadas"""
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        
        # Consulta con JOINs para obtener los nombres
        query = """
        SELECT 
            lpc.id,
            lpc.id_usuario,
            e.nombres as nombres_empleado,
            e.apellidos as apellidos_empleado,
            CONCAT(e.nombres, ' ', e.apellidos) as nombre_completo_empleado,
            lpc.id_contacto,
            ucp.nombres,
            ucp.apellidos,
            CONCAT(ucp.nombres, ' ', ucp.apellidos) as nombre_completo_contacto,
            lpc.id_evento,
            ev.evento as nombre_evento,
            lpc.fecha_hora
        FROM logs_primer_contacto lpc
        LEFT JOIN empleados e ON lpc.id_usuario = e.id
        LEFT JOIN union_contactos_personas ucp ON lpc.id_contacto = ucp.id
        LEFT JOIN eventos ev ON lpc.id_evento = ev.id
        ORDER BY lpc.fecha_hora DESC
        """
        
        cursor.execute(query)
        logs_data = cursor.fetchall()
        
        # Total de registros
        total_logs = len(logs_data)
        
        # Convertir datetime a string para JSON
        for log in logs_data:
            if log.get('fecha_hora'):
                log['fecha_hora'] = log['fecha_hora'].isoformat()
        
        cursor.close()
        conexionBD.close()
        
        return {
            "success": True,
            "titulo": "Logs de Primer Contacto",
            "total_logs": total_logs,
            "logs": logs_data,
            "generated_at": datetime.now().isoformat()
        }
        
    except Exception as e:
        logging.error(f"Error obteniendo logs de primer contacto: {e}")
        return {"success": False, "error": str(e)}