"""Independently compare a public ZIP to sealed source bytes; never import its packager."""
import hashlib
import json
from pathlib import Path,PurePosixPath
import re
import sys
from zipfile import ZipFile

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest
from pallet.pose_review_geometry import canonical

ROOT_FILES={'report_zh.html','report-font.otf','FONT_LICENSE.txt','manifest.json','verification.json',
    'proposals.jsonl','new_proposals.jsonl','manual_proposals.jsonl','shortfalls.json','template_inventory.json',
    'font_coverage.json','vertex2_before_after.png','review_dispositions.jsonl','review_completion_statement.json'}
FOLDERS={'cases','images','masks','labelme','templates','refined','generation','quota_generation','quota100_generation',
    'quota100_continue_generation','quota100_complete_generation','remaining_classes_generation','remaining_expand_generation',
    'remaining_continue_generation','remaining_round2_generation','remaining_round3_generation','remaining_round4_generation','remaining_round5_generation'}


def safe_name(name):
    path=PurePosixPath(name)
    return (not path.is_absolute() and '..' not in path.parts and '\\' not in name and str(path)==name and
        path.suffix in ('.png','.json','.jsonl','.html','.txt','.otf') and
        (name in ROOT_FILES or len(path.parts)>1 and path.parts[0] in FOLDERS) and
        not any(t in name for t in ('.sqlite','source_records','all_manual_sources','access_key')))


def audit(root):
    proof=json.loads((root/'delivery_verification.json').read_text());seal=json.loads((root/'verification.json').read_text())
    assert proof['state']==seal['state']=='passed' and seal['manifest_sha256']==digest(root/'manifest.json')
    assert seal['proposals_sha256']==digest(root/'proposals.jsonl') and proof['archive']=='pallet_mask_refined_review.zip'
    archive=root/proof['archive'];assert digest(archive)==proof['sha256']
    expected={str(p.relative_to(root)) for p in root.rglob('*') if p.is_file() and safe_name(str(p.relative_to(root)))}
    with ZipFile(archive) as zipped:
        names=zipped.namelist();hashes=json.loads(zipped.read('checksums.json'))
        assert len(names)==len(set(names))==proof['files'] and set(names)==set(hashes)|{'checksums.json','README_zh.txt'}
        assert set(hashes)==expected and hashes==proof['source_hashes']
        for name,h in hashes.items():
            assert safe_name(name) and not (root/name).is_symlink() and (root/name).resolve().is_relative_to(root)
            raw=zipped.read(name);assert hashlib.sha256(raw).hexdigest()==h==digest(root/name)
            if name.endswith(('.json','.jsonl','.html')):
                text=raw.decode('utf-8')
                assert not re.search(r'(?<![A-Za-z0-9_])(?:current_payload_raw|human_event_payload_raw|saved_event_payload_raw|access_key)(?![A-Za-z0-9_])',text)
                def inspect(value):
                    if isinstance(value,list):
                        for item in value:inspect(item)
                    if isinstance(value,dict):
                        for key,item in value.items():
                            assert key not in {'current_payload','human_event_payload','saved_event_payload','human_event_raw','saved_event_raw','access_key'}
                            hash_keys={'current_payload_raw_sha256','human_event_raw_sha256','human_event_payload_raw_sha256',
                                'saved_event_raw_sha256','saved_event_payload_raw_sha256'}
                            if key in hash_keys or key.startswith(('current_payload_raw_','human_event_payload_raw_','saved_event_payload_raw_')):
                                assert key in hash_keys and isinstance(item,str) and re.fullmatch('[0-9a-f]{64}',item)
                            inspect(item)
                if name.endswith('.json'):inspect(json.loads(text))
                if name.endswith('.jsonl'):
                    for line in text.splitlines():
                        if line.strip():inspect(json.loads(line))
        assert zipped.testzip() is None
    return dict(state='passed',entries=len(names),source_files_recomputed=len(hashes),archive_sha256=proof['sha256'],
        private_databases_and_raw_events_excluded=True,source_files_unchanged=True,verification_script_sha256=digest(__file__))


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--directory',type=Path,required=True);parser.add_argument('--output',type=Path,required=True)
    args=parser.parse_args();root=args.directory.resolve();out=args.output.resolve();result=out/'archive_independent_acceptance.json'
    if root.parent!=PROJECT/'outputs' or not out.is_relative_to(PROJECT/'outputs') or result.exists():raise ValueError('Use explicit source and fresh acceptance paths')
    value=audit(root);result.write_bytes(canonical(value)+b'\n');print(json.dumps(value),flush=True)
