"""Audit 1: assumptions pass 1/2 relied on, checked on EVERY row of the released shards (read-only).
  * the whole dataset's ms_ids are exactly 0..3N-1, each once
  * within each triplet (3k, 3k+1, 3k+2): identical atomic numbers in identical order, identical cell, identical pbc
  * the stored side (dimer rows) equals ms % 3 - 1
Also counts per-shard contiguity (whether each shard's ms_ids form one consecutive run, which SaddleFlow's loader assumes).
  usage: verify_integrity.py [workers]
"""
import glob, sys, os
import numpy as np
from multiprocessing import Pool
ROOT = "/scratch/08405/ilgar/MaterialsSaddles"; SUBS = ["lemat", "mp20bat", "oc20", "oc22"]


def work(path):
    from ase.db import connect
    rows = {}
    for row in connect(path).select():
        ms = int(row.key_value_pairs["ms_id"]); side = row.key_value_pairs.get("side")
        rows[ms] = (row.numbers.tobytes(), np.array(row.cell, float), tuple(bool(x) for x in row.pbc), side)
    bad_z = bad_cell = bad_pbc = bad_side = incomplete = 0
    for ms, (z, c, p, side) in rows.items():
        if side is not None and int(side) != ms % 3 - 1: bad_side += 1
        if ms % 3 != 1: continue
        if ms - 1 not in rows or ms + 1 not in rows: incomplete += 1; continue
        for o in (ms - 1, ms + 1):
            zo, co, po, _ = rows[o]
            if zo != z: bad_z += 1
            if np.abs(co - c).max() > 1e-6: bad_cell += 1
            if po != p: bad_pbc += 1
    ids = np.sort(np.fromiter(rows.keys(), np.int64))
    contiguous = bool(len(ids) == 0 or ids[-1] - ids[0] + 1 == len(ids))
    return path, ids, dict(bad_z=bad_z, bad_cell=bad_cell, bad_pbc=bad_pbc, bad_side=bad_side, incomplete=incomplete), contiguous


if __name__ == "__main__":
    nw = int(sys.argv[1]) if len(sys.argv) > 1 else 64
    paths = sorted(p for s in SUBS for p in glob.glob(f"{ROOT}/{s}/*.aselmdb"))
    paths.sort(key=lambda p: -os.path.getsize(p))
    tot = dict(bad_z=0, bad_cell=0, bad_pbc=0, bad_side=0, incomplete=0); allids = []; noncontig = []
    with Pool(nw) as pool:
        for k, (p, ids, c, contig) in enumerate(pool.imap_unordered(work, paths)):
            for key in tot: tot[key] += c[key]
            allids.append(ids)
            if not contig: noncontig.append(os.path.basename(p))
            if (k + 1) % 64 == 0: print(f"  {k+1}/{len(paths)} shards", flush=True)
    ids = np.sort(np.concatenate(allids))
    print("rows:", len(ids), " ms_id range:", ids[0], ids[-1], " exactly 0..3N-1 once each:", bool(np.array_equal(ids, np.arange(len(ids)))))
    print("per-triplet mismatches:", tot)
    print("shards whose ms_ids are NOT one consecutive run:", len(noncontig), noncontig[:5])