// ❌ Broken pattern: Naive cache-aside vulnerable to all three failure modes
export async function getProductDetails(productId: string) {
  // 1. Vulnerable to Penetration: Non-existent IDs always miss and hit DB
  const cached = await redis.get(`product:${productId}`);
  if (cached) return JSON.parse(cached);

  // 2. Vulnerable to Stampede: If this hot product expires, 5,000 concurrent requests
  // all execute this expensive multi-table JOIN simultaneously!
  const product = await db.product.findUnique({
    where: { id: productId },
    include: { reviews: true, inventory: true, seller: true },
  });

  // 3. Vulnerable to Avalanche: Setting a rigid 3600s TTL causes bulk keys to expire together
  if (product) {
    await redis.set(`product:${productId}`, JSON.stringify(product), 'EX', 3600);
  }
  return product;
}

// ✅ Production Singleflight Group in TypeScript
export class SingleflightGroup<T> {
  private inFlight = new Map<string, Promise<T>>();

  async do(key: string, fn: () => Promise<T>): Promise<T> {
    const existing = this.inFlight.get(key);
    if (existing) {
      // Coalesce onto the in-flight execution (0 extra DB queries)
      return existing;
    }

    const promise = (async () => {
      try {
        return await fn();
      } finally {
        this.inFlight.delete(key);
      }
    })();

    this.inFlight.set(key, promise);
    return promise;
  }
}

// ✅ Distributed Mutex for Cache Repopulation
export async function getWithDistributedMutex(key: string, ttlSec = 300): Promise<string> {
  let val = await redis.get(key);
  if (val) return val;

  const lockKey = `lock:${key}`;
  const lockToken = crypto.randomUUID();
  
  // Try to acquire distributed lock with 5-second lease
  const acquired = await redis.set(lockKey, lockToken, 'NX', 'PX', 5000);

  if (acquired) {
    try {
      // Re-check cache inside lock in case another worker populated it
      val = await redis.get(key);
      if (val) return val;

      const fresh = await computeExpensiveDatabaseQuery();
      await redis.set(key, fresh, 'EX', ttlSec);
      return fresh;
    } finally {
      // Atomic Lua release to guarantee we only release our own lock
      const luaScript = `
        if redis.call("get", KEYS[1]) == ARGV[1] then
          return redis.call("del", KEYS[1])
        else
          return 0
        end
      `;
      await redis.eval(luaScript, 1, lockKey, lockToken);
    }
  } else {
    // Lock contention: Wait 50ms and retry from cache
    await new Promise((resolve) => setTimeout(resolve, 50));
    return getWithDistributedMutex(key, ttlSec);
  }
}

// ✅ Production XFetch Probabilistic Early Expiration Implementation
interface CachedEnvelope<T> {
  data: T;
  delta: number;   // Time taken to compute in milliseconds
  expiry: number;  // Absolute unix timestamp (ms)
}

export async function getWithXFetch<T>(
  key: string,
  ttlMs: number,
  computeFn: () => Promise<T>,
  beta = 1.0
): Promise<T> {
  const raw = await redis.get(key);
  const now = Date.now();

  if (raw) {
    const envelope: CachedEnvelope<T> = JSON.parse(raw);
    const timeRemaining = envelope.expiry - now;

    // XFetch Decision Rule: Probabilistically trigger early background refresh
    const shouldRecomputeEarly = 
      (envelope.delta * beta * -Math.log(Math.random())) > timeRemaining;

    if (!shouldRecomputeEarly) {
      return envelope.data;
    }

    // Trigger asynchronous background recomputation without blocking caller
    recomputeAndCache(key, ttlMs, computeFn).catch(console.error);
    return envelope.data;
  }

  // Hard cache miss: compute synchronously
  return await recomputeAndCache(key, ttlMs, computeFn);
}

async function recomputeAndCache<T>(key: string, ttlMs: number, computeFn: () => Promise<T>): Promise<T> {
  const start = Date.now();
  const freshData = await computeFn();
  const delta = Date.now() - start;
  const expiry = Date.now() + ttlMs;

  const envelope: CachedEnvelope<T> = { data: freshData, delta, expiry };
  // Set physical Redis TTL higher than envelope expiry to allow SWR recomputation window
  await redis.set(key, JSON.stringify(envelope), 'PX', ttlMs * 2);
  return freshData;
}

// ✅ Production Penetration Defense: RedisBloom Cuckoo Filter + Null Sentinel
export async function getProductProtected(productId: string): Promise<Product | null> {
  const cacheKey = `product:${productId}`;

  // 1. Query L2 Cache
  const cached = await redis.get(cacheKey);
  if (cached) {
    if (cached === '__NULL__') return null; // Null-Object Sentinel
    return JSON.parse(cached);
  }

  // 2. Query Cuckoo Filter via RedisBloom module (CF.EXISTS)
  const existsInFilter = await redis.send_command('CF.EXISTS', 'cf:products', productId);
  if (!existsInFilter) {
    // Fast path: Key is guaranteed not to exist in PostgreSQL. Return null in 0.2ms!
    return null;
  }

  // 3. Probabilistic pass: Query PostgreSQL
  const product = await db.product.findUnique({ where: { id: productId } });

  if (product) {
    await redis.set(cacheKey, JSON.stringify(product), 'EX', 3600);
  } else {
    // 4. False positive protection: Cache short-lived Null Sentinel (60s)
    await redis.set(cacheKey, '__NULL__', 'EX', 60);
  }

  return product;
}

# redis.conf: Enable Active Memory Defragmentation
activedefrag yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 30
active-defrag-cycle-min 5
active-defrag-cycle-max 50