"""Bound public auth bodies before FastAPI assembles JSON for validation."""
from __future__ import annotations

from starlette.exceptions import HTTPException
from starlette.responses import JSONResponse
from starlette.types import ASGIApp, Message, Receive, Scope, Send

from hermes_cli.dashboard_auth.middleware import _path_is_public

# Auth exchanges contain credentials and tokens, not files. Leave ample room for
# those small JSON payloads without allowing anonymous, unbounded buffering.
AUTH_BODY_LIMIT: int = 64 * 1024


class _AuthBodyTooLarge(HTTPException):
    def __init__(self) -> None:
        super().__init__(status_code=413, detail="Request body too large")


class AuthBodyLimitMiddleware:
    def __init__(self, app: ASGIApp) -> None:
        self.app = app

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        if (scope["type"] != "http" or scope["method"] != "POST"
                or not scope["path"].startswith("/auth/")
                or not _path_is_public(scope["path"])):
            await self.app(scope, receive, send)
            return

        response = JSONResponse({"detail": "Request body too large"}, status_code=413)
        for name, value in scope.get("headers", []):
            if name == b"content-length":
                try:
                    length = int(value)
                except ValueError:
                    continue
                if length > AUTH_BODY_LIMIT:
                    await response(scope, receive, send)
                    return

        received = 0
        started = False

        async def limited_receive() -> Message:
            nonlocal received
            message = await receive()
            if message["type"] == "http.request":
                received += len(message.get("body", b""))
                if received > AUTH_BODY_LIMIT:
                    # HTTPException survives FastAPI's JSON parsing error handler.
                    raise _AuthBodyTooLarge()
            return message

        async def tracked_send(message: Message) -> None:
            nonlocal started
            if message["type"] == "http.response.start":
                started = True
            await send(message)

        try:
            await self.app(scope, limited_receive, tracked_send)
        except _AuthBodyTooLarge:
            if started:
                raise
            await response(scope, receive, send)