"""Analyze a recorded events JSONL for pitch count, plate_y calibration, PCI stability."""

from __future__ import annotations

import json

import sys

from collections import defaultdict

from pathlib import Path

import numpy as np

from rich.console import Console

console = Console()

def load_events(path: Path) -> list[dict]:

    out: list[dict] = []

    with open(path, "r", encoding="utf-8") as f:

        for line in f:

            line = line.strip()

            if not line:

                continue

            try:

                out.append(json.loads(line))

            except Exception:

                pass

    return out

def analyze(events: list[dict]) -> None:

    ball_tracks = [e for e in events if e.get("type") == "ball_track"]

    ball_misses = [e for e in events if e.get("type") == "ball_miss"]

    pitch_preds = [e for e in events if e.get("type") == "pitch_pred"]

    pci_tracks = [e for e in events if e.get("type") == "pci_track"]

    pci_misses = [e for e in events if e.get("type") == "pci_miss"]

    total_ball = len(ball_tracks) + len(ball_misses)

    total_pci = len(pci_tracks) + len(pci_misses)

    console.print("[bold]Session totals[/bold]")

    console.print(f"  ball: {len(ball_tracks)}/{total_ball} hits ({100*len(ball_tracks)/max(total_ball,1):.1f}%), {len(pitch_preds)} predictions")

    console.print(f"  pci:  {len(pci_tracks)}/{total_pci} hits ({100*len(pci_tracks)/max(total_pci,1):.1f}%)")

    pitches: dict[int, list[dict]] = defaultdict(list)

    for e in ball_tracks:

        pid = int(e.get("pitch_id", 0))

        pitches[pid].append(e)

    console.print(f"\n[bold]Pitches detected[/bold]: {len(pitches)}")

    max_ys = []

    preds_per_pitch: dict[int, list[dict]] = defaultdict(list)

    for pp in pitch_preds:

        preds_per_pitch[int(pp.get("pitch_id", 0))].append(pp)

    for pid in sorted(pitches.keys()):

        pts = pitches[pid]

        if len(pts) < 2:

            continue

        xs = np.array([p["x"] for p in pts])

        ys = np.array([p["y"] for p in pts])

        ts = np.array([p["ts_ns"] for p in pts])

        dur_ms = (ts[-1] - ts[0]) / 1e6

        max_y = float(ys.max())

        y_delta = float(ys.max() - ys.min())

        pred_n = len(preds_per_pitch.get(pid, []))

        console.print(

            f"  pitch #{pid:3d}  n={len(pts):3d}  dur={dur_ms:6.0f}ms  "

            f"x=({xs.min():.0f}..{xs.max():.0f})  y=({ys.min():.0f}..{ys.max():.0f})  "

            f"max_y={max_y:.0f}  dy={y_delta:.0f}  preds={pred_n}"

        )

        if y_delta >= 100:

            max_ys.append(max_y)

    console.print("\n[bold]plate_y calibration[/bold]")

    if max_ys:

        arr = np.array(max_ys)

        console.print(f"  real pitches (dy>=100px): {len(arr)}")

        console.print(f"  max_y stats: mean={arr.mean():.1f}  p50={np.percentile(arr,50):.1f}  p95={np.percentile(arr,95):.1f}  max={arr.max():.1f}")

        rec = float(np.percentile(arr, 90)) / 1080.0

        console.print(f"  [green]suggested plate_y_frac ~= {rec:.3f}[/green]  (was 0.72)")

    else:

        console.print("  no pitches with >=100px y-delta - probably none captured or trajectories too short")

    console.print("\n[bold]PCI centroid stability[/bold]")

    if pci_tracks:

        xs = np.array([p["x"] for p in pci_tracks])

        ys = np.array([p["y"] for p in pci_tracks])

        console.print(f"  samples: {len(pci_tracks)}")

        console.print(f"  x: mean={xs.mean():.0f}  std={xs.std():.0f}  range=({xs.min():.0f}..{xs.max():.0f})")

        console.print(f"  y: mean={ys.mean():.0f}  std={ys.std():.0f}  range=({ys.min():.0f}..{ys.max():.0f})")

    else:

        console.print("  no PCI hits recorded")

def main() -> int:

    if len(sys.argv) < 2:

        console.print("usage: analyze_session.py <events.jsonl>")

        return 2

    events = load_events(Path(sys.argv[1]))

    console.print(f"loaded {len(events)} events from {sys.argv[1]}")

    analyze(events)

    return 0

if __name__ == "__main__":

    sys.exit(main())