// Fonte: _source/samples/metadado-ceoimp.json + metadado-ceovlr.json
export interface IndicadorMetadado {
  id: number;
  codigo: string;
  titulo: string;
  tituloCompleto: string;
  descricao: string;
  data_atualizacao_dado: string | null;     // ISO 8601 ou null
  ultima_atualizacao: string | null;         // sempre null nos samples
  diretrizNacional: string | null;           // sempre null nos samples
  objetivoRelevancia: string;                // HTML
  metodo_calculo: string;
  formula_calculo: string;
  referencia_consulta: string;
  referencia_consulta_denominador: string | null; // sempre null nos samples
  procedimento_operacional: string | null;   // sempre null nos samples
  fonte_dados: string;                       // HTML
  conceituacao: string;                      // HTML
  interpretacao: string;                     // HTML
  usos: string;                              // HTML
  analise: string;
  limitacoes: string;
  notas: string;
  observacoes: string | null;                // sempre null nos samples
  referencia_bibliografica: string | null;   // sempre null nos samples
  doi: string | null;                        // sempre null nos samples
  ativo: boolean;
  acumulativo: boolean;
  privado: boolean;
  universal: boolean;
  indice_referencia: number | null;          // sempre null nos samples
  ano_referencia: number | null;             // sempre null nos samples
  descritivo_unidade_medida: string;         // pode vir vazio
  prefixo: string | null;
  cache_ttl: number;                         // segundos (CEOIMP: 43200)
  dt_inclusao: string;                       // ISO 8601
  dt_atualizacao: string;                    // ISO 8601
  co_unidade_medida: number;                 // 1 = Moeda, 2 = Número
  co_polaridade: number;
  co_granularidade: number;

  Tags: Array<{
    codigo: number;
    descricao: string;
    TagCategoria: { codigo: number; descricao: string };
  }>;

  IndicadoresRelacionados: IndicadorMetadado[];   // recursivo (parcial)
  Politicas: Politica[];

  ResponsavelTecnico:   ResponsavelUnidade[];
  ResponsavelGerencial: ResponsavelUnidade[];

  Granularidade: { codigo: number; sigla: string; descricao: string };
  CriterioAgregacao: { codigo: number; descricao: string };
  UnidadeMedida: { codigo: number; descricao: 'Número' | 'Moeda' | string; fl_fator: number };
  Polaridade: { codigo: number; descricao: string };
  PeriodicidadeAtualizacao:    { codigo: number; descricao: string };
  PeriodicidadeAvaliacao:      { codigo: number; descricao: string };
  PeriodicidadeMonitoramento:  { codigo: number; descricao: string };
  ClassificacaoIndicador:      { codigo: number; descricao: string };
  Classificacao6sIndicador:    { codigo: number; descricao: string };
  TipoConsulta:                { codigo: number; descricao: string };
  VisualizacaoIndicador: Array<{ codigo: number; nome: string }>;

  ParametroFonte: { codigo: number; sigla: string } | null;  // null em CEOIMP, presente em CEOVLR
  UnidadeEspacialAnalise: unknown | null;
  BancoDados: { codigo: number; descricao: string; url: string; co_tipo_banco_dados: number | null };

  Fonte: unknown[];
  CategoriasAnalise: unknown[];
  InstrumentosPlanejamento: unknown[];
}

interface ResponsavelUnidade {
  codigo: number;
  sigla: string;
  nome: string;
  unidadePai?: number;
  ativa?: 'S' | 'N';
  tipo?: number;
}

interface Politica {
  codigo: number;
  sigla: string;
  nome: string;
  ano: number;
  ativo: boolean;
  legislacao_nome: string;
  legislacao_link: string;
  publico: boolean;
  // ... demais campos administrativos
}

// Fonte: _source/samples/listagem-paginada.json (envelope { count, rows })
export interface ListagemPaginada<T> {
  count: number;
  rows: T[];
}

// Fonte: _source/samples/carga-financeiro.json + carga-anual.json
// Formato: YYYYMM (ex: 202602 = fevereiro de 2026)
export interface Carga {
  co_anomes: number;
}

// Fonte: _source/samples/resultset-br-ceoimp.json + resultset-br-ceovlr.json
// O nome da chave de valor é o próprio código do indicador em maiúscula.
// Template literal type permite inferir a chave dinâmica.
export type ResultsetBR<TCodigo extends string> = Array<
  { anomes: number } & { [K in TCodigo]: number }
