Multi-Tier Caching.

# Cache headers in FastAPI

from fastapi import FastAPI, Response, Depends
from fastapi.responses import FileResponse
import hashlib

app = FastAPI()


# Static assets: Long cache with content hash
@app.get("/static/{filename}")
async def get_static(filename: str):
    file_path = f"static/{filename}"
    
    # Generate ETag from content
    with open(file_path, 'rb') as f:
        content_hash = hashlib.md5(f.read()).hexdigest()
    
    return FileResponse(
        file_path,
        headers={
            "Cache-Control": "public, max-age=31536000, immutable",
            "ETag": f'"{content_hash}"'
        }
    )


# API responses: Short cache with revalidation
@app.get("/api/products/{product_id}")
async def get_product(product_id: str, response: Response):
    product = await fetch_product(product_id)
    
    # Cache for 5 minutes, allow stale for 1 minute while revalidating
    response.headers["Cache-Control"] = "public, max-age=300, stale-while-revalidate=60"
    response.headers["ETag"] = f'"{product["version"]}"'
    
    return product


# Personalized content: Private cache only
@app.get("/api/me/profile")
async def get_my_profile(response: Response, user = Depends(get_current_user)):
    profile = await fetch_profile(user.id)
    
    # Only browser can cache, not CDN
    response.headers["Cache-Control"] = "private, max-age=60"
    
    return profile


# Sensitive data: No caching
@app.get("/api/me/payment-methods")
async def get_payment_methods(response: Response):
    # Never cache payment info
    response.headers["Cache-Control"] = "no-store"
    
    return await fetch_payment_methods()

# CDN configuration example (CloudFront-style)

CDN_CACHE_BEHAVIORS = {
    # Static assets: Aggressive caching
    "/static/*": {
        "ttl_default": 86400 * 365,  # 1 year
        "ttl_min": 86400,
        "ttl_max": 86400 * 365,
        "compress": True,
        "forward_headers": [],  # Don't vary on headers
        "forward_query_strings": False,
        "cache_methods": ["GET", "HEAD"],
    },
    
    # API - Public endpoints: Moderate caching
    "/api/products/*": {
        "ttl_default": 60,  # 1 minute
        "ttl_min": 0,
        "ttl_max": 3600,
        "compress": True,
        "forward_headers": ["Accept", "Accept-Language"],
        "forward_query_strings": True,  # Different params = different cache
        "cache_methods": ["GET"],
    },
    
    # API - Authenticated: No CDN caching
    "/api/me/*": {
        "ttl_default": 0,
        "ttl_min": 0,
        "ttl_max": 0,
        "forward_headers": ["Authorization", "Cookie"],
        "cache_methods": [],  # Don't cache
    },
    
    # Media: Long cache with purge capability
    "/media/*": {
        "ttl_default": 86400 * 7,  # 1 week
        "ttl_min": 3600,
        "ttl_max": 86400 * 30,
        "compress": False,  # Already compressed (images, video)
        "forward_headers": [],
        "forward_query_strings": False,
    },
}

# CDN Purge Implementation

import httpx
from typing import List


class CDNPurgeService:
    """
    Service to invalidate CDN cache.
    
    Different CDN providers have different APIs.
    This is a generic implementation.
    """
    
    def __init__(self, cdn_api_url: str, api_key: str):
        self.cdn_api_url = cdn_api_url
        self.api_key = api_key
        self.client = httpx.AsyncClient()
    
    async def purge_url(self, url: str) -> bool:
        """Purge a specific URL from CDN."""
        response = await self.client.post(
            f"{self.cdn_api_url}/purge",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"urls": [url]}
        )
        return response.status_code == 200
    
    async def purge_pattern(self, pattern: str) -> bool:
        """Purge URLs matching pattern (e.g., /products/*)."""
        response = await self.client.post(
            f"{self.cdn_api_url}/purge",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"pattern": pattern}
        )
        return response.status_code == 200
    
    async def purge_tag(self, tag: str) -> bool:
        """Purge all URLs with a specific cache tag."""
        response = await self.client.post(
            f"{self.cdn_api_url}/purge",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"tag": tag}
        )
        return response.status_code == 200


# Integration with product updates
class ProductService:
    def __init__(self, db, cache, cdn_purge: CDNPurgeService):
        self.db = db
        self.cache = cache
        self.cdn = cdn_purge
    
    async def update_product(self, product_id: str, data: dict) -> dict:
        # Update database
        product = await self.db.update_product(product_id, data)
        
        # Invalidate application cache
        await self.cache.delete(f"product:{product_id}")
        
        # Purge CDN
        await self.cdn.purge_url(f"/api/products/{product_id}")
        await self.cdn.purge_pattern(f"/api/products?*")  # List pages
        
        return product

# API Gateway Caching Implementation

