# Paralléliser des appels I/O indépendants avec asyncio.gather
import asyncio
import httpx


async def get_dashboard_data(user_id: int):
    async with httpx.AsyncClient() as client:
        # les 3 appels partent EN MÊME TEMPS, pas l'un après l'autre
        orders_task = client.get(f"https://api.example.com/users/{user_id}/orders")
        stats_task = client.get(f"https://api.example.com/users/{user_id}/stats")
        notifications_task = client.get(f"https://api.example.com/users/{user_id}/notifications")

        orders, stats, notifications = await asyncio.gather(orders_task, stats_task, notifications_task)

    return {
        "orders": orders.json(),
        "stats": stats.json(),
        "notifications": notifications.json(),
    }

# Connection pooling HTTP réutilisable — un seul client partagé, pas un par requête
from contextlib import asynccontextmanager

http_client: httpx.AsyncClient | None = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    global http_client
    http_client = httpx.AsyncClient(
        limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
        timeout=httpx.Timeout(10.0, connect=5.0),
    )
    yield
    await http_client.aclose()


app = FastAPI(lifespan=lifespan)


@app.get("/proxy/{path:path}")
async def proxy(path: str):
    response = await http_client.get(f"https://api.example.com/{path}")
    return response.json()

# Pool de connexions DB dimensionné correctement — sous-dimensionné = requêtes en attente
engine = create_async_engine(
    DATABASE_URL,
    pool_size=20,            # connexions permanentes : ~ (nb workers * concurrence attendue)
    max_overflow=10,          # marge temporaire sous pic de charge
    pool_timeout=30,           # délai d'attente avant erreur si le pool est saturé
    pool_recycle=1800,          # recycle les connexions après 30 min (évite les timeouts DB/firewall)
)

# Cache applicatif — éviter de recalculer/re-fetcher des données coûteuses et peu volatiles
from functools import lru_cache
import time

_cache: dict[str, tuple[float, Any]] = {}


async def get_cached_or_fetch(key: str, ttl_seconds: int, fetch_fn):
    now = time.time()
    if key in _cache:
        cached_at, value = _cache[key]
        if now - cached_at < ttl_seconds:
            return value

    value = await fetch_fn()
    _cache[key] = (now, value)
    return value


@app.get("/expensive-report")
async def expensive_report():
    return await get_cached_or_fetch("report", ttl_seconds=300, fetch_fn=compute_heavy_report)

# Cache Redis pour un environnement multi-instances (le cache mémoire local n'est PAS partagé)
import redis.asyncio as redis
import json

redis_client = redis.from_url("redis://localhost:6379")


async def get_product_cached(product_id: int, db: AsyncSession) -> dict:
    cache_key = f"product:{product_id}"

    cached = await redis_client.get(cache_key)
    if cached:
        return json.loads(cached)

    product = await db.get(Product, product_id)
    data = {"id": product.id, "name": product.name, "price": product.price}

    await redis_client.set(cache_key, json.dumps(data), ex=300)  # expire après 5 minutes
    return data

# Lancer plusieurs workers Uvicorn pour exploiter tous les cœurs CPU
uvicorn app.main:app --workers 4 --host 0.0.0.0 --port 8000