// queueMicrotask — defer until current sync block finishes
console.log('A')
queueMicrotask(() => console.log('B'))
console.log('C')
// Output: A, C, B
// 'B' runs in the microtask checkpoint after the synchronous script macrotask completes

type SettledResult<T> =
  | { status: 'fulfilled'; value: T }
  | { status: 'rejected';  reason: unknown }

async function fetchDashboard(userId: string) {
  // ❌ Promise.all — one failure kills the entire dashboard
  const [user, orders, inventory] = await Promise.all([
    fetchUser(userId),
    fetchOrders(userId),
    fetchInventory(),
  ])

  // ✅ Promise.allSettled — all three run; partial data is still usable
  const results = await Promise.allSettled([
    fetchUser(userId),
    fetchOrders(userId),
    fetchInventory(),
  ])

  const user      = results[0].status === 'fulfilled' ? results[0].value : null
  const orders    = results[1].status === 'fulfilled' ? results[1].value : []
  const inventory = results[2].status === 'fulfilled' ? results[2].value : {}

  // Render what we have — degrade gracefully for missing sections
  return renderDashboard({ user, orders, inventory })
}

async function fetchWithFallback(primaryUrl: string, fallbackUrl: string): Promise<Response> {
  // ❌ Promise.race — if primary rejects first (e.g., DNS failure),
  //    race settles immediately with the rejection, ignoring fallback
  return Promise.race([fetch(primaryUrl), fetch(fallbackUrl)])

  // ✅ Promise.any — if primary rejects, fallback still wins
  //    Returns the FIRST FULFILLED response, ignoring rejections
  return Promise.any([fetch(primaryUrl), fetch(fallbackUrl)])
  // Primary DNS failure → ignored, fallback response wins
  // Both fail → AggregateError containing both reasons
}

// CDN fallback pattern
async function loadAsset(path: string): Promise<ArrayBuffer> {
  const cdnHosts = [
    `https://cdn1.example.com${path}`,
    `https://cdn2.example.com${path}`,
    `https://cdn3.example.com${path}`,
  ]

  try {
    const response = await Promise.any(cdnHosts.map(url => fetch(url)))
    return response.arrayBuffer()
  } catch (err) {
    if (err instanceof AggregateError) {
      throw new Error(`All CDN hosts failed: ${err.errors.map(e => e.message).join(', ')}`)
    }
    throw err
  }
}

// ✅ Timeout wrapper using Promise.race
function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
  const timeout = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms)
  )
  return Promise.race([promise, timeout])
  // If the operation takes longer than ms, timeout rejects first
  // Promise.race settles with the rejection immediately
}

async function fetchWithTimeout(url: string): Promise<Response> {
  return withTimeout(fetch(url), 5000)
  // Rejects after 5s if fetch hasn't resolved
}

// ⚠️ Difference from Promise.any:
// Promise.race — race-condition detection (first to settle, rejection wins)
// Promise.any  — fallback selection (first to succeed, rejections ignored)

// A regular async function produces ONE value
async function fetchPage(page: number): Promise<User[]> {
  const res = await fetch(`/api/users?page=${page}`)
  return res.json()
}

// An async generator produces MANY values, one at a time, on demand
async function* fetchAllPages(pageSize = 50): AsyncGenerator<User[], void, void> {
  let page = 0

  while (true) {
    const users = await fetch(`/api/users?page=${page}&size=${pageSize}`)
      .then(r => r.json() as Promise<User[]>)

    if (users.length === 0) return  // No more pages — generator terminates

    yield users  // ← Suspend here; resume when consumer calls .next()
    page++
  }
}

// ❌ Naive approach: load all pages into memory first
async function exportAllUsersWrong(): Promise<void> {
  const allPages = await Promise.all(
    Array.from({ length: 100 }, (_, i) => fetchPage(i))
    // ← Fires ALL 100 requests simultaneously, holds ALL data in memory
    //   For 100 pages × 50 users × 2KB = 10 MB in memory before any export begins
  )
  await writeToCSV(allPages.flat())
}

// ✅ Streaming with async generator: O(1) memory — one page at a time
async function exportAllUsers(): Promise<void> {
  const csv = createWriteStream('users.csv')

  for await (const page of fetchAllPages()) {
    // Generator fetches page 0, yields — we process it, write to CSV, then
    // the loop calls .next() → generator fetches page 1, yields — repeat
    // At any point in time, only ONE page's data is in memory
    await writePageToCSV(csv, page)
  }

  csv.end()
}

// Generic paginated API consumer — works for any API with cursor or page-based pagination
async function* paginatedFetch<T>(
  buildUrl: (cursor: string | null) => string,
  extractNextCursor: (response: PaginatedResponse<T>) => string | null
): AsyncGenerator<T, void, void> {
  let cursor: string | null = null

  while (true) {
    const response: PaginatedResponse<T> = await fetch(buildUrl(cursor))
      .then(r => {
        if (!r.ok) throw new Error(`HTTP ${r.status}: ${buildUrl(cursor)}`)
        return r.json()
      })

    yield* response.items  // ← yield* delegates — yields each item individually

    cursor = extractNextCursor(response)
    if (cursor === null) return  // No next page — done
  }
}

// Usage: GitHub repository stars
for await (const star of paginatedFetch(
  cursor => `https://api.github.com/repos/owner/repo/stargazers?after=${cursor ?? ''}`,
  response => response.cursor ?? null
)) {
  await db.upsert('stars', star)
  // Each star processed and stored before the next page is fetched
}

// Streaming from multiple sources concurrently — generator composition
async function* mergeStreams<T>(...streams: AsyncIterable<T>[]): AsyncGenerator<T> {
  // Each stream produces values; we yield whichever arrives first
  const iterators = streams.map(s => s[Symbol.asyncIterator]())

  const pending = iterators.map((iter, i) =>
    iter.next().then(result => ({ result, index: i }))
  )

  while (pending.some(p => p !== null)) {
    const { result, index } = await Promise.race(pending.filter(Boolean))

    if (!result.done) {
      yield result.value
      pending[index] = iterators[index].next()
        .then(r => ({ result: r, index }))
    } else {
      pending[index] = null
    }
  }
}