import axios from "axios";
import { GlobalFunctions, TransferAreaProperties } from "@/GlobalFunctions";

import { resolveCommanderBaseUrl } from "./fechamentoBaseUrl";

export type UnidadeLookupRow = {
  id: string;
  nome: string;
  estabelecimentoId: string;
};

const cacheByCodigo = new Map<string, UnidadeLookupRow>();

type UnidadesListResponse = {
  data: Array<{
    id: string;
    nome: string;
    estabelecimentoId: string;
  }>;
};

async function buildLookupHeaders(): Promise<Record<string, string>> {
  const token = await GlobalFunctions.getToken();
  const apiKey = import.meta.env.VITE_API_KEY || "";
  return {
    "Content-Type": "application/json",
    ...(apiKey ? { apikey: apiKey } : {}),
    ...(token ? { Authorization: `Bearer ${token}` } : {}),
  };
}

export function clearCommanderUnidadeIdCache(): void {
  cacheByCodigo.clear();
}

/** Código de estabelecimento vindo do Transfer (host), ou string vazia. */
export function getEstabelecimentoCodigoFromTransfer(): string {
  const raw = GlobalFunctions.getTransferProperty(TransferAreaProperties.EstabelecimentoCodigo);
  const codigo =
    typeof raw === "string" ? raw.trim() : raw != null && String(raw).trim() !== "" ? String(raw).trim() : "";
  return codigo;
}

/**
 * Consulta `GET /unidades?estabelecimentoId=…` sem lançar; retorna `null` se não houver linha.
 * Resultado é cacheado por código.
 */
export async function lookupUnidadeByEstabelecimento(codigo: string): Promise<UnidadeLookupRow | null> {
  const key = codigo.trim();
  if (!key) {
    return null;
  }

  const cached = cacheByCodigo.get(key);
  if (cached) {
    return cached;
  }

  const baseUrl = resolveCommanderBaseUrl();
  const headers = await buildLookupHeaders();
  const response = await axios.get<UnidadesListResponse>(`${baseUrl}/unidades`, {
    headers,
    params: {
      estabelecimentoId: key,
      page: 1,
      perPage: 10,
    },
  });

  const row =
    response.data.data?.find((u) => u.estabelecimentoId === key) ?? response.data.data?.[0];
  if (!row?.id) {
    return null;
  }

  const mapped: UnidadeLookupRow = {
    id: row.id,
    nome: row.nome,
    estabelecimentoId: row.estabelecimentoId,
  };
  cacheByCodigo.set(key, mapped);
  return mapped;
}

/**
 * Resolve o UUID da unidade no Commander a partir do código de estabelecimento
 * disponibilizado pelo host (mesmo padrão de `audioGeneration.ts` / Codex).
 * Lança se o código estiver ausente ou não existir unidade cadastrada.
 */
export async function resolveCommanderUnidadeId(): Promise<string> {
  const codigo = getEstabelecimentoCodigoFromTransfer();
  if (!codigo) {
    throw new Error(
      "EstabelecimentoCodigo não disponível (TransferArea). Não foi possível resolver a unidade para o Commander.",
    );
  }

  const row = await lookupUnidadeByEstabelecimento(codigo);
  if (!row) {
    throw new Error(
      `Nenhuma unidade encontrada no Commander para o estabelecimento "${codigo}". Cadastre a unidade ou verifique o código.`,
    );
  }

  return row.id;
}
