"""Validate an benchmark inputs and published per-example results."""
import collections
import hashlib
import json
from pathlib import Path
import pyarrow.parquet as pq
from huggingface_hub import DatasetCard

ROOT=Path(__file__).resolve().parents[1]
VARIANTS=('original','reversed','serialization_control')
FORBIDDEN={'predicted_label','chosen_key','correct','confidence','probability_0','probability_1','response_id','evaluated'}


def validate(root=ROOT):
    manifest=json.loads((root/'SHA256SUMS.json').read_text())
    actual={str(p.relative_to(root)) for p in root.rglob('*')
            if p.is_file() and p.name!='SHA256SUMS.json' and '__pycache__' not in p.parts}
    assert actual==set(manifest),'Unlisted or missing publication files'
    for name,checksum in manifest.items():
        assert hashlib.sha256((root/name).read_bytes()).hexdigest()==checksum,name
    card=DatasetCard.load(str(root/'README.md'))
    assert {c['config_name'] for c in card.data.configs}=={'requests','case_index','model_results'}
    configs={c['config_name']:c['data_files'] for c in card.data.configs}
    assert configs['requests']==[dict(split=v,path=f'data/requests-{v}.parquet') for v in VARIANTS]
    assert configs['case_index']==[dict(split='cases',path='data/case-index.parquet')]
    expected={f'data/requests-{v}.parquet' for v in VARIANTS}|{'data/case-index.parquet'}
    result_counts=dict(original=415827,reversed=415827,serialization_control=83183,repeat=246313,unsupported=352)
    expected.update(f'data/model-results-{v}.parquet' for v in result_counts)
    assert configs['model_results']==[dict(split=v,path=f'data/model-results-{v}.parquet') for v in result_counts]
    for variant,count in result_counts.items():
        assert pq.ParquetFile(root/f'data/model-results-{variant}.parquet').metadata.num_rows==count
    assert {name for name in manifest if name.startswith('data/')}==expected
    tables={}
    for variant in VARIANTS:
        table=pq.read_table(root/'data'/f'requests-{variant}.parquet')
        assert not FORBIDDEN.intersection(table.column_names)
        assert table.num_rows==83183
        tables[variant]=table.to_pylist()
    original={r['pair_id']:r for r in tables['original']}
    assert len(original)==83183
    for i,a in enumerate(tables['original']):
        b=tables['reversed'][i];c=tables['serialization_control'][i]
        for row in [a,b,c]:
            assert row['pair_id']==a['pair_id'] and row['state']==a['state']
            assert row['instruction']==a['instruction'] and row['gold_label']==a['gold_label']
            assert row['state_available'] and row['state']
            assert hashlib.sha256(row['state'].encode()).hexdigest()==row['state_sha256']
            assert next(o['semantic_label'] for o in row['options'] if o['key']==row['gold_key'])==row['gold_label']
        assert [o['key'] for o in a['options']]==[o['key'] for o in b['options']]==['A','B']
        assert [o['text'] for o in a['options']]==[o['text'] for o in b['options']][::-1]
        assert a['options']==c['options'][::-1]
    groups=collections.defaultdict(list)
    for row in original.values():groups[row['state_sha256']].append(row)
    index=pq.read_table(root/'data/case-index.parquet')
    assert not FORBIDDEN.intersection(index.column_names)
    rows=index.to_pylist();assert len(rows)==83183 and len({r['pair_id'] for r in rows})==83183
    for row in rows:
        source=original[row['pair_id']];group=groups[source['state_sha256']]
        assert row['content_group_id']==source['state_sha256']
        assert row['benchmark']==source['benchmark'] and row['duplicate_rows']==len(group)
        assert row['duplicate_benchmarks']==sorted({r['benchmark'] for r in group})
        assert row['label_conflict']==(len({r['gold_label'] for r in group})>1)
        assert row['rubric_conflict']==(len({r['instruction'] for r in group})>1)
    text=(root/'README.md').read_text()
    for section in ['## Results','### Correct answers: original options','### Wrong answers: original options',
                    '### Correct answers: reversed options','### Correct answers: order-only test',
                    '### Did changing the options change the answer?','### Results at a glance']:
        assert section in text
    for name in ['Original Jev','CLM','Laya','Open-Jev','Laya Multilingual']:assert name in text
    return dict(passed=True,request_rows=249549,case_index_rows=83183,
                model_result_dataset_rows=1161502,result_location='model_results and README.md',
                full_text_harmbench_rows_per_variant=sum(r['benchmark'].startswith('HarmBench') for r in original.values()),
                checksum_files=len(manifest))


if __name__=='__main__':print(json.dumps(validate(),indent=2))