Bloquear a publicação de registro inválido

// src/lib/radar/schema.ts
import { z } from "zod";

export const COMBUSTIVEIS = [
  "gasolina-comum",
  "gasolina-aditivada",
  "etanol",
  "diesel-s10",
  "glp",
] as const;

export const SchemaPrecoMunicipio = z.object({
  // 7 dígitos: o código IBGE completo, com o dígito verificador.
  // Aceitar 6 dígitos deixaria passar o código truncado, que casa
  // com o município errado na hora do join.
  codigoIbge: z
    .string()
    .regex(/^[0-9]{7}$/, { error: "codigoIbge precisa ter exatamente 7 dígitos" }),

  municipio: z.string().trim().min(2, { error: "municipio vazio" }),
  uf: z.string().length(2, { error: "uf precisa ter 2 letras" }),

  combustivel: z.enum(COMBUSTIVEIS),

  // A ANP publica por semana. Data ISO no formato AAAA-MM-DD.
  semanaReferencia: z.iso.date(),

  // Faixa larga de propósito: ela não existe para adivinhar o preço
  // certo, existe para pegar erro de unidade e de separador decimal.
  // 574 (centavos) e 0.0574 (divisão errada) morrem aqui.
  precoMedio: z
    .number()
    .min(0.5, { error: "precoMedio abaixo da faixa plausível" })
    .max(30, { error: "precoMedio acima da faixa plausível" }),

  // Inteiro positivo. Zero postos pesquisados com preço preenchido
  // é contradição interna do registro.
  postosPesquisados: z.number().int().positive(),
});

export type PrecoMunicipio = z.infer<typeof SchemaPrecoMunicipio>;

// scripts/ingestao/ingerir-precos.ts
import { SchemaPrecoMunicipio, type PrecoMunicipio } from "../../src/lib/radar/schema";

type Reprovacao = { linha: number; campo: string; motivo: string };

export type Relatorio = {
  aprovados: PrecoMunicipio[];
  reprovados: Reprovacao[];
};

/**
 * `brutos` são as linhas já convertidas de CSV para objetos, sem
 * nenhuma coerção de tipo. Continuam `unknown` de propósito.
 */
export function ingerir(brutos: unknown[]): Relatorio {
  const aprovados: PrecoMunicipio[] = [];
  const reprovados: Reprovacao[] = [];

  brutos.forEach((bruto, indice) => {
    const resultado = SchemaPrecoMunicipio.safeParse(bruto);

    if (resultado.success) {
      aprovados.push(resultado.data);
      return;
    }

    // Uma linha de relatório por problema, não por registro:
    // um registro pode falhar em três campos ao mesmo tempo.
    for (const issue of resultado.error.issues) {
      reprovados.push({
        linha: indice + 2, // +1 pelo índice zero, +1 pelo cabeçalho do CSV
        campo: issue.path.join(".") || "(raiz)",
        motivo: issue.message,
      });
    }
  });

  return { aprovados, reprovados };
}

/** O gate. Chamado pelo script de ingestão, antes do `next build`. */
export function aplicarGate(rel: Relatorio): void {
  if (rel.reprovados.length === 0) {
    console.log(`ingestão ok: ${rel.aprovados.length} registros validados`);
    return;
  }

  console.error(`ingestão reprovada: ${rel.reprovados.length} problemas`);
  for (const r of rel.reprovados.slice(0, 50)) {
    console.error(`  linha ${r.linha} | campo ${r.campo} | ${r.motivo}`);
  }
  if (rel.reprovados.length > 50) {
    console.error(`  ... e mais ${rel.reprovados.length - 50}`);
  }
  process.exit(1);
}

// src/lib/radar/schema.ts (continuação)
import { z } from "zod";

const Identificacao = {
  codigoIbge: z.string().regex(/^[0-9]{7}$/),
  municipio: z.string().trim().min(2),
  uf: z.string().length(2),
  combustivel: z.enum(COMBUSTIVEIS),
  semanaReferencia: z.iso.date(),
};

/**
 * União discriminada: a ausência de coleta vira um estado do registro,
 * com forma própria. O compilador passa a exigir que o template trate
 * o caso "sem-coleta" antes de ler `precoMedio`, porque nesse ramo o
 * campo não existe.
 */
