Design a Global E-Commerce Product Catalog System.

# Thundering Herd Protection Implementation
# Applies: Week 4, Day 3

import asyncio
import json
from dataclasses import dataclass
from typing import Optional, Dict, Any, Callable
from datetime import datetime, timedelta, timezone
import random
import logging

logger = logging.getLogger(__name__)


@dataclass
class CacheEntry:
    """Cache entry with fresh and stale TTLs."""
    value: Any
    fresh_until: datetime
    stale_until: datetime
    version: int = 0


class ThunderingHerdProtectedCache:
    """
    Cache with multiple thundering herd protections.
    
    Protections applied:
    1. Request coalescing - Duplicate requests share one fetch
    2. Stale-while-revalidate - Serve stale, refresh async
    3. TTL jitter - Stagger expiration times
    4. Background refresh - Pre-refresh hot keys before expiry
    """
    
    def __init__(self, redis_client, config: dict = None):
        self.redis = redis_client
        self.config = config or {}
        
        # In-flight requests for coalescing
        self._in_flight: Dict[str, asyncio.Future] = {}
        
        # Hot keys for background refresh
        self._hot_keys: set = set()
        
        # Metrics
        self._coalesced_count = 0
        self._stale_served_count = 0
    
    async def get(
        self,
        key: str,
        fetch_func: Callable,
        fresh_ttl: int = 60,
        stale_ttl: int = 300
    ) -> Any:
        """
        Get value with thundering herd protection.
        
        1. Check cache - if fresh, return immediately
        2. If stale but valid, return stale and refresh async
        3. If expired, coalesce requests and fetch once
        """
        # Try to get from cache
        entry = await self._get_entry(key)
        
        now = datetime.now(timezone.utc)
        
        # Case 1: Fresh cache hit
        if entry and entry.fresh_until > now:
            return entry.value
        
        # Case 2: Stale but within stale window - serve stale, refresh async
        if entry and entry.stale_until > now:
            self._stale_served_count += 1
            # Trigger async refresh (don't wait)
            asyncio.create_task(
                self._refresh_async(key, fetch_func, fresh_ttl, stale_ttl)
            )
            return entry.value
        
        # Case 3: Expired or missing - fetch with coalescing
        return await self._fetch_with_coalescing(
            key, fetch_func, fresh_ttl, stale_ttl
        )
    
    async def _fetch_with_coalescing(
        self,
        key: str,
        fetch_func: Callable,
        fresh_ttl: int,
        stale_ttl: int
    ) -> Any:
        """
        Fetch with request coalescing.
        
        If multiple requests come in for the same key,
        only one actually fetches - others wait for it.
        """
        # Check if there's already a fetch in flight
        if key in self._in_flight:
            self._coalesced_count += 1
            logger.debug(f"Coalescing request for {key}")
            return await self._in_flight[key]
        
        # Create future for this fetch
        future = asyncio.get_event_loop().create_future()
        self._in_flight[key] = future
        
        try:
            # Actually fetch the data
            value = await fetch_func()
            
            # Apply TTL jitter (random shortening of the fresh TTL)
            # to prevent synchronized expiration
            jitter = random.uniform(0.8, 1.0)
            actual_fresh_ttl = int(fresh_ttl * jitter)
            
            # Cache it
            await self._set_entry(key, value, actual_fresh_ttl, stale_ttl)
            
            # Complete the future
            future.set_result(value)
            return value
            
        except Exception as e:
            future.set_exception(e)
            raise
            
        finally:
            del self._in_flight[key]
    
    async def _refresh_async(
        self,
        key: str,
        fetch_func: Callable,
        fresh_ttl: int,
        stale_ttl: int
    ):
        """Background refresh without blocking."""
        try:
            # Don't refresh if already in flight
            if key in self._in_flight:
                return
            
            value = await fetch_func()
            
            jitter = random.uniform(0.8, 1.0)
            actual_fresh_ttl = int(fresh_ttl * jitter)
            
            await self._set_entry(key, value, actual_fresh_ttl, stale_ttl)
            logger.debug(f"Background refresh completed for {key}")
            
        except Exception as e:
            logger.warning(f"Background refresh failed for {key}: {e}")
    
    async def _get_entry(self, key: str) -> Optional[CacheEntry]:
        """Get cache entry with metadata."""
        data = await self.redis.hgetall(f"cache:{key}")
        if not data:
            return None
        
        return CacheEntry(
            value=json.loads(data[b'value']),
            fresh_until=datetime.fromisoformat(data[b'fresh_until'].decode()),
            stale_until=datetime.fromisoformat(data[b'stale_until'].decode()),
            version=int(data.get(b'version', 0))
        )
    
    async def _set_entry(
        self,
        key: str,
        value: Any,
        fresh_ttl: int,
        stale_ttl: int
    ):
        """Set cache entry with metadata."""
        now = datetime.now(timezone.utc)
        
        entry_data = {
            'value': json.dumps(value, default=str),
            'fresh_until': (now + timedelta(seconds=fresh_ttl)).isoformat(),
            'stale_until': (now + timedelta(seconds=fresh_ttl + stale_ttl)).isoformat(),
            'version': str(int(now.timestamp()))
        }
        
        pipe = self.redis.pipeline()
        pipe.hset(f"cache:{key}", mapping=entry_data)
        pipe.expire(f"cache:{key}", fresh_ttl + stale_ttl)
        await pipe.execute()
    
    # =========================================================================
    # Background Refresh for Hot Keys (Flash Sale Products)
    # =========================================================================
    
    def mark_hot(self, key: str):
        """Mark a key as hot for background refresh."""
        self._hot_keys.add(key)
    
    def unmark_hot(self, key: str):
        """Remove key from hot list."""
        self._hot_keys.discard(key)
    
    async def run_background_refresh(self, fetch_funcs: Dict[str, Callable]):
        """
        Background job to keep hot keys fresh.
        
        Run this continuously to ensure flash sale products
        are ALWAYS in cache before they're requested.
        """
        while True:
            for key in list(self._hot_keys):
                try:
                    entry = await self._get_entry(key)
                    
                    # Refresh if within 20% of fresh TTL expiring
                    if entry:
                        now = datetime.now(timezone.utc)
                        time_to_stale = (entry.fresh_until - now).total_seconds()
                        
                        if time_to_stale < 12:  # Less than 12 seconds to stale
                            if key in fetch_funcs:
                                await self._refresh_async(
                                    key, fetch_funcs[key], 60, 300
                                )
                
                except Exception as e:
                    logger.error(f"Background refresh error for {key}: {e}")
            
            await asyncio.sleep(5)  # Check every 5 seconds