from fastapi import FastAPI, Request, Response
from fastapi.responses import JSONResponse
import hashlib
import json
from typing import Optional


class GatewayCache:
    """
    API Gateway response cache.
    
    Caches responses based on:
    - HTTP method
    - URL path
    - Query parameters
    - Selected headers (Accept, Accept-Language)
    """
    
    def __init__(self, redis_client, default_ttl: int = 60):
        self.redis = redis_client
        self.default_ttl = default_ttl
        
        # Paths that should be cached
        self.cacheable_paths = {
            "/api/products": 60,
            "/api/categories": 300,
            "/api/config": 3600,
        }
        
        # Headers that affect cache key
        self.vary_headers = ["Accept", "Accept-Language", "Accept-Encoding"]
    
    def _build_cache_key(self, request: Request) -> str:
        """Build cache key from request."""
        parts = [
            request.method,
            str(request.url.path),
            str(sorted(request.query_params.items())),
        ]
        
        # Add varied headers
        for header in self.vary_headers:
            value = request.headers.get(header, "")
            parts.append(f"{header}:{value}")
        
        key_string = "|".join(parts)
        return f"gateway_cache:{hashlib.sha256(key_string.encode()).hexdigest()}"
    
    def _is_cacheable(self, request: Request) -> bool:
        """Check if request is cacheable."""
        if request.method not in ("GET", "HEAD"):
            return False
        
        # Check if path matches cacheable patterns
        path = request.url.path
        for pattern in self.cacheable_paths:
            if path.startswith(pattern):
                return True
        
        return False
    
    def _get_ttl(self, request: Request) -> int:
        """Get TTL for request."""
        path = request.url.path
        for pattern, ttl in self.cacheable_paths.items():
            if path.startswith(pattern):
                return ttl
        return self.default_ttl
    
    async def get_cached_response(self, request: Request) -> Optional[Response]:
        """Try to get cached response."""
        if not self._is_cacheable(request):
            return None
        
        cache_key = self._build_cache_key(request)
        cached = await self.redis.get(cache_key)
        
        if cached:
            data = json.loads(cached)
            return JSONResponse(
                content=data["body"],
                status_code=data["status_code"],
                headers={
                    **data["headers"],
                    "X-Cache": "HIT",
                    "X-Cache-Key": cache_key[:16]
                }
            )
        
        return None
    
    async def cache_response(
        self,
        request: Request,
        response_body: dict,
        status_code: int,
        headers: dict
    ):
        """Cache a response."""
        if not self._is_cacheable(request):
            return
        
        if status_code != 200:
            return
        
        cache_key = self._build_cache_key(request)
        ttl = self._get_ttl(request)
        
        data = {
            "body": response_body,
            "status_code": status_code,
            "headers": {k: v for k, v in headers.items() if k.lower() not in ("content-length", "transfer-encoding")}
        }
        
        await self.redis.setex(cache_key, ttl, json.dumps(data))


# Middleware for automatic caching
class CacheMiddleware:
    def __init__(self, app, cache: GatewayCache):
        self.app = app
        self.cache = cache
    
    async def __call__(self, scope, receive, send):
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return
        
        request = Request(scope, receive)
        
        # Try cache
        cached_response = await self.cache.get_cached_response(request)
        if cached_response:
            await cached_response(scope, receive, send)
            return
        
        # Not cached - forward to app
        await self.app(scope, receive, send)

# Auth Token Validation Cache

class AuthCache:
    """
    Cache authentication token validation results.
    
    Reduces load on auth service by caching valid tokens.
    Short TTL ensures revoked tokens stop working quickly.
    """
    
    def __init__(self, redis_client, auth_service, ttl: int = 60):
        self.redis = redis_client
        self.auth_service = auth_service
        self.ttl = ttl
    
    async def validate_token(self, token: str) -> Optional[dict]:
        """
        Validate token with caching.
        
        Returns user info if valid, None if invalid.
        """
        cache_key = f"auth:{self._hash_token(token)}"
        
        # Check cache
        cached = await self.redis.get(cache_key)
        if cached:
            if cached == "INVALID":
                return None
            return json.loads(cached)
        
        # Validate with auth service
        try:
            user = await self.auth_service.validate(token)
            
            if user:
                # Cache valid result, and remember which keys belong to this
                # user so they can all be revoked without a KEYS scan
                pipe = self.redis.pipeline()
                pipe.setex(cache_key, self.ttl, json.dumps(user))
                pipe.sadd(f"auth_user_keys:{user['id']}", cache_key)
                pipe.expire(f"auth_user_keys:{user['id']}", self.ttl)
                await pipe.execute()
                return user
            else:
                # Cache invalid result (shorter TTL)
                await self.redis.setex(cache_key, 10, "INVALID")
                return None
                
        except Exception as e:
            # Auth service error - don't cache; fail closed (re-raise)
            logger.error(f"Auth service error: {e}")
            raise
    
    def _hash_token(self, token: str) -> str:
        """Hash token for cache key (security)."""
        return hashlib.sha256(token.encode()).hexdigest()
    
    async def invalidate_token(self, token: str):
        """Invalidate a cached token (on logout/revoke)."""
        cache_key = f"auth:{self._hash_token(token)}"
        await self.redis.delete(cache_key)
    
    async def invalidate_user_tokens(self, user_id: str):
        """Invalidate all cached tokens for a user."""
        # Token keys are hashes (auth:{sha256}), so no pattern can find a
        # user's tokens; use the per-user set recorded in validate_token
        set_key = f"auth_user_keys:{user_id}"
        keys = await self.redis.smembers(set_key)
        if keys:
            await self.redis.delete(*keys)
        await self.redis.delete(set_key)

