"""Benchmark the routers on identical scenarios.

    python examples/benchmark_routers.py                       # data/
    python examples/benchmark_routers.py --data data_small --reference potential --csv figures/benchmark.csv

Every episode is replayed under every router, so the comparison is *paired*: for each router the
script reports its per-episode difference to a reference router (loss ratio, mean delay) with a
bootstrap 95 % confidence interval over episodes and the fraction of episodes it wins, then
breaks the loss ratio down by each design factor and the flow-level path stretch and queueing
delay. The script also asserts the structural properties the analysis relies on (every episode
present under every router, aligned pairs), so it doubles as an end-to-end read test.
"""
import argparse
import sys
from pathlib import Path

import numpy as np
import pandas as pd

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))

from src.dataset import FACTORS, Dataset  # noqa: E402

METRICS = ["loss_ratio", "mean_delay", "p99_delay", "link_utilisation", "link_saturation", "route_changes"]


def bootstrap_ci(values: np.ndarray, rng: np.random.Generator, samples: int = 2000, level: float = 0.95):
    """Percentile bootstrap confidence interval of the mean over episodes."""
    means = rng.choice(values, size=(samples, len(values)), replace=True).mean(axis=1)
    lo, hi = np.percentile(means, [50 * (1 - level), 50 * (1 + level)])
    return values.mean(), lo, hi


def paired_table(summary: pd.DataFrame, reference: str, rng: np.random.Generator) -> pd.DataFrame:
    wide = {m: summary.pivot(index="episode_id", columns="router", values=m) for m in ("loss_ratio", "mean_delay")}
    rows = []
    for router in wide["loss_ratio"].columns:
        if router == reference:
            continue
        d_loss = (wide["loss_ratio"][router] - wide["loss_ratio"][reference]).to_numpy()
        pair = wide["mean_delay"][[router, reference]].dropna()   # NaN delay only if nothing was delivered
        d_delay = (pair[router] - pair[reference]).to_numpy()
        m, lo, hi = bootstrap_ci(d_loss, rng)
        md, dlo, dhi = bootstrap_ci(d_delay, rng)
        rows.append({"router": router, "episodes": len(d_loss),
                     "loss_diff": m, "loss_ci_low": lo, "loss_ci_high": hi,
                     "wins_loss": np.mean(d_loss < 0), "ties_loss": np.mean(d_loss == 0),
                     "delay_diff": md, "delay_ci_low": dlo, "delay_ci_high": dhi,
                     "wins_delay": np.mean(d_delay < 0)})
    return pd.DataFrame(rows).set_index("router")


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
    parser.add_argument("--reference", default="shortest_path", help="router the others are compared with")
    parser.add_argument("--csv", type=Path, default=None, help="write the per-episode joined summary here")
    parser.add_argument("--seed", type=int, default=0, help="bootstrap seed")
    args = parser.parse_args()
    pd.set_option("display.width", 160)
    pd.set_option("display.precision", 4)

    ds = Dataset(args.data)
    summary = ds.summary("router_summary")
    routers = list(ds.routers)
    assert set(summary.router) == set(routers), "router_summary does not contain every configured router"
    per_episode = summary.groupby("episode_id").router.nunique()
    assert (per_episode == len(routers)).all(), "every episode must be present under every router"
    assert args.reference in routers, f"--reference must be one of {routers}"
    print(f"{ds.path}: {summary.episode_id.nunique()} episodes x {len(routers)} routers, "
          f"{len(ds.config.cells)} design cells\n")

    print("Mean over episodes:")
    print(summary.groupby("router")[METRICS].mean().loc[routers].to_string(), "\n")

    print(f"Paired differences to '{args.reference}' (negative = better; bootstrap 95 % CI over episodes):")
    print(paired_table(summary, args.reference, np.random.default_rng(args.seed)).to_string(), "\n")

    for factor in FACTORS:
        if summary[factor].nunique() > 1:
            print(f"Mean loss ratio by {factor}:")
            print(summary.pivot_table(index=factor, columns="router", values="loss_ratio", aggfunc="mean")[routers]
                  .to_string(), "\n")

    flows = ds.summary("flow_summary")
    delivered = flows[flows.delivered > 0].copy()
    delivered["path_stretch"] = delivered.mean_hops / delivered.min_hops
    delivered["latency_stretch"] = delivered.mean_path_latency / delivered.min_latency
    print("Flow level (flows with at least one delivered packet):")
    print(delivered.groupby("router").agg(flows=("flow", "size"), lossless_share=("dropped", lambda d: np.mean(d == 0)),
                                           path_stretch=("path_stretch", "mean"),
                                           latency_stretch=("latency_stretch", "mean"),
                                           queueing_delay=("mean_queueing_delay", "mean"),
                                           p99_delay=("p99_delay", "mean")).loc[routers].to_string(), "\n")

    if args.csv:
        args.csv.parent.mkdir(parents=True, exist_ok=True)
        summary.to_csv(args.csv, index=False)
        print(f"Per-episode summary written to {args.csv}")
    print("All checks passed.")


if __name__ == "__main__":
    main()