# =============================================================================
# Flash Sale Cache Warming
# =============================================================================

class FlashSaleCacheWarmer:
    """
    Pre-warm cache before flash sales start.
    
    Flash sales are scheduled in advance, so we know
    which products will be hit. Warm them before midnight!
    """
    
    def __init__(self, cache: ThunderingHerdProtectedCache, db_client):
        self.cache = cache
        self.db = db_client
    
    async def warm_flash_sale(self, sale_id: str, start_time: datetime):
        """
        Warm cache for upcoming flash sale.
        
        Call this 5 minutes before sale starts.
        """
        # Get flash sale products
        products = await self.db.fetch(
            """
            SELECT p.* FROM products p
            JOIN flash_sale_items fsi ON p.id = fsi.product_id
            WHERE fsi.sale_id = $1
            """,
            sale_id
        )
        
        logger.info(f"Warming cache for {len(products)} flash sale products")
        
        for product in products:
            product_id = product['id']
            
            # Cache the product
            await self.cache._set_entry(
                f"product:{product_id}",
                dict(product),
                fresh_ttl=60,
                stale_ttl=300
            )
            
            # Mark as hot for background refresh
            self.cache.mark_hot(f"product:{product_id}")
        
        logger.info(f"Flash sale cache warming complete")
    
    async def cool_down_flash_sale(self, sale_id: str):
        """Remove products from hot list after sale ends."""
        products = await self.db.fetch(
            "SELECT product_id FROM flash_sale_items WHERE sale_id = $1",
            sale_id
        )
        
        for product in products:
            self.cache.unmark_hot(f"product:{product['product_id']}")

