"""Parameterized read-only public-byte and authenticated-local supplement checks."""
from concurrent.futures import ThreadPoolExecutor
from http.cookiejar import CookieJar
import hashlib
import json
from pathlib import Path
import sys
from urllib.request import build_opener, HTTPCookieProcessor

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT)); sys.path.insert(0, str(PROJECT/'scripts'))
from scripts.check_mask_under50_public import fetch
from scripts.check_mask_under50_public_v3 import public_get
from pallet.cluster_targets import digest
from pallet.mask_quota_saved_extension import file_inventory
from pallet.pose_review_geometry import canonical
from pallet.mask_review_continuation import audit_snapshot


def read(path):
    return json.loads(Path(path).read_text())


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


def check(batch, output, source_audit_output):
    require(type(batch) is int and batch >= 4, 'Explicit fourth-or-later supplement batch required')
    output = Path(output).resolve(); source_audit_output = Path(source_audit_output).resolve()
    require(output.parent == PROJECT/'outputs' and not output.exists(), 'Fresh acceptance output required')
    tasks = PROJECT/f'outputs/pallet_mask_under50_requests_v{batch}'
    managed = PROJECT/f'outputs/pallet_mask_under50_managed_v{batch}'
    manifest = read(tasks/'manifest.json'); seal = read(tasks/'verification.json')
    require(seal['state'] == 'passed' and seal['manifest_sha256'] == digest(tasks/'manifest.json'), 'Independent task seal required')
    output.mkdir(mode=0o700)
    package, configs = file_inventory(tasks), file_inventory(PROJECT/'configs')
    base = read(managed/'public_access.json')['public_url']; local = f'http://127.0.0.1:{3394+batch}'
    response = public_get(base, '/healthz'); health = response.json()
    require(response.status_code == 200 and health['targets'] == 1550 and health['publication_version'] == 15
        and health['manual_template_requests'] == manifest['request_count'] and health['editing_enabled'], 'Service identity differs')
    def asset(item):
        name, expected = item; response = public_get(base, '/template-requests/'+name)
        require(response.status_code == 200, 'Public asset unavailable: '+name)
        if name == 'report_zh.html':
            require('少于50份人工轮廓' in response.content.decode() and b'mgEditor' in response.content
                and b'under50ScopeNote' in response.content, 'Task page or editor missing')
        else:
            require(hashlib.sha256(response.content).hexdigest() == expected, 'Public asset bytes differ: '+name)
        require(response.headers.get('x-content-type-options') == 'nosniff' and response.headers.get('content-security-policy'), 'Protection headers missing')
        return dict(path='/template-requests/'+name, sha256=hashlib.sha256(response.content).hexdigest(), bytes=len(response.content))
    with ThreadPoolExecutor(max_workers=4) as pool:
        public_assets = list(pool.map(asset, manifest['public_assets'].items()))
    auth = build_opener(HTTPCookieProcessor(CookieJar()))
    secret = (PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip()
    require(fetch(auth, local, '/api/review/login', {'key': secret})[0] == 200, 'Local authentication failed')
    proposals = [json.loads(line) for line in (tasks/'proposals.jsonl').read_text().splitlines()]
    observations = []
    for proposal in proposals:
        key = proposal['target_key']; status, raw, _ = fetch(auth, local, '/api/review/targets/'+key); detail = json.loads(raw)
        require(status == 200 and detail['proposal_polygon'] == proposal['polygon'] and detail['assistant_preannotation_source']
            and not detail['proposal_dependency_stale'], 'Wrong editable target binding')
        if detail['review']:
            require(detail['review']['preannotation_provenance']['worklist_manifest_sha256'] == digest(tasks/'manifest.json'), 'Concurrent real-save source differs')
        observations.append(dict(target_key=key, actual_saved_revision=detail['review']['revision'] if detail['review'] else 0))
        response = public_get(base, f'/images/{key}.png')
        require(response.status_code == 200 and hashlib.sha256(response.content).hexdigest() == proposal['preannotation']['image_sha256'], 'Editor image alias differs')
    require(fetch(auth, local, '/api/review/logout', {})[0] == 200, 'Local logout failed')
    for path in ('/template-requests/internal/shortlist.jsonl', '/template-requests/manifest.json', '/mask_reviews.sqlite3', '/access_key.txt'):
        require(public_get(base, path).status_code == 404, 'Private resource exposed')
    require(public_get(base, '/api/review/targets/'+proposals[0]['target_key']).status_code == 401, 'Public edit details need authentication')
    old_services = []
    for name, port, count in [('pallet_mask_gallery_managed_v1', 3393, 26)]+[
            (f'pallet_mask_under50_managed_v{n}', 3394+n, read(PROJECT/f'outputs/pallet_mask_under50_requests_v{n}/manifest.json')['request_count'])
            for n in range(1, batch)]:
        status, raw, _ = fetch(build_opener(), f'http://127.0.0.1:{port}', '/healthz'); value = json.loads(raw)
        require(status == 200 and value['targets'] == 1550 and value['manual_template_requests'] == count, 'Prior service was replaced')
        old_services.append(dict(managed_directory=name, request_count=count, public_url=read(PROJECT/'outputs'/name/'public_access.json')['public_url']))
    audit_snapshot(source_audit_output)
    require(package == file_inventory(tasks) and configs == file_inventory(PROJECT/'configs'), 'Sealed task/global configuration changed')
    result = dict(state='passed_public_bytes_and_local_authenticated_editor_binding', batch=batch,
        public_url=base+f'/template-requests/?batch=under50-v{batch}', request_count=len(proposals), class_counts=manifest['class_counts'],
        public_assets_verified=public_assets, local_authenticated_details=observations, public_editor_image_aliases_verified=len(proposals),
        public_authentication_denial_verified=True, private_resources_denied=True, old_local_services_preserved=old_services,
        source_event_audit_sha256=digest(source_audit_output/'audit.json'), task_verification_sha256=digest(tasks/'verification.json'),
        code_sha256=digest(__file__), serving_code_sha256=digest(PROJECT/f'scripts/serve_mask_under50_review_v{batch}.py'),
        production_annotation_requests_sent=0, only_local_login_logout_posts=True, contour_accuracy_certified=False,
        public_authenticated_browser_not_tested=True)
    with (output/'public_acceptance.json').open('xb') as stream:
        stream.write(canonical(result)+b'\n')
    print(json.dumps({k: v for k, v in result.items() if k in ('state', 'public_url', 'request_count', 'class_counts')}), flush=True)


if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--batch', type=int, required=True); parser.add_argument('--output', type=Path, required=True)
    parser.add_argument('--source-audit-output', type=Path, required=True)
    args = parser.parse_args(); check(args.batch, args.output, args.source_audit_output)
