#!/usr/bin/env python3
"""Generate or check fast-tokenizer references at the revisions in manifest.json.

Adapted from apocryphx/swift-transformers PR #360; see README.md for attribution.
Only Python reference outputs are written; Swift output never becomes a golden.
"""
import argparse
import datetime
import json
from pathlib import Path

import tokenizers
import transformers
from transformers import AutoTokenizer

ROOT = Path(__file__).resolve().parent.parent


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--check', action='store_true', help='Compare reference entries without writing files')
    args = parser.parse_args()
    manifest = json.loads((ROOT / 'manifest.json').read_text(encoding='utf-8'))
    failed = False
    for corpus in manifest['corpora']:
        inputs = json.loads((ROOT / corpus['inputs']).read_text(encoding='utf-8'))
        assert inputs and len({i['id'] for i in inputs}) == len(inputs), 'Empty corpus or duplicate IDs'
        for spec in corpus['baselines']:
            model = spec['model_id']
            revision = spec['revision']
            assert len(revision) == 40 and all(c in '0123456789abcdef' for c in revision)
            print(f'{corpus["id"]}: {model}@{revision}', flush=True)
            tokenizer = AutoTokenizer.from_pretrained(model, revision=revision, use_fast=True)
            assert tokenizer.is_fast, 'References must use the fast tokenizer'
            entries = []
            for row in inputs:
                ids = tokenizer(row['text'], add_special_tokens=True)['input_ids']
                entries.append({
                    'id': row['id'],
                    'input_ids': ids,
                    'tokens': tokenizer.convert_ids_to_tokens(ids),
                    'decoded_with_special': tokenizer.decode(ids, skip_special_tokens=False),
                    'decoded_skip_special': tokenizer.decode(ids, skip_special_tokens=True),
                })
            path = ROOT / spec['path']
            if args.check:
                previous = json.loads(path.read_text(encoding='utf-8'))['entries']
                matches = previous == entries
                print(f'  {len(entries)} entries: {"MATCH" if matches else "DIFFER"}', flush=True)
                failed |= not matches
                continue
            payload = {
                'metadata': {
                    'model_id': model, 'model_revision': revision,
                    'transformers_version': transformers.__version__,
                    'tokenizers_version': tokenizers.__version__,
                    'generated_at': datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0).isoformat(),
                    'input_count': len(entries),
                },
                'entries': entries,
            }
            path.parent.mkdir(parents=True, exist_ok=True)
            path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
    raise SystemExit(1 if failed else 0)


if __name__ == '__main__':
    main()