Erros

import requests


class SherlockerApiError(Exception):
    def __init__(self, problem: dict):
        self.code = problem.get("code")
        self.status = problem.get("status")
        self.detail = problem.get("detail")
        self.instance = problem.get("instance")
        self.problem = problem
        super().__init__(f"{self.code}: {self.detail}")


def handle_sherlocker_error(resp: requests.Response) -> None:
    """Tratamento unico para /analyses e /operations."""
    problem = resp.json()
    code = problem.get("code")

    if code == "validation_error":
        # Corrija a requisicao: veja problem["errors"]; key NOVA no reenvio
        msgs = ", ".join(e["message"] for e in problem.get("errors", []))
        raise SherlockerApiError({**problem, "detail": f"Validacao falhou: {msgs}"})

    if code == "bad_request":
        # Provavelmente header ausente (ex.: Idempotency-Key)
        raise SherlockerApiError(problem)

    if code == "unauthorized":
        # Verifique ou rotacione a chave de API
        raise SherlockerApiError(problem)

    if code == "insufficient_tokens":
        # problem["required"] e problem["balance"] estao disponiveis
        raise SherlockerApiError(problem)

    if code == "feature_not_enabled":
        # Direcione o usuario para solicitar acesso
        print(f"Solicite acesso em: {problem.get('request_access_url')}")
        raise SherlockerApiError(problem)

    if code == "idempotency_conflict":
        # Consulte o run/operacao existente em vez de repetir o POST
        raise SherlockerApiError(problem)

    if code == "conflict":
        # Bordero: /result antes de completed — continue o polling do GET /operations/{id}
        raise SherlockerApiError(problem)

    if code in ("forbidden", "not_found", "no_engine"):
        raise SherlockerApiError(problem)

    # server_error / http_error / desconhecido:
    # retry com a MESMA key e back-off; inclua problem["instance"] no suporte
    raise SherlockerApiError(problem)

/**
 * Body de erro RFC 7807 (application/problem+json):
 * { type, title, status, code, detail, instance }
 * Campos extras conforme o code:
 *   errors: [{ field, message }]        (validation_error)
 *   required, balance                   (insufficient_tokens)
 *   request_access_url                  (feature_not_enabled)
 * Tratamento unico para /analyses e /operations.
 */
async function handleSherlockerError(res) {
  const problem = await res.json();

  switch (problem.code) {
    case "validation_error":
      // Corrija a requisicao: veja problem.errors[]; key NOVA no reenvio
      throw new Error(`Validacao falhou: ${problem.errors?.map((e) => e.message).join(", ")}`);

    case "bad_request":
      // Provavelmente header ausente (ex.: Idempotency-Key)
      throw new Error(`Requisicao invalida: ${problem.detail}`);

    case "unauthorized":
      // Verifique ou rotacione a chave de API
      throw new Error("Chave de API invalida");

    case "insufficient_tokens":
      // problem.required e problem.balance estao disponiveis
      throw new Error(`Tokens insuficientes (precisa de ${problem.required}, saldo ${problem.balance})`);

    case "feature_not_enabled":
      // Direcione o usuario para solicitar acesso
      console.error(`Solicite acesso em: ${problem.request_access_url}`);
      throw new Error("Feature nao habilitada para este workspace");

    case "forbidden":
      throw new Error("Acesso negado");

    case "not_found":
      throw new Error("Analise ou operacao nao encontrada");

    case "idempotency_conflict":
      // Consulte o run/operacao existente em vez de repetir o POST
      throw new Error("Requisicao concorrente em andamento: faca polling da original");

    case "conflict":
      // Bordero: /result antes de completed — continue o polling do GET /operations/{id}
      throw new Error("Operacao ainda nao concluida: aguarde status completed");

    case "no_engine":
      throw new Error("Nenhuma engine disponivel para esta requisicao");

    case "server_error":
    default:
      // Retry com a MESMA key e back-off; inclua problem.instance no suporte
      throw new Error(`Erro no servidor (instance: ${problem.instance})`);
  }
}