"""Offline integrity and metric audit for the public six-arm release (stdlib only)."""
from collections import Counter
import hashlib
from html.parser import HTMLParser
import json
from pathlib import Path
import re
import tarfile


def main():
    root = Path(__file__).resolve().parent
    release = root / 'e1-luna-six-way-20261003'
    def sha(data):
        return hashlib.sha256(data).hexdigest()
    checksums = {}
    for line in (root / 'SHA256SUMS').read_text().splitlines():
        expected, name = line.split('  ', 1)
        assert not Path(name).is_absolute() and '..' not in Path(name).parts
        assert sha((root / name).read_bytes()) == expected, name
        checksums[name] = expected
    manifest = json.loads((release / 'manifest.json').read_text())
    expected_members = {(m['archive'], m['path']): m for m in manifest['members'] if 'archive' in m}
    seen, archive_totals = set(), {}
    credential = re.compile(rb'\b(?:hf_[A-Za-z0-9]{10,}|sk-[A-Za-z0-9_-]{10,})\b')
    for name in checksums:
        path = root / name
        if path.suffix != '.gz':
            assert not credential.search(path.read_bytes()), 'Credential-like string in ' + name
    for archive_path in sorted((release / 'raw').glob('*.tar.gz')):
        arm = archive_path.name.removesuffix('.tar.gz')
        totals = Counter()
        with tarfile.open(archive_path, 'r:gz') as archive:
            for member in archive:
                assert member.isfile() and not Path(member.name).is_absolute() and '..' not in Path(member.name).parts
                key = (str(archive_path.relative_to(release)), member.name)
                assert key not in seen and key in expected_members
                seen.add(key)
                raw = archive.extractfile(member).read()
                assert sha(raw) == expected_members[key]['published_sha256'], key
                assert not credential.search(raw), 'Credential-like string in ' + member.name
                value = json.loads(raw)
                if member.name.endswith('/episode.json') or (arm.startswith('harbor') and member.name.endswith('/summary.json')):
                    totals['n'] += 1
                    if arm.startswith('paper'):
                        passed, tokens, calls = value['clean_pass'], value['tokens_in'] + value['tokens_out'], value['llm_calls']
                    elif arm.startswith('native'):
                        passed, tokens, calls = value['status'] == 'pass', value['usage']['total_tokens'], value['usage']['model_responses']
                    else:
                        passed, tokens, calls = value['grade']['status'] == 'pass', value['tokens']['total_tokens'], value['api_calls']
                    totals['passed'] += int(passed)
                    totals['total_tokens'] += tokens
                    totals['model_calls'] += calls
        archive_totals[arm] = totals
    assert seen == set(expected_members)
    rows = [json.loads(line) for line in (release / 'results.jsonl').read_text().splitlines()]
    assert len(rows) == len({(r['arm'], r['task']) for r in rows}) == 588
    summary = json.loads((release / 'summary.json').read_text())
    tasks = set(json.loads((release / 'tasks/selected-task-ids.json').read_text()))
    assert len(tasks) == 98
    assert {json.loads(line)['tid'] for line in (release / 'tasks/tasks.jsonl').read_text().splitlines()} == tasks
    for arm, expected in summary['groups'].items():
        group = [r for r in rows if r['arm'] == arm]
        assert len(group) == 98 and {r['task'] for r in group} == tasks
        assert all(r['total_tokens'] == r['input_tokens'] + r['output_tokens'] for r in group)
        totals = {'n': len(group), 'passed': sum(r['status'] == 'pass' for r in group),
                  'total_tokens': sum(r['total_tokens'] for r in group), 'model_calls': sum(r['api_calls'] for r in group)}
        assert totals == dict(archive_totals[arm]), arm
        assert all(expected[k] == v for k, v in totals.items()), arm
    class Links(HTMLParser):
        def __init__(self):
            super().__init__()
            self.hrefs, self.ids = [], set()
        def handle_starttag(self, tag, attrs):
            a = dict(attrs)
            if 'id' in a:
                self.ids.add(a['id'])
            if tag == 'a' and 'href' in a:
                self.hrefs.append(a['href'])
    for path in release.glob('*.html'):
        parsed = Links()
        parsed.feed(path.read_text())
        for href in parsed.hrefs:
            if href.startswith('#'):
                assert href[1:] in parsed.ids, href
            elif not href.startswith(('http:', 'https:')):
                assert (path.parent / href.split('#')[0]).exists(), href
    print(json.dumps({'verified_files': len(checksums), 'verified_archive_members': len(seen),
                      'episodes': len(rows), 'groups': archive_totals, 'status': 'PASS'}, indent=2))


if __name__ == '__main__':
    main()