"""Public transport/authenticated reads; never calls an annotation POST endpoint."""
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
from contextlib import closing
import hashlib
import json
from pathlib import Path
import sqlite3
import sys

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
from pallet.mask_quality_recovery import fingerprint,POSE,GALLERY
from scripts.review_http_pool import ReadOnlyHTTP

ROOT=PROJECT/'outputs/pallet_mask_model_requests_v1';OUT=PROJECT/'outputs/pallet_mask_model_public_acceptance_v2'
STATE=PROJECT/'outputs/pallet_mask_model_managed_v1/public_access.json'
REVIEWS=PROJECT/'outputs/pallet_mask_model_reviews_v1/mask_reviews.sqlite3'


def main():
    if OUT.exists():raise ValueError('Preserve earlier public transport evidence')
    OUT.mkdir(mode=0o700)
    state=json.loads(STATE.read_text());base=state['public_url']
    if not base.startswith('https://') or not base.endswith('.trycloudflare.com'):raise ValueError('Explicit current dedicated HTTPS public endpoint required')
    manifest=json.loads((ROOT/'manifest.json').read_text());proposals=[json.loads(s) for s in (ROOT/'proposals.jsonl').read_text().splitlines()]
    db=REVIEWS
    before=dict(pose=fingerprint(POSE),gallery=fingerprint(GALLERY),model=fingerprint(db))
    client=ReadOnlyHTTP(base)
    def get(path,expected=200):
        response=client.get(path,expected=expected)
        return response.status_code,response.content,dict(response.headers)
    health=json.loads(get('/healthz')[1]);assert health['service']=='pallet_mask_model_preannotation_review' and health['targets']==manifest['request_count'] and health['machine_drafts_not_human_completed'] is True
    assert health['publication_version']==manifest.get('source_namespace','model-native-v1')
    page=get('/')[1].decode();assert page.count('<article id="target-')==manifest['request_count'] and '/review-ui/editor.js' in page and '未保存不计完成' in page
    reps=[next(p for p in proposals if p['class_id']==c) for c in sorted({p['class_id'] for p in proposals})]
    names=['report-font.otf','FONT_LICENSE.txt','model-editor.js']+[f'{d}/{p["target_key"]}.{ext}' for p in reps for d,ext in [('images','png'),('cases','png'),('masks','png'),('labelme','json')]]
    def asset(name):
        status,raw,headers=get('/'+name);assert status==200 and hashlib.sha256(raw).hexdigest()==manifest['public_assets'][name]
        if name.startswith('labelme/') and 'standard_counts' in manifest:
            label=json.loads(raw);k=manifest['standard_counts'][str(label['class_id'])]
            assert label['num_keypoints']==len(label['keypoints_xy'])==k
            assert len([s for s in label['shapes'] if s['shape_type']=='point'])==k
        return dict(path=name,sha256=hashlib.sha256(raw).hexdigest(),size=len(raw))
    with ThreadPoolExecutor(max_workers=4) as pool:assets=list(pool.map(asset,names))
    for path in ('/private/predictions.jsonl','/proposals.jsonl','/manifest.json','/input_manifest.json','/api/review/summary'):
        get(path,401 if path.startswith('/api/') else 404)
    key=(PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip()
    assert client.login(key,gallery=True).status_code==200
    assert json.loads(get('/api/review/bootstrap')[1])['authenticated'] is True
    summary=json.loads(get('/api/review/summary')[1]);details=[]
    for p in reps:
        d=json.loads(get('/api/review/targets/'+p['target_key'])[1])
        assert d['proposal_polygon']==p['polygon'] and not d['proposal_dependency_stale']
        if manifest.get('allow_template_initialization'):
            assert d['initialization_source']==p['initialization'] and d['quality_override_authorized'] is True
            assert d['model_preannotation_source']==(p['initialization']['kind']=='model_class_K')
            assert d['template_initialization_source']==(p['initialization']['kind']=='same_class_template')
            assert d['image_reuse']==p['image_reuse'] and d['quality_certified'] is False
        else:assert d['model_preannotation_source'] is True
        assert d['model_provenance']['checkpoint_sha256']==manifest['checkpoint_sha256']
        if 'standard_counts' in manifest:
            k=manifest['standard_counts'][str(p['class_id'])]
            assert len(d['proposal_polygon'])==d['class_keypoint_constraint']['standard_count']==k
        details.append(dict(target_key=p['target_key'],class_id=p['class_id'],source_binding=d['source_binding']))
    after=dict(pose=fingerprint(POSE),gallery=fingerprint(GALLERY),model=fingerprint(db))
    with closing(sqlite3.connect(db.resolve().as_uri()+'?mode=ro',uri=True)) as connection:events=connection.execute('SELECT count(*) FROM events').fetchone()[0]
    receipt=dict(state='passed_public_HTTPS_sampled_assets_and_authenticated_reads_not_Safari_or_accuracy',base=base,
        health=health,manifest_sha256=digest(ROOT/'manifest.json'),page_target_cards=manifest['request_count'],classes_checked=sorted({p['class_id'] for p in reps}),
        public_class_keypoint_counts_checked='standard_counts' in manifest,
        public_assets_checked=assets,all_other_assets_verified_locally_only=True,authenticated_target_reads=details,
        private_resources_not_public=True,production_annotation_POST_attempts=0,production_annotation_writes=0,
        real_model_review_events=events,real_saved_reviews_at_check=len(summary['reviews']),
        source_fingerprints_before=before,source_fingerprints_after=after,concurrent_human_changes=before!=after,
        bounded_read_only_transport_retries=client.retries,
        boot_autostart_configured=False,temporary_Quick_Tunnel_URL=True,real_iPhone_Safari_tested=False,model_accuracy_certified=False,code_sha256=digest(__file__))
    with (OUT/'public_acceptance.json').open('xb') as stream:stream.write(canonical(receipt)+b'\n')
    client.close()
    print(json.dumps(dict(state=receipt['state'],public_url=base,assets_checked=len(assets),class_reads=len(details),production_annotation_writes=0,concurrent_human_changes=before!=after)))


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--output',type=Path,default=OUT);args=parser.parse_args();OUT=args.output.resolve()
    if OUT.parent!=PROJECT/'outputs' or not OUT.name.startswith('pallet_mask_model_public_acceptance_'):raise ValueError('Fresh public evidence directory required')
    try:main()
    except Exception as error:
        if OUT.exists() and not (OUT/'failure.json').exists() and not (OUT/'public_acceptance.json').exists():
            secret=(PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip()
            with (OUT/'failure.json').open('xb') as stream:stream.write(canonical(dict(state='failed_transport_or_public_contract_not_passed',
                error=str(error).replace(secret,'[redacted]'),annotation_POST_attempts=0,production_annotation_writes=0))+b'\n')
        raise