# Structured cache keys for multi-tier systems

class CacheKeyBuilder:
    """
    Build structured cache keys for multi-tier caching.
    
    Key format: {prefix}:{version}:{entity}:{id}:{variant}
    
    Example: app:v2:product:12345:en
    """
    
    def __init__(self, prefix: str = "app", version: str = "v1"):
        self.prefix = prefix
        self.version = version
    
    def product(self, product_id: str, locale: str = None) -> str:
        key = f"{self.prefix}:{self.version}:product:{product_id}"
        if locale:
            key += f":{locale}"
        return key
    
    def product_list(self, category: str, page: int, locale: str = None) -> str:
        key = f"{self.prefix}:{self.version}:products:{category}:page{page}"
        if locale:
            key += f":{locale}"
        return key
    
    def user_profile(self, user_id: str) -> str:
        return f"{self.prefix}:{self.version}:user:{user_id}:profile"
    
    def user_feed(self, user_id: str) -> str:
        return f"{self.prefix}:{self.version}:feed:{user_id}"
    
    def session(self, session_id: str) -> str:
        return f"{self.prefix}:session:{session_id}"  # No version - survives deploys
    
    def rate_limit(self, key: str, window: str) -> str:
        return f"{self.prefix}:ratelimit:{key}:{window}"
    
    def invalidation_pattern(self, entity: str, id: str = "*") -> str:
        """Pattern for bulk invalidation."""
        return f"{self.prefix}:{self.version}:{entity}:{id}:*"


# Usage
keys = CacheKeyBuilder(prefix="myapp", version="v3")

# After schema change, bump version to v4
# All v3 keys become orphaned and expire naturally
# No explicit invalidation needed!

# Multi-Tier Invalidation Service

from dataclasses import dataclass
from typing import List, Optional
import asyncio


@dataclass
class InvalidationResult:
    """Result of multi-tier invalidation."""
    success: bool
    browser_invalidated: bool  # Can only suggest via headers
    cdn_invalidated: bool
    gateway_invalidated: bool
    app_cache_invalidated: bool
    errors: List[str]


