// BAD: Immediate retry with no delay
async function fetchWithRetry(url, retries = 3) {
  for (let i = 0; i < retries; i++) {
    const response = await fetch(url);
    if (response.ok) return response;
    // Immediate retry -- hammers the server
  }
  throw new Error('All retries failed');
}

function exponentialDelay(attempt, baseDelay = 1000) {
  return baseDelay * Math.pow(2, attempt);
  // attempt 0: 1000ms (1s)
  // attempt 1: 2000ms (2s)
  // attempt 2: 4000ms (4s)
  // attempt 3: 8000ms (8s)
}

// Full jitter: random delay between 0 and the exponential max
function fullJitter(attempt, baseDelay = 1000) {
  const maxDelay = baseDelay * Math.pow(2, attempt);
  return Math.random() * maxDelay;
}

// Equal jitter: half fixed + half random (more predictable minimum wait)
function equalJitter(attempt, baseDelay = 1000) {
  const maxDelay = baseDelay * Math.pow(2, attempt);
  const half = maxDelay / 2;
  return half + Math.random() * half;
}

// Decorrelated jitter (AWS recommendation): each delay is random
// between baseDelay and 3x the previous delay
function decorrelatedJitter(previousDelay, baseDelay = 1000) {
  return Math.min(
    MAX_DELAY,
    Math.random() * (previousDelay * 3 - baseDelay) + baseDelay
  );
}

interface RetryOptions {
  maxRetries: number;        // Maximum number of retry attempts
  baseDelay: number;         // Base delay in milliseconds
  maxDelay: number;          // Cap on delay to prevent absurd waits
  maxTotalTime: number;      // Total time budget for all retries
  retryableStatuses: number[]; // Which HTTP codes to retry
}

const DEFAULT_OPTIONS: RetryOptions = {
  maxRetries: 3,
  baseDelay: 1000,
  maxDelay: 30000,           // 30 seconds max per retry
  maxTotalTime: 60000,       // 60 seconds total budget
  retryableStatuses: [408, 429, 500, 502, 503, 504],
};

async function fetchWithRetry(
  url: string,
  init: RequestInit = {},
  options: Partial<RetryOptions> = {}
): Promise<Response> {
  const opts = { ...DEFAULT_OPTIONS, ...options };
  const startTime = Date.now();

  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
    try {
      const response = await fetch(url, init);

      // Success -- return immediately
      if (response.ok) return response;

      // Non-retryable error -- fail immediately
      if (!opts.retryableStatuses.includes(response.status)) {
        throw new HttpError(response.status, await response.text());
      }

      // 429 with Retry-After header -- respect the server's request
      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After');
        if (retryAfter) {
          const waitMs = parseInt(retryAfter, 10) * 1000;
          await sleep(Math.min(waitMs, opts.maxDelay));
          continue;
        }
      }
    } catch (error) {
      // Network errors (DNS failure, connection refused) are retryable
      if (error instanceof HttpError) throw error;
      if (attempt === opts.maxRetries) throw error;
    }

    // Check total time budget
    if (Date.now() - startTime > opts.maxTotalTime) {
      throw new Error(`Retry budget exhausted after ${Date.now() - startTime}ms`);
    }

    // Calculate delay with full jitter
    const exponentialDelay = opts.baseDelay * Math.pow(2, attempt);
    const cappedDelay = Math.min(exponentialDelay, opts.maxDelay);
    const jitteredDelay = Math.random() * cappedDelay;

    console.log(
      `Retry ${attempt + 1}/${opts.maxRetries} after ${Math.round(jitteredDelay)}ms`
    );
    await sleep(jitteredDelay);
  }

  throw new Error(`All ${opts.maxRetries} retries exhausted`);
}

function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

class HttpError extends Error {
  constructor(public status: number, public body: string) {
    super(`HTTP ${status}: ${body}`);
  }
}

Client (timeout: 5s)
  --> API Gateway (timeout: 10s)
    --> Order Service (timeout: 30s)
      --> Payment Service (timeout: 60s)

Client (timeout: 30s)
  --> API Gateway (timeout: 25s)
    --> Order Service (timeout: 20s)
      --> Payment Service (timeout: 15s)

// Configuring timeouts correctly in a service chain
const DOWNSTREAM_TIMEOUT = 15000; // 15s for the service we call
const OUR_TIMEOUT = 20000;        // 20s for our own processing (> downstream)

// When calling downstream
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), DOWNSTREAM_TIMEOUT);

try {
  const response = await fetch('https://payment-service.internal/charge', {
    signal: controller.signal,
    method: 'POST',
    body: JSON.stringify(chargeData),
  });
  return response;
} catch (error) {
  if (error.name === 'AbortError') {
    // Downstream timed out -- return 504 to our caller
    return new Response('Payment service timeout', { status: 504 });
  }
  throw error;
} finally {
  clearTimeout(timeout);
}

class CircuitBreaker {
  private failures = 0;
  private lastFailureTime = 0;
  private state: 'closed' | 'open' | 'half-open' = 'closed';

  constructor(
    private threshold: number = 5,   // failures before opening
    private cooldown: number = 30000  // 30s before trying again
  ) {}

  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === 'open') {
      if (Date.now() - this.lastFailureTime > this.cooldown) {
        this.state = 'half-open'; // Try one request
      } else {
        throw new Error('Circuit breaker is open');
      }
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  private onSuccess() {
    this.failures = 0;
    this.state = 'closed';
  }

  private onFailure() {
    this.failures++;
    this.lastFailureTime = Date.now();
    if (this.failures >= this.threshold) {
      this.state = 'open';
    }
  }
}

// Usage
const paymentBreaker = new CircuitBreaker(5, 30000);

try {
  const result = await paymentBreaker.call(() =>
    fetchWithRetry('https://payment-service.internal/charge', { method: 'POST' })
  );
} catch (error) {
  // Circuit is open -- use fallback or queue for later
  await queueForLater(chargeData);
}