admin / Bid-Sentinel

"""Audit-trail capture: a writer + middleware that records app activity."""
from __future__ import annotations

import logging

from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request

from app.database import AsyncSessionLocal
from app.models import AuditLog
from app.security import decode_access_token

logger = logging.getLogger("audit")

_MUTATING = {"POST", "PATCH", "PUT", "DELETE"}
# Paths we don't audit (noise / handled explicitly elsewhere).
_SKIP_PREFIXES = ("/health", "/docs", "/openapi", "/auth/login")


async def write_audit(
    actor: str,
    action: str,
    detail: str = "",
    status_code: int | None = None,
    ip: str | None = None,
) -> None:
    """Persist one audit entry. Never raises (logging must not break requests)."""
    try:
        async with AsyncSessionLocal() as db:
            db.add(
                AuditLog(
                    actor=actor or "anonymous",
                    action=action[:255],
                    detail=(detail or "")[:512],
                    status_code=status_code,
                    ip=ip,
                )
            )
            await db.commit()
    except Exception as exc:  # noqa: BLE001
        logger.warning("Failed to write audit entry: %s", exc)


def actor_from_request(request: Request) -> str:
    auth = request.headers.get("authorization", "")
    if auth.lower().startswith("bearer "):
        payload = decode_access_token(auth[7:])
        if payload and payload.get("sub"):
            return payload["sub"]
    return "anonymous"


class AuditMiddleware(BaseHTTPMiddleware):
    """Logs every mutating request (POST/PATCH/PUT/DELETE) with actor + status."""

    async def dispatch(self, request: Request, call_next):
        response = await call_next(request)
        try:
            path = request.url.path
            if request.method in _MUTATING and not path.startswith(_SKIP_PREFIXES):
                ip = request.client.host if request.client else None
                await write_audit(
                    actor=actor_from_request(request),
                    action=f"{request.method} {path}",
                    status_code=response.status_code,
                    ip=ip,
                )
        except Exception as exc:  # noqa: BLE001
            logger.warning("Audit middleware error: %s", exc)
        return response