#!/usr/bin/env python3
# SPDX-License-Identifier: Apache-2.0
# Original VerifierBench contributions; third-party terms remain applicable.
"""Export generation-only or evaluator-only inputs; never execute candidates."""
import argparse
import hashlib
import json
import re
from pathlib import Path

import pyarrow.parquet as pq
from appworld_reconstruction import FAMILIES, appworld_backfill, gold_body

PACKAGE = Path(__file__).resolve().parents[1]


def sha(data):
    return hashlib.sha256(data).hexdigest()


def rows(version, kind):
    if version != 'paper' or kind not in ('tasks', 'evaluation'):
        raise ValueError('This release provides only the frozen paper222 configurations.')
    name = 'tasks' if kind == 'tasks' else 'candidates'
    return pq.read_table(PACKAGE / 'data' / (name + '.parquet')).to_pylist()


def canonical(obj):
    return json.dumps(obj, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode()


def reconstruct_task(row, manifest, appworld_root):
    record = manifest[row['task_id']]
    template = record['template_json'].encode()
    assert sha(template) == row['task_spec_sha256'] == record['template_sha256']
    spec = appworld_backfill(json.loads(template), row['source_task_id'], root=str(appworld_root))
    if spec is None:
        raise ValueError('Missing AppWorld official task data: ' + row['task_id'])
    blob = canonical(spec)
    if sha(blob) != row['effective_spec_sha256']:
        raise ValueError('AppWorld effective task hash mismatch: ' + row['task_id'])
    return blob


def reconstruct_candidate(row, appworld_root, cache):
    source_id, _, suffix = row['source_candidate_id'].partition('::')
    if source_id not in cache:
        body = gold_body(source_id, str(appworld_root / 'data'))
        if body is None:
            raise ValueError('Missing AppWorld official compiled solution: ' + source_id)
        recipes = [('gold', body), ('base_empty', 'def solution(apis, requester):\n    pass')]
        for _, operator in FAMILIES:
            recipes.extend(operator(body))
        cache[source_id] = recipes
    _, _, name = suffix.partition('_')
    matches = []
    for recipe, solution in cache[source_id]:
        if recipe != name:
            continue
        # Same construction-marker fold used by pipeline/views.py::scrub.
        # It operates on serialized payloads, before constructing the public view.
        payload = json.loads(re.sub(r'v4v[ _\-]?[A-Za-z0-9_]*', 'alt',
                                    json.dumps({'solution': solution}, ensure_ascii=False)))
        obj = dict(candidate_id=row['candidate_id'], task_id=row['task_id'], schema_version='1.0',
                   verifier_form='tool_state_transition', payload=payload)
        blob = json.dumps(obj, ensure_ascii=False, sort_keys=True, indent=1).encode()
        if sha(blob) == row['candidate_view_sha256']:
            matches.append(blob)
    if not matches:
        raise ValueError('No exact AppWorld reconstruction matched: ' + row['candidate_id'])
    return matches[0]


def materialize(version, kind, output, appworld_root):
    if version != 'paper' or kind not in ('generation', 'evaluation'):
        raise ValueError('Use version=paper with kind=generation or evaluation.')
    output = output.resolve()
    if output == PACKAGE or PACKAGE in output.parents:
        raise ValueError('Output must be outside the release package (AppWorld plaintext is local-only).')
    if output.exists() and any(output.iterdir()):
        raise ValueError('Output directory must be empty; existing files are never overwritten.')
    if appworld_root is None:
        raise ValueError('--appworld-root is required for the full pool; partial exports are refused.')
    manifest = {r['task_id']: r for r in json.loads((PACKAGE / 'metadata/appworld_reconstruction.json').read_text())}
    selected = rows(version, 'tasks' if kind == 'generation' else 'evaluation')
    files, labels, cache = [], [], {}
    for row in selected:
        if kind == 'generation':
            if row['task_spec_json'] is None:
                blob = reconstruct_task(row, manifest, appworld_root)
            else:
                original = row['task_spec_json'].encode()
                assert sha(original) == row['task_spec_sha256']
                blob = canonical(json.loads(original))
                assert sha(blob) == row['effective_spec_sha256'], row['task_id']
            files.append((Path(row['task_id']) / 'task_spec.public.json', blob))
        else:
            blob = (row['candidate_view_json'].encode() if row['candidate_view_json'] is not None
                    else reconstruct_candidate(row, appworld_root, cache))
            assert sha(blob) == row['candidate_view_sha256']
            files.append((Path(row['task_id']) / 'candidates' / (row['candidate_id'] + '.json'), blob))
            labels.append({k: row[k] for k in ('task_id', 'candidate_id', 'label', 'candidate_class', 'candidate_view_sha256')})
    # Complete and verify every item before writing any output.
    for path, blob in files:
        dest = output / path
        dest.parent.mkdir(parents=True, exist_ok=True)
        dest.write_bytes(blob)
    if kind == 'evaluation':
        (output / 'labels.jsonl').write_text(''.join(json.dumps(r, ensure_ascii=False) + '\n' for r in labels))
    return dict(version=version, kind=kind, verified_files=len(files))


def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('--version', choices=('paper',), default='paper')
    p.add_argument('--kind', choices=('generation', 'evaluation'), required=True)
    p.add_argument('--output', type=Path, required=True)
    p.add_argument('--appworld-root', type=Path, required=True)
    a = p.parse_args()
    print(json.dumps(materialize(a.version, a.kind, a.output, a.appworld_root), indent=2))


if __name__ == '__main__':
    main()