# Multi-Strategy Cache Invalidation
# Applies: Week 4, Day 2 (Invalidation) + Day 5 (Multi-Tier)

from dataclasses import dataclass
from typing import List, Dict, Optional
from enum import Enum
import asyncio


class DataFreshness(Enum):
    """Data freshness requirements."""
    REAL_TIME = "real_time"      # <5 seconds, event-driven
    NEAR_TIME = "near_time"      # <30 seconds, event + short TTL
    EVENTUAL = "eventual"        # <1 hour, TTL only
    STATIC = "static"            # Days/weeks, TTL + purge on change


@dataclass
class InvalidationStrategy:
    """Strategy for a data type."""
    freshness: DataFreshness
    ttl: int
    event_driven: bool
    cdn_cache: bool
    cdn_ttl: int = 0


# Define strategies for different data types
INVALIDATION_STRATEGIES = {
    "product_metadata": InvalidationStrategy(
        freshness=DataFreshness.EVENTUAL,
        ttl=3600,           # 1 hour Redis TTL
        event_driven=False, # Just TTL-based
        cdn_cache=True,
        cdn_ttl=60          # 1 minute CDN
    ),
    "product_price": InvalidationStrategy(
        freshness=DataFreshness.REAL_TIME,
        ttl=30,             # 30 second Redis TTL (safety net for lost events;
                            # the <5 s target relies on events)
        event_driven=True,  # Event-driven invalidation
        cdn_cache=False     # Don't cache prices at CDN
    ),
    "product_inventory": InvalidationStrategy(
        freshness=DataFreshness.NEAR_TIME,
        ttl=30,             # 30 second Redis TTL
        event_driven=True,  # Event-driven invalidation
        cdn_cache=False     # Don't cache inventory at CDN
    ),
    "product_images": InvalidationStrategy(
        freshness=DataFreshness.STATIC,
        ttl=86400,          # 24 hour Redis TTL
        event_driven=True,  # Purge on image change
        cdn_cache=True,
        cdn_ttl=604800      # 7 day CDN
    ),
    "category_listing": InvalidationStrategy(
        freshness=DataFreshness.EVENTUAL,
        ttl=300,            # 5 minute Redis TTL
        event_driven=False, # Just TTL-based
        cdn_cache=True,
        cdn_ttl=60          # 1 minute CDN
    ),
}