class MultiTierInvalidationService:
    """
    Coordinates cache invalidation across all tiers.
    
    Order of invalidation:
    1. Application cache (Redis) - fastest
    2. API Gateway cache
    3. CDN - slowest to propagate
    4. Browser - can only influence future requests
    """
    
    def __init__(
        self,
        redis_client,
        gateway_cache,
        cdn_service,
        event_publisher
    ):
        self.redis = redis_client
        self.gateway = gateway_cache
        self.cdn = cdn_service
        self.events = event_publisher
    
    async def invalidate_product(
        self,
        product_id: str,
        eager_cdn_purge: bool = True
    ) -> InvalidationResult:
        """
        Invalidate a product across all cache tiers.
        """
        errors = []
        
        # 1. Application cache (immediate)
        app_success = await self._invalidate_app_cache(product_id, errors)
        
        # 2. API Gateway cache
        gateway_success = await self._invalidate_gateway_cache(product_id, errors)
        
        # 3. CDN
        cdn_success = True
        if eager_cdn_purge:
            cdn_success = await self._invalidate_cdn(product_id, errors)
        else:
            # Queue CDN purge for background processing
            await self.events.publish("cdn-purge-queue", {
                "type": "product",
                "id": product_id
            })
        
        return InvalidationResult(
            success=app_success and gateway_success and cdn_success,
            browser_invalidated=False,  # Can't force browser
            cdn_invalidated=cdn_success,
            gateway_invalidated=gateway_success,
            app_cache_invalidated=app_success,
            errors=errors
        )
    
    async def _invalidate_app_cache(self, product_id: str, errors: List[str]) -> bool:
        """Invalidate Redis cache."""
        try:
            keys_to_delete = [
                f"product:{product_id}",
                f"product_page:{product_id}",
                f"product:{product_id}:*",  # Pattern for variants
            ]
            
            pipe = self.redis.pipeline()
            for key in keys_to_delete:
                if '*' in key:
                    # Pattern delete - scan and delete
                    cursor = 0
                    while True:
                        cursor, keys = await self.redis.scan(cursor, match=key, count=100)
                        if keys:
                            pipe.delete(*keys)
                        if cursor == 0:
                            break
                else:
                    pipe.delete(key)
            
            await pipe.execute()
            return True
            
        except Exception as e:
            errors.append(f"Redis invalidation failed: {e}")
            return False
    
    async def _invalidate_gateway_cache(self, product_id: str, errors: List[str]) -> bool:
        """Invalidate API Gateway cache."""
        try:
            patterns = [
                f"/api/products/{product_id}",
                f"/api/products?*",  # List endpoints
            ]
            
            for pattern in patterns:
                await self.gateway.invalidate_pattern(pattern)
            
            return True
            
        except Exception as e:
            errors.append(f"Gateway invalidation failed: {e}")
            return False
    
    async def _invalidate_cdn(self, product_id: str, errors: List[str]) -> bool:
        """Invalidate CDN cache."""
        try:
            urls = [
                f"/api/products/{product_id}",
                f"/api/products/{product_id}/*",
                f"/products/{product_id}",  # Product page
            ]
            
            results = await asyncio.gather(*[
                self.cdn.purge_url(url) for url in urls
            ], return_exceptions=True)
            
            for i, result in enumerate(results):
                if isinstance(result, Exception):
                    errors.append(f"CDN purge failed for {urls[i]}: {result}")
            
            return all(not isinstance(r, Exception) for r in results)
            
        except Exception as e:
            errors.append(f"CDN invalidation failed: {e}")
            return False
    
    async def invalidate_bulk(
        self,
        entity_type: str,
        entity_ids: List[str]
    ) -> InvalidationResult:
        """
        Bulk invalidation for multiple entities.
        
        More efficient than individual invalidations.
        """
        errors = []
        
        # 1. Application cache - bulk delete
        try:
            pipe = self.redis.pipeline()
            for entity_id in entity_ids:
                pipe.delete(f"{entity_type}:{entity_id}")
            await pipe.execute()
            app_success = True
        except Exception as e:
            errors.append(f"Bulk Redis invalidation failed: {e}")
            app_success = False
        
        # 2. Gateway - invalidate pattern
        try:
            await self.gateway.invalidate_pattern(f"/api/{entity_type}s/*")
            gateway_success = True
        except Exception as e:
            errors.append(f"Gateway invalidation failed: {e}")
            gateway_success = False
        
        # 3. CDN - use cache tags if available
        try:
            await self.cdn.purge_tag(f"{entity_type}")
            cdn_success = True
        except Exception as e:
            errors.append(f"CDN invalidation failed: {e}")
            cdn_success = False
        
        return InvalidationResult(
            success=app_success and gateway_success and cdn_success,
            browser_invalidated=False,
            cdn_invalidated=cdn_success,
            gateway_invalidated=gateway_success,
            app_cache_invalidated=app_success,
            errors=errors
        )

# Event-Driven Invalidation System

class InvalidationEventHandler:
    """
    Handles invalidation events for all cache tiers.
    
    Listens to data change events and coordinates
    cache invalidation across tiers.
    """
    
    def __init__(self, invalidation_service: MultiTierInvalidationService):
        self.invalidation = invalidation_service
    
    async def handle_event(self, event: dict):
        """Route event to appropriate handler."""
        event_type = event.get("type")
        
        handlers = {
            "product.updated": self._handle_product_updated,
            "product.deleted": self._handle_product_deleted,
            "product.price_changed": self._handle_price_change,
            "category.updated": self._handle_category_updated,
            "inventory.updated": self._handle_inventory_updated,
            "user.updated": self._handle_user_updated,
            "global.invalidate": self._handle_global_invalidate,
        }
        
        handler = handlers.get(event_type)
        if handler:
            await handler(event)
        else:
            logger.warning(f"Unknown invalidation event type: {event_type}")
    
    async def _handle_product_updated(self, event: dict):
        """Handle product update - full invalidation."""
        product_id = event["product_id"]
        
        result = await self.invalidation.invalidate_product(
            product_id,
            eager_cdn_purge=True
        )
        
        if not result.success:
            logger.error(f"Product invalidation failed: {result.errors}")
    
    async def _handle_price_change(self, event: dict):
        """Handle price change - priority invalidation."""
        product_id = event["product_id"]
        
        # Price changes are high priority - invalidate everywhere immediately
        result = await self.invalidation.invalidate_product(
            product_id,
            eager_cdn_purge=True
        )
        
        # Also invalidate any deals/promotions pages
        await self.invalidation.invalidate_bulk(
            "deals_page",
            ["current", "featured"]
        )
    
    async def _handle_inventory_updated(self, event: dict):
        """Handle inventory update - partial invalidation."""
        product_id = event["product_id"]
        
        # Inventory is usually cached with short TTL
        # Just invalidate application cache, CDN will expire quickly
        await self.invalidation._invalidate_app_cache(product_id, [])
    
    async def _handle_category_updated(self, event: dict):
        """Handle category update - affects multiple products."""
        category_id = event["category_id"]
        
        # Invalidate category cache
        await self.invalidation.invalidate_bulk(
            "category",
            [category_id]
        )
        
        # Invalidate product listings in this category
        await self.invalidation.gateway.invalidate_pattern(
            f"/api/products?category={category_id}*"
        )
        await self.invalidation.cdn.purge_pattern(
            f"/api/products?category={category_id}*"
        )
    
    async def _handle_user_updated(self, event: dict):
        """Handle user update - private cache only."""
        user_id = event["user_id"]
        
        # User data is private - only in app cache
        await self.invalidation.redis.delete(f"user:{user_id}")
        await self.invalidation.redis.delete(f"user:{user_id}:profile")
    
    async def _handle_global_invalidate(self, event: dict):
        """Handle global invalidation - nuclear option."""
        entity_type = event.get("entity_type", "*")
        
        logger.warning(f"Global invalidation triggered for {entity_type}")
        
        # Bump cache version (makes all keys invalid)
        await self.invalidation.redis.incr("cache_version")
        
        # Purge CDN entirely for this entity type
        await self.invalidation.cdn.purge_pattern(f"/api/{entity_type}*")


