scripts/analyze.py

#!/usr/bin/env python3
"""
Analyse the consolidated LocalNet-Dynamics dataset.

Reads dataset/localnet_dynamics.parquet (or .csv), prints a text report and
writes dataset/analysis.json with every number the documentation quotes:
overall statistics, hour-of-day and day-by-day profiles, the two regimes
separated by a change point in the daily loss share, outage and high-latency
episodes with their diagnosis (path change, first hop, queueing), the
conditional effect of ICMP loss on the other probes, the ICMP/TCP path split,
DNS and HTTP facts, autocorrelation, speed-test quality and label statistics.

    python analyze.py
    python analyze.py --input dataset/localnet_dynamics.csv --no-report

The figures are rendered by plot_figures.py from the same functions.
"""

from __future__ import annotations

import argparse
import json
import sys
from datetime import datetime, timezone
from pathlib import Path

import numpy as np
import pandas as pd

ROOT = Path(__file__).resolve().parent.parent

METRICS = ["rtt_avg_ms", "rtt_min_ms", "rtt_max_ms", "jitter_ms", "packet_loss_pct",
           "gateway_rtt_avg_ms", "tcp_connect_min_ms", "tcp_connect_median_ms",
           "dns_resolve_ms", "dns_recursive_ms", "http_ms", "download_mbps", "upload_mbps"]
LABELS = ["label_outage", "label_packet_loss", "label_high_latency", "label_high_jitter",
          "label_gateway_degraded", "label_anomaly"]
ACF_LAGS_MIN = [0.5, 1, 2.5, 5, 10, 30, 60, 180, 360, 720, 1440]

# Latency episodes: runs of label_high_latency, merged across gaps of at most
# MERGE_GAP samples and kept when they span at least MIN_EPISODE_MIN minutes.
MERGE_GAP = 10
MIN_EPISODE_MIN = 30
# An episode whose first-hop RTT exceeds the run's gateway threshold is a
# first-hop event; one whose ICMP or TCP latency floor rises by at least
# FLOOR_SHIFT_MS over the run median is a path change; anything else is queueing.
FLOOR_SHIFT_MS = 5.0
TCP_SPLIT_MS = 5.0                 # TCP floor above ICMP floor by more than this
SPEEDTEST_PING_FAILED_MS = 600_000  # speedtest-cli counts a failed latency probe as 3600 s


# --------------------------------------------------------------------------- #
# Loading and helpers
# --------------------------------------------------------------------------- #

def load(path: Path) -> pd.DataFrame:
    df = pd.read_parquet(path) if path.suffix == ".parquet" else pd.read_csv(path, low_memory=False)
    df["ts"] = pd.to_datetime(df["timestamp_utc"], utc=True)
    df["ts_local"] = pd.to_datetime(df["timestamp_local"].astype(str).str[:19],
                                    format="%Y-%m-%dT%H:%M:%S", errors="coerce")
    for col in LABELS:
        if col in df.columns:
            df[col] = df[col].fillna(0).astype(int)
    for col in METRICS + ["gateway_packet_loss_pct", "packets_received", "speedtest_ping_ms"]:
        if col in df.columns:
            df[col] = pd.to_numeric(df[col], errors="coerce").astype(float)
    return df.sort_values("ts").reset_index(drop=True)


def q(series: pd.Series, p: float) -> float | None:
    v = series.dropna()
    return round(float(v.quantile(p)), 3) if len(v) else None


def describe(series: pd.Series) -> dict | None:
    v = series.dropna().astype(float)
    if v.empty:
        return None
    return {"n": int(v.size), "median": round(float(v.median()), 3), "mean": round(float(v.mean()), 3),
            "p95": round(float(v.quantile(0.95)), 3), "p99": round(float(v.quantile(0.99)), 3),
            "max": round(float(v.max()), 3)}


def share(mask: pd.Series) -> float:
    return round(100.0 * float(mask.mean()), 2) if len(mask) else 0.0


