"""
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.keepedu_http import post_json_comprimido
from app.settings import KEEPEDU_API_KEY
from app.tenant import get_api_base_url, get_institute_id, resolve_keepedu_url

KEEPEDU_IMPORTAR_TIMEOUT_SECONDS = 30


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


def _cabecalhos_imagem_keepedu() -> dict[str, str]:
    return {
        "ApiKey": KEEPEDU_API_KEY,
        "Institute": get_institute_id(),
        "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 = get_api_base_url().rstrip("/")
    if base.endswith("/api"):
        base = base[:-4]
    if not base:
        return ""
    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.",
        }

    url_folha = resolve_keepedu_url(
        "avaliacoes/ver-folha-resposta",
        "KEEPEDU_VER_FOLHA_RESPOSTA_URL",
    )
    if not url_folha:
        return {
            "ok": False,
            "erro": "URL da API KeepEdu não configurada (escola na sessão ou KEEPEDU_VER_FOLHA_RESPOSTA_URL).",
        }

    if not KEEPEDU_API_KEY or not get_institute_id():
        return {
            "ok": False,
            "erro": "Configure KEEPEDU_API_KEY e o instituto da escola ativa em KEEPEDU_INSTITUTES (ou KEEPEDU_INSTITUTE como fallback).",
        }

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

    try:
        resposta = post_json_comprimido(
            url_folha,
            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"))
    # A API pode devolver `success: true` e um caminho, embora a própria
    # resposta informe `imagem_existe: false`. Esse caso não é um espelho
    # disponível: o link normalmente responde 404 e deve cair no fallback.
    imagem_existe = corpo.get("imagem_existe") is True
    sucesso_api = bool(corpo.get("success")) and imagem_existe

    mensagem = str(corpo.get("error") or corpo.get("mensagem") or corpo.get("message") or "").strip()
    if not sucesso_api and not mensagem and caminho_imagem:
        mensagem = "A KeepEdu informou que a imagem espelho ainda não existe para este cartão."

    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"