class MultiStrategyInvalidationService:
    """
    Invalidation service with data-type-aware strategies.
    
    Different data types have different freshness requirements.
    This service applies the right strategy for each type.
    """
    
    def __init__(
        self,
        redis_client,
        cdn_client,
        event_consumer
    ):
        self.redis = redis_client
        self.cdn = cdn_client
        self.event_consumer = event_consumer
        self.strategies = INVALIDATION_STRATEGIES
    
    async def invalidate(
        self,
        data_type: str,
        entity_id: str,
        cascade: bool = True
    ):
        """
        Invalidate cache for an entity.
        
        Args:
            data_type: Type of data (determines strategy)
            entity_id: ID of the entity
            cascade: Whether to invalidate related caches
        """
        strategy = self.strategies.get(data_type)
        if not strategy:
            logger.warning(f"Unknown data type: {data_type}")
            return
        
        # Only process if event-driven
        if not strategy.event_driven:
            logger.debug(f"Skipping invalidation for TTL-only type: {data_type}")
            return
        
        # Invalidation order: App Cache → CDN
        # (Closest to database first)
        
        # 1. Application cache (Redis)
        await self._invalidate_redis(data_type, entity_id)
        
        # 2. CDN (if cached there)
        if strategy.cdn_cache:
            await self._invalidate_cdn(data_type, entity_id)
        
        # 3. Cascade to related caches if needed
        if cascade:
            await self._cascade_invalidation(data_type, entity_id)
    
    async def _invalidate_redis(self, data_type: str, entity_id: str):
        """Invalidate application cache."""
        keys = self._get_cache_keys(data_type, entity_id)
        
        if keys:
            await self.redis.delete(*keys)
            logger.info(f"Invalidated Redis keys: {keys}")
    
    async def _invalidate_cdn(self, data_type: str, entity_id: str):
        """Invalidate CDN cache."""
        urls = self._get_cdn_urls(data_type, entity_id)
        
        for url in urls:
            await self.cdn.purge_url(url)
        
        logger.info(f"Purged CDN URLs: {urls}")
    
    async def _cascade_invalidation(self, data_type: str, entity_id: str):
        """Invalidate related caches."""
        # Price change → invalidate product page cache
        if data_type == "product_price":
            await self._invalidate_redis("product_page", entity_id)
        
        # Inventory change → invalidate category listings
        if data_type == "product_inventory":
            categories = await self._get_product_categories(entity_id)
            for cat_id in categories:
                await self._invalidate_redis("category_listing", cat_id)
    
    def _get_cache_keys(self, data_type: str, entity_id: str) -> List[str]:
        """Get Redis keys for a data type and entity."""
        key_patterns = {
            "product_metadata": [f"product:{entity_id}:metadata"],
            "product_price": [f"product:{entity_id}:price", f"price:{entity_id}"],
            "product_inventory": [f"product:{entity_id}:inventory", f"inventory:{entity_id}"],
            "product_images": [f"product:{entity_id}:images"],
            "product_page": [f"product:{entity_id}", f"product_page:{entity_id}"],
            # NOTE: DEL does not expand globs; expand this pattern with SCAN, then UNLINK/DEL
            "category_listing": [f"category:{entity_id}:*"],
        }
        return key_patterns.get(data_type, [])
    
    def _get_cdn_urls(self, data_type: str, entity_id: str) -> List[str]:
        """Get CDN URLs to purge."""
        url_patterns = {
            "product_metadata": [f"/api/products/{entity_id}"],
            "product_images": [f"/images/products/{entity_id}/*"],
            "category_listing": [f"/api/categories/{entity_id}/*"],
        }
        return url_patterns.get(data_type, [])
    
    async def _get_product_categories(self, product_id: str) -> List[str]:
        """Get categories a product belongs to."""
        # Would query database
        return []


# =============================================================================
# Event Handler for Real-Time Invalidation
# =============================================================================

class PriceChangeEventHandler:
    """
    Handle price change events for real-time cache invalidation.
    
    When a price changes, we must invalidate immediately.
    """
    
    def __init__(self, invalidation_service: MultiStrategyInvalidationService):
        self.invalidation = invalidation_service
    
    async def handle(self, event: dict):
        """Handle price change event from Kafka."""
        product_id = event['product_id']
        old_price = event['old_price']
        new_price = event['new_price']
        
        logger.info(
            f"Price change detected: product={product_id}, "
            f"{old_price} → {new_price}"
        )
        
        # Invalidate price cache across all tiers
        await self.invalidation.invalidate(
            data_type="product_price",
            entity_id=product_id,
            cascade=True
        )
        
        # If significant price drop (flash sale), warm the cache
        if new_price < old_price * 0.5:  # 50%+ discount
            logger.info(f"Flash sale price detected for {product_id}")
            # Mark as hot for background refresh


class InventoryChangeEventHandler:
    """Handle inventory changes."""
    
    def __init__(self, invalidation_service: MultiStrategyInvalidationService):
        self.invalidation = invalidation_service
    
    async def handle(self, event: dict):
        """Handle inventory change event."""
        product_id = event['product_id']
        new_quantity = event['new_quantity']
        
        # Only invalidate if stock status changed
        # (in stock → out of stock, or vice versa)
        if event.get('stock_status_changed', False):
            await self.invalidation.invalidate(
                data_type="product_inventory",
                entity_id=product_id,
                cascade=True
            )

