Exercise: Rate Limit and Error Handling

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

// Builds a deterministic mock API call: each call returns the next
// status code in a fixed, pre-scripted sequence.
function createMockApiCall(statusSequence) {
  let index = 0;
  return function mockApiCall() {
    const status = statusSequence[Math.min(index, statusSequence.length - 1)];
    index++;
    return { status };
  };
}

async function callWithHandling(mockApiCall, options = {}) {
  const maxRetries = options.maxRetries ?? 3;
  const initialDelayMs = options.initialDelayMs ?? 50;
  const log = [];
  let delay = initialDelayMs;

  for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
    const response = mockApiCall();
    log.push(`Attempt ${attempt}: received ${response.status}`);

    if (response.status === 200) {
      log.push("Result: success.");
      return { ok: true, message: "Loaded successfully.", attempts: attempt, log };
    }

    if (response.status === 401) {
      log.push("Result: stopped (not retryable).");
      return { ok: false, message: "Please sign in again.", attempts: attempt, log };
    }

    if (response.status === 403) {
      log.push("Result: stopped (not retryable).");
      return { ok: false, message: "You don't have access to this.", attempts: attempt, log };
    }

    if (response.status === 404) {
      log.push("Result: stopped (not retryable).");
      return { ok: false, message: "That item couldn't be found.", attempts: attempt, log };
    }

    if (response.status === 429 || response.status === 500) {
      const label = response.status === 429 ? "rate limited" : "server error";
      if (attempt > maxRetries) {
        log.push("Result: gave up after max retries.");
        const msg =
          response.status === 429
            ? "Still busy after several tries. Please try again shortly."
            : "The service is having trouble. Please try again shortly.";
        return { ok: false, message: msg, attempts: attempt, log };
      }
      log.push(`Result: ${label}, backing off ${delay}ms then retrying.`);
      await sleep(delay);
      delay *= 2; // exponential backoff
      continue;
    }

    log.push("Result: stopped (unrecognized status).");
    return { ok: false, message: "Something unexpected happened.", attempts: attempt, log };
  }
}

async function main() {
  console.log("--- Scenario A: rate limited twice, then succeeds ---");
  const callA = createMockApiCall([429, 429, 200]);
  const resultA = await callWithHandling(callA, { maxRetries: 3, initialDelayMs: 20 });
  console.log(resultA.log.join("\n"));
  console.log(`Final: ok=${resultA.ok} message="${resultA.message}" attempts=${resultA.attempts}`);

  console.log("\n--- Scenario B: needs auth ---");
  const callB = createMockApiCall([401]);
  const resultB = await callWithHandling(callB, { maxRetries: 3, initialDelayMs: 20 });
  console.log(resultB.log.join("\n"));
  console.log(`Final: ok=${resultB.ok} message="${resultB.message}" attempts=${resultB.attempts}`);

  console.log("\n--- Scenario C: server errors exceed retry budget ---");
  const callC = createMockApiCall([500, 500, 500, 500]);
  const resultC = await callWithHandling(callC, { maxRetries: 2, initialDelayMs: 20 });
  console.log(resultC.log.join("\n"));
  console.log(`Final: ok=${resultC.ok} message="${resultC.message}" attempts=${resultC.attempts}`);
}

main();