>;

// Uso:
// type EvolucaoCEOIMP = ResultsetBR<'CEOIMP'>;
// const r: EvolucaoCEOIMP = [{ anomes: 202602, CEOIMP: 1175 }];

// Fonte: _source/samples/resultset-mn-trecho.json
export type ResultsetMN<TCodigo extends string> = Array<
  {
    anomes: number;
    uf: string;          // sigla, ex: "AC"
    regiao: string;      // nome, ex: "Norte"
    local: string;       // nome do município
    codigogeo: number;   // código IBGE 6 dígitos sem dígito verificador
  } & { [K in TCodigo]: number }
>;

// Os 7 indicadores SAPS Bucal cobertos pelo piloto.
// Fonte: _source/endpoints-saps-bucal.txt
export type CodigoIndicadorSAPS =
  | 'CEOIMP'
  | 'CEOVLR'
  | 'SBESB'
  | 'SBESB40H'
  | 'SBRCUOM'
  | 'SBUOMP'
  | 'SBVRFAF';

// Subset dos que vêm com cargas mensais e ano corrente parcial:
export type CodigoIndicadorFinanceiro = 'CEOVLR' | 'SBRCUOM' | 'SBVRFAF';

// Mais robusto que `co_unidade_medida === 1` porque o campo
// `descritivo_unidade_medida` é vazio em CEOIMP e SBVRFAF e em SBRCUOM
// vem só "valor" — `UnidadeMedida.descricao` é o único confiável.
// Fonte: comparação metadado-ceoimp.json (Número) × metadado-ceovlr.json (Moeda).
export function isIndicadorFinanceiro(meta: IndicadorMetadado): boolean {
  return meta.UnidadeMedida.descricao === 'Moeda';
}

import { unstable_cache } from 'next/cache';

const API_BASE = process.env.MGDI_API_BASE!; // http://apisix.demas.saude.gov/api-dev

export const fetchMetadado = unstable_cache(
  async (codigo: CodigoIndicadorSAPS): Promise<IndicadorMetadado> => {
    const res = await fetch(`${API_BASE}/indicador/${codigo}`, {
      signal: AbortSignal.timeout(30_000),
    });
    if (!res.ok) throw new Error(`MGDI ${codigo}: HTTP ${res.status}`);
    return res.json();
  },
  ['mgdi-metadado'],
  { revalidate: 60 * 60 * 24 } // 24h
);

// Fonte da regra: _source/01-cobertura-api-simpe-saude-bucal.md §4.1
// Indicadores financeiros (CEOVLR, SBRCUOM, SBVRFAF) vêm com cargas mensais.
// O parâmetro anodata=-5 retorna a competência mais recente de cada ano calendário,
// então pros financeiros vem 202602 (parcial) misturado com 202512, 202412, etc.
// Não filtramos — marcamos. A decisão visual fica a cargo do componente.

type PontoBR<C extends string> = { anomes: number } & { [K in C]: number };
type PontoBRMarcado<C extends string> = PontoBR<C> & { parcial: boolean };

export function marcarAnoParcial<C extends string>(
  rs: ResultsetBR<C>,
  anoCorrente: number = new Date().getFullYear(),
): PontoBRMarcado<C>[] {
  return rs.map((p) => {
    const ano = Math.floor(p.anomes / 100);
    const mes = p.anomes % 100;
    return { ...p, parcial: ano === anoCorrente && mes !== 12 };
  });
}

export const fetchEvolucaoBR = unstable_cache(
  async <C extends CodigoIndicadorSAPS>(codigo: C) => {
    const url = `${API_BASE}/indicador/${codigo}/resultset?tipo=BR&anodata=-5`;
    const rs = (await fetch(url).then((r) => r.json())) as ResultsetBR<C>;
    return marcarAnoParcial(rs);
  },
  ['mgdi-resultset-br'],
  { revalidate: 60 * 60 * 6 } // 6h
);

// Fonte da regra: _source/01-cobertura-api-simpe-saude-bucal.md §4.3
// O endpoint MN com anodata=-1 retorna TODAS as cargas do último ano calendário,
// não 1 ponto por município. É obrigatório agrupar por codigogeo mantendo
// o item com anomes máximo, senão o mapa renderiza com valor errado.

