export type Brand<T, Name extends string> = T & { readonly __brand: Name };
export type CustomerId = Brand<string, 'CustomerId'>;
export type QuoteId = Brand<string, 'QuoteId'>;
export type Quote = { id: QuoteId; customerId: CustomerId; totalCents: number };
export type State =
  | { status: 'idle' }
  | { status: 'loading'; request: number }
  | { status: 'ready'; quote: Quote }
  | { status: 'approved'; quote: Quote; approvedBy: string }
  | { status: 'error'; message: string };
export type Event =
  | { type: 'load'; request: number }
  | { type: 'received'; quote: Quote }
  | { type: 'approve'; approver: string }
  | { type: 'failed'; message: string }
  | { type: 'reset' };
// Extract is a conditional type; this mapped type preserves each event's payload.
export type Handlers<E extends { type: string }> = {
  [K in E['type']]: (event: Extract<E, { type: K }>) => string;
};
export type Result<T> = { ok: true; value: T } | { ok: false; error: string };
export function parseQuote(input: unknown): Result<Quote> {
  if (typeof input !== 'object' || input === null || Array.isArray(input))
    return { ok: false, error: 'A quote must be an object.' };
  const row = input as Record<string, unknown>;
  if (typeof row.id !== 'string' || !/^Q-[0-9]{3}$/.test(row.id))
    return { ok: false, error: 'Quote ID must look like Q-001.' };
  if (typeof row.customerId !== 'string' || !/^C-[0-9]{3}$/.test(row.customerId))
    return { ok: false, error: 'Customer ID must look like C-001.' };
  if (typeof row.totalCents !== 'number' || !Number.isSafeInteger(row.totalCents) || row.totalCents < 0)
    return { ok: false, error: 'Price must be a non-negative, safe whole number of cents.' };
  return { ok: true, value: { id: row.id as QuoteId, customerId: row.customerId as CustomerId, totalCents: row.totalCents } };
}
export function assertNever(value: never): never { throw new Error('Unhandled event: ' + JSON.stringify(value)); }
export function transition(state: State, event: Event): State {
  switch (event.type) {
    case 'load': return { status: 'loading', request: event.request };
    case 'received': return { status: 'ready', quote: event.quote };
    case 'approve': return state.status === 'ready' && event.approver.trim()
      ? { status: 'approved', quote: state.quote, approvedBy: event.approver.trim() }
      : { status: 'error', message: 'Load a valid quote before approving it.' };
    case 'failed': return { status: 'error', message: event.message };
    case 'reset': return { status: 'idle' };
    default: return assertNever(event);
  }
}
export function unsafeAmount(input: unknown): number {
  // Intentionally broken: assertions disappear when TypeScript becomes JavaScript.
  const quote = input as Quote;
  return quote.totalCents / 100;
}
export async function raceResponses(guarded: boolean, delay = 40, signal?: AbortSignal): Promise<{ selected: string; trace: string[] }> {
  let latest = 0, selected = '', trace: string[] = [];
  const request = async (name: string, ms: number) => {
    const mine = ++latest;
    await new Promise<void>((resolve, reject) => {
      if (signal?.aborted) { reject(new DOMException('Canceled', 'AbortError')); return; }
      const abort = () => { clearTimeout(timer); signal?.removeEventListener('abort', abort); reject(new DOMException('Canceled', 'AbortError')); };
      const timer = setTimeout(() => { signal?.removeEventListener('abort', abort); resolve(); }, ms);
      signal?.addEventListener('abort', abort, { once: true });
    });
    if (signal?.aborted) return;
    if (guarded && mine !== latest) { trace.push(name + ' finished late; ignored.'); return; }
    selected = name; trace.push(name + ' became the selected quote.');
  };
  await Promise.all([request('Older request', delay * 3), request('Newer request', delay)]);
  return { selected, trace };
}
