"""Health checks (Kubernetes-style)."""

import time
from typing import Dict, Any


class SondeoSalud:
    """Health probe para verificar salud del agente (Kubernetes-style).
    
    Proporciona tres tipos de sondeos:
    - Liveness: ¿El agente está vivo/responsive? (rescata procesos colgados)
    - Readiness: ¿El agente está listo para procesar tareas?
    - Startup: ¿El agente completó la inicialización?
    """
    
    def __init__(self, nombre_agente: str, umbral_inactividad: float = 60.0):
        """
        Inicializa sondeo de salud.
        
        Args:
            nombre_agente: Nombre del agente
            umbral_inactividad: Segundos de inactividad antes de marcar como no vivo
        """
        self.nombre_agente = nombre_agente
        self.umbral_inactividad = umbral_inactividad
        self.timestamp_inicio = time.time()
        self.ultimoContacto = time.time()
        self.lock = __import__('threading').Lock()
    
    def marcar_contacto(self):
        """Marca que el agente está activo."""
        with self.lock:
            self.ultimoContacto = time.time()
    
    def sondeo_liveness(self) -> Dict[str, Any]:
        """
        Verifica si el agente está vivo y responsive.
        
        Returns:
            Dict con status: "alive" o "dead"
        """
        with self.lock:
            inactividad_actual = time.time() - self.ultimoContacto
            esta_vivo = inactividad_actual < self.umbral_inactividad
            
            return {
                "status": "alive" if esta_vivo else "dead",
                "segundos_inactivo": round(inactividad_actual, 2),
                "umbral_segundos": self.umbral_inactividad,
                "tipo": "liveness",
                "timestamp": time.time(),
            }
    
    def sondeo_readiness(self, agente_vivo: bool, tamaño_cola: int, capacidad_cola: int) -> Dict[str, Any]:
        """
        Verifica si el agente está listo para procesar tareas.
        
        Args:
            agente_vivo: ¿El agente tiene vivo=True?
            tamaño_cola: Tamaño actual de la cola
            capacidad_cola: Capacidad máxima de la cola
        
        Returns:
            Dict con status: "ready" o "not_ready"
        """
        with self.lock:
            # Agente NO está listo si: no está vivo OR cola está saturada (>80%)
            porcentaje_saturacion = (tamaño_cola / capacidad_cola * 100) if capacidad_cola > 0 else 0
            esta_listo = agente_vivo and porcentaje_saturacion < 80.0
            
            return {
                "status": "ready" if esta_listo else "not_ready",
                "agente_vivo": agente_vivo,
                "tamaño_cola": tamaño_cola,
                "capacidad_cola": capacidad_cola,
                "porcentaje_saturacion": round(porcentaje_saturacion, 2),
                "tipo": "readiness",
                "timestamp": time.time(),
            }
    
    def sondeo_startup(self, inicializacion_completa: bool) -> Dict[str, Any]:
        """
        Verifica si el agente completó la inicialización.
        
        Args:
            inicializacion_completa: ¿Se completó la inicialización?
        
        Returns:
            Dict con status: "started" o "starting"
        """
        with self.lock:
            tiempo_desde_inicio = time.time() - self.timestamp_inicio
            
            return {
                "status": "started" if inicializacion_completa else "starting",
                "tiempo_desde_inicio": round(tiempo_desde_inicio, 2),
                "inicializacion_completa": inicializacion_completa,
                "tipo": "startup",
                "timestamp": time.time(),
            }
    
    def obtener_estado_general(self, agente_vivo: bool, tamaño_cola: int, capacidad_cola: int) -> Dict[str, Any]:
        """Obtiene estado general de todos los sondeos."""
        liveness = self.sondeo_liveness()
        readiness = self.sondeo_readiness(agente_vivo, tamaño_cola, capacidad_cola)
        startup = self.sondeo_startup(agente_vivo)
        
        return {
            "agente": self.nombre_agente,
            "liveness": liveness,
            "readiness": readiness,
            "startup": startup,
            "saludable": liveness["status"] == "alive" and readiness["status"] == "ready",
        }
