from contextlib import asynccontextmanager
from fastapi import FastAPI
from fastapi_rc import cachemanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup
    cachemanager.init(
        redis_url="redis://localhost:6379/0",
        max_connections=50,
        socket_timeout=5.0,
    )
    yield
    # Shutdown
    await cachemanager.close()

app = FastAPI(lifespan=lifespan)

from fastapi import APIRouter
from fastapi_rc import RedisClient, CacheServiceDep

router = APIRouter()

# Pattern 1: Direct Redis (full control)
@router.get("/users/{user_id}")
async def get_user(user_id: str, redis: RedisClient):
    cached = await redis.get(f"users:{user_id}")
    if cached:
        return {"user": json.loads(cached), "cached": True}

    user = await fetch_user_from_db(user_id)
    await redis.set(f"users:{user_id}", json.dumps(user), ex=300)
    return {"user": user, "cached": False}


# Pattern 2: CacheService (common patterns)
@router.get("/products")
async def list_products(cache: CacheServiceDep):
    products = await cache.get_or_set(
        identifier="all_products",
        factory=lambda: fetch_all_products_from_db(),
        ttl=600
    )
    return products

from fastapi_rc import RedisClient

@router.post("/batch")
async def batch_operation(redis: RedisClient):
    # Pipeline for bulk operations
    async with redis.pipeline(transaction=False) as pipe:
        for item in items:
            pipe.set(f"item:{item.id}", item.json(), ex=300)
        await pipe.execute()

    # Pattern-based invalidation
    async for key in redis.scan_iter("users:123:*"):
        await redis.delete(key)

from fastapi_rc import CacheService, RedisClient
from pydantic import BaseModel

class User(BaseModel):
    id: str
    email: str
    name: str

@router.get("/users/{user_id}")
async def get_user(user_id: str, redis: RedisClient):
    user_cache = CacheService(
        redis,
        namespace="users",
        model=User,
        default_ttl=600,
        use_jitter=True  # Prevents cache stampedes
    )

    # Cache-aside pattern (auto-fetch if missing)
    user = await user_cache.get_or_set(
        identifier=user_id,
        factory=lambda: db.get_user(user_id)
    )
    return user

# Custom dependency for your facet/domain
from typing import Annotated
from fastapi import Depends

async def get_gym_cache(redis: RedisClient) -> CacheService:
    return CacheService(
        redis,
        namespace="gym",
        default_ttl=1800,  # 30 minutes
        prefix="myapp",
        version="v1"
    )

GymCache = Annotated[CacheService, Depends(get_gym_cache)]

@router.get("/gym/stats/{user_id}")
async def get_gym_stats(user_id: str, gym_cache: GymCache):
    stats = await gym_cache.get_or_set(
        identifier=user_id,
        factory=lambda: calculate_gym_stats(user_id)
    )
    return stats

# Proactive deletion on write
@router.put("/users/{user_id}")
async def update_user(user_id: str, data: UserUpdate, redis: RedisClient):
    updated = await db.update_user(user_id, data)

    # Delete exact keys
    await redis.delete(f"users:{user_id}")

    # Pattern-based invalidation
    async for key in redis.scan_iter(f"users:{user_id}:*"):
        await redis.delete(key)

    return updated


# Or with CacheService
@router.delete("/products/{product_id}")
async def delete_product(product_id: str, redis: RedisClient):
    product_cache = CacheService(redis, "products")

    # Delete specific entry
    await product_cache.delete(product_id)

    # Invalidate all related entries
    count = await product_cache.invalidate_pattern(f"{product_id}:*")

    return {"deleted": True, "cache_invalidated": count}

from fastapi_rc import get_ttl_with_jitter

# Sessions (security-driven)
session_ttl = 1800  # 30 min

# Static config (rarely changes)
config_ttl = 86400  # 24 hrs

# Product catalog (balance freshness + load)
product_ttl = 900  # 15 min

# Search results (high change rate)
search_ttl = 60  # 1 min

# With jitter to prevent stampedes
ttl = get_ttl_with_jitter(base_ttl=300, jitter_percent=0.1)  # 300s ± 30s

# CacheService already handles errors gracefully
@router.get("/users/{user_id}")
async def get_user(user_id: str, redis: RedisClient):
    user_cache = CacheService(redis, "users")

    # Returns None if cache fails (doesn't crash)
    cached = await user_cache.get(user_id)
    if cached:
        return cached

    # Fallback to database
    return await db.get_user(user_id)

cachemanager.init(
    redis_url="redis://localhost:6379/0",      # Required
    max_connections=50,                         # Pool size (10-200)
    socket_timeout=5.0,                         # Socket timeout (seconds)
    socket_connect_timeout=2.0,                 # Connect timeout
    health_check_interval=30,                   # Ping interval
    decode_responses=True,                      # Auto-decode bytes to strings
)

cache = CacheService(
    redis=redis_client,                         # Required: Redis client
    namespace="users",                          # Required: Cache namespace
    model=User,                                 # Optional: Pydantic model for validation
    default_ttl=300,                            # Default: 300 seconds
    use_jitter=True,                            # Add TTL jitter (prevents stampedes)
    prefix="myapp",                             # Key prefix (default: "cache")
    version="v1",                               # Cache version (for invalidation)
)

@router.get("/health/redis")
async def redis_health():
    if not cachemanager.is_available:
        return {"status": "unavailable"}

    if await cachemanager.ping():
        return {"status": "healthy"}

    return {"status": "unhealthy"}

import pytest
from fakeredis import FakeAsyncRedis
from fastapi_rc import cachemanager

@pytest.fixture
async def fake_redis():
    return FakeAsyncRedis()

@pytest.fixture
def app_with_cache(fake_redis):
    # Override real Redis with fake
    cachemanager._client = fake_redis
    yield app
    cachemanager._client = None

def test_cached_endpoint(app_with_cache):
    client = TestClient(app_with_cache)

    # First request - cache miss
    response1 = client.get("/users/123")
    assert response1.json()["cached"] == False

    # Second request - cache hit
    response2 = client.get("/users/123")
    assert response2.json()["cached"] == True