"""Validate a generated dataset: structure, design coverage, physical invariants and reproducibility.

    python scripts/validate_dataset.py                 # validates data/
    python scripts/validate_dataset.py --out data_large --resimulate 5

Checks, in order: every shard has every table; the design is balanced and the splits present;
packet conservation and metric consistency across the summary and telemetry tables; buffers,
link loads and potentials respect their physical bounds; a sample of episodes re-simulated from
``config.json`` reproduces the stored tables bit for bit; and a stored potential-field snapshot
is recovered from the graph state and queue depths with the sparse SuperLU reference solver.
Exits with status 1 if any check fails.

The step-level tables are far larger than memory at the full design (``flow_telemetry`` alone is
episodes x routers x steps x tracked_flows = 2.6e8 rows), so every check over them streams the
shards one record batch at a time and folds partial aggregates together; peak memory is a few
hundred MB regardless of dataset size.
"""
import os

for _var in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
    os.environ.setdefault(_var, "1")

import argparse
import json
import sys
from pathlib import Path
from typing import Iterator, Sequence

import numpy as np
import pyarrow as pa
import pyarrow.dataset as pads

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

from src.config import SimConfig  # noqa: E402
from src.graph_generator import effective_capacity, TopologyEvent, Topology  # noqa: E402
from src.physics_engine import grounded_solve, live_graph  # noqa: E402
from src.simulation_loop import simulate_episode  # noqa: E402
from src.telemetry_logger import read_table, shard_files, table_names  # noqa: E402

BATCH_ROWS = 1 << 18   # rows per streamed record batch (~10 MB for the scalar telemetry columns)
READAHEAD = 2          # batches/fragments the scanner may buffer ahead; keeps peak memory flat
FOLD_EVERY = 8         # partial aggregates combined before they accumulate

failures = []


def check(condition: bool, message: str) -> None:
    status = "ok " if condition else "FAIL"
    print(f"  [{status}] {message}")
    if not condition:
        failures.append(message)


# --------------------------------------------------------------------------------------
# Streaming helpers.  Nothing below ever materialises a whole step-level table: the shards are
# read one record batch at a time and folded into a dense per-group accumulator whose size is
# fixed by the design (episodes x routers x tracked flows), not by the number of rows.
# --------------------------------------------------------------------------------------

def scan(data_dir: Path, table: str, columns: Sequence[str], filter=None,
         batch_rows: int = BATCH_ROWS) -> Iterator[pa.RecordBatch]:
    """Record batches of a table's shards, reading only `columns`."""
    files = [str(p) for p in shard_files(data_dir, table)]
    dataset = pads.dataset(files, format="parquet")
    yield from dataset.to_batches(columns=list(columns), filter=filter, batch_size=batch_rows,
                                  batch_readahead=READAHEAD, fragment_readahead=READAHEAD)


class Groups:
    """Dense (episode, router[, flow]) -> slot mapping shared by a telemetry and a summary table."""

    def __init__(self, episode_ids: Sequence[int], routers: Sequence[str], width: int = 1):
        ids = np.asarray(sorted(int(e) for e in episode_ids), np.int64)
        self.episode_ids = ids
        self.lookup = np.full(int(ids.max()) + 1, -1, np.int64)
        self.lookup[ids] = np.arange(len(ids))
        self.routers = list(routers)
        self.router_slot = {r: i for i, r in enumerate(self.routers)}
        self.width = int(width)
        self.size = len(ids) * len(self.routers) * self.width

    def slots(self, batch: pa.RecordBatch) -> np.ndarray:
        episode = self.lookup[batch.column("episode_id").to_numpy(zero_copy_only=False).astype(np.int64)]
        encoded = batch.column("router").dictionary_encode()
        codes = np.array([self.router_slot[v] for v in encoded.dictionary.to_pylist()], np.int64)
        router = codes[encoded.indices.to_numpy(zero_copy_only=False).astype(np.int64)]
        slot = (episode * len(self.routers) + router) * self.width
        if self.width > 1:
            slot = slot + batch.column("flow").to_numpy(zero_copy_only=False).astype(np.int64)
        return slot

    def label(self, slot: int) -> str:
        episode, rest = divmod(int(slot), len(self.routers) * self.width)
        router, flow = divmod(rest, self.width)
        name = f"episode {self.episode_ids[episode]}, router {self.routers[router]}"
        return name + (f", flow {flow}" if self.width > 1 else "")


