import type { createAdminClient } from "@/lib/supabase-server";

/**
 * A XBZ vira um fornecedor de verdade no cadastro de quem a conecta.
 *
 * Hoje a integração é uma ilha dentro do próprio menu Fornecedores: o produto
 * importado vira produto do catálogo, mas a XBZ nunca aparece na lista de
 * fornecedores, nada dela entra no histórico, e o pedido enviado não conversa
 * com contas a pagar. Nascendo como fornecedor, ela passa a andar pelo mesmo
 * caminho de qualquer outro.
 *
 * Só para quem conectar: nada é criado retroativamente na base de quem já usa,
 * porque isso seria escrever em dado de cliente sem ele pedir.
 */

const NOME_DA_XBZ = "XBZ Brindes";
const SITE_DA_XBZ = "minhaxbz.com.br";

export type ResultadoDoFornecedorDaXbz =
  | { criado: true; supplierId: string }
  | { criado: false; supplierId: string | null; motivo: "ja_existia" | "falhou" };

/**
 * Cria o fornecedor da XBZ se ele ainda não existir na empresa.
 *
 * O documento nasce em branco de propósito. O CNPJ que a integração guarda é o
 * da PRÓPRIA gráfica, o login dela na XBZ, e não o da XBZ: preencher com ele
 * gravaria o documento errado em 15 bases de uma vez. Inventar um número
 * também está fora de questão. Então o cadastro entra como "pendente", que é
 * exatamente o que ele é, e a pessoa completa quando quiser.
 */
export async function garantirFornecedorDaXbz(
  admin: ReturnType<typeof createAdminClient>,
  companyId: string,
  actorUserId: string | null
): Promise<ResultadoDoFornecedorDaXbz> {
  /* Procura por nome porque é o que existe: sem documento, não há chave
     melhor. O `ilike` sem curinga evita casar com nome parecido por acidente. */
  const { data: existente } = await admin
    .from("suppliers")
    .select("id")
    .eq("company_id", companyId)
    .ilike("name", NOME_DA_XBZ)
    .is("deleted_at", null)
    .maybeSingle();

  if (existente?.id) {
    return { criado: false, supplierId: String(existente.id), motivo: "ja_existia" };
  }

  /* A categoria é resolvida aqui em vez de reaproveitar o helper da rota de
     fornecedores para não arrastar uma dependência entre os dois módulos por
     causa de uma linha. */
  let categoryId: string | null = null;
  const { data: categoria } = await admin
    .from("supplier_categories")
    .select("id")
    .eq("company_id", companyId)
    .ilike("name", "Brindes")
    .maybeSingle();

  if (categoria?.id) {
    categoryId = String(categoria.id);
  } else {
    const { data: nova } = await admin
      .from("supplier_categories")
      .insert({ company_id: companyId, name: "Brindes" })
      .select("id")
      .maybeSingle();
    categoryId = nova?.id ? String(nova.id) : null;
  }

  const { data: criado, error } = await admin
    .from("suppliers")
    .insert({
      company_id: companyId,
      category_id: categoryId,
      name: NOME_DA_XBZ,
      legal_name: NOME_DA_XBZ,
      cnpj: "",
      document_type: "cnpj",
      city: "",
      email: "",
      phone: "",
      payment_terms_primary: "À vista",
      payment_terms_secondary: "Boleto",
      /* "pendente" e não "ativo": falta o documento, e o status já é o aviso. */
      status: "pendente",
      notes: `Cadastro criado sozinho quando você ligou a integração com a XBZ (${SITE_DA_XBZ}). Complete o CNPJ e o contato quando puder.`,
      created_by: actorUserId,
    })
    .select("id")
    .maybeSingle();

  if (error || !criado?.id) {
    /* Falhar aqui não pode impedir a integração de salvar: o fornecedor é uma
       comodidade, a credencial é o que a pessoa veio fazer. */
    return { criado: false, supplierId: null, motivo: "falhou" };
  }

  await admin.from("supplier_activity_log").insert({
    company_id: companyId,
    supplier_id: criado.id,
    entity_type: "supplier",
    entity_id: criado.id,
    action: "supplier.created",
    description: "Fornecedor XBZ criado a partir da integração.",
    payload: { origem: "xbz" },
    actor_user_id: actorUserId,
  });

  return { criado: true, supplierId: String(criado.id) };
}