Rate limiting

const RETRYABLE_STATUS = new Set([429, 502, 503, 504]);

interface RetryOptions {
  maxAttempts?: number;
  baseDelayMs?: number;
  maxDelayMs?: number;
}

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

export async function fetchWithRetry(
  url: string,
  init: RequestInit = {},
  options: RetryOptions = {},
): Promise<Response> {
  const maxAttempts = options.maxAttempts ?? 5;
  const baseDelayMs = options.baseDelayMs ?? 500;
  const maxDelayMs = options.maxDelayMs ?? 30_000;

  let lastError: unknown;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      const response = await fetch(url, init);

      if (!RETRYABLE_STATUS.has(response.status)) return response;
      if (attempt === maxAttempts) return response;

      // Rispetta Retry-After se presente, altrimenti backoff esponenziale con full jitter.
      const header = response.headers.get('Retry-After');
      const serverDelay = header ? Number.parseInt(header, 10) * 1000 : 0;
      const backoff = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
      const jittered = Math.random() * backoff;

      await sleep(Math.max(serverDelay, jittered));
    } catch (error) {
      lastError = error;
      if (attempt === maxAttempts) break;

      const backoff = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
      await sleep(Math.random() * backoff);
    }
  }

  throw lastError ?? new Error('Numero massimo di tentativi superato');
}