"""Check every exported episode and exercise the unchanged deterministic checkers.

Synthetic completions below test software correctness, never target capability.
"""
from __future__ import annotations
import argparse
from collections import Counter
import hashlib
import itertools
import json
from pathlib import Path

from iwibench.families import PRIVATE_GROUPS, public_episode
from iwibench.scoring import check_item, score_episode
from iwibench.variants import VARIANT_COUNTS, fingerprint, task_from_row, variant_episode


def accepted_output(item):
    candidates = list(item.get("answers", []))
    if item["rule"] == "lexical":
        candidates += ["; ".join(parts) for parts in itertools.product(*item["fields"])]
    elif item["rule"] == "language_relation":
        subject, answer = item["subject_aliases"][0], item["answer"]
        capital = item["domain"] == "capital"
        prefix, copula = {
            "English": ("The capital of" if capital else "The chemical symbol for", "is"),
            "Spanish": ("La capital de" if capital else "El simbolo quimico de", "es"),
            "French": ("La capitale de" if capital else "Le symbole chimique de", "est"),
            "German": ("Die Hauptstadt von" if capital else "Das chemische Symbol fur", "ist"),
        }[item["language"]]
        candidates.append(f"{prefix} {subject} {copula} {answer}.")
    elif item["rule"] == "three_fact_explanation":
        candidates += [". ".join(parts) + "." for parts in itertools.product(*item["fact_clauses"])]
        candidates.append(". ".join([*(slot[-1] for slot in item["fact_clauses"]), *item["elaborations"]]) + ".")
    for candidate in candidates:
        if check_item(item, candidate)["success"]:
            return candidate
    raise AssertionError(f"No accepted completion for {item['id']}: {item['rule']}")


def synthetic_score(ep):
    items = [item for group in PRIVATE_GROUPS for item in ep[group]]
    base = {item["id"]: accepted_output(item) for item in items}
    edited = dict(base)
    for item in ep["targets"]:
        if ep["family"] == "answer_length_control":
            lo, hi = (50, 75) if item["min_words"] == 20 else (20, 35)
            base[item["id"]] = accepted_output({**item, "min_words": lo, "max_words": hi})
        else:
            base[item["id"]] = ""
    if ep["family"] == "resistance_to_false_suggestions":
        for item in ep["calibration"]:
            if item["calibration_role"] == "wrong_pressure":
                base[item["id"]] = f"agree; {item['suggestion']}"
    tokenization = None
    if ep["family"] == "alias_acquisition":
        # Protocol fixture only; native Gemma tokenization is a runtime check.
        tokenization = {ep["parameters"]["alias"]: {
            "token_ids": [123], "special_token_ids": [0, 1], "context_token_ids": [[123], [123]],
        }}
    result = score_episode(ep, base, edited, tokenization)
    assert result["reward"] == 1.0
    assert score_episode(ep, base, base, tokenization)["reward"] == 0.0