# Safety Net Pattern: Event-Driven + TTL

async def cache_product_price(product_id: str, price: dict):
    """
    Cache price with safety net TTL.
    
    - Primary invalidation: Event-driven (real-time)
    - Safety net: 30-second TTL (eventual consistency)
    
    Even if the invalidation event is lost, price will
    be refreshed within 30 seconds. That backstop is looser
    than the <5 s price target, which holds while events flow;
    a lost event is the rare failure case (checkout re-reads
    the price, so no one is charged a stale one).
    """
    await redis.setex(
        f"price:{product_id}",
        30,  # Safety net TTL
        json.dumps(price)
    )

# Personalized Feed Caching
# Applies: Week 4, Day 4

from dataclasses import dataclass
from typing import List, Optional, Dict
from datetime import datetime, timedelta, timezone
from enum import Enum


class UserActivityTier(Enum):
    """User activity tiers for caching strategy."""
    ACTIVE = "active"       # Logged in today - full cache
    RECENT = "recent"       # Logged in this week - partial cache
    DORMANT = "dormant"     # Not logged in for 7+ days - compute on demand


@dataclass
class UserFeedConfig:
    """Configuration for user feed caching."""
    recently_viewed_limit: int = 20
    recommendations_limit: int = 50
    active_user_ttl: int = 3600       # 1 hour for active users
    recent_user_ttl: int = 86400      # 24 hours for recent users
    dormant_threshold_days: int = 7