export const SchemaRegistro = z.discriminatedUnion("cobertura", [
  z.object({
    ...Identificacao,
    cobertura: z.literal("coletado"),
    precoMedio: z.number().min(0.5).max(30),
    postosPesquisados: z.number().int().positive(),
  }),
  z.object({
    ...Identificacao,
    cobertura: z.literal("sem-coleta"),
    // Sem preço e sem postos. Não é null nem zero: os campos não existem.
    ultimaSemanaComColeta: z.iso.date().nullable(),
  }),
]);

export type Registro = z.infer<typeof SchemaRegistro>;

/** O que pode virar página indexável sai daqui, e só daqui. */
export function temInventario(r: Registro): r is Extract<Registro, { cobertura: "coletado" }> {
  return r.cobertura === "coletado";
}

// src/lib/radar/fonte.ts
import { z } from "zod";
import { SchemaRegistro, temInventario, type Registro } from "./schema";
import dadosDaSemana from "../../../data/anp-semana-corrente.json";

/** Slug ASCII: acento em path quebra canonical e sitemap. */
function slugify(nome: string): string {
  return nome
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-|-$/g, "");
}

let cache: Registro[] | null = null;

/** Única leitura validada do lote. Tudo no projeto passa por aqui. */
export function registrosValidados(): Registro[] {
  if (cache) return cache;

  const parsed = z.array(SchemaRegistro).safeParse(dadosDaSemana);
  if (!parsed.success) {
    // Se o gate de ingestão rodou, isto nunca dispara. Se alguém
    // editou o JSON à mão pulando o gate, o build para aqui.
    throw new Error(
      `dados da semana inválidos: ${parsed.error.issues.length} problemas`,
    );
  }

  cache = parsed.data;
  return cache;
}

/** A lista canônica de páginas publicáveis. Um filtro, um lugar. */
export function paginasPublicaveis() {
  return registrosValidados()
    .filter(temInventario)
    .map((r) => ({
      uf: r.uf.toLowerCase(),
      municipio: slugify(r.municipio),
      combustivel: r.combustivel,
      atualizadoEm: r.semanaReferencia,
    }));
}

// -------------------------------------------------------------
// src/app/precos/[uf]/[municipio]/[combustivel]/page.tsx
import { paginasPublicaveis } from "@/lib/radar/fonte";

export function generateStaticParams() {
  return paginasPublicaveis().map(({ uf, municipio, combustivel }) => ({
    uf,
    municipio,
    combustivel,
  }));
}

// -------------------------------------------------------------
// src/app/sitemap.ts
import type { MetadataRoute } from "next";
import { paginasPublicaveis } from "@/lib/radar/fonte";

export default function sitemap(): MetadataRoute.Sitemap {
  return paginasPublicaveis().map((p) => ({
    url: `https://exemplo.com.br/precos/${p.uf}/${p.municipio}/${p.combustivel}`,
    lastModified: p.atualizadoEm,
  }));
}

// scripts/ingestao/plausibilidade.ts
import { temInventario, type Registro } from "../../src/lib/radar/schema";

/** Fator de variação semanal acima do qual tratamos como suspeita de parse. */
const LIMITE_VARIACAO = 1.5;

function chave(r: Registro) {
  return `${r.codigoIbge}:${r.combustivel}`;
}

export function conferirPlausibilidade(
  atual: Registro[],
  anterior: Registro[],
): { chave: string; anterior: number; atual: number; fator: number }[] {
  const mapaAnterior = new Map<string, number>();
  for (const r of anterior) {
    if (temInventario(r)) mapaAnterior.set(chave(r), r.precoMedio);
  }

  const suspeitos = [];
  for (const r of atual) {
    if (!temInventario(r)) continue;

    const antes = mapaAnterior.get(chave(r));
    // Sem semana anterior não há comparação possível. Primeira coleta
    // de um município não é suspeita, é estreia.
    if (antes === undefined) continue;

    const fator = r.precoMedio / antes;
    if (fator > LIMITE_VARIACAO || fator < 1 / LIMITE_VARIACAO) {
      suspeitos.push({ chave: chave(r), anterior: antes, atual: r.precoMedio, fator });
    }
  }

  return suspeitos;
}