export function ultimaPorMunicipio<C extends string>(
  rs: ResultsetMN<C>,
): ResultsetMN<C> {
  const acc = new Map<number, ResultsetMN<C>[number]>();
  for (const row of rs) {
    const atual = acc.get(row.codigogeo);
    if (!atual || row.anomes > atual.anomes) acc.set(row.codigogeo, row);
  }
  return Array.from(acc.values());
}

export const fetchMapaMN = unstable_cache(
  async <C extends CodigoIndicadorSAPS>(codigo: C) => {
    const url = `${API_BASE}/indicador/${codigo}/resultset?tipo=MN&anodata=-1`;
    const rs = (await fetch(url).then((r) => r.json())) as ResultsetMN<C>;
    return ultimaPorMunicipio(rs); // cache guarda já agrupado
  },
  ['mgdi-resultset-mn'],
  { revalidate: 60 * 60 * 24 } // 24h
);

// Fonte da regra: _source/01-cobertura-api-simpe-saude-bucal.md §4.2 + §6
// Os campos `titulo` e `tituloCompleto` da API NÃO são consistentes entre
// indicadores. A Mariana monta o dicionário oficial; aqui ficam placeholders.

interface TituloCard {
  cardTitulo: string;
  cardSubtitulo: string;
  graficoEvolucao: string;
  mapa: string;
}

// TODO(Mariana): preencher os 7 indicadores com títulos do mockup.
const TITULOS_INDICADORES: Partial<Record<CodigoIndicadorSAPS, TituloCard>> = {
  CEOIMP: {
    cardTitulo: 'CEO cofinanciados',
    cardSubtitulo: 'Nº CEO cofinanciados',
    graficoEvolucao: 'Evolução anual do número de CEO, Brasil',
    mapa: 'Distribuição do número de CEO por município',
  },
  // ...
};

export function resolverTitulo(
  codigo: CodigoIndicadorSAPS,
  meta: IndicadorMetadado,
): TituloCard {
  const dict = TITULOS_INDICADORES[codigo];
  if (dict) return dict;
  // Fallback: usa o tituloCompleto pra todos os 4 slots.
  return {
    cardTitulo: meta.tituloCompleto,
    cardSubtitulo: meta.tituloCompleto,
    graficoEvolucao: meta.tituloCompleto,
    mapa: meta.tituloCompleto,
  };
}

const fmtMoeda  = new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL', maximumFractionDigits: 0 });
const fmtNumero = new Intl.NumberFormat('pt-BR', { style: 'decimal' });

export function formatarValor(meta: IndicadorMetadado, valor: number): string {
  return isIndicadorFinanceiro(meta) ? fmtMoeda.format(valor) : fmtNumero.format(valor);
}

// Componente server-side. Lib de gráfico/mapa fica como pseudocódigo.
import { LineChart } from '@/lib/charts';   // pseudocódigo
import { MapaBR }    from '@/lib/mapa';     // pseudocódigo
import { FichaInfo } from './FichaInfo';

interface CardIndicadorProps { codigo: CodigoIndicadorSAPS; }

export async function CardIndicador({ codigo }: CardIndicadorProps) {
  const [meta, evolucao, mapa] = await Promise.all([
    fetchMetadado(codigo),
    fetchEvolucaoBR(codigo),
    fetchMapaMN(codigo),
  ]);

  const titulos = resolverTitulo(codigo, meta);

  return (
    <article className="card-indicador">
      <header>
        <h3>{titulos.cardTitulo}</h3>
        <FichaInfo codigo={codigo} />          {/* (4) ícone (i) */}
      </header>

      <LineChart                                 /* (2) evolução BR */
        title={titulos.graficoEvolucao}
        data={evolucao.map((p) => ({
          x: p.anomes,
          y: (p as any)[codigo] as number,
          parcial: p.parcial,
        }))}
        formatY={(v) => formatarValor(meta, v)}
      />

      <MapaBR                                    /* (3) mapa por município */
        title={titulos.mapa}
        data={mapa.map((m) => ({
          codigogeo: m.codigogeo,
          valor: (m as any)[codigo] as number,
          local: m.local,
        }))}
        formatV={(v) => formatarValor(meta, v)}
      />
    </article>
  );
}