import asyncio
import time
from fastapi import FastAPI, Depends, Header, Query
from fastapi.routing import APIRoute
from typing import Optional


# -----------------------
# Dependencies
# -----------------------

# Sync dependency
def get_token_header(x_token: str = Header(...)) -> str:
    if x_token != "secret-token":
        raise ValueError("Invalid token")
    return x_token


# Async dependency
async def get_query_param(q: Optional[str] = Query(None)) -> str:
    await asyncio.sleep(0.001)  # simulate small async delay
    return q or "default"


# Nested dependency (sync)
def get_user(token: str = Depends(get_token_header)) -> dict:
    return {"username": "test_user", "token": token}


# Nested dependency (async)
async def get_full_context(
    user: dict = Depends(get_user),
    query: str = Depends(get_query_param),
) -> dict:
    await asyncio.sleep(0.001)
    return {"user": user, "query": query}


# -----------------------
# App & route definition
# -----------------------

app = FastAPI()


@app.get("/items/{item_id}", dependencies=[Depends(get_token_header)])
async def read_item(
    item_id: int,
    context: dict = Depends(get_full_context),
) -> dict:
    return {"item_id": item_id, "context": context}


# -----------------------
# Performance test
# -----------------------

def test_get_route_handler_performance(loop_count: int = 50_000_000):
    route: APIRoute = app.routes[-1]
    assert route.path == '/items/{item_id}'

    start_time = time.perf_counter()

    for _ in range(loop_count):
        route.get_route_handler()

    duration = time.perf_counter() - start_time

    print(f"Called get_route_handler() {loop_count:,} times in {duration:.4f}s")
    print(f"Average per call: {duration / loop_count * 1e6:.2f} µs")


if __name__ == "__main__":
    test_get_route_handler_performance()