class Sums:
    """Per-group sums of integer counters, accumulated batch by batch."""

    def __init__(self, groups: Groups, values: Sequence[str]):
        self.groups = groups
        self.values = list(values)
        self.rows = np.zeros(groups.size, np.int64)
        self.totals = {v: np.zeros(groups.size, np.int64) for v in self.values}

    def add(self, batch: pa.RecordBatch) -> None:
        slot = self.groups.slots(batch)
        self.rows += np.bincount(slot, minlength=self.groups.size)
        for name in self.values:
            column = batch.column(name).to_numpy(zero_copy_only=False).astype(np.float64)
            self.totals[name] += np.rint(np.bincount(slot, weights=column,
                                                     minlength=self.groups.size)).astype(np.int64)

    @property
    def present(self) -> np.ndarray:
        return self.rows > 0


def accumulate(data_dir: Path, table: str, groups: Groups, values: Sequence[str],
               batch_rows: int = BATCH_ROWS, on_batch=None) -> Sums:
    """Stream `table` and sum `values` per group."""
    sums = Sums(groups, values)
    columns = ["episode_id", "router"] + (["flow"] if groups.width > 1 else [])
    extra = [v for v in values if v not in columns]
    for batch in scan(data_dir, table, columns + extra, batch_rows=batch_rows):
        if on_batch is not None:
            on_batch(batch)
        sums.add(batch)
    return sums


def compare_sums(streamed: Sums, reference: Sums, columns: Sequence[str], label: str) -> None:
    """Check that per-group sums streamed from a telemetry table equal those of a summary table."""
    groups = streamed.groups
    same_groups = bool((streamed.present == reference.present).all())
    if not same_groups:
        missing = np.flatnonzero(streamed.present != reference.present)
        check(False, f"{label}: {len(missing)} group(s) on one side only, e.g. {groups.label(missing[0])}")
        return
    check(True, f"{label}: the same groups appear in both tables")
    where = streamed.present
    bad = [c for c in columns if not bool((streamed.totals[c][where] == reference.totals[c][where]).all())]
    if bad:
        c = bad[0]
        first = np.flatnonzero(where & (streamed.totals[c] != reference.totals[c]))[0]
        check(False, f"{label} (differs in {', '.join(bad)}; first at {groups.label(first)}: "
                     f"{streamed.totals[c][first]} vs {reference.totals[c][first]})")
    else:
        check(True, label)


# --------------------------------------------------------------------------------------
# Checks
# --------------------------------------------------------------------------------------

def structure(data_dir: Path, cfg: SimConfig) -> int:
    print("Structure")
    tables = table_names(cfg.routers)
    counts = {t: len(shard_files(data_dir, t)) for t in tables}
    n_shards = max(counts.values()) if counts else 0
    check(n_shards > 0, f"{n_shards} shards present")
    check(all(c == n_shards for c in counts.values()), "every table has every shard")
    check((data_dir / "manifest.json").exists(), "manifest.json present")
    return n_shards


def coverage(data_dir: Path, cfg: SimConfig) -> None:
    print("Design coverage")
    ep = read_table(data_dir, "episodes", columns=["episode_id", "cell_id", "replicate", "split"]).to_pandas()
    per_cell = ep.cell_id.value_counts()
    check(len(per_cell) == len(cfg.cells), f"all {len(cfg.cells)} design cells present")
    check(per_cell.max() - per_cell.min() <= 1, f"balanced: {per_cell.min()}-{per_cell.max()} episodes per cell")
    check(ep.episode_id.is_unique, "episode ids unique")
    check({"train", "validation", "test"} <= set(ep.split) or cfg.replicates < 5,
          f"splits present: {sorted(set(ep.split))}")


FLOW_SUMMARY_COLUMNS = ["offered", "delivered", "dropped", "in_flight", "loss_ratio", "mean_delay",
                        "min_latency", "min_hops", "mean_hops", "p50_delay", "p95_delay", "p99_delay",
                        "max_delay", "mean_queueing_delay", "mean_path_latency"]