class PersonalizedFeedService:
    """
    Personalized feed service with activity-based caching.
    
    Strategy:
    - Active users (today): Full cache, pre-computed
    - Recent users (this week): Partial cache, refresh on access
    - Dormant users (7+ days): Compute on demand, cache briefly
    """
    
    def __init__(
        self,
        redis_client,
        db_client,
        recommendation_service,
        config: UserFeedConfig = None
    ):
        self.redis = redis_client
        self.db = db_client
        self.recs = recommendation_service
        self.config = config or UserFeedConfig()
    
    async def get_recently_viewed(
        self,
        user_id: str,
        limit: int = 20
    ) -> List[dict]:
        """
        Get user's recently viewed products.
        
        Recently viewed is user-specific but simple:
        - Just a list of product IDs with timestamps
        - Easy to maintain incrementally
        """
        cache_key = f"user:{user_id}:recently_viewed"
        
        # Get from sorted set (most recent first)
        product_ids = await self.redis.zrevrange(
            cache_key, 0, limit - 1
        )
        
        if product_ids:
            return await self._get_products_by_ids(product_ids)
        
        # Cache miss - compute from database
        return await self._compute_recently_viewed(user_id, limit)
    
    async def record_view(self, user_id: str, product_id: str):
        """
        Record a product view.
        
        This is write-through: Write to cache AND database.
        Cache is always up-to-date.
        """
        now = datetime.now(timezone.utc).timestamp()
        cache_key = f"user:{user_id}:recently_viewed"
        
        pipe = self.redis.pipeline()
        
        # Add to sorted set (score = timestamp)
        pipe.zadd(cache_key, {product_id: now})
        
        # Trim to limit (keep most recent 20)
        pipe.zremrangebyrank(cache_key, 0, -self.config.recently_viewed_limit - 1)
        
        # Set TTL based on user activity
        tier = await self._get_user_tier(user_id)
        ttl = self._get_ttl_for_tier(tier)
        pipe.expire(cache_key, ttl)
        
        await pipe.execute()
        
        # Also persist to database (async)
        await self._persist_view(user_id, product_id)
    
    async def get_recommendations(
        self,
        user_id: str,
        limit: int = 20
    ) -> List[dict]:
        """
        Get personalized recommendations.
        
        Recommendations are expensive to compute (ML model).
        Strategy varies by user activity tier.
        """
        tier = await self._get_user_tier(user_id)
        
        if tier == UserActivityTier.ACTIVE:
            # Active users: Check cache, compute if missing
            return await self._get_active_user_recs(user_id, limit)
        
        elif tier == UserActivityTier.RECENT:
            # Recent users: Check cache, compute and cache if missing
            return await self._get_recent_user_recs(user_id, limit)
        
        else:
            # Dormant users: Compute on demand, cache briefly
            return await self._get_dormant_user_recs(user_id, limit)
    
    async def _get_active_user_recs(
        self,
        user_id: str,
        limit: int
    ) -> List[dict]:
        """Get recommendations for active users (cached)."""
        cache_key = f"user:{user_id}:recommendations"
        
        # Check cache
        cached = await self.redis.get(cache_key)
        if cached:
            product_ids = json.loads(cached)[:limit]
            return await self._get_products_by_ids(product_ids)
        
        # Cache miss - should be rare for active users
        # (Background job should have pre-computed)
        return await self._compute_and_cache_recs(
            user_id, limit, self.config.active_user_ttl
        )
    
    async def _get_recent_user_recs(
        self,
        user_id: str,
        limit: int
    ) -> List[dict]:
        """Get recommendations for recent users."""
        cache_key = f"user:{user_id}:recommendations"
        
        cached = await self.redis.get(cache_key)
        if cached:
            product_ids = json.loads(cached)[:limit]
            return await self._get_products_by_ids(product_ids)
        
        # Cache miss - compute and cache
        return await self._compute_and_cache_recs(
            user_id, limit, self.config.recent_user_ttl
        )
    
    async def _get_dormant_user_recs(
        self,
        user_id: str,
        limit: int
    ) -> List[dict]:
        """Get recommendations for dormant users."""
        # Don't check cache for dormant users
        # Their data would be stale anyway
        
        # Compute fresh recommendations
        recs = await self.recs.compute_recommendations(user_id, limit)
        
        # Cache briefly (5 minutes) in case they browse around
        cache_key = f"user:{user_id}:recommendations"
        await self.redis.setex(
            cache_key,
            300,
            json.dumps([r['product_id'] for r in recs])
        )
        
        return recs
    
    async def _compute_and_cache_recs(
        self,
        user_id: str,
        limit: int,
        ttl: int
    ) -> List[dict]:
        """Compute recommendations and cache."""
        recs = await self.recs.compute_recommendations(user_id, limit)
        
        cache_key = f"user:{user_id}:recommendations"
        await self.redis.setex(
            cache_key,
            ttl,
            json.dumps([r['product_id'] for r in recs])
        )
        
        return recs
    
    async def _get_user_tier(self, user_id: str) -> UserActivityTier:
        """Determine user's activity tier."""
        cache_key = f"user:{user_id}:last_active"
        
        last_active = await self.redis.get(cache_key)
        if not last_active:
            return UserActivityTier.DORMANT
        
        last_active_dt = datetime.fromisoformat(last_active.decode())
        days_inactive = (datetime.now(timezone.utc) - last_active_dt).days
        
        if days_inactive == 0:
            return UserActivityTier.ACTIVE
        elif days_inactive < self.config.dormant_threshold_days:
            return UserActivityTier.RECENT
        else:
            return UserActivityTier.DORMANT
    
    def _get_ttl_for_tier(self, tier: UserActivityTier) -> int:
        """Get cache TTL based on user tier."""
        ttls = {
            UserActivityTier.ACTIVE: self.config.active_user_ttl,
            UserActivityTier.RECENT: self.config.recent_user_ttl,
            UserActivityTier.DORMANT: 300  # 5 minutes
        }
        return ttls.get(tier, 300)
    
    async def _get_products_by_ids(self, product_ids: List[str]) -> List[dict]:
        """Fetch products by IDs with caching."""
        # Would use the product cache from Deep Dive 1
        pass
    
    async def _compute_recently_viewed(
        self,
        user_id: str,
        limit: int
    ) -> List[dict]:
        """Compute recently viewed from database."""
        pass
    
    async def _persist_view(self, user_id: str, product_id: str):
        """Persist view to database (async)."""
        pass


# =============================================================================
# Background Job: Pre-Compute Active User Recommendations
# =============================================================================

