import { mensagemDeErro } from './biblioteca.js';
/**
 * Parte 6 — Os quatro combinadores, sobre as mesmas três fontes.
 *
 *   npx tsx src/06-combinadores.ts
 *
 * Cenário: a ficha de um livro pode vir de três fontes. A mais rápida delas é
 * justamente a que está quebrada — é o caso que separa os quatro combinadores.
 *
 *   catalogoParceiro  100 ms  rejeita
 *   acervoLocal       250 ms  responde
 *   catalogoNacional  400 ms  responde
 */

import { cronometro, esperar } from './biblioteca.js';

type Ficha = { fonte: string; titulo: string };

function catalogoParceiro(): Promise<Ficha> {
  return esperar(100).then(() => {
    throw new Error('catálogo do parceiro fora do ar');
  });
}

async function acervoLocal(): Promise<Ficha> {
  await esperar(250);
  return { fonte: 'acervo local', titulo: 'Vidas Secas' };
}

async function catalogoNacional(): Promise<Ficha> {
  await esperar(400);
  return { fonte: 'catálogo nacional', titulo: 'Vidas Secas (1938)' };
}

function fontes(): Array<Promise<Ficha>> {
  return [catalogoParceiro(), acervoLocal(), catalogoNacional()];
}

async function comAll(): Promise<void> {
  const marcar = cronometro();
  try {
    const fichas = await Promise.all(fontes());
    marcar(`all        : ${fichas.length} fichas`);
  } catch (erro) {
    marcar(`all        : rejeitou — ${mensagemDeErro(erro)}`);
  }
}

async function comAllSettled(): Promise<void> {
  const marcar = cronometro();
  const resultados = await Promise.allSettled(fontes());
  const ok = resultados.filter((r) => r.status === 'fulfilled').length;
  const falhas = resultados.length - ok;
  marcar(`allSettled : esperou todas — ${ok} respostas, ${falhas} falha(s)`);
}

async function comRace(): Promise<void> {
  const marcar = cronometro();
  try {
    const ficha = await Promise.race(fontes());
    marcar(`race       : ${ficha.fonte}`);
  } catch (erro) {
    marcar(`race       : rejeitou — ${mensagemDeErro(erro)}`);
  }
}

async function comAny(): Promise<void> {
  const marcar = cronometro();
  try {
    const ficha = await Promise.any(fontes());
    marcar(`any        : ${ficha.fonte}`);
  } catch (erro) {
    // Quando TODAS rejeitam, `any` rejeita com um AggregateError, que carrega
    // a lista de erros em `.errors`.
    marcar(`any        : todas falharam — ${(erro as AggregateError).errors.length} erros`);
  }
}

async function principal(): Promise<void> {
  await comAll();
  await comAllSettled();
  await comRace();
  await comAny();
}

void principal();

/**
 * Resumindo o critério de escolha:
 *
 *   all         preciso de todas; qualquer falha invalida o conjunto
 *   allSettled  preciso do relatório completo, sucesso e falha
 *   race        preciso da primeira que LIQUIDAR — inclusive rejeitando
 *   any         preciso da primeira que DER CERTO; falha só se todas falharem
 *
 * A linha do `race` é a que costuma surpreender: ele não procura a primeira
 * resposta boa, procura a primeira notícia. Como a fonte quebrada é a mais
 * rápida, o `race` entrega o erro dela. É exatamente essa propriedade que
 * torna o `race` útil para impor um tempo limite (arquivo 07).
 */