def flow_summary_elementwise(data_dir: Path, batch_rows: int) -> None:
    """Per-row invariants of flow_summary, accumulated over streamed batches."""
    results = dict(conservation=True, loss=True, delay=True, hops=True, quantiles=True, decomposition=True)
    for batch in scan(data_dir, "flow_summary", FLOW_SUMMARY_COLUMNS, batch_rows=batch_rows):
        c = {name: batch.column(name).to_numpy(zero_copy_only=False) for name in FLOW_SUMMARY_COLUMNS}
        ok = c["delivered"] > 0
        results["conservation"] &= bool((c["offered"] == c["delivered"] + c["dropped"] + c["in_flight"]).all())
        results["loss"] &= bool(((c["loss_ratio"] >= 0) & (c["loss_ratio"] <= 1)).all())
        results["delay"] &= bool((c["mean_delay"][ok] >= c["min_latency"][ok] - 1e-3).all())
        results["hops"] &= bool((c["mean_hops"][ok] >= c["min_hops"][ok] - 1e-3).all())
        results["quantiles"] &= bool(((c["p50_delay"][ok] <= c["p95_delay"][ok] + 1e-3)
                                      & (c["p95_delay"][ok] <= c["p99_delay"][ok] + 1e-3)
                                      & (c["p99_delay"][ok] <= c["max_delay"][ok] + 1e-3)).all())
        results["decomposition"] &= bool(np.allclose(c["mean_delay"][ok],
                                                     c["mean_queueing_delay"][ok] + c["mean_path_latency"][ok],
                                                     atol=1e-2))
    check(results["conservation"], "flow conservation: offered = delivered + dropped + in-flight")
    check(results["loss"], "loss ratio within [0, 1]")
    check(results["delay"], "mean delay >= minimum path latency")
    check(results["hops"], "mean hops >= minimum hop count")
    check(results["quantiles"], "delay quantiles ordered")
    check(results["decomposition"], "delay = queueing + propagation")


def invariants(data_dir: Path, cfg: SimConfig, batch_rows: int = BATCH_ROWS) -> None:
    print("Invariants")
    flow_summary_elementwise(data_dir, batch_rows)

    episode_ids = read_table(data_dir, "episodes", columns=["episode_id"]).column("episode_id").to_pylist()
    counters = ["offered", "delivered", "dropped", "in_flight"]
    per_router = Groups(episode_ids, cfg.routers)

    router_summary = read_table(data_dir, "router_summary")
    reference = Sums(per_router, counters)
    for batch in router_summary.to_batches():
        reference.add(batch)
    check(bool((reference.rows <= 1).all()), "router_summary has one row per (episode, router)")
    compare_sums(accumulate(data_dir, "flow_summary", per_router, counters, batch_rows),
                 reference, counters, "router summary equals the sum of its flows")
    util = router_summary.column("link_utilisation").to_numpy(zero_copy_only=False)
    sat = router_summary.column("link_saturation").to_numpy(zero_copy_only=False)
    check(bool(((util >= 0) & (util <= 1) & (sat >= 0) & (sat <= 1)).all()), "utilisation within [0, 1]")

    admission = {"ok": True}

    def admitted_le_offered(batch: pa.RecordBatch) -> None:
        admission["ok"] &= bool((batch.column("admitted").to_numpy(zero_copy_only=False)
                                 <= batch.column("offered").to_numpy(zero_copy_only=False)).all())

    steps = ["offered", "delivered", "dropped"]
    compare_sums(accumulate(data_dir, "network_telemetry", per_router, steps + ["admitted"], batch_rows,
                            on_batch=admitted_le_offered),
                 reference, steps, "network telemetry sums to the router summary")

    per_flow = Groups(episode_ids, cfg.routers, width=int(cfg.tracked_flows))
    tracked = accumulate(data_dir, "flow_telemetry", per_flow, steps + ["admitted"], batch_rows,
                         on_batch=admitted_le_offered)
    flow_reference = Sums(per_flow, steps)
    for batch in scan(data_dir, "flow_summary", ["episode_id", "router", "flow"] + steps,
                      filter=pads.field("flow") < int(cfg.tracked_flows), batch_rows=batch_rows):
        flow_reference.add(batch)
    compare_sums(tracked, flow_reference, steps, "tracked-flow telemetry sums to the flow summary")
    check(admission["ok"], "admitted <= offered")


