"""Bounded in-process metrics (no Prometheus dependency).

Not for multi-worker aggregation — Phase-1 uses a single Uvicorn worker.
"""

from __future__ import annotations

import threading
import time
from collections import defaultdict, deque
from typing import Any


class _Metrics:
    def __init__(self, *, max_latency_samples: int = 256) -> None:
        self._lock = threading.Lock()
        self._counters: dict[str, int] = defaultdict(int)
        self._latency_ms: dict[str, deque[float]] = defaultdict(
            lambda: deque(maxlen=max_latency_samples)
        )
        self._started_at = time.time()

    def incr(self, name: str, value: int = 1) -> None:
        with self._lock:
            self._counters[name] += int(value)

    def observe_ms(self, name: str, duration_ms: float) -> None:
        with self._lock:
            self._latency_ms[name].append(float(duration_ms))

    def snapshot(self) -> dict[str, Any]:
        with self._lock:
            lat: dict[str, Any] = {}
            for key, samples in self._latency_ms.items():
                if not samples:
                    continue
                ordered = sorted(samples)
                n = len(ordered)
                p95 = ordered[min(n - 1, int(n * 0.95))]
                lat[key] = {
                    "count": n,
                    "avg_ms": round(sum(ordered) / n, 2),
                    "p95_ms": round(p95, 2),
                    "max_ms": round(ordered[-1], 2),
                }
            return {
                "uptime_seconds": round(time.time() - self._started_at, 1),
                "counters": dict(self._counters),
                "latency": lat,
            }

    def reset_for_tests(self) -> None:
        with self._lock:
            self._counters.clear()
            self._latency_ms.clear()
            self._started_at = time.time()


metrics = _Metrics()