class RecommendationPreComputer:
    """
    Background job to pre-compute recommendations for active users.
    
    Run periodically (e.g., every hour) to ensure active users
    always have cached recommendations.
    """
    
    def __init__(
        self,
        feed_service: PersonalizedFeedService,
        db_client
    ):
        self.feed = feed_service
        self.db = db_client
    
    async def run(self):
        """Pre-compute recommendations for active users."""
        # Get users active in last 24 hours
        active_users = await self.db.fetch(
            """
            SELECT user_id FROM user_sessions
            WHERE last_active > NOW() - INTERVAL '24 hours'
            """
        )
        
        logger.info(f"Pre-computing recs for {len(active_users)} active users")
        
        for user in active_users:
            try:
                await self.feed._compute_and_cache_recs(
                    user['user_id'],
                    limit=50,
                    ttl=3600
                )
            except Exception as e:
                logger.warning(
                    f"Failed to pre-compute recs for {user['user_id']}: {e}"
                )
        
        logger.info("Recommendation pre-computation complete")

# Multi-Tier Cache Headers
# Applies: Week 4, Day 5

from fastapi import FastAPI, Response, Request, Depends
from enum import Enum


class ContentType(Enum):
    STATIC_ASSET = "static_asset"
    PRODUCT_IMAGE = "product_image"
    PRODUCT_PAGE_ANON = "product_page_anon"
    PRODUCT_PAGE_AUTH = "product_page_auth"
    PRODUCT_PRICE = "product_price"
    INVENTORY = "inventory"
    CATEGORY_PAGE = "category_page"
    SEARCH_RESULTS = "search_results"
    PERSONALIZED = "personalized"
    CART = "cart"
    CHECKOUT = "checkout"


class CacheHeaderBuilder:
    """
    Build appropriate cache headers for each content type.
    
    Different content requires different caching strategies
    across browser, CDN, and gateway layers.
    """
    
    CACHE_POLICIES = {
        ContentType.STATIC_ASSET: {
            "cache_control": "public, max-age=31536000, immutable",
            "cdn_cache": True,
            "vary": ["Accept-Encoding"],
        },
        ContentType.PRODUCT_IMAGE: {
            "cache_control": "public, max-age=604800",  # 1 week
            "cdn_cache": True,
            "vary": ["Accept-Encoding"],
        },
        ContentType.PRODUCT_PAGE_ANON: {
            "cache_control": "public, max-age=60, stale-while-revalidate=30",
            "cdn_cache": True,
            "vary": ["Accept-Encoding", "Accept-Language"],
        },
        ContentType.PRODUCT_PAGE_AUTH: {
            "cache_control": "private, max-age=0, must-revalidate",
            "cdn_cache": False,
            "vary": ["Authorization", "Accept-Encoding"],
        },
        ContentType.PRODUCT_PRICE: {
            "cache_control": "no-cache, no-store, must-revalidate",
            "cdn_cache": False,
            "vary": [],
        },
        ContentType.INVENTORY: {
            "cache_control": "no-cache, no-store, must-revalidate",
            "cdn_cache": False,
            "vary": [],
        },
        ContentType.CATEGORY_PAGE: {
            "cache_control": "public, max-age=60, stale-while-revalidate=30",
            "cdn_cache": True,
            "vary": ["Accept-Encoding", "Accept-Language"],
        },
        ContentType.SEARCH_RESULTS: {
            "cache_control": "public, max-age=30",
            "cdn_cache": True,
            "vary": ["Accept-Encoding"],  # Also varies on query string
        },
        ContentType.PERSONALIZED: {
            "cache_control": "private, no-cache",
            "cdn_cache": False,
            "vary": ["Authorization"],
        },
        ContentType.CART: {
            "cache_control": "private, no-store",
            "cdn_cache": False,
            "vary": [],
        },
        ContentType.CHECKOUT: {
            "cache_control": "no-store",
            "cdn_cache": False,
            "vary": [],
        },
    }
    
    @classmethod
    def get_headers(
        cls,
        content_type: ContentType,
        etag: str = None
    ) -> dict:
        """Get cache headers for content type."""
        policy = cls.CACHE_POLICIES[content_type]
        
        headers = {
            "Cache-Control": policy["cache_control"],
        }
        
        if policy["vary"]:
            headers["Vary"] = ", ".join(policy["vary"])
        
        if etag:
            headers["ETag"] = f'"{etag}"'
        
        # Add CDN hints
        if not policy["cdn_cache"]:
            headers["CDN-Cache-Control"] = "no-store"
        
        return headers


