// A simple cache-aside implementation with Redis
async function getUserProfile(userId) {
  const cacheKey = `user:profile:${userId}`;

  // 1. Check the cache first
  const cached = await redis.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }

  // 2. Cache miss - fetch from database
  const user = await db.query(
    'SELECT id, name, email, avatar_url FROM users WHERE id = ?',
    [userId]
  );

  // 3. Store in cache with a 5-minute TTL
  await redis.setex(cacheKey, 300, JSON.stringify(user));

  return user;
}

// Cache product details for 10 minutes
await redis.setex(`product:${productId}`, 600, JSON.stringify(product));

// Cache leaderboard for 30 seconds (changes frequently)
await redis.setex('leaderboard:top100', 30, JSON.stringify(leaderboard));

// Cache rarely-changing config for 1 hour
await redis.setex('app:config', 3600, JSON.stringify(config));

async function updateUserProfile(userId, updates) {
  // 1. Update the database
  await db.query(
    'UPDATE users SET name = ?, email = ? WHERE id = ?',
    [updates.name, updates.email, userId]
  );

  // 2. Immediately invalidate the cache
  await redis.del(`user:profile:${userId}`);

  // The next request will fetch fresh data and repopulate the cache
}

// Cache-aside (most common): app manages cache explicitly
async function saveOrder(order) {
  await db.insert('orders', order);
  await redis.del(`user:orders:${order.userId}`); // invalidate
}

// Write-through: always write to cache AND database together
async function saveOrder(order) {
  await db.insert('orders', order);
  const orders = await db.query(
    'SELECT * FROM orders WHERE user_id = ?', [order.userId]
  );
  await redis.setex(
    `user:orders:${order.userId}`, 300, JSON.stringify(orders)
  );
}

// Write-behind (async): write to cache immediately, flush to DB later
// Faster writes, but risk of data loss if cache crashes before flush
async function saveOrder(order) {
  await redis.lpush('pending:orders', JSON.stringify(order));
  // A background worker drains this queue into the database
}

// Naive approach - vulnerable to stampede
async function getLeaderboard() {
  const cached = await redis.get('leaderboard');
  if (cached) return JSON.parse(cached);

  // If this expires during a traffic spike, 500 concurrent requests
  // all reach here simultaneously and hammer the database
  const data = await db.query('SELECT ... expensive aggregation ...');
  await redis.setex('leaderboard', 60, JSON.stringify(data));
  return data;
}

// Better: use a lock to let only one request rebuild the cache
async function getLeaderboard() {
  const cached = await redis.get('leaderboard');
  if (cached) return JSON.parse(cached);

  const lockKey = 'lock:leaderboard';
  const acquired = await redis.set(lockKey, '1', 'NX', 'EX', 10);

  if (acquired) {
    // We got the lock - rebuild the cache
    const data = await db.query('SELECT ... expensive aggregation ...');
    await redis.setex('leaderboard', 60, JSON.stringify(data));
    await redis.del(lockKey);
    return data;
  } else {
    // Another request is rebuilding - wait briefly and try again
    await new Promise(resolve => setTimeout(resolve, 100));
    return getLeaderboard();
  }
}