"""Validate all publication bundles, evidence counts and anonymous-safe data.

Reads at most one compressed episode at a time. Never prints source contents.
"""
from pathlib import Path
import argparse
import collections
import gzip
import json
import math
import resource

import numpy as np
import pandas as pd
import pyarrow.parquet as pq

from export_corpus import Builder, Redactor, digest, dumps, telemetry


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--check-originals", action="store_true")
    args = parser.parse_args()
    out = Path(__file__).resolve().parents[1]
    episodes = pd.concat([pd.read_parquet(out / f"data/{c}.parquet") for c in ["olmo", "qwen", "forest"]], ignore_index=True)
    sources = pd.read_parquet(out / "data/sources.parquet")
    coverage = pd.read_parquet(out / "data/coverage.parquet")
    examples = pd.read_parquet(out / "data/example_summary.parquet")
    tokens = pd.read_parquet(out / "data/token_diagnostics.parquet")
    joins = pd.read_parquet(out / "data/forest_joins.parquet")
    inventory = pd.read_csv(out / "provenance/recording_inventory.csv", keep_default_na=False)
    assert episodes.episode_id.is_unique
    assert episodes.groupby("collection").size().to_dict() == {"forest":371,"olmo":570,"qwen":510}
    assert examples.groupby("example_kind").size().to_dict() == {"experiment1_judge_packet":144,"final":218,"process":8633,"rejection":74}
    assert len(inventory) == 1958
    assert not inventory.path.str.match(r"(?:tmax|opd_exp)/").any()
    assert (inventory.archive_member == "").all()
    assert not sources.source_path.str.contains(r"codex-session-trajectories|(?:^|/)\.codex/|^tmax/").any()
    expected = {"invalid":3,"trajectory_missing_at_archive_time":368,"27b_summary_only":64,"original_raw_run_missing":1}
    assert coverage.status.value_counts().to_dict() == expected, coverage.status.value_counts().to_dict()
    assert len(episodes[episodes.retained_experiment2_id.notna()]) == 503
    assert set(tokens.episode_id).issubset(set(episodes.episode_id))
    verified = joins[joins.match_status == "verified_trial_uuid_and_branch"]
    assert (verified.candidate_count == 1).all()
    assert verified.episode_id.notna().all()
    assert set(verified.episode_id).issubset(set(episodes.loc[episodes.collection == "forest", "episode_id"]))
    assert joins.loc[joins.match_status != "verified_trial_uuid_and_branch", "episode_id"].isna().all()
    forest_keys = collections.defaultdict(set)
    for r in inventory[inventory.project == "forestOfAudits"].itertuples():
        key = Builder.forest_identity(None, r.path)
        if key:
            from export_corpus import identity
            forest_keys[key].add(identity(r.episode_key))
    for r in verified.itertuples():
        key = Builder.forest_identity(None, r.public_source_path)
        assert forest_keys[key] == {r.episode_id}
    redactor = Redactor()
    source_count, token_count, bundle_count = 0, 0, 0
    max_bundle_bytes = 0
    episode_events = collections.Counter()
    for i, row in enumerate(episodes.itertuples()):
        path = out / row.detail_path
        with gzip.open(path, "rb") as handle:
            raw = handle.read()
        max_bundle_bytes = max(max_bundle_bytes, len(raw))
        bundle = json.loads(raw)
        assert bundle["episode"]["episode_id"] == row.episode_id
        assert sum(e["canonical_view"] for e in bundle["events"]) == row.events
        episode_events[row.episode_id] = len(bundle["events"])
        raw_tokens = []
        for view in bundle["recordings"]:
            source = view["source"]
            payload = dumps(view["data"]).encode()
            assert digest(payload) == source["publication_sha256"], source["source_path"]
            if args.check_originals:
                original = out.parent / source["source_path"]
                assert digest(original.read_bytes()) == source["source_sha256"], source["source_path"]
            before = len(redactor.rows)
            redactor.clean(view["data"], source["source_path"])
            assert len(redactor.rows) == before, f"Credential pattern remains in {source['source_path']}"
            obj = view["data"]
            if isinstance(obj, dict):
                for s in obj.get("steps", []):
                    m = s.get("metrics") or {}
                    if isinstance(m.get("completion_token_ids"), list) and isinstance(m.get("logprobs"), list):
                        raw_tokens.append(telemetry(m))
                for batch in (obj.get("agent_result") or {}).get("rollout_details") or []:
                    ids, lps = batch.get("completion_token_ids", []), batch.get("logprobs", [])
                    if ids and isinstance(ids[0], list):
                        for j in range(max(len(ids), len(lps))):
                            raw_tokens.append(telemetry({"completion_token_ids":ids[j] if j<len(ids) else [],"logprobs":lps[j] if j<len(lps) else []}))
                    else:
                        raw_tokens.append(telemetry(batch))
            source_count += 1
        stored = bundle["token_diagnostics"]
        assert len(raw_tokens) == len(stored), row.episode_id
        for raw_t, stored_t in zip(raw_tokens, stored):
            assert raw_t["alignment"] == stored_t["alignment"]
            assert raw_t["token_count"] == stored_t["token_count"]
            if raw_t["alignment"] == "aligned":
                assert math.isclose(raw_t["nll_sum"], stored_t["nll_sum"], rel_tol=1e-10, abs_tol=1e-8)
        good = [t for t in stored if t["alignment"] == "aligned"]
        count = sum(t["token_count"] for t in good)
        if count:
            assert math.isclose(sum(t["nll_sum"] for t in good)/count, row.selected_token_surprisal_nats, rel_tol=1e-9)
        token_count += len(stored)
        bundle_count += 1
        if i % 200 == 0:
            print(f"Verified {i}/{len(episodes)} bundles", flush=True)
    assert token_count == len(tokens)
    parquet_counts = collections.Counter()
    for p in (out / "data/events").rglob("*.parquet"):
        for batch in pq.ParquetFile(p).iter_batches(batch_size=4096, columns=["episode_id"]):
            parquet_counts.update(batch.column(0).to_pylist())
    assert parquet_counts == episode_events
    # Derived/public source copies are checked without printing their data.
    for row in sources[sources.public_path.notna()].itertuples() if "public_path" in sources else []:
        p = out / row.public_path
        raw = gzip.decompress(p.read_bytes()) if p.suffix == ".gz" else p.read_bytes()
        assert digest(raw) == row.publication_sha256, row.source_path
        redactor.text(raw.decode(), row.source_path, "$")
    # Scan every remaining derived/auxiliary compressed copy and table payload.
    for p in out.rglob("*.gz"):
        if "recordings" in p.parts:
            continue
        raw = gzip.decompress(p.read_bytes())
        if p.name.endswith(".jsonl.gz"):
            values = [json.loads(line) for line in raw.splitlines() if line.strip()]
        else:
            values = json.loads(raw)
        before = len(redactor.rows)
        redactor.clean(values, str(p.relative_to(out)))
        assert len(redactor.rows) == before, f"Credential pattern in {p.name}"
    for name in ["annotations", "examples", "q09_transitions", "qwen27b_summary_only"]:
        frame = pd.read_parquet(out / f"data/{name}.parquet")
        for column in [c for c in frame if c.endswith("_json")]:
            for value in frame[column].dropna():
                before = len(redactor.rows)
                redactor.clean(json.loads(value), name)
                assert len(redactor.rows) == before, f"Credential pattern in table {name}"
    assert not redactor.rows
    report = {"status":"passed", "episode_counts":episodes.groupby("collection").size().to_dict(),
              "bundles_verified":bundle_count, "embedded_source_hashes_verified":source_count,
              "token_sequences_recomputed":token_count, "event_rows_verified":sum(parquet_counts.values()),
              "example_counts":examples.groupby("example_kind").size().to_dict(),
              "coverage":expected, "verified_forest_example_joins":len(verified),
              "max_uncompressed_bundle_bytes":max_bundle_bytes,
              "peak_validation_rss_mib":resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024,
              "original_source_hashes_checked":args.check_originals,
              "credential_scan":"all publication recording views and derived public copies"}
    (out / "provenance/validation.json").write_text(json.dumps(report,indent=2)+"\n")
    print(json.dumps(report,indent=2))


if __name__ == "__main__":
    main()