"""Exact upstream splitting, lossless Parquet, and validated graph caches."""
import argparse
import gc
import hashlib
import json
from pathlib import Path
import pickle
import sys

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
import awkward as ak
import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
import torch
from config import CONFIG
from data.preprocess_events import preprocess_and_split_events
from dataset import PhyGHTDataset
from download_data import digest

RUN = ROOT / 'runs/release-20261112'
PACKAGE = ROOT / 'release/artifacts/dataset'
SCHEMA = pa.schema([
    ('event_id', pa.int64()), ('pileup', pa.int32()),
    ('jets', pa.list_(pa.list_(pa.float64()))),
    ('trks', pa.list_(pa.list_(pa.float64()))),
    ('jet_trk_IDs', pa.list_(pa.list_(pa.int64()))),
])


def assert_equal(a, b):
    # Arrow's nullable schema adds optional-type wrappers even when no value is
    # null. Compare every nesting length and every numeric bit independently
    # of those type wrappers; no precision or membership tolerance is allowed.
    assert len(a) == len(b) and a.ndim == b.ndim, 'Changed event/list dimensions'
    for axis in range(1, a.ndim):
        assert ak.to_list(ak.num(a, axis=axis)) == ak.to_list(ak.num(b, axis=axis)), 'Changed list boundaries'
    av = ak.to_numpy(ak.flatten(a, axis=None))
    bv = ak.to_numpy(ak.flatten(b, axis=None))
    assert av.dtype == bv.dtype and av.shape == bv.shape and av.tobytes() == bv.tobytes(), 'Changed numeric bits'