def change_point(series: pd.Series) -> tuple:
    """Split index that minimises the within-segment sum of squares (one break)."""
    x = series.dropna().values.astype(float)
    n = len(x)
    if n < 4:
        k = max(1, n // 2)
        return series.dropna().index[k], float(x[:k].mean()), float(x[k:].mean())
    cs, cs2 = np.cumsum(x), np.cumsum(x * x)
    best = None
    for k in range(2, n - 1):
        a = cs2[k - 1] - cs[k - 1] ** 2 / k
        b = (cs2[-1] - cs2[k - 1]) - (cs[-1] - cs[k - 1]) ** 2 / (n - k)
        if best is None or a + b < best[0]:
            best = (a + b, k)
    k = best[1]
    return series.dropna().index[k], float(x[:k].mean()), float(x[k:].mean())


def runs_of(mask: np.ndarray, merge_gap: int) -> list[tuple[int, int]]:
    idx = np.flatnonzero(mask)
    if idx.size == 0:
        return []
    runs, start, prev = [], idx[0], idx[0]
    for i in idx[1:]:
        if i - prev > merge_gap:
            runs.append((start, prev))
            start = i
        prev = i
    runs.append((start, prev))
    return runs


def acf(series: pd.Series, lag: int) -> float | None:
    s = series.astype(float)
    if lag >= len(s) - 2:
        return None
    value = s.autocorr(lag)
    return round(float(value), 3) if np.isfinite(value) else None


# --------------------------------------------------------------------------- #
# Sections
# --------------------------------------------------------------------------- #

def overview(df: pd.DataFrame, summary: dict | None) -> dict:
    span = (df["ts"].max() - df["ts"].min()).total_seconds() / 86400.0
    out = {
        "rows": int(len(df)),
        "runs": int(df["run_id"].nunique()),
        "first_utc": df["ts"].min().strftime("%Y-%m-%dT%H:%M:%SZ"),
        "last_utc": df["ts"].max().strftime("%Y-%m-%dT%H:%M:%SZ"),
        "first_local": str(df["timestamp_local"].iloc[0]),
        "last_local": str(df["timestamp_local"].iloc[-1]),
        "span_days": round(span, 2),
        "full_days": int((df.groupby("date_local").size() >= 2700).sum()),
        "coverage_pct": summary.get("coverage_pct") if summary else None,
        "max_gap_s": float(df["gap_before_s"].max()),
        "gaps_of_2_intervals": int((df["gap_before_s"] == 2 * df["interval_s"].median()).sum()),
        "gaps_over_2_intervals": int((df["gap_before_s"] > 2 * df["interval_s"].median()).sum()),
        "gaps_over_2_intervals_after_speedtest": int((df["download_mbps"].shift(1).notna()
                                                      & (df["gap_before_s"] > 2 * df["interval_s"].median())).sum()),
        "rows_with_notes": int(df["notes"].fillna("").astype(str).str.len().gt(0).sum()),
        "wifi_rows": int(df["wifi_signal_pct"].notna().sum()) if "wifi_signal_pct" in df else 0,
        "link_types": {str(k): int(v) for k, v in df["link_type"].value_counts().items()},
        "metrics": {c: describe(df[c]) for c in METRICS if c in df.columns and describe(df[c])},
    }
    return out


def hour_profile(df: pd.DataFrame) -> list[dict]:
    rows = []
    for hour, part in df.groupby("hour_local"):
        rows.append({
            "hour": int(hour), "n": int(len(part)),
            "rtt_median": q(part["rtt_avg_ms"], 0.5), "rtt_p25": q(part["rtt_avg_ms"], 0.25),
            "rtt_p75": q(part["rtt_avg_ms"], 0.75), "rtt_p95": q(part["rtt_avg_ms"], 0.95),
            "jitter_median": q(part["jitter_ms"], 0.5),
            "loss_share_pct": share(part["packet_loss_pct"] > 0),
            "loss_share_weekday_pct": share(part.loc[part["is_weekend"] == 0, "packet_loss_pct"] > 0),
            "loss_share_weekend_pct": share(part.loc[part["is_weekend"] == 1, "packet_loss_pct"] > 0),
            "http_p95": q(part["http_ms"], 0.95),
            "http_over_1s_pct": share(part["http_ms"].dropna() > 1000),
            "high_latency_pct": share(part["label_high_latency"] == 1),
            "gateway_p95": q(part["gateway_rtt_avg_ms"], 0.95),
        })
    return rows


def weekday_weekend(df: pd.DataFrame) -> dict:
    out = {}
    for name, part in (("weekday", df[df["is_weekend"] == 0]), ("weekend", df[df["is_weekend"] == 1])):
        out[name] = {"n": int(len(part)), "rtt_median": q(part["rtt_avg_ms"], 0.5),
                     "rtt_p95": q(part["rtt_avg_ms"], 0.95), "loss_share_pct": share(part["packet_loss_pct"] > 0),
                     "jitter_median": q(part["jitter_ms"], 0.5), "http_median": q(part["http_ms"], 0.5)}
    return out


def daily(df: pd.DataFrame) -> list[dict]:
    rows = []
    for date, part in df.groupby("date_local"):
        rows.append({
            "date": str(date), "weekday": int(part["weekday_local"].iloc[0]), "n": int(len(part)),
            "rtt_median": q(part["rtt_avg_ms"], 0.5), "rtt_p95": q(part["rtt_avg_ms"], 0.95),
            "rtt_min_median": q(part["rtt_min_ms"], 0.5),
            "tcp_min_median": q(part["tcp_connect_min_ms"], 0.5),
            "loss_share_pct": share(part["packet_loss_pct"] > 0),
            "mean_loss_pct": round(float(part["packet_loss_pct"].mean()), 3),
            "jitter_median": q(part["jitter_ms"], 0.5),
            "http_p95": q(part["http_ms"], 0.95),
            "anomaly_pct": share(part["label_anomaly"] == 1),
            "gateway_degraded": int(part["label_gateway_degraded"].sum()),
        })
    return rows


def period_stats(part: pd.DataFrame) -> dict:
    return {
        "n": int(len(part)),
        "days": int(part["date_local"].nunique()),
        "rtt_median": q(part["rtt_avg_ms"], 0.5), "rtt_p95": q(part["rtt_avg_ms"], 0.95),
        "rtt_p99": q(part["rtt_avg_ms"], 0.99),
        "jitter_median": q(part["jitter_ms"], 0.5), "jitter_p95": q(part["jitter_ms"], 0.95),
        "loss_share_pct": share(part["packet_loss_pct"] > 0),
        "mean_loss_pct": round(float(part["packet_loss_pct"].mean()), 3),
        "tcp_median": q(part["tcp_connect_median_ms"], 0.5),
        "dns_cached_median": q(part["dns_resolve_ms"], 0.5),
        "dns_recursive_median": q(part["dns_recursive_ms"], 0.5),
        "http_median": q(part["http_ms"], 0.5), "http_p95": q(part["http_ms"], 0.95),
        "http_over_1s_pct": share(part["http_ms"].dropna() > 1000),
        "labels_pct": {c: share(part[c] == 1) for c in LABELS},
    }


def regimes(df: pd.DataFrame) -> dict:
    daily_loss = df.groupby("date_local")["packet_loss_pct"].apply(lambda s: float((s > 0).mean()))
    if len(daily_loss) < 2:
        split, before, after = daily_loss.index[0], float(daily_loss.iloc[0]), float(daily_loss.iloc[0])
        first = second = df
    else:
        split, before, after = change_point(daily_loss)
        first = df[df["date_local"] < split]
        second = df[df["date_local"] >= split]
    return {
        "method": "single least-squares change point in the daily share of samples with ICMP loss",
        "split_date": str(split),
        "daily_loss_share_before_pct": round(100 * before, 2),
        "daily_loss_share_after_pct": round(100 * after, 2),
        "before": {"first_date": str(first["date_local"].min()), "last_date": str(first["date_local"].max()),
                   **period_stats(first)},
        "after": {"first_date": str(second["date_local"].min()), "last_date": str(second["date_local"].max()),
                  **period_stats(second)},
    }


def outages(df: pd.DataFrame) -> list[dict]:
    out = []
    for a, b in runs_of(df["label_outage"].values == 1, merge_gap=2):
        part = df.iloc[a:b + 1]
        interval = float(df["interval_s"].median())
        out.append({
            "start_local": str(part["timestamp_local"].iloc[0]),
            "end_local": str(part["timestamp_local"].iloc[-1]),
            "weekday": int(part["weekday_local"].iloc[0]),
            "samples": int(len(part)),
            "minutes": round((float(part["epoch_s"].iloc[-1] - part["epoch_s"].iloc[0]) + interval) / 60.0, 1),
            "gateway_unreachable": bool((part["gateway_packet_loss_pct"] == 100).all()),
            "gateway_loss_sample_before": float(df["gateway_packet_loss_pct"].iloc[a - 1]) if a > 0 else None,
        })
    return out


def latency_episodes(df: pd.DataFrame, thresholds: dict) -> list[dict]:
    """High-latency episodes with a diagnosis from the probe that moved."""
    out = []
    for run_id, part in df.groupby("run_id", sort=False):
        part = part.reset_index(drop=True)
        rtt_floor = float(part["rtt_min_ms"].median())
        tcp_floor = float(part["tcp_connect_min_ms"].median())
        gw_thr = (thresholds.get(run_id, {}).get("gateway_rtt_avg_ms") or {}).get("threshold")
        for a, b in runs_of(part["label_high_latency"].values == 1, MERGE_GAP):
            ep = part.iloc[a:b + 1]
            minutes = (float(ep["epoch_s"].iloc[-1] - ep["epoch_s"].iloc[0])) / 60.0
            if minutes < MIN_EPISODE_MIN:
                continue
            rtt_min_med = float(ep["rtt_min_ms"].median())
            tcp_min_med = float(ep["tcp_connect_min_ms"].median())
            gw_med = float(ep["gateway_rtt_avg_ms"].median())
            if gw_thr is not None and gw_med > gw_thr:
                kind = "first hop"
            elif max(rtt_min_med - rtt_floor, tcp_min_med - tcp_floor) >= FLOOR_SHIFT_MS:
                kind = "path change"
            else:
                kind = "queueing"
            out.append({
                "run_id": run_id,
                "start_local": str(ep["timestamp_local"].iloc[0]),
                "end_local": str(ep["timestamp_local"].iloc[-1]),
                "weekday": int(ep["weekday_local"].iloc[0]),
                "hours": round(minutes / 60.0, 2),
                "samples": int(len(ep)),
                "labelled_samples": int(ep["label_high_latency"].sum()),
                "rtt_min_median": round(rtt_min_med, 2),
                "rtt_avg_median": q(ep["rtt_avg_ms"], 0.5),
                "tcp_min_median": round(tcp_min_med, 2),
                "gateway_median": round(gw_med, 2),
                "jitter_median": q(ep["jitter_ms"], 0.5),
                "dns_cached_median": q(ep["dns_resolve_ms"], 0.5),
                "http_median": q(ep["http_ms"], 0.5),
                "loss_share_pct": share(ep["packet_loss_pct"] > 0),
                "run_rtt_min_median": round(rtt_floor, 2),
                "run_tcp_min_median": round(tcp_floor, 2),
                "kind": kind,
            })
    return out


def loss_analysis(df: pd.DataFrame) -> dict:
    ok = df[df["label_outage"] == 0]
    received = ok["packets_received"].dropna().astype(int)
    classes = {
        "no_loss": ok[ok["packet_loss_pct"] == 0],
        "one_lost": ok[ok["packets_received"] == ok["packets_sent"] - 1],
        "two_plus_lost": ok[(ok["packets_received"] <= ok["packets_sent"] - 2) & (ok["packets_received"] > 0)],
    }
    conditional = {}
    for name, part in classes.items():
        conditional[name] = {
            "n": int(len(part)),
            "rtt_median": q(part["rtt_avg_ms"], 0.5),
            "jitter_median": q(part["jitter_ms"], 0.5),
            "tcp_median": q(part["tcp_connect_median_ms"], 0.5),
            "tcp_p95": q(part["tcp_connect_median_ms"], 0.95),
            "tcp_missing_pct": share(part["tcp_connect_median_ms"].isna()),
            "http_median": q(part["http_ms"], 0.5),
            "http_p95": q(part["http_ms"], 0.95),
            "http_over_1s_pct": share(part["http_ms"].dropna() > 1000),
            "dns_recursive_over_200ms_pct": share(part["dns_recursive_ms"].dropna() > 200),
            "gateway_loss_pct": share(part["gateway_packet_loss_pct"] > 0),
        }
    indicator = (df["packet_loss_pct"] > 0).astype(int)
    p_loss = float(indicator.mean())
    p_cond = float(indicator[1:][indicator[:-1].values == 1].mean())
    return {
        "samples_with_loss_pct": share(df["packet_loss_pct"] > 0),
        "mean_loss_pct": round(float(df["packet_loss_pct"].mean()), 3),
        "packets_received_counts": {int(k): int(v) for k, v in received.value_counts().sort_index().items()},
        "gateway_loss_samples_pct": share(df["gateway_packet_loss_pct"] > 0),
        "gateway_loss_outside_outages_samples": int((ok["gateway_packet_loss_pct"] > 0).sum()),
        "persistence": {"p_loss": round(p_loss, 4), "p_loss_given_previous_loss": round(p_cond, 4),
                        "ratio": round(p_cond / p_loss, 2) if p_loss else None},
        "conditional": conditional,
    }


def tcp_icmp(df: pd.DataFrame) -> dict:
    gap = df["tcp_connect_min_ms"] - df["rtt_min_ms"]
    hourly = (gap > TCP_SPLIT_MS).astype(float).groupby(df["ts_local"].dt.floor("h")).mean()
    split, before, after = change_point(hourly)
    sec = df[df["ts_local"] >= split]
    v = sec["tcp_connect_min_ms"].dropna()
    return {
        "tcp_min_minus_icmp_min_median_ms": round(float(gap.median()), 3),
        "tcp_median_minus_icmp_avg_median_ms": round(float((df["tcp_connect_median_ms"] - df["rtt_avg_ms"]).median()), 3),
        "split_local": split.strftime("%Y-%m-%dT%H:%M"),
        "long_path_share_before_pct": round(100 * before, 2),
        "long_path_share_after_pct": round(100 * after, 2),
        "after_split": {
            "tcp_min_p25": q(v, 0.25), "tcp_min_median": q(v, 0.5), "tcp_min_p75": q(v, 0.75),
            "icmp_min_median": q(sec["rtt_min_ms"], 0.5), "icmp_avg_median": q(sec["rtt_avg_ms"], 0.5),
            "share_tcp_min_over_17ms_pct": share(v > 17),
        },
        "before_split": {
            "tcp_min_median": q(df.loc[df["ts_local"] < split, "tcp_connect_min_ms"], 0.5),
            "icmp_min_median": q(df.loc[df["ts_local"] < split, "rtt_min_ms"], 0.5),
        },
    }


def dns_http(df: pd.DataFrame) -> dict:
    c, r, h = df["dns_resolve_ms"].dropna(), df["dns_recursive_ms"].dropna(), df["http_ms"].dropna()
    return {
        "dns_cached": {"median": q(c, 0.5), "p05": q(c, 0.05), "p95": q(c, 0.95),
                       "share_under_15ms_pct": share(c < 15), "share_under_5ms_pct": share(c < 5)},
        "dns_recursive": {"median": q(r, 0.5), "p95": q(r, 0.95), "p99": q(r, 0.99),
                          "share_over_200ms_pct": share(r > 200)},
        "dns_recursive_minus_cached_median_ms": round(float((df["dns_recursive_ms"] - df["dns_resolve_ms"]).median()), 2),
        "dns_timeouts": int(df["notes"].fillna("").astype(str).str.contains("dns: timeout|dns recursive: timeout").sum()),
        "dns_timeouts_during_outages": int((df["notes"].fillna("").astype(str).str.contains("dns: timeout|dns recursive: timeout")
                                            & (df["label_outage"] == 1)).sum()),
        "http": {"median": q(h, 0.5), "p90": q(h, 0.9), "p95": q(h, 0.95), "p99": q(h, 0.99),
                 "share_1000_1400ms_pct": share((h >= 1000) & (h < 1400)),
                 "share_3900_4400ms_pct": share((h >= 3900) & (h < 4400)),
                 "share_over_1s_pct": share(h > 1000), "share_over_5s_pct": share(h > 5000),
                 "timeouts": int(df["notes"].fillna("").astype(str).str.contains("http: timed out").sum()),
                 "status_counts": {str(int(k)): int(v) for k, v in df["http_status"].dropna().value_counts().items()}},
    }


def autocorrelation(df: pd.DataFrame) -> dict:
    interval = float(df["interval_s"].median())
    lags = [max(1, int(round(m * 60 / interval))) for m in ACF_LAGS_MIN]
    series = {
        "rtt_avg_ms": df["rtt_avg_ms"],
        "log_rtt_avg_ms": np.log(df["rtt_avg_ms"]),
        "jitter_ms": df["jitter_ms"],
        "loss_indicator": (df["packet_loss_pct"] > 0).astype(float),
        "tcp_connect_min_ms": df["tcp_connect_min_ms"],
        "dns_recursive_ms": df["dns_recursive_ms"],
        "http_ms": df["http_ms"],
    }
    return {"lag_minutes": ACF_LAGS_MIN, "lag_samples": lags,
            "values": {name: [acf(s, l) for l in lags] for name, s in series.items()}}


def speedtest(df: pd.DataFrame) -> dict:
    sp = df[df["download_mbps"].notna()].copy()
    if sp.empty:
        return {"tests": 0}
    failed_ping = sp["speedtest_ping_ms"].isna() | (sp["speedtest_ping_ms"] >= SPEEDTEST_PING_FAILED_MS)
    top = (sp.groupby("speedtest_server")
             .agg(n=("download_mbps", "size"), download_median=("download_mbps", "median"),
                  download_max=("download_mbps", "max"), upload_median=("upload_mbps", "median"),
                  ping_median=("speedtest_ping_ms", "median"))
             .sort_values("n", ascending=False).head(10))
    return {
        "tests": int(len(sp)),
        "servers": int(sp["speedtest_server"].nunique()),
        "failed_latency_probe": int(failed_ping.sum()),
        "zero_download": int((sp["download_mbps"] == 0).sum()),
        "zero_upload": int((sp["upload_mbps"] == 0).sum()),
        "download": describe(sp["download_mbps"]),
        "upload": describe(sp["upload_mbps"]),
        "download_quantiles": {str(p): q(sp["download_mbps"], p) for p in (0.1, 0.25, 0.5, 0.75, 0.9)},
        "upload_quantiles": {str(p): q(sp["upload_mbps"], p) for p in (0.1, 0.25, 0.5, 0.75, 0.9)},
        "ping_valid": describe(sp.loc[~failed_ping, "speedtest_ping_ms"]),
        "download_median_night_0_4": q(sp.loc[sp["hour_local"].between(0, 4), "download_mbps"], 0.5),
        "download_median_day_9_16": q(sp.loc[sp["hour_local"].between(9, 16), "download_mbps"], 0.5),
        "sample_duration_median_s": q(sp["sample_duration_s"], 0.5),
        "top_servers": [{"server": str(k), **{c: (int(v) if c == "n" else round(float(v), 1)) for c, v in row.items()}}
                        for k, row in top.iterrows()],
    }


def labels(df: pd.DataFrame) -> dict:
    M = df[LABELS[:-1]]
    return {
        "counts": {c: int(df[c].sum()) for c in LABELS},
        "share_pct": {c: share(df[c] == 1) for c in LABELS},
        "exactly_one_label": int((M.sum(axis=1) == 1).sum()),
        "two_or_more_labels": int((M.sum(axis=1) >= 2).sum()),
        "high_latency_in_episodes_pct": None,
    }


# --------------------------------------------------------------------------- #
# Report
# --------------------------------------------------------------------------- #

def analyse(df: pd.DataFrame, summary: dict | None) -> dict:
    thresholds = {r["run_id"]: r.get("thresholds", {}) for r in (summary or {}).get("runs", [])}
    eps = latency_episodes(df, thresholds)
    result = {
        "generated_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
        "overview": overview(df, summary),
        "hour_profile": hour_profile(df),
        "weekday_weekend": weekday_weekend(df),
        "daily": daily(df),
        "regimes": regimes(df),
        "outages": outages(df),
        "latency_episodes": eps,
        "loss": loss_analysis(df),
        "tcp_icmp": tcp_icmp(df),
        "dns_http": dns_http(df),
        "autocorrelation": autocorrelation(df),
        "speedtest": speedtest(df),
        "labels": labels(df),
    }
    total = int(df["label_high_latency"].sum())
    inside = sum(e["labelled_samples"] for e in eps)
    result["labels"]["high_latency_in_episodes_pct"] = round(100.0 * inside / total, 1) if total else None
    result["labels"]["episode_kinds"] = {k: sum(1 for e in eps if e["kind"] == k)
                                         for k in ("path change", "first hop", "queueing")}
    return result


def print_report(r: dict) -> None:
    o = r["overview"]
    print(f"rows {o['rows']:,}  runs {o['runs']}  span {o['span_days']} days  "
          f"{o['first_utc']} -> {o['last_utc']}  coverage {o['coverage_pct']} %")
    print()
    print(f"{'metric':<24}{'n':>8}{'median':>10}{'mean':>10}{'p95':>10}{'p99':>10}{'max':>12}")
    for col, d in o["metrics"].items():
        print(f"{col:<24}{d['n']:>8}{d['median']:>10.2f}{d['mean']:>10.2f}{d['p95']:>10.2f}"
              f"{d['p99']:>10.2f}{d['max']:>12.2f}")
    g = r["regimes"]
    print()
    print(f"regimes (split {g['split_date']}):")
    for name in ("before", "after"):
        p = g[name]
        print(f"  {name:<7}{p['first_date']} .. {p['last_date']}  n={p['n']:,}  rtt med {p['rtt_median']}  "
              f"p95 {p['rtt_p95']}  loss {p['loss_share_pct']} %  jitter med {p['jitter_median']}  "
              f"http>1s {p['http_over_1s_pct']} %  anomaly {p['labels_pct']['label_anomaly']} %")
    print()
    print(f"outages: {len(r['outages'])}")
    for e in r["outages"]:
        print(f"  {e['start_local'][:16]}  {e['minutes']} min  {e['samples']} samples  "
              f"gateway unreachable: {e['gateway_unreachable']}")
    print()
    print(f"high-latency episodes >= {MIN_EPISODE_MIN} min: {len(r['latency_episodes'])}")
    for e in r["latency_episodes"]:
        print(f"  {e['start_local'][:16]} -> {e['end_local'][11:16]}  {e['hours']:>5.2f} h  "
              f"rtt min {e['rtt_min_median']:>5.1f}  avg {e['rtt_avg_median']:>5.1f}  tcp min {e['tcp_min_median']:>5.1f}  "
              f"gw {e['gateway_median']:>5.1f}  {e['kind']}")
    t = r["tcp_icmp"]
    print()
    print(f"tcp/icmp: floor offset {t['tcp_min_minus_icmp_min_median_ms']} ms; long-path share "
          f"{t['long_path_share_before_pct']} % -> {t['long_path_share_after_pct']} % from {t['split_local']}")
    L = r["loss"]
    print(f"loss: {L['samples_with_loss_pct']} % of samples; P(loss|loss) = {L['persistence']['p_loss_given_previous_loss']}"
          f" vs {L['persistence']['p_loss']}")
    for name, c in L["conditional"].items():
        print(f"  {name:<14}n={c['n']:>6}  jitter med {c['jitter_median']:.2f}  tcp med {c['tcp_median']:.2f}  "
              f"http>1s {c['http_over_1s_pct']:.2f} %  dns rec>200ms {c['dns_recursive_over_200ms_pct']:.2f} %")
    s = r["speedtest"]
    if s.get("tests"):
        print(f"speed tests: {s['tests']} on {s['servers']} servers, {s['failed_latency_probe']} failed latency probes, "
              f"{s['zero_download']} zero downloads; download median {s['download']['median']} max {s['download']['max']}; "
              f"upload median {s['upload']['median']} p95 {s['upload']['p95']}")
    print()
    print("labels:")
    for col, n in r["labels"]["counts"].items():
        print(f"  {col:<24}{n:>8}  ({r['labels']['share_pct'][col]} %)")
    print()
    print("hour-of-day (local):")
    print(f"{'hour':>4}{'n':>7}{'rtt med':>9}{'rtt p95':>9}{'loss %':>8}{'wkday %':>9}{'wkend %':>9}{'http>1s %':>11}{'hi-lat %':>10}")
    for h in r["hour_profile"]:
        print(f"{h['hour']:>4}{h['n']:>7}{h['rtt_median']:>9.2f}{h['rtt_p95']:>9.2f}{h['loss_share_pct']:>8.2f}"
              f"{h['loss_share_weekday_pct']:>9.2f}{h['loss_share_weekend_pct']:>9.2f}{h['http_over_1s_pct']:>11.2f}"
              f"{h['high_latency_pct']:>10.2f}")


def main(argv: list[str] | None = None) -> int:
    p = argparse.ArgumentParser(description="Statistics and findings for the consolidated dataset.")
    p.add_argument("--input", default=None,
                   help="consolidated parquet or CSV (default: dataset/localnet_dynamics.parquet)")
    p.add_argument("--summary", default=None, help="summary.json written by build_dataset.py")
    p.add_argument("--output", default=None, help="analysis JSON (default: dataset/analysis.json)")
    p.add_argument("--no-report", action="store_true", help="write the JSON without printing the report")
    args = p.parse_args(argv)

    path = Path(args.input) if args.input else ROOT / "dataset" / "localnet_dynamics.parquet"
    if not path.exists() and not args.input:
        path = ROOT / "dataset" / "localnet_dynamics.csv"
    if not path.exists():
        raise SystemExit(f"{path} not found; run build_dataset.py first")
    summary_path = Path(args.summary) if args.summary else path.parent / "summary.json"
    summary = json.loads(summary_path.read_text(encoding="utf-8")) if summary_path.exists() else None

    df = load(path)
    result = analyse(df, summary)
    out = Path(args.output) if args.output else path.parent / "analysis.json"
    out.write_text(json.dumps(result, indent=2), encoding="utf-8")
    if not args.no_report:
        print_report(result)
        print()
    print(f"analysis written to {out}")
    return 0


if __name__ == "__main__":
    sys.exit(main())