"""
Consulta da folha de resposta cadastrada no KeepEdu (visualização no histórico).
"""
from __future__ import annotations

from typing import Any

import requests

from app.settings import (
    KEEPEDU_API_BASE_URL,
    KEEPEDU_API_KEY,
    KEEPEDU_IMPORTAR_TIMEOUT_SECONDS,
    KEEPEDU_INSTITUTE,
    KEEPEDU_ORIGIN_URL,
    KEEPEDU_VER_FOLHA_RESPOSTA_URL,
)


def _cabecalhos_keepedu() -> dict[str, str]:
    return {
        "ApiKey": KEEPEDU_API_KEY,
        "Institute": KEEPEDU_INSTITUTE,
        "Content-Type": "application/json",
        "Accept": "application/json",
    }


def _cabecalhos_imagem_keepedu() -> dict[str, str]:
    return {
        "ApiKey": KEEPEDU_API_KEY,
        "Institute": KEEPEDU_INSTITUTE,
        "Accept": "image/*,*/*",
    }


def _resolver_url_imagem(caminho: str) -> str:
    texto = str(caminho or "").strip()
    if not texto:
        return ""
    if texto.startswith(("http://", "https://")):
        return texto

    base = KEEPEDU_API_BASE_URL.rstrip("/")
    if base.endswith("/api"):
        base = base[:-4]
    if not base:
        base = KEEPEDU_ORIGIN_URL
    return f"{base.rstrip('/')}/{texto.lstrip('/')}"


def _normalizar_id_numerico(valor: Any) -> int | None:
    texto = str(valor or "").strip()
    if not texto or texto == "—":
        return None
    if texto.isdigit():
        return int(texto)
    return None


def ver_folha_resposta_keepedu(aluno_id: Any, simulado_id: Any) -> dict[str, Any]:
    """
    POST { aluno_id, simulado_id } em KEEPEDU_VER_FOLHA_RESPOSTA_URL.
    """
    aluno = _normalizar_id_numerico(aluno_id)
    simulado = _normalizar_id_numerico(simulado_id)

    if aluno is None:
        return {
            "ok": False,
            "erro": "Informe um ID de aluno válido para consultar a folha no KeepEdu.",
        }
    if simulado is None:
        return {
            "ok": False,
            "erro": "Informe um ID de simulado/avaliação válido para consultar a folha no KeepEdu.",
        }

    if not KEEPEDU_VER_FOLHA_RESPOSTA_URL:
        return {
            "ok": False,
            "erro": "KEEPEDU_VER_FOLHA_RESPOSTA_URL não configurada.",
        }

    if not KEEPEDU_API_KEY or not KEEPEDU_INSTITUTE:
        return {
            "ok": False,
            "erro": "Configure KEEPEDU_API_KEY e KEEPEDU_INSTITUTE no .env.",
        }

    payload = {"aluno_id": aluno, "simulado_id": simulado}

    try:
        resposta = requests.post(
            KEEPEDU_VER_FOLHA_RESPOSTA_URL,
            json=payload,
            headers=_cabecalhos_keepedu(),
            timeout=KEEPEDU_IMPORTAR_TIMEOUT_SECONDS,
        )
    except requests.exceptions.Timeout:
        return {"ok": False, "erro": "Tempo limite excedido ao consultar a folha no KeepEdu."}
    except requests.exceptions.RequestException as exc:
        return {"ok": False, "erro": f"Erro ao consultar a folha no KeepEdu: {exc}"}

    try:
        corpo = resposta.json()
    except ValueError:
        return {
            "ok": False,
            "erro": f"Resposta inválida do KeepEdu (HTTP {resposta.status_code}).",
        }

    if not isinstance(corpo, dict):
        return {"ok": False, "erro": "Resposta inesperada do KeepEdu."}

    caminho_imagem = _resolver_url_imagem(corpo.get("caminho_imagem"))
    imagem_existe = bool(corpo.get("imagem_existe")) or bool(caminho_imagem)
    sucesso_api = bool(corpo.get("success")) and imagem_existe

    mensagem = str(corpo.get("error") or corpo.get("mensagem") or corpo.get("message") or "").strip()

    return {
        "ok": True,
        "http_status": resposta.status_code,
        "success": sucesso_api,
        "imagem_url": caminho_imagem if sucesso_api else "",
        "imagem_existe": imagem_existe,
        "mensagem": mensagem,
        "aluno_id": aluno,
        "simulado_id": simulado,
        "raw": corpo,
    }


def baixar_imagem_folha_resposta(url_remota: str) -> tuple[bytes, str]:
    """Baixa bytes da imagem hospedada no KeepEdu para servir via proxy local."""
    url = str(url_remota or "").strip()
    if not url:
        raise ValueError("URL da imagem não informada.")

    resposta = requests.get(
        url,
        headers=_cabecalhos_imagem_keepedu(),
        timeout=KEEPEDU_IMPORTAR_TIMEOUT_SECONDS,
    )
    if resposta.status_code >= 400:
        raise ValueError(f"KeepEdu retornou HTTP {resposta.status_code} ao buscar a imagem.")

    conteudo = resposta.content
    if not conteudo:
        raise ValueError("KeepEdu retornou imagem vazia.")

    content_type = str(resposta.headers.get("Content-Type") or "image/jpeg").split(";")[0].strip()
    return conteudo, content_type or "image/jpeg"