def main():
    p = argparse.ArgumentParser()
    p.add_argument('variant', choices=['mu200', 'mu60'])
    args = p.parse_args()
    variant = args.variant
    status_path = RUN / f'{variant}_data_validated.json'
    raw_report = json.loads((RUN / f'{variant}_raw_verified.json').read_text())
    path = Path(raw_report['path'])
    assert path.stat().st_size == raw_report['bytes']
    assert digest(path, 'md5') == raw_report['md5'], 'Raw file changed since verification'
    with open(path, 'rb') as stream:
        raw = pickle.load(stream)
    assert {'jets', 'trks', 'jet_trk_IDs'} == set(raw), set(raw)
    assert all(len(x) == 10000 for x in raw.values())
    assert bool(ak.all(ak.num(raw['jets'], axis=2) == 6))
    assert bool(ak.all(ak.num(raw['trks'], axis=2) == 8))
    assert bool(ak.all(ak.num(raw['jets'], axis=1) == ak.num(raw['jet_trk_IDs'], axis=1)))
    for name in ['jets', 'trks']:
        assert np.isfinite(ak.to_numpy(ak.flatten(raw[name], axis=None))).all(), name
    tracks_per_event = ak.to_numpy(ak.num(raw['trks'], axis=1))
    jets_per_event = ak.to_numpy(ak.num(raw['jets'], axis=1))
    assert tracks_per_event.min() >= CONFIG['K_NEIGHBORS']
    assert jets_per_event.min() > 0
    shuffled = np.random.RandomState(42).permutation(10000)
    indices = {'train': shuffled[:8000], 'validation': shuffled[8000:9000], 'test': shuffled[9000:]}
    assert len(np.unique(np.concatenate(list(indices.values())))) == 10000
    report = {
        'variant': variant, 'raw': raw_report, 'seed': 42,
        'split_algorithm': 'numpy.random.RandomState(42).permutation(10000); 80/10/10',
        'counts': {k: len(v) for k, v in indices.items()},
        'tracks_min_median_max': [int(tracks_per_event.min()), float(np.median(tracks_per_event)), int(tracks_per_event.max())],
        'jets_min_median_max': [int(jets_per_event.min()), float(np.median(jets_per_event)), int(jets_per_event.max())],
        'raw_awkward_types': {k: str(v.type) for k, v in raw.items()},
        'parquet_files': [], 'equivalent_model_inputs': 0,
        'missing_association_ids': 0, 'duplicate_track_ids': 0,
    }
    split_dir = RUN / 'processed_data'
    split_dir.mkdir(exist_ok=True)
    np.savez(split_dir / f'{variant}_event_indices_seed42.npz', **indices)
    json_indices = PACKAGE / 'splits' / f'{variant}_seed42.json'
    json_indices.parent.mkdir(parents=True, exist_ok=True)
    json_indices.write_text(json.dumps({k: v.tolist() for k, v in indices.items()}))
    preprocess_and_split_events(str(path), str(split_dir), f'{variant}_10k_events', seed=42)
    CONFIG.update(DATASET_NAME=f'{variant}_10k_events', PROCESSED_DATA_DIR=str(split_dir))
    graph_dir = RUN / 'graphs' / variant
    graph_dir.mkdir(parents=True, exist_ok=True)
    for split, event_ids in indices.items():
        ds = PhyGHTDataset(split)
        graphs = []
        for i, original_id in enumerate(event_ids):
            # Check exact event membership against the independently generated indices.
            for name, actual in [('jets', ds.jets_ak[i]), ('trks', ds.tracks_ak[i]), ('jet_trk_IDs', ds.jet_trk_ids_ak[i])]:
                assert_equal(raw[name][original_id], actual)
            track_ids = ak.to_numpy(ds.tracks_ak[i][:, 6])
            assert np.array_equal(track_ids, track_ids.astype(np.int64))
            report['duplicate_track_ids'] += len(track_ids) - len(np.unique(track_ids))
            assoc_ids = ak.to_numpy(ak.flatten(ds.jet_trk_ids_ak[i], axis=None))
            report['missing_association_ids'] += int((~np.isin(assoc_ids, track_ids)).sum())
            graph = ds[i]
            graph.event_id = int(original_id)
            graphs.append(graph)
        graph_path = graph_dir / f'{split}.pt'
        torch.save(graphs, graph_path)
        for shard, start in enumerate(range(0, len(event_ids), 250)):
            ids = event_ids[start:start + 250]
            arrays = [pa.array(ids), pa.array(np.full(len(ids), int(variant[2:]), dtype=np.int32))]
            arrays += [ak.to_arrow(raw[key][ids], extensionarray=False) for key in ['jets', 'trks', 'jet_trk_IDs']]
            table = pa.Table.from_arrays(arrays, names=SCHEMA.names).cast(SCHEMA)
            out = PACKAGE / variant / f'{split}-{shard:05d}.parquet'
            out.parent.mkdir(parents=True, exist_ok=True)
            pq.write_table(table, out, compression='zstd', row_group_size=25)
            restored = pq.read_table(out)
            assert restored.schema == SCHEMA
            assert restored.column('event_id').to_pylist() == ids.tolist()
            for key in ['jets', 'trks', 'jet_trk_IDs']:
                assert_equal(raw[key][ids], ak.from_arrow(restored[key]))
            # Exercise upstream graph construction on every converted event.
            converted = PhyGHTDataset.__new__(PhyGHTDataset)
            converted.jets_ak = ak.from_arrow(restored['jets'])
            converted.tracks_ak = ak.from_arrow(restored['trks'])
            converted.jet_trk_ids_ak = ak.from_arrow(restored['jet_trk_IDs'])
            for local_id in range(len(ids)):
                original_graph = graphs[start + local_id]
                converted_graph = converted[local_id]
                for node, attrs in [('track', ['x', 'label']), ('jet', ['x', 'y'])]:
                    for attr in attrs:
                        assert torch.equal(original_graph[node][attr], converted_graph[node][attr])
                edge = ('jet', 'contains', 'track')
                assert torch.equal(original_graph[edge].edge_index, converted_graph[edge].edge_index)
                report['equivalent_model_inputs'] += 1
            report['parquet_files'].append({'path': str(out.relative_to(PACKAGE)), 'sha256': digest(out), 'rows': len(ids)})
        print(f'{variant} {split}: {len(graphs)} graphs and lossless Parquet verified', flush=True)
        del ds, graphs
        gc.collect()
    assert report['duplicate_track_ids'] == 0, 'Ambiguous track identifiers'
    assert report['equivalent_model_inputs'] == 10000
    report['status'] = 'validated'
    status_path.write_text(json.dumps(report, indent=2))
    (PACKAGE / f'{variant}_validation.json').write_text(json.dumps(report, indent=2))
    print(json.dumps({k:v for k,v in report.items() if k != 'parquet_files'}), flush=True)


if __name__ == '__main__':
    main()