"""Exhaustive public bytes/API acceptance using bounded persistent connections."""
from concurrent.futures import ThreadPoolExecutor
from contextlib import closing
from datetime import datetime,timezone
import hashlib
import json
from pathlib import Path
import sqlite3
import sys

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT));sys.path.insert(0,str(PROJECT/'scripts'))
from pallet.cluster_targets import digest
from pallet.mask_gallery import Gallery,active_directory
from pallet.mask_review_preservation import saved_revision_preserved,event_prefix_preserved
from pallet.mask_template_requests import load_requests
from pallet.pose_review_geometry import canonical
from review_http_pool import ReadOnlyHTTP


def require(value,message):
    if not value:raise ValueError(message)


def stored(path,table,*,immutable=False):
    with closing(sqlite3.connect(path.resolve().as_uri()+'?mode=ro'+('&immutable=1' if immutable else ''),uri=True)) as db:
        require(db.execute('PRAGMA quick_check').fetchone()[0]=='ok','Review database integrity failed')
        return ({k:json.loads(p) for k,p in db.execute(f'SELECT target_key,payload FROM {table}')},
            list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id')))


def checked_bytes(client,route,expected):
    response=client.get(route)
    require(hashlib.sha256(response.content).hexdigest()==expected,'Public bytes differ: '+route)
    return route


def main():
    import argparse
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output',type=Path,required=True)
    parser.add_argument('--version',type=int,required=True)
    parser.add_argument('--workers',type=int,default=8)
    args=parser.parse_args();out=args.output.resolve();result=out/'public_acceptance.json'
    require(out.is_relative_to(PROJECT/'outputs') and not result.exists(),'Use a fresh acceptance directory')
    require(1<=args.workers<=12,'Bound HTTP acceptance concurrency to at most 12')
    root=active_directory();manifest=json.loads((root/'manifest.json').read_text());gallery=Gallery(root)
    require(gallery.publication_version==args.version==manifest['publication_version'],'Unexpected active publication')
    canonical_records=gallery.proposals;new=[json.loads(s) for s in (root/'new_proposals.jsonl').read_text().splitlines()]
    manual=[json.loads(s) for s in (root/'manual_proposals.jsonl').read_text().splitlines()]
    artifacts=json.loads((root/'artifact_hashes.json').read_text())
    for route,(path,_,expected) in gallery.assets.items():
        require(artifacts[str(path.relative_to(root))]==expected,'Sealed public artifact differs: '+route)
    original_saved,original_events=stored(out/'gallery_reviews_before.sqlite3','reviews')
    snapshot_saved,_=stored(root/'gallery_reviews_snapshot.sqlite3','reviews',immutable=True)
    require(all(saved_revision_preserved(v,snapshot_saved.get(k)) for k,v in original_saved.items()),'Generation lost previous saved revisions')
    tasks=load_requests(PROJECT/'configs/active_mask_template_requests.json',PROJECT)
    require(tasks is not None,'Expected a separate sealed manual worklist')
    base=json.loads((PROJECT/'outputs/pallet_mask_gallery_managed_v1/public_access.json').read_text())['public_url']
    observed=[]
    with ReadOnlyHTTP(base) as client,ThreadPoolExecutor(max_workers=args.workers) as pool:
        health=client.get('/healthz').json()
        require(health['targets']==gallery.count and health['publication_version']==args.version and
            health['editing_enabled'] and health['manual_template_requests']==tasks['count'],'Public health differs')
        asset_plan=[(route,expected) for route,(_,_,expected) in gallery.assets.items() if route!='/report_zh.html']
        checked=list(pool.map(lambda item:checked_bytes(client,*item),asset_plan))
        task_plan=[]
        task_page=tasks['page']
        if tasks.get('preannotations'):
            fragment=(PROJECT/'pallet/assets/mask_gallery/editor.html').read_text()
            task_page=task_page.replace('</html>',fragment+'</html>') if '</html>' in task_page else task_page+fragment
        for route,(path,_,expected) in tasks['assets'].items():
            require(digest(path)==expected,'Frozen task asset changed')
            served=hashlib.sha256(task_page.encode()).hexdigest() if path.name=='report_zh.html' else expected
            task_plan.append((route,served))
        for key in tasks.get('preannotations',{}):
            task_plan.append(('/images/'+key+'.png',tasks['assets'][f'/template-requests/images/{key}.png'][2]))
        task_checked=list(pool.map(lambda item:checked_bytes(client,*item),task_plan))
        for route in ('/mask_reviews.sqlite3','/gallery_reviews_snapshot.sqlite3','/reviews_snapshot.sqlite3','/access_key.txt',
                '/template-requests/requests.jsonl','/template-requests/manifest.json','/template-requests/independent_verification.json',
                '/template-requests/proposals.jsonl','/template-requests/internal/shortlist.jsonl',
                '/pending_original_rectangle_saves.jsonl','/source_registry.json','/registration_attempts.jsonl',
                '/preannotation_source_evidence/proposals.jsonl','/parent_evidence/gallery_reviews_snapshot.sqlite3'):
            client.get(route,expected=404)
        sample=(new or manual or list(canonical_records.values()))[0]['target_key']
        client.get('/api/review/targets/'+sample,expected=401)
        password=(PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip()
        response=client.login(password,gallery=True)
        require('HttpOnly' in response.headers.get('Set-Cookie','') and 'Secure' in response.headers.get('Set-Cookie',''),'Unsafe authentication cookie')
        # Workers were created before login; recreate their sessions with only the
        # actual login cookie and the same bounded read-only client contract.
        with ReadOnlyHTTP(base) as authenticated:
            authenticated.cookies.update(client.cookies)
            def saved_detail(item):
                key,old=item;detail=authenticated.get('/api/review/targets/'+key).json()
                require(saved_revision_preserved(old,detail['review']),'Saved human revision was not preserved: '+key)
                return key
            saved_checked=list(pool.map(saved_detail,snapshot_saved.items()))
            def candidate_detail(proposal):
                key=proposal['target_key'];detail=authenticated.get('/api/review/targets/'+key).json()
                require(detail['proposal_polygon']==proposal['polygon'] and not detail['proposal_dependency_stale'],
                    'Candidate polygon/source revision differs: '+key)
                review=detail['review']
                if review is not None:
                    require(review['target_key']==key and review['human_edited'] and review['source_binding']==detail['source_binding'],
                        'New actual human review has the wrong source binding')
                return key if review is not None else None
            observed=[key for key in pool.map(candidate_detail,new) if key is not None]
            def manual_detail(proposal):
                key=proposal['target_key'];detail=authenticated.get('/api/review/targets/'+key).json()
                require((detail['saved_pose_manual_source'] or detail.get('saved_pose_review_source') or detail.get('saved_gallery_manual_source')) and
                    detail['proposal_polygon']==proposal['polygon'] and not detail['proposal_dependency_stale'],
                    'Saved manual/review-only source differs: '+key)
                if detail['review'] is not None:require(detail['review']['source_binding']==detail['source_binding'],'Independent review binding differs')
                return key
            manual_checked=list(pool.map(manual_detail,manual))
            def preannotation_detail(proposal):
                key=proposal['target_key'];detail=authenticated.get('/api/review/targets/'+key).json()
                require(detail.get('assistant_preannotation_source') is True and detail['proposal_polygon']==proposal['polygon']
                    and not detail['proposal_dependency_stale'],'Preannotation polygon/source protection differs: '+key)
                require(not detail['saved_pose_manual_source'] and not detail['saved_pose_review_source'],
                    'An assistant draft must not be labelled a saved human/pose source')
                if detail['review'] is not None:require(detail['review']['source_binding']==detail['source_binding'],'New real preannotation review binding differs')
                return key
            preannotations_checked=list(pool.map(preannotation_detail,tasks.get('preannotations',{}).values()))
            authenticated_retries=list(authenticated.retries)
        page=client.get('/').text
        require('mgEditor' in page and 'manualTemplateRequests' in page,'Missing online editor/worklist controls')
        for name in ('editor.js','editor.css','editor-font.otf','FONT_LICENSE.txt'):
            checked_bytes(client,'/review-ui/'+name,digest(PROJECT/'pallet/assets/mask_gallery'/name))
        retries=list(client.retries)+authenticated_retries
    latest,events=stored(PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3','reviews')
    require(event_prefix_preserved(original_events,events) and all(saved_revision_preserved(v,latest.get(k)) for k,v in original_saved.items()),
        'Human history changed or regressed during acceptance')
    baseline=json.loads((out/'gallery_deployment_before.json').read_text())
    for name,expected in baseline['frozen'].items():require(digest(PROJECT/name)==expected,'Old publication file changed: '+name)
    for name,previous in baseline['services'].items():
        now=json.loads((PROJECT/'outputs'/name/'supervisor.json').read_text())
        require(now['pid']==previous['pid'] and now['tunnel']['pid']==previous['tunnel']['pid'],'Supervisor/tunnel was replaced')
        if name=='pallet_structure_review_managed_v1':require(now['app']['pid']==previous['app']['pid'],'Original structure application was replaced')
    value=dict(state='passed',publication_version=args.version,public_url=base+f'/?revision={args.version}#new-batch',targets=gallery.count,new=len(new),
        public_assets_verified=len(checked),public_task_routes_verified=len(task_checked),saved_human_targets_preserved=len(original_saved),
        historical_events_preserved=len(original_events),generation_snapshot_saved_targets_verified=len(saved_checked),
        saved_pose_sources_preserved=sum(p.get('origin')=='original_pose_human_revision' for p in manual),
        saved_gallery_manual_sources_preserved=sum(p.get('schema')=='saved_gallery_mask_entry_v1' for p in manual),
        saved_manual_sources_verified=len(manual_checked),user_saved_new_candidates_observed=observed,
        separately_preannotated_tasks_verified=len(preannotations_checked),preannotated_tasks_not_counted_in_gallery=True,
        bounded_persistent_http_workers=args.workers,all_routes_verified_over_actual_public_origin=True,
        transient_transport_retries=retries,all_tunnels_and_supervisors_preserved=True,old_gallery_files_unchanged=True,
        production_annotation_writes=0,browser_acceptance_separate=True,verified_at=datetime.now(timezone.utc).isoformat())
    result.write_bytes(canonical(value)+b'\n');print(json.dumps({k:v for k,v in value.items() if k!='transient_transport_retries'}),flush=True)


if __name__=='__main__':main()