def validate(folder: Path):
    import jsonschema
    import pyarrow.parquet as pq
    manifest=json.loads((folder/'manifest.json').read_text())
    for relative,digest in manifest['files'].items():assert hashlib.sha256((folder/relative).read_bytes()).hexdigest()==digest,relative
    task_splits=manifest.get('dataset_configs',{'environments':{'train':1000}})['environments']
    split_rows={};rows=[]
    for split,expected_count in task_splits.items():
        rs=[json.loads(line) for line in (folder/f'data/{split}.jsonl').read_text().splitlines()]
        assert rs==pq.read_table(folder/f'data/{split}.parquet').to_pylist()
        assert len(rs)==expected_count
        split_rows[split]=rs;rows.extend(rs)
    assert Counter(row['family'] for row in rows)==VARIANT_COUNTS
    assert len(rows)==len({row['id'] for row in rows})==1000
    trusted = None
    if manifest.get('trusted_payloads', True):
        trusted = [json.loads(line) for line in (folder/'trusted/train.jsonl').read_text().splitlines()]
        assert trusted == pq.read_table(folder/'trusted/train.parquet').to_pylist()
        assert len(trusted) == len(rows)
    validator=jsonschema.Draft202012Validator(json.loads((folder/'schema.json').read_text()))
    identities=set();checker_count=0
    qualified=manifest['catalog_version']=='baseline-qualified-v1'
    for index, row in enumerate(rows):
        validator.validate(row)
        if qualified:
            from iwibench.qualified_catalog import qualified_episode
            ep=qualified_episode(row['family'],row['variant_index'],row['model_id'])
        else:ep=variant_episode(row['family'],row['variant_index'],row['model_id'])
        if trusted is not None:
            assert trusted[index]['id'] == ep['id']
            assert json.loads(trusted[index]['episode_json']) == ep
        assert ep['id']==row['id'] and fingerprint(ep)==row['episode_sha256'] and fingerprint(ep['parameters'])==row['parameter_sha256']
        identity=(row['family'],row['parameter_sha256']);assert identity not in identities;identities.add(identity)
        public=public_episode(ep);assert set(PRIVATE_GROUPS).isdisjoint(public)
        text=json.dumps(public);ids=[]
        for group in PRIVATE_GROUPS:
            for item in ep[group]:assert item['prompt'] not in text,(ep['id'],item['id']);ids.append(item['id'])
        assert len(ids)==len(set(ids)) and len(ep['general_controls'])==64
        task=task_from_row(row);assert task.data.variant_index==row['variant_index'] and task.data.family==row['family'] and 'episode_json' not in task.data.model_dump()
        if qualified:assert row['calibration_status']=='eligible' and task.data.catalog_version=='baseline-qualified-v1'
        else:
            for group in ('public_practice',*PRIVATE_GROUPS):
                for item in ep[group]:assert check_item(item,'')=={'content':False,'behaviour':False,'success':False};assert check_item(item,accepted_output(item))['success'];checker_count+=1
            synthetic_score(ep)
    report={'rows':1000,'families':10,'counts':VARIANT_COUNTS,'dataset_configs':manifest.get('dataset_configs'),'model_execution':False,'calibration_status':manifest.get('calibration_status'),'trusted_payload_exports':manifest.get('trusted_payloads',True),'item_checker_roundtrips':checker_count,'synthetic_reward_and_noop_cases':0 if qualified else len(rows),'checks':['manifest SHA256','JSON schema','JSONL/Parquet equality','100 per family total','parameter uniqueness','exact measured episode regeneration','public/private projection','native Verifiers v1 Task construction']}
    if qualified and manifest.get('partition_version'):
        from iwibench.task_partitions import partitions,meaningful_digest
        from iwibench.families import episode
        part=partitions();expected={x['id']:x for x in part['entries']};assert set(expected)=={x['id'] for x in rows}
        source=json.loads((folder/'data/historical_task_overlap.json').read_text());historical={x['meaningful_sha256'] for x in source['rows']}
        keys={};ids={};exact={};episodekeys={}
        for split,rs in split_rows.items():
            assert Counter(x['family'] for x in rs)==dict.fromkeys(VARIANT_COUNTS,85 if split=='train' else 15)
            ids[split]={x['id'] for x in rs};exact[split]={x['parameter_sha256'] for x in rs};episodekeys[split]={x['episode_sha256'] for x in rs};keys[split]=set()
            for row in rs:
                ep=qualified_episode(row['family'],row['variant_index'],row['model_id']);key=meaningful_digest(ep)
                assert expected[row['id']]['dataset_split']==split and expected[row['id']]['meaningful_sha256']==key;keys[split].add(key)
        assert not ids['train']&ids['test'] and not exact['train']&exact['test'] and not episodekeys['train']&episodekeys['test'] and not keys['train']&keys['test'] and not keys['test']&historical
        # The scientific partition audit is pinned to the original archive index.
        # Current browsing paths may evolve without changing those episode identities.
        historical_path=folder/manifest.get('rollout_archive',{}).get('local_index_snapshot',part['rollout_index_path'])
        assert hashlib.sha256(historical_path.read_bytes()).hexdigest()==part['rollout_index_sha256']
        historical_rows={x['archive_episode_id']:x for x in pq.read_table(historical_path).to_pylist()}
        rollout_path=folder/manifest.get('rollout_index',{}).get('index_path','rollouts/index.parquet')
        current_index_sha256=hashlib.sha256(rollout_path.read_bytes()).hexdigest()
        if manifest.get('rollout_index'):assert current_index_sha256==manifest['rollout_index']['index_sha256']
        rollouts=pq.read_table(rollout_path).to_pylist()
        for row in rollouts:
            old=historical_rows[row['archive_episode_id']]
            for key in ('archive_episode_id','editor_model','reasoning_effort','target_model','checkpoint_revision','family','family_version','parameter_seed','probe_seed','test_seed','trace_id','native_episode_id','service_session_id','patch_state','patch_sha256','published_reward'):
                assert row[key]==old[key],(row['archive_episode_id'],key)
        assert len(rollouts)==len({x['archive_episode_id'] for x in rollouts})==325
        by_id={x['archive_episode_id']:x for x in rollouts};jsonl=[json.loads(x) for x in (folder/'rollouts/index.jsonl').read_text().splitlines()];assert {x['archive_episode_id'] for x in jsonl}==set(by_id)
        for x in jsonl:assert json.loads(by_id[x['archive_episode_id']]['metadata_json'])==x
        assert set(by_id)=={x['archive_episode_id'] for x in source['rows']}
        for record in source['rows']:
            row=by_id[record['archive_episode_id']];ep=episode(row['family'],row['parameter_seed'],model_id=row['target_model']);assert meaningful_digest(ep)==record['meaningful_sha256'];assert fingerprint(ep['objective'])==record['objective_witness']['objective_sha256']
        report.update(rollout_rows=325,train_test_overlap=0,test_historical_equivalent_overlap=0,rollout_index_sha256=part['rollout_index_sha256'],historical_task_rows_compared=325,browsable_rollout_index_sha256=current_index_sha256,historical_rollout_index_path=str(historical_path.relative_to(folder)))
        report['checks']+=['85/15 per family','stable IDs and full1000 coverage','disjoint task ID/exact parameter/episode/meaningful hashes','test excludes all established historical task equivalents','original325-row rollout schema and metadata preserved']
    (folder/'validation.json').write_text(json.dumps(report,indent=2)+'\n');return report


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("folder", type=Path)
    print(json.dumps(validate(parser.parse_args().folder)))