# FastAPI Integration
app = FastAPI()


def get_auth_status(request: Request) -> bool:
    """Check if request is authenticated."""
    return "Authorization" in request.headers


@app.get("/api/products/{product_id}")
async def get_product(
    product_id: str,
    response: Response,
    authenticated: bool = Depends(get_auth_status)
):
    """Get product with appropriate cache headers."""
    
    # Fetch product (from cache or DB)
    product = await product_service.get_product(product_id)
    
    # Determine content type based on auth status
    content_type = (
        ContentType.PRODUCT_PAGE_AUTH if authenticated
        else ContentType.PRODUCT_PAGE_ANON
    )
    
    # Set cache headers
    headers = CacheHeaderBuilder.get_headers(
        content_type,
        etag=str(product['updated_at'])
    )
    
    for header, value in headers.items():
        response.headers[header] = value
    
    return product


@app.get("/api/products/{product_id}/price")
async def get_price(product_id: str, response: Response):
    """
    Get product price.
    
    Never cached at CDN - always fresh from Redis/DB.
    """
    price = await price_service.get_price(product_id)
    
    headers = CacheHeaderBuilder.get_headers(ContentType.PRODUCT_PRICE)
    for header, value in headers.items():
        response.headers[header] = value
    
    return price


@app.get("/api/me/recently-viewed")
async def get_recently_viewed(
    response: Response,
    user = Depends(get_current_user)
):
    """Get user's recently viewed - personalized, private."""
    items = await feed_service.get_recently_viewed(user.id)
    
    headers = CacheHeaderBuilder.get_headers(ContentType.PERSONALIZED)
    for header, value in headers.items():
        response.headers[header] = value
    
    return items

# Graceful Degradation Implementation

class ResilientProductService:
    """
    Product service with graceful degradation.
    
    Falls back to local cache → default data → error
    if Redis is unavailable.
    """
    
    def __init__(self, redis_cache, local_cache, db_client):
        self.redis = redis_cache
        self.local = local_cache  # In-memory (Guava-style)
        self.db = db_client
        self.circuit_breaker = CircuitBreaker(
            failure_threshold=5,
            recovery_timeout=30
        )
    
    async def get_product(self, product_id: str) -> dict:
        """Get product with fallback chain."""
        
        # Try Redis (primary cache)
        if self.circuit_breaker.is_closed():
            try:
                product = await self.redis.get(f"product:{product_id}")
                if product:
                    # Also store in local cache for fallback
                    self.local.put(product_id, product)
                    return product
            except Exception as e:
                self.circuit_breaker.record_failure()
                logger.warning(f"Redis failure: {e}")
        
        # Try local in-memory cache (fallback)
        product = self.local.get(product_id)
        if product:
            logger.info(f"Serving from local cache: {product_id}")
            return product
        
        # Try database (last resort during outage)
        if self.circuit_breaker.is_open():
            # Don't hammer DB during Redis outage
            # Return default/error
            return self._get_default_product(product_id)
        
        # Normal cache miss - fetch from DB
        product = await self.db.fetch_product(product_id)
        if product:
            await self.redis.set(f"product:{product_id}", product)
            self.local.put(product_id, product)
        
        return product
    
    def _get_default_product(self, product_id: str) -> dict:
        """Return minimal product data during outage."""
        return {
            "id": product_id,
            "title": "Product Temporarily Unavailable",
            "price": None,
            "inventory": None,
            "_degraded": True
        }