#!/usr/bin/env python3
"""Check data/ against the closebench package.

    python verify.py [--src /path/to/checkout] [--n 5] [--sample-seed 0]

On every row: row counts, seed sets, mode-by-seed, world/truth pairing.
For N random seeds (default 5), in both locales:
  1. rebuild the world from the package and compare the serialised record with the
     stored line byte for byte (worlds and truth files);
  2. "oracle": post the fixes from the stored truth row as adjusting entries on
     (a) the rebuilt world and (b) a world reconstructed purely from the JSONL rows
     (the README recipe) -- grade() must return passed=True, score=1.0 in both;
  3. en and ru rows carry identical numbers (dates, accounts, amounts, fixes).
Exit status 1 if anything fails.
"""
from __future__ import annotations
import argparse, json, os, random, sys

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
from build import SEEDS, LANGS, DATA, mode_for, import_closebench, world_record, truth_record, dumps  # noqa: E402

FAILS = 0


def check(cond: bool, msg: str) -> bool:
    global FAILS
    print(("  ok    " if cond else "  FAIL  ") + msg)
    if not cond:
        FAILS += 1
    return cond


def read_jsonl(path: str) -> list[tuple[bytes, dict]]:
    """(raw line without newline, parsed object) per row."""
    with open(path, "rb") as f:
        return [(ln.rstrip(b"\n"), json.loads(ln)) for ln in f if ln.strip()]


def world_from_rows(wrow: dict, trow: dict | None = None):
    """Rebuild a gradeable World from dataset rows alone (no .build(), no seed replay)."""
    from closebench.world import World, Document, PlantedError
    from closebench.ledger import Entry, Line, D
    world = World(seed=wrow["seed"], lang=wrow["lang"], difficulty=wrow["mode"])
    world.name = wrow["company"]
    world.period_start, world.period_end = wrow["period"]["start"], wrow["period"]["end"]
    for e in wrow["entries"]:
        world.ledger.post(Entry(e["eid"], e["date"], e["memo"],
                                [Line(l["account"], D(l["debit"]), D(l["credit"])) for l in e["lines"]],
                                e["source"], e["ref"]))
    world.ledger._seq = len(wrow["entries"])
    world.documents = [Document(**d) for d in wrow["documents"]]
    if trow is not None:
        world.errors = [PlantedError(**err) for err in trow["errors"]]
    return world


def oracle(world, trow: dict) -> dict:
    """Post exactly the fix for every planted error, then grade."""
    from closebench.tools import Session
    from closebench.grader import grade
    s = Session(world)
    for err in trow["errors"]:
        fix = err["fix"]
        s.post_entry(fix["period"][1], err["err_id"], [
            {"account": fix["debit_account"], "debit": fix["amount"]},
            {"account": fix["credit_account"], "credit": fix["amount"]},
        ])
    return grade(world, s)


def numbers(wrow: dict, trow: dict):
    """Everything about a world except its text."""
    return ([(e["eid"], e["date"], e["source"], e["ref"], e["lines"]) for e in wrow["entries"]],
            [(d["doc_id"], d["kind"], d["date"]) for d in wrow["documents"]],
            [(x["err_id"], x["kind"], x["entry_ids"], x["accounts"], x["amount"], x["fix"]) for x in trow["errors"]])


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--src", help="closebench source checkout to import from (if not pip-installed)")
    ap.add_argument("--data", default=DATA)
    ap.add_argument("--n", type=int, default=5, help="how many random seeds to rebuild (default 5)")
    ap.add_argument("--sample-seed", type=int, help="fix the random choice of seeds")
    a = ap.parse_args()
    World, version = import_closebench(a.src)
    print(f"closebench {version}; data={a.data}")

    files = {}
    for lang in LANGS:
        for kind in ("worlds", "truth"):
            p = os.path.join(a.data, f"{kind}-{lang}.jsonl")
            files[kind, lang] = read_jsonl(p)

    print("structure")
    for (kind, lang), rows in sorted(files.items()):
        seeds = [r["seed"] for _, r in rows]
        check(len(rows) == len(SEEDS), f"{kind}-{lang}: {len(rows)} rows (expected {len(SEEDS)})")
        check(seeds == SEEDS, f"{kind}-{lang}: seeds are exactly {SEEDS[0]}..{SEEDS[49]}, {SEEDS[50]}..{SEEDS[-1]} in order")
        check(all(r["mode"] == mode_for(r["seed"]) and r["lang"] == lang for _, r in rows),
              f"{kind}-{lang}: mode matches seed rule and lang column on every row")
    for lang in LANGS:
        w_keys = [(r["seed"], r["mode"]) for _, r in files["worlds", lang]]
        t_keys = [(r["seed"], r["mode"]) for _, r in files["truth", lang]]
        check(w_keys == t_keys, f"{lang}: worlds and truth rows pair up one-to-one")
        check(all(len(r["errors"]) > 0 for _, r in files["truth", lang]), f"{lang}: every truth row has >= 1 error")

    rng = random.Random(a.sample_seed)
    picked = sorted(rng.sample(SEEDS, a.n))
    print(f"sampled seeds: {picked}" + (f" (--sample-seed {a.sample_seed})" if a.sample_seed is not None else " (random)"))
    idx = {sd: i for i, sd in enumerate(SEEDS)}
    for sd in picked:
        mode = mode_for(sd)
        for lang in LANGS:
            raw_w, wrow = files["worlds", lang][idx[sd]]
            raw_t, trow = files["truth", lang][idx[sd]]
            w = World(seed=sd, lang=lang, difficulty=mode).build()
            check(dumps(world_record(w)).encode("utf-8") == raw_w,
                  f"seed {sd} {lang} {mode}: rebuilt snapshot == stored worlds line, byte for byte ({len(raw_w):,d} bytes)")
            check(dumps(truth_record(w)).encode("utf-8") == raw_t,
                  f"seed {sd} {lang} {mode}: rebuilt truth == stored truth line, byte for byte")
            r1 = oracle(w, trow)
            check(r1["passed"] and r1["score"] == 1.0 and not r1["missed"] and not r1["spurious_entries"],
                  f"seed {sd} {lang}: oracle on package-built world -> score {r1['score']}, passed {r1['passed']}, "
                  f"{len(r1['found'])}/{len(trow['errors'])} found")
            r2 = oracle(world_from_rows(wrow, trow), trow)
            check(r2["passed"] and r2["score"] == 1.0,
                  f"seed {sd} {lang}: oracle on world rebuilt from JSONL rows -> score {r2['score']}, passed {r2['passed']}")
        check(numbers(files["worlds", "en"][idx[sd]][1], files["truth", "en"][idx[sd]][1])
              == numbers(files["worlds", "ru"][idx[sd]][1], files["truth", "ru"][idx[sd]][1]),
              f"seed {sd}: en and ru differ only in text")

    print(f"{'ALL CHECKS PASSED' if not FAILS else f'{FAILS} CHECK(S) FAILED'}")
    sys.exit(1 if FAILS else 0)


if __name__ == "__main__":
    main()