def physical_bounds(data_dir: Path, cfg: SimConfig, episode_ids) -> None:
    print("Physical bounds (sampled episodes)")
    episodes = read_table(data_dir, "episodes").to_pandas().set_index("episode_id")
    events = read_table(data_dir, "events").to_pandas()
    for eid in episode_ids:
        ep = episodes.loc[eid]
        net = read_table(data_dir, "network_telemetry", filters=[("episode_id", "=", int(eid))]).to_pandas()
        queue = np.stack(net.queue_depth)
        check(queue.min() >= 0 and queue.max() <= cfg.buffer_size, f"episode {eid}: queue depths within the buffer")
        check((np.stack(net.node_dropped).sum(1) == net.dropped).all(), f"episode {eid}: node drops sum to step drops")
        link = read_table(data_dir, "link_telemetry", filters=[("episode_id", "=", int(eid))]).to_pandas()
        topo = Topology(int(ep.n_nodes), np.stack([ep.edge_u, ep.edge_v], 1).astype(np.int16),
                        ep.capacity.astype(np.int16), ep.latency.astype(np.int16),
                        np.zeros(0, np.int16), np.zeros(0, np.int8), np.zeros((0, 2), np.float32))
        evs = [TopologyEvent(e.kind, int(e.start), int(e.end),
                             edge=int(np.flatnonzero((ep.edge_u == e.edge_u) & (ep.edge_v == e.edge_v))[0]) if e.kind == "link_failure" else -1,
                             node=int(e.node), factor=float(e.factor))
               for e in events[events.episode_id == eid].itertuples()]
        steps = sorted({0} | {e.start for e in evs} | {e.end for e in evs if e.end < ep.steps})
        cap_at = {t: effective_capacity(topo, evs, t) for t in steps}
        bounds = np.array([cap_at[steps[np.searchsorted(steps, t, side="right") - 1]] for t in link.step])
        loads = np.maximum(np.stack(link.load_uv), np.stack(link.load_vu))
        check((loads <= bounds).all(), f"episode {eid}: link loads never exceed the capacity in force")
        if "potential_field" in table_names(cfg.routers):
            pf = read_table(data_dir, "potential_field", filters=[("episode_id", "=", int(eid))]).to_pandas()
            phi = np.stack(pf.potential).reshape(len(pf), int(ep.tracked_flows), int(ep.n_nodes))
            sinks = ep.flow_sink[: int(ep.tracked_flows)]
            check(phi.min() >= 0 and np.all(phi[:, np.arange(len(sinks)), sinks] == 0),
                  f"episode {eid}: potentials non-negative and zero at the sinks")


def tables_equal(a: pa.Table, b: pa.Table) -> bool:
    """Exact equality of two tables, treating NaN as equal to NaN."""
    if a.num_rows != b.num_rows or not a.schema.equals(b.schema, check_metadata=False):
        return False
    for name in a.column_names:
        x, y = a.column(name).combine_chunks(), b.column(name).combine_chunks()
        if pa.types.is_list(x.type):
            if not x.offsets.equals(y.offsets):
                return False
            x, y = x.flatten(), y.flatten()
        if pa.types.is_floating(x.type):
            if not np.array_equal(x.to_numpy(zero_copy_only=False), y.to_numpy(zero_copy_only=False), equal_nan=True):
                return False
        elif not x.equals(y):
            return False
    return True


def reproducibility(data_dir: Path, cfg: SimConfig, episode_ids) -> None:
    print("Reproducibility (re-simulating from config.json)")
    for eid in episode_ids:
        fresh = simulate_episode(cfg, int(eid))
        same = all(tables_equal(read_table(data_dir, name, filters=[("episode_id", "=", int(eid))]), table)
                   for name, table in fresh.items())
        check(same, f"episode {eid}: every table reproduced bit for bit")


