"""Back up rollout inputs; publicly validate editing without real annotation writes."""
import argparse
from contextlib import closing
from http.cookiejar import CookieJar
import json
import os
from pathlib import Path
import sqlite3
import sys
import time
from urllib.error import HTTPError
from urllib.request import Request,urlopen,build_opener,HTTPCookieProcessor

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

OUT=PROJECT/'outputs/pallet_mask_editor_validation_v1'
REVIEWS=PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3'


def before():
    path=OUT/'gallery_before_deployment.json'
    if path.exists():raise ValueError('Do not overwrite deployment evidence')
    root=active_directory()
    files={str(p.relative_to(PROJECT)):digest(p) for p in root.rglob('*') if p.is_file() and not p.name.endswith(('-shm','-wal'))}
    services={name:json.loads((PROJECT/'outputs'/name/'supervisor.json').read_text()) for name in
        ('pallet_mask_gallery_managed_v1','pallet_pose_review_managed_v1','pallet_structure_review_managed_v1')}
    review_existed=REVIEWS.exists()
    if review_existed:
        with closing(sqlite3.connect(REVIEWS.resolve().as_uri()+'?mode=ro',uri=True)) as src,closing(sqlite3.connect(OUT/'mask_reviews_before.sqlite3')) as dst:src.backup(dst)
    path.write_bytes(canonical(dict(frozen_gallery_files=files,services=services,mask_review_database_existed=review_existed,
        pose_font_sha256=digest(PROJECT/'pallet/assets/pose_review/ui-font.otf'),
        active_proposals_sha256=digest(PROJECT/'configs/active_mask_template_proposals.json')))+b'\n')
    print(json.dumps(dict(state='backup_complete',frozen_files=len(files),review_database_existed=review_existed)),flush=True)


def after():
    path=OUT/'editor_public_acceptance.json'
    if path.exists():raise ValueError('Do not overwrite completed acceptance')
    frozen=json.loads((OUT/'gallery_before_deployment.json').read_text())
    access_path=PROJECT/'outputs/pallet_mask_gallery_managed_v1/public_access.json'
    access=json.loads(access_path.read_text());base=access['public_url']
    health=json.load(urlopen(base+'/healthz',timeout=60));assert health['editing_enabled'] and health['targets']==56
    assert health['editor_version']=='mask-gallery-editor-v1'
    html=urlopen(base+'/?editor=1',timeout=60).read().decode();assert '/review-ui/editor.js' in html
    for name in ('editor.js','editor.css','editor-font.otf','FONT_LICENSE.txt'):
        with urlopen(base+'/review-ui/'+name,timeout=60) as response:
            import hashlib
            assert hashlib.sha256(response.read()).hexdigest()==digest(ASSETS/name)
    boot=json.load(urlopen(base+'/api/review/bootstrap',timeout=60));assert not boot['authenticated']
    key=json.loads((active_directory()/'new_proposals.jsonl').read_text().splitlines()[0])['target_key']
    for route in ('/api/review/targets/'+key,'/api/review/summary','/api/review/export/'+key+'/mask.png'):
        try:urlopen(base+route,timeout=60);raise AssertionError('Unauthenticated private review access')
        except HTTPError as e:assert e.code==401
    try:
        urlopen(Request(base+'/api/review/annotations/'+key,data=b'{}',headers={'Content-Type':'application/json','X-Review-Request':'1'}),timeout=60)
        raise AssertionError('Unauthenticated editing allowed')
    except HTTPError as e:assert e.code==401
    for route in ('/mask_reviews.sqlite3','/reviews_snapshot.sqlite3','/access_key.txt','/review-ui/editor.html','/api/annotations/'+key):
        try:urlopen(base+route,timeout=60);raise AssertionError('Private path exposed')
        except HTTPError as e:assert e.code==404
    with closing(sqlite3.connect(REVIEWS.resolve().as_uri()+'?mode=ro',uri=True)) as db:
        events_before=[tuple(r) for r in db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id')]
        current_before=dict(db.execute('SELECT target_key,payload FROM reviews'))
    os.environ.setdefault('PLAYWRIGHT_NODEJS_PATH','/tmp/opencode/pallet_review_browser_tools/node');sys.path.insert(0,'/tmp/opencode/pallet_review_pw132')
    from playwright.sync_api import sync_playwright
    checks=[];mutations=[];errors=[]
    def wait(page,condition):
        deadline=time.monotonic()+90
        while time.monotonic()<deadline:
            if page.evaluate(condition):return
            time.sleep(.1)
        raise AssertionError(condition)
    with sync_playwright() as pw:
        browser=pw.chromium.launch(executable_path='/tmp/opencode/pallet_pose_browser/chrome-linux64/chrome',headless=True,
            args=['--no-sandbox','--disable-dev-shm-usage','--disable-gpu','--disable-software-rasterizer'])
        for width in (1400,390):
            context=browser.new_context(viewport=dict(width=width,height=844 if width==390 else 1000),is_mobile=width==390,has_touch=width==390)
            page=context.new_page();page.on('pageerror',lambda e:errors.append(str(e)))
            def deny(route):mutations.append(route.request.url);route.fulfill(status=403,content_type='application/json',body='{"error":"public acceptance does not save annotations"}')
            page.route('**/api/review/annotations/**',deny)
            page.goto(base+'/?revision=3&editor=1#new-batch',wait_until='domcontentloaded',timeout=60000)
            wait(page,'window.maskGalleryDiagnostics && document.querySelectorAll(".mg-edit-button[data-key]").length===56')
            assert page.locator('article:visible').count()==5
            page.locator(f'.mg-edit-button[data-key="{key}"]').click()
            wait(page,'document.querySelector("#mgLogin").open')
            assert page.locator('#mgLogin').is_visible()
            page.locator('#mgAccessKey').fill((PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip())
            page.locator('#mgLoginSubmit').click()
            wait(page,'maskGalleryDiagnostics().open && maskGalleryDiagnostics().imageStatus==="ready" && !maskGalleryDiagnostics().loading')
            d=page.evaluate('maskGalleryDiagnostics()');assert d['target']==key and not d['dirty']
            page.evaluate('document.fonts.ready');assert page.evaluate('document.fonts.check(\'16px GalleryEditorSans\',\'拖动顶点点击边增点修订保存\')')
            page.locator('#mgZoomIn').click();page.locator('#mgZoomOut').click()
            same=page.evaluate('maskGalleryDiagnostics()');assert same['polygon']==d['polygon'] and not same['dirty']
            assert page.evaluate('document.documentElement.scrollWidth<=innerWidth')
            assert page.evaluate('document.querySelector("#mgEditor").scrollWidth<=document.querySelector("#mgEditor").clientWidth+2')
            page.locator('#mgCanvas').scroll_into_view_if_needed();page.screenshot(path=str(OUT/f'public_editor_{width}px.png'))
            page.locator('#mgClose').click();assert not page.evaluate('maskGalleryDiagnostics().open')
            assert not errors
            checks.append(dict(viewport=width,login_required=True,existing_pose_access_key_accepted=True,
                original_coordinate_editor_loaded=True,all_56_edit_buttons=True,view_changes_do_not_edit=True,
                original_polygon=d['polygon'],no_overflow=True,page_errors=errors[:],annotation_requests=0))
            context.close()
        browser.close()
    assert not mutations and not errors
    with closing(sqlite3.connect(REVIEWS.resolve().as_uri()+'?mode=ro',uri=True)) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        assert events_before==[tuple(r) for r in db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id')]
        assert current_before==dict(db.execute('SELECT target_key,payload FROM reviews'))
    for file,sha in frozen['frozen_gallery_files'].items():assert digest(PROJECT/file)==sha
    assert digest(PROJECT/'pallet/assets/pose_review/ui-font.otf')==frozen['pose_font_sha256']
    assert digest(PROJECT/'configs/active_mask_template_proposals.json')==frozen['active_proposals_sha256']
    for name,old in frozen['services'].items():
        now=json.loads((PROJECT/'outputs'/name/'supervisor.json').read_text())
        assert now['pid']==old['pid'] and now['tunnel']['pid']==old['tunnel']['pid']
        if name!='pallet_mask_gallery_managed_v1':assert now['app']['pid']==old['app']['pid']
    for name in ('supervisor.json','public_access.json'):
        p=access_path.with_name(name);s=json.loads(p.read_text());s.update(read_only=False,editing_enabled=True,
            authentication_required=False,authentication_required_for_editing=True,editor_version='mask-gallery-editor-v1',
            review_directory='outputs/pallet_mask_gallery_reviews_v1',gallery_config='configs/active_mask_gallery.json',
            gallery='outputs/pallet_mask_template_bulk_v5/report_zh.html')
        tmp=p.with_suffix('.editor.tmp');tmp.write_text(json.dumps(s,ensure_ascii=False,indent=2)+'\n');tmp.replace(p)
    from fontTools.ttLib import TTFont
    required={ord(c) for p in [ASSETS/'editor.html',ASSETS/'editor.js',ASSETS/'editor.css',PROJECT/'pallet/mask_gallery_review.py',PROJECT/'pallet/mask_gallery.py'] for c in p.read_text() if '\u3400'<=c<='\u9fff'}
    assert required<=set(TTFont(ASSETS/'editor-font.otf').getBestCmap())
    result=dict(state='passed',public_url=base+'/?revision=3&editor=1#new-batch',editor_version='mask-gallery-editor-v1',
        authenticated_editing_enabled=True,anonymous_browsing_preserved=True,saved_revisions=len(current_before),
        browser_checks=checks,annotation_mutation_requests=mutations,production_annotation_writes=0,
        source_gallery_files_unchanged=True,pose_and_structure_apps_not_restarted=True,all_tunnels_and_supervisors_unchanged=True,
        edit_API_login_and_private_path_checks=True,editor_font_all_Chinese_covered=True,real_iPhone_Safari_tested=False)
    path.write_bytes(canonical(result)+b'\n');print(json.dumps(result),flush=True)


if __name__=='__main__':
    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--stage',choices=['before','after'],required=True);a=p.parse_args()
    before() if a.stage=='before' else after()
