import base64
import time
import logging

logger = logging.getLogger(__name__)

class VisionCritic:
    PROMPT_ANATOMY = (
        "Analiza detalladamente esta ilustración anime de forma puramente técnica y anatómica.\n"
        "Busca errores críticos:\n"
        "- Manos con más de 5 dedos o dedos deformes\n"
        "- Ojos bizcos, desalineados o pupilas derretidas\n"
        "- Extremidades flotantes o miembros extras\n"
        "- Clones o personas deformes en reflejos/espejos\n"
        "- Cuerpos estirados artificialmente\n"
        "- Fondos abstractos planos en lugar de escenarios reales\n\n"
        "Responde ESTRICTAMENTE con una sola de estas opciones:\n"
        "'APROBADO' si la imagen es anatómicamente correcta.\n"
        "'RECHAZADO: [descripción breve del error]' si detectas mutaciones graves."
    )

    PROMPT_OUTFIT = (
        "Analiza esta ilustración anime. Verifica si el outfit y el escenario son coherentes "
        "entre sí (ej: no debería haber traje de baño en una oficina, ni uniforme escolar en la playa).\n"
        "Responde con 'APROBADO' si son coherentes, o 'RECHAZADO: [motivo]' si no lo son."
    )

    def __init__(self, vision_client, max_retries=3, auto_approve_on_error=True, delay_between_requests=31):
        self.client = vision_client
        self.max_retries = max_retries
        self.auto_approve_on_error = auto_approve_on_error
        self.delay_between_requests = delay_between_requests
        self.last_request_time = 0

    def _wait_for_rate_limit(self):
        elapsed = time.time() - self.last_request_time
        if elapsed < self.delay_between_requests:
            wait_time = self.delay_between_requests - elapsed
            logger.info(f"Esperando {wait_time:.1f}s para respetar rate limit (2 RPM)...")
            time.sleep(wait_time)
        self.last_request_time = time.time()

    def audit_anatomy(self, image_bytes):
        image_b64 = base64.b64encode(image_bytes).decode("utf-8")

        for attempt in range(self.max_retries):
            self._wait_for_rate_limit()
            verdict = self.client.analyze(image_b64, self.PROMPT_ANATOMY)

            if self.client.is_approved(verdict):
                return True, "APROBADO", attempt + 1

            if attempt < self.max_retries - 1:
                logger.warning(f"Intento {attempt + 1} rechazado: {verdict}. Reintentando...")

        return False, verdict, self.max_retries

    def audit_coherence(self, image_bytes):
        image_b64 = base64.b64encode(image_bytes).decode("utf-8")
        self._wait_for_rate_limit()
        verdict = self.client.analyze(image_b64, self.PROMPT_OUTFIT)
        return self.client.is_approved(verdict), verdict

    def full_audit(self, image_bytes):
        logger.info("=== INICIANDO AUDITORÍA COMPLETA ===")

        anatomy_ok, anatomy_verdict, attempts = self.audit_anatomy(image_bytes)
        if not anatomy_ok:
            logger.warning(f"RECHAZADO por anatomía: {anatomy_verdict}")
            return False, anatomy_verdict, {"anatomy": False, "coherence": None}

        coherence_ok, coherence_verdict = self.audit_coherence(image_bytes)
        if not coherence_ok:
            logger.warning(f"RECHAZADO por incoherencia: {coherence_verdict}")
            return False, coherence_verdict, {"anatomy": True, "coherence": False}

        logger.info("APROBADO en auditoría completa")
        return True, "APROBADO", {"anatomy": True, "coherence": True}