def field_reconstruction(data_dir: Path, cfg: SimConfig, eid: int) -> None:
    print("Potential-field reconstruction (sparse reference solver)")
    ep = read_table(data_dir, "episodes", filters=[("episode_id", "=", int(eid))]).to_pandas().iloc[0]
    events = read_table(data_dir, "events", filters=[("episode_id", "=", int(eid))]).to_pandas()
    pf = read_table(data_dir, "potential_field", filters=[("episode_id", "=", int(eid))]).to_pandas()
    row = pf.iloc[len(pf) // 2]
    step = int(row.step)
    net = read_table(data_dir, "network_telemetry",
                     filters=[("episode_id", "=", int(eid)), ("router", "=", "potential"), ("step", "=", step)]).to_pandas()
    queue = np.asarray(net.queue_depth.iloc[0], np.float64)
    n = int(ep.n_nodes)
    cap = ep.capacity.astype(np.float64)
    factor, failed = np.ones(n), np.zeros(len(cap), bool)
    for e in events[(events.start <= step) & (step < events.end)].itertuples():
        if e.kind == "node_degradation":
            factor[e.node] *= e.factor
        else:
            failed |= (ep.edge_u == e.edge_u) & (ep.edge_v == e.edge_v)
    cap = np.maximum(1, np.floor(cap * factor[ep.edge_u] * factor[ep.edge_v]))
    cap[failed] = 0
    g = live_graph(n, np.stack([ep.edge_u, ep.edge_v], 1), cap.astype(np.int16), ep.latency.astype(np.int16))
    stored = np.asarray(row.potential, np.float64).reshape(int(ep.tracked_flows), n)
    injection = cfg.background_injection / (n - 1) + cfg.congestion_gain * queue / cfg.buffer_size
    worst = 0.0
    for f in range(int(ep.tracked_flows)):
        b = injection.copy()
        b[ep.flow_source[f]] += cfg.source_injection
        phi = grounded_solve(g, int(ep.flow_sink[f]), b)
        worst = max(worst, np.abs(phi - stored[f]).max() / max(np.abs(phi).max(), 1e-12))
    check(worst < 1e-5, f"episode {eid}, step {step}: stored field matches the sparse solve (max rel err {worst:.1e})")


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--out", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
    parser.add_argument("--resimulate", type=int, default=3, help="episodes to re-simulate for the reproducibility check")
    parser.add_argument("--seed", type=int, default=0, help="seed for choosing the sampled episodes")
    parser.add_argument("--batch-rows", type=int, default=BATCH_ROWS,
                        help=f"rows per streamed record batch in the invariant checks (default: {BATCH_ROWS})")
    args = parser.parse_args()
    cfg = SimConfig.load(args.out / "config.json")
    n_shards = structure(args.out, cfg)
    if n_shards == 0:
        sys.exit("no shards found")
    coverage(args.out, cfg)
    invariants(args.out, cfg, max(1024, args.batch_rows))
    ids = read_table(args.out, "episodes", columns=["episode_id", "size"]).to_pandas().sort_values("size")
    rng = np.random.default_rng(args.seed)
    sample = [int(ids.episode_id.iloc[i]) for i in
              np.unique(np.linspace(0, len(ids) - 1, max(1, args.resimulate)).astype(int))]
    if len(ids) > args.resimulate:
        sample = sorted(set(sample) | {int(x) for x in rng.choice(ids.episode_id, 1, replace=False)})
    physical_bounds(args.out, cfg, sample)
    reproducibility(args.out, cfg, sample[:args.resimulate])
    if "potential_field" in table_names(cfg.routers):
        field_reconstruction(args.out, cfg, sample[0])
    manifest = json.loads((args.out / "manifest.json").read_text(encoding="utf-8"))
    print(f"\nDataset v{manifest['dataset_version']}: {manifest['design']['episodes_present']} episodes, "
          f"{sum(t['bytes'] for t in manifest['tables'].values()) / 1e9:.2f} GB")
    if failures:
        sys.exit(f"{len(failures)} check(s) failed: " + "; ".join(failures))
    print("All checks passed.")


if __name__ == "__main__":
    main()