# Consumer that processes invalidation events
async def run_invalidation_consumer(kafka_consumer, handler: InvalidationEventHandler):
    """Run the invalidation event consumer."""
    async for message in kafka_consumer:
        try:
            event = json.loads(message.value.decode())
            await handler.handle_event(event)
            await kafka_consumer.commit()
        except Exception as e:
            logger.error(f"Failed to process invalidation event: {e}")

# Auth-Aware Caching

class AuthAwareCacheMiddleware:
    """
    Middleware that applies different caching strategies
    based on authentication status.
    """
    
    def __init__(self, app, cache_service):
        self.app = app
        self.cache = cache_service
    
    async def __call__(self, scope, receive, send):
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return
        
        request = Request(scope, receive)
        is_authenticated = self._is_authenticated(request)
        
        # Set caching strategy based on auth
        if is_authenticated:
            await self._handle_authenticated(request, scope, receive, send)
        else:
            await self._handle_anonymous(request, scope, receive, send)
    
    def _is_authenticated(self, request: Request) -> bool:
        """Check if request is authenticated."""
        return (
            "Authorization" in request.headers or
            "session_id" in request.cookies
        )
    
    async def _handle_anonymous(self, request, scope, receive, send):
        """Handle anonymous request - aggressive caching."""
        # Try CDN-style caching
        cached = await self.cache.get_cached_response(request)
        if cached:
            await cached(scope, receive, send)
            return
        
        # Forward to app with caching headers
        response_started = False
        original_body = []
        
        async def send_wrapper(message):
            nonlocal response_started
            if message["type"] == "http.response.start":
                # Add cache headers for anonymous
                headers = dict(message.get("headers", []))
                # Only GETs that don't set cookies may be shared publicly;
                # a cached Set-Cookie would hand one visitor's session to others
                if scope["method"] == "GET" and b"set-cookie" not in headers:
                    headers[b"cache-control"] = b"public, max-age=60"
                    headers[b"vary"] = b"Accept-Encoding"
                else:
                    headers[b"cache-control"] = b"no-store"
                message["headers"] = list(headers.items())
                response_started = True
            await send(message)
        
        await self.app(scope, receive, send_wrapper)
    
    async def _handle_authenticated(self, request, scope, receive, send):
        """Handle authenticated request - private caching."""
        
        async def send_wrapper(message):
            if message["type"] == "http.response.start":
                headers = dict(message.get("headers", []))
                # Private cache only - no CDN
                headers[b"cache-control"] = b"private, max-age=0, must-revalidate"
                headers[b"vary"] = b"Authorization, Cookie"
                message["headers"] = list(headers.items())
            await send(message)
        
        await self.app(scope, receive, send_wrapper)

# Response Caching Decision Tree

class ResponseCachePolicy:
    """
    Determines caching policy for API responses.
    """
    
    def get_cache_headers(
        self,
        request: Request,
        response_data: dict,
        endpoint: str
    ) -> dict:
        """Determine appropriate cache headers."""
        
        # Start with defaults
        headers = {
            "Cache-Control": "no-cache",
            "Vary": "Accept, Accept-Encoding"
        }
        
        # Check authentication
        if self._is_authenticated(request):
            # Authenticated: Private cache only
            headers["Cache-Control"] = "private, max-age=0"
            headers["Vary"] += ", Authorization"
            return headers
        
        # Anonymous: Apply endpoint-specific rules
        policy = self._get_endpoint_policy(endpoint)
        
        if policy["cacheable"]:
            directives = [
                "public",
                f"max-age={policy['max_age']}",
            ]
            
            if policy.get("stale_while_revalidate"):
                directives.append(
                    f"stale-while-revalidate={policy['stale_while_revalidate']}"
                )
            
            if policy.get("immutable"):
                directives.append("immutable")
            
            headers["Cache-Control"] = ", ".join(directives)
            
            # Add ETag for conditional requests
            if "version" in response_data:
                headers["ETag"] = f'"{response_data["version"]}"'
        
        return headers
    
    def _get_endpoint_policy(self, endpoint: str) -> dict:
        """Get caching policy for endpoint."""
        policies = {
            "/api/products": {
                "cacheable": True,
                "max_age": 60,
                "stale_while_revalidate": 30,
            },
            "/api/products/{id}": {
                "cacheable": True,
                "max_age": 300,
                "stale_while_revalidate": 60,
            },
            "/api/categories": {
                "cacheable": True,
                "max_age": 3600,
                "stale_while_revalidate": 300,
            },
            "/api/search": {
                "cacheable": True,
                "max_age": 30,  # Short for search results
            },
            "/api/cart": {
                "cacheable": False,  # User-specific
            },
            "/api/checkout": {
                "cacheable": False,  # Sensitive
            },
        }
        
        # Match endpoint to policy
        for pattern, policy in policies.items():
            if self._matches_pattern(endpoint, pattern):
                return policy
        
        return {"cacheable": False}
    
    def _matches_pattern(self, endpoint: str, pattern: str) -> bool:
        """Simple pattern matching for endpoints."""
        if "{" not in pattern:
            return endpoint.startswith(pattern)
        
        # Handle patterns like /api/products/{id}
        pattern_parts = pattern.split("/")
        endpoint_parts = endpoint.split("/")
        
        if len(pattern_parts) != len(endpoint_parts):
            return False
        
        for p, e in zip(pattern_parts, endpoint_parts):
            if p.startswith("{") and p.endswith("}"):
                continue  # Wildcard match
            if p != e:
                return False
        
        return True

# Complete Multi-Tier Cache System

import asyncio
import hashlib
import json
import logging
from dataclasses import dataclass
from typing import Dict, List, Optional, Any
from datetime import datetime, timezone
from enum import Enum

logger = logging.getLogger(__name__)


# =============================================================================
# Configuration
# =============================================================================

@dataclass
class MultiTierCacheConfig:
    """Configuration for multi-tier cache system."""
    
    # Application cache (Redis)
    app_cache_default_ttl: int = 300
    app_cache_max_ttl: int = 86400
    
    # Gateway cache
    gateway_cache_enabled: bool = True
    gateway_cache_ttl: int = 60
    
    # CDN
    cdn_enabled: bool = True
    cdn_default_ttl: int = 60
    cdn_purge_on_update: bool = True
    
    # Browser
    browser_cache_default: int = 0
    browser_cache_static: int = 31536000
    
    # Invalidation
    async_invalidation: bool = True
    invalidation_queue: str = "cache-invalidation"


class CacheLayer(Enum):
    BROWSER = "browser"
    CDN = "cdn"
    GATEWAY = "gateway"
    APPLICATION = "application"
    DATABASE = "database"


# =============================================================================
# Cache Layer Interfaces
# =============================================================================

class ICacheLayer:
    """Interface for cache layers."""
    
    async def get(self, key: str) -> Optional[Any]:
        raise NotImplementedError
    
    async def set(self, key: str, value: Any, ttl: int = None) -> bool:
        raise NotImplementedError
    
    async def delete(self, key: str) -> bool:
        raise NotImplementedError
    
    async def delete_pattern(self, pattern: str) -> int:
        raise NotImplementedError


class ApplicationCache(ICacheLayer):
    """Redis-based application cache."""
    
    def __init__(self, redis_client, config: MultiTierCacheConfig):
        self.redis = redis_client
        self.config = config
    
    async def get(self, key: str) -> Optional[Any]:
        try:
            value = await self.redis.get(key)
            return json.loads(value) if value else None
        except Exception as e:
            logger.warning(f"App cache get error: {e}")
            return None
    
    async def set(self, key: str, value: Any, ttl: int = None) -> bool:
        ttl = min(ttl or self.config.app_cache_default_ttl, self.config.app_cache_max_ttl)
        try:
            await self.redis.setex(key, ttl, json.dumps(value, default=str))
            return True
        except Exception as e:
            logger.warning(f"App cache set error: {e}")
            return False
    
    async def delete(self, key: str) -> bool:
        try:
            await self.redis.delete(key)
            return True
        except Exception as e:
            logger.warning(f"App cache delete error: {e}")
            return False
    
    async def delete_pattern(self, pattern: str) -> int:
        deleted = 0
        try:
            cursor = 0
            while True:
                cursor, keys = await self.redis.scan(cursor, match=pattern, count=100)
                if keys:
                    await self.redis.delete(*keys)
                    deleted += len(keys)
                if cursor == 0:
                    break
        except Exception as e:
            logger.warning(f"App cache pattern delete error: {e}")
        return deleted


class CDNCache(ICacheLayer):
    """CDN cache layer (via API)."""
    
    def __init__(self, cdn_client, config: MultiTierCacheConfig):
        self.cdn = cdn_client
        self.config = config
    
    async def get(self, key: str) -> Optional[Any]:
        # CDN is transparent - we don't read from it directly
        return None
    
    async def set(self, key: str, value: Any, ttl: int = None) -> bool:
        # CDN caching is controlled by headers, not direct sets
        return True
    
    async def delete(self, key: str) -> bool:
        if not self.config.cdn_enabled:
            return True
        try:
            return await self.cdn.purge_url(key)
        except Exception as e:
            logger.warning(f"CDN purge error: {e}")
            return False
    
    async def delete_pattern(self, pattern: str) -> int:
        if not self.config.cdn_enabled:
            return 0
        try:
            result = await self.cdn.purge_pattern(pattern)
            return 1 if result else 0
        except Exception as e:
            logger.warning(f"CDN pattern purge error: {e}")
            return 0


# =============================================================================
# Multi-Tier Cache Manager
# =============================================================================

class MultiTierCacheManager:
    """
    Manages caching across all tiers.
    
    Provides unified interface for:
    - Reading from multiple tiers
    - Writing to appropriate tiers
    - Invalidating across all tiers
    """
    
    def __init__(
        self,
        app_cache: ApplicationCache,
        cdn_cache: CDNCache,
        gateway_cache: Optional[ICacheLayer],
        event_publisher,
        config: MultiTierCacheConfig
    ):
        self.app_cache = app_cache
        self.cdn_cache = cdn_cache
        self.gateway_cache = gateway_cache
        self.events = event_publisher
        self.config = config
        
        # Layer order for reads (fastest first)
        self.read_layers = [self.app_cache]
        
        # Layer order for invalidation (innermost first, so outer layers
        # refill from fresh data)
        self.invalidation_layers = [
            self.app_cache,
            self.gateway_cache,
            self.cdn_cache,
        ]
    
    async def get(
        self,
        key: str,
        fetch_func: callable = None,
        ttl: int = None
    ) -> Optional[Any]:
        """
        Get value from cache hierarchy.
        
        Checks each layer in order, returns first hit.
        On miss, optionally fetches and caches.
        """
        # Try each read layer
        for layer in self.read_layers:
            if layer:
                value = await layer.get(key)
                if value is not None:
                    return value
        
        # All layers missed
        if fetch_func is None:
            return None
        
        # Fetch from source
        value = await fetch_func()
        
        if value is not None:
            # Cache in application layer
            await self.app_cache.set(key, value, ttl)
        
        return value
    
    async def set(
        self,
        key: str,
        value: Any,
        ttl: int = None,
        layers: List[CacheLayer] = None
    ) -> bool:
        """
        Set value in specified cache layers.
        
        By default, only sets in application layer.
        CDN caching is typically done via headers.
        """
        layers = layers or [CacheLayer.APPLICATION]
        success = True
        
        for layer in layers:
            if layer == CacheLayer.APPLICATION:
                success = success and await self.app_cache.set(key, value, ttl)
        
        return success
    
    async def invalidate(
        self,
        keys: List[str],
        patterns: List[str] = None,
        cdn_urls: List[str] = None,
        sync: bool = None
    ) -> bool:
        """
        Invalidate cache across all tiers.
        
        Args:
            keys: Specific keys to invalidate
            patterns: Patterns to match for bulk invalidation
            cdn_urls: CDN URLs/patterns to purge
            sync: Force synchronous invalidation
        """
        sync = sync if sync is not None else not self.config.async_invalidation
        
        if sync:
            return await self._invalidate_sync(keys, patterns, cdn_urls)
        else:
            return await self._invalidate_async(keys, patterns, cdn_urls)
    
    async def _invalidate_sync(
        self,
        keys: List[str],
        patterns: List[str] = None,
        cdn_urls: List[str] = None
    ) -> bool:
        """Synchronous invalidation across all tiers."""
        success = True
        
        # Application cache
        for key in keys:
            success = success and await self.app_cache.delete(key)
        
        for pattern in (patterns or []):
            await self.app_cache.delete_pattern(pattern)
        
        # Gateway cache
        if self.gateway_cache:
            for key in keys:
                await self.gateway_cache.delete(key)
            for pattern in (patterns or []):
                await self.gateway_cache.delete_pattern(pattern)
        
        # CDN
        for url in (cdn_urls or []):
            success = success and await self.cdn_cache.delete(url)
        
        return success
    
    async def _invalidate_async(
        self,
        keys: List[str],
        patterns: List[str] = None,
        cdn_urls: List[str] = None
    ) -> bool:
        """Queue invalidation for async processing."""
        event = {
            "type": "cache.invalidate",
            "keys": keys,
            "patterns": patterns or [],
            "cdn_urls": cdn_urls or [],
            "timestamp": datetime.now(timezone.utc).isoformat()
        }
        
        # Invalidate app cache immediately (fast)
        for key in keys:
            await self.app_cache.delete(key)
        
        # Queue the rest for async processing
        await self.events.publish(self.config.invalidation_queue, event)
        
        return True
    
    def get_cache_headers(
        self,
        ttl: int,
        private: bool = False,
        vary: List[str] = None,
        etag: str = None
    ) -> Dict[str, str]:
        """
        Generate HTTP cache headers.
        
        Call this when building responses to control
        browser and CDN caching.
        """
        directives = []
        
        if private:
            directives.append("private")
        else:
            directives.append("public")
        
        directives.append(f"max-age={ttl}")
        
        if ttl > 0:
            # Add stale-while-revalidate for better UX
            swr = min(ttl // 2, 60)
            directives.append(f"stale-while-revalidate={swr}")
        
        headers = {
            "Cache-Control": ", ".join(directives)
        }
        
        if vary:
            headers["Vary"] = ", ".join(vary)
        
        if etag:
            headers["ETag"] = f'"{etag}"'
        
        return headers


# =============================================================================
# Repository with Multi-Tier Caching
# =============================================================================

class CachedProductRepository:
    """
    Product repository with multi-tier caching.
    
    Demonstrates integration of cache manager with business logic.
    """
    
    def __init__(
        self,
        db_client,
        cache_manager: MultiTierCacheManager
    ):
        self.db = db_client
        self.cache = cache_manager
    
    async def get_product(self, product_id: str) -> Optional[dict]:
        """Get product with multi-tier caching."""
        cache_key = f"product:{product_id}"
        
        return await self.cache.get(
            key=cache_key,
            fetch_func=lambda: self._fetch_product(product_id),
            ttl=300
        )
    
    async def _fetch_product(self, product_id: str) -> Optional[dict]:
        """Fetch product from database."""
        row = await self.db.fetch_one(
            "SELECT * FROM products WHERE id = $1",
            product_id
        )
        return dict(row) if row else None
    
    async def update_product(
        self,
        product_id: str,
        data: dict
    ) -> Optional[dict]:
        """Update product with cache invalidation."""
        
        # Update database
        product = await self.db.fetch_one(
            """
            UPDATE products 
            SET name = $2, price = $3, updated_at = NOW()
            WHERE id = $1
            RETURNING *
            """,
            product_id, data.get("name"), data.get("price")
        )
        
        if not product:
            return None
        
        # Invalidate all cache tiers
        await self.cache.invalidate(
            keys=[
                f"product:{product_id}",
                f"product_page:{product_id}",
            ],
            patterns=[
                f"products:*",  # Product lists
            ],
            cdn_urls=[
                f"/api/products/{product_id}",
                f"/api/products?*",
                f"/products/{product_id}",
            ]
        )
        
        return dict(product)
    
    async def get_products_list(
        self,
        category: str = None,
        page: int = 1,
        limit: int = 20
    ) -> dict:
        """Get product list with caching."""
        cache_key = f"products:list:{category or 'all'}:page{page}"
        
        return await self.cache.get(
            key=cache_key,
            fetch_func=lambda: self._fetch_products_list(category, page, limit),
            ttl=60  # Short TTL for lists
        )
    
    async def _fetch_products_list(
        self,
        category: str,
        page: int,
        limit: int
    ) -> dict:
        """Fetch product list from database."""
        offset = (page - 1) * limit
        
        if category:
            rows = await self.db.fetch(
                """
                SELECT * FROM products 
                WHERE category = $1 
                ORDER BY created_at DESC 
                LIMIT $2 OFFSET $3
                """,
                category, limit, offset
            )
        else:
            rows = await self.db.fetch(
                """
                SELECT * FROM products 
                ORDER BY created_at DESC 
                LIMIT $1 OFFSET $2
                """,
                limit, offset
            )
        
        return {
            "products": [dict(row) for row in rows],
            "page": page,
            "limit": limit
        }
    
    def get_response_headers(
        self,
        product: dict,
        authenticated: bool
    ) -> dict:
        """Get cache headers for product response."""
        return self.cache.get_cache_headers(
            ttl=60 if not authenticated else 0,
            private=authenticated,
            vary=["Accept-Encoding"] + (["Authorization"] if authenticated else []),
            etag=str(product.get("updated_at", ""))
        )