"""Check the supplementary worklist without submitting any annotations."""
from contextlib import closing
import json
import os
from pathlib import Path
import sqlite3
import sys
import time
from urllib.parse import urlsplit,unquote

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.mask_template_requests import load_requests
from pallet.pose_review_geometry import canonical
from review_http_retry import open_checked,RETRIES

OUT=PROJECT/'outputs/pallet_mask_template_requests_validation_v1'


def main():
    output=OUT/'public_acceptance.json'
    if output.exists():raise ValueError('Preserve completed acceptance')
    data=load_requests(PROJECT/'configs/active_mask_template_requests.json',PROJECT)
    root=data['directory'];requests=list(map(json.loads,(root/'requests.jsonl').read_text().splitlines()))
    base=json.loads((PROJECT/'outputs/pallet_mask_gallery_managed_v1/public_access.json').read_text())['public_url']
    pose=json.loads((PROJECT/'outputs/pallet_pose_review_managed_v1/public_access.json').read_text())['public_url']
    import hashlib
    for route,(path,mime,expected) in data['assets'].items():
        assert hashlib.sha256(path.read_bytes()).hexdigest()==expected,route
        served=hashlib.sha256(data['page'].encode()).hexdigest() if path.name=='report_zh.html' else expected
        with open_checked(base+route) as response:assert hashlib.sha256(response.read()).hexdigest()==served,route
    health=json.load(open_checked(base+'/healthz'))
    batch=PROJECT/json.loads((PROJECT/'configs/active_mask_gallery.json').read_text())['directory']
    accepted_count=json.loads((batch/'verification.json').read_text())['proposals_verified']
    assert health['targets']==accepted_count and health['manual_template_requests']==len(requests)
    before=json.loads((OUT/'before.json').read_text())
    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
    errors=[];writes=[];checks=[]
    def wait(page,condition):
        end=time.monotonic()+90
        while time.monotonic()<end:
            if page.evaluate(condition):return
            time.sleep(.1)
        raise AssertionError(condition)
    launch={};proxy_url=os.environ.get('HTTPS_PROXY') or os.environ.get('https_proxy')
    if proxy_url:
        p=urlsplit(proxy_url);launch['proxy']=dict(server=f'{p.scheme}://{p.hostname}:{p.port}',bypass='127.0.0.1,localhost')
        if p.username is not None:launch['proxy']['username']=unquote(p.username)
        if p.password is not None:launch['proxy']['password']=unquote(p.password)
    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'],**launch)
        for width in (1400,390):
            ctx=browser.new_context(viewport=dict(width=width,height=1000 if width==1400 else 844),is_mobile=width==390,has_touch=width==390)
            page=ctx.new_page();page.on('pageerror',lambda e:errors.append(str(e)))
            def deny(route):
                writes.append(route.request.url);route.fulfill(status=403,content_type='application/json',body='{"error":"read-only acceptance"}')
            page.route('**/api/annotations/**',deny);page.route('**/api/review/annotations/**',deny)
            page.goto(base+'/template-requests/',wait_until='domcontentloaded',timeout=90000)
            page.evaluate('document.fonts.ready')
            assert page.locator('article').count()==len(requests)
            assert page.evaluate('document.documentElement.scrollWidth<=innerWidth')
            page.screenshot(path=str(OUT/f'requests_{width}.png'))
            link=page.locator('a[href*="?target="]').first.get_attribute('href')
            assert link.startswith(pose+'/?target=')
            key=link.split('?target=',1)[1].split('&',1)[0]
            page.goto(link,wait_until='domcontentloaded',timeout=90000)
            page.locator('#accessKey').fill((PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip())
            page.locator('#loginForm button').click()
            wait(page,f'window.poseReviewDiagnostics && poseReviewDiagnostics().target==="{key}" && poseReviewDiagnostics().imageStatus==="ready"')
            assert not page.evaluate('poseReviewDiagnostics().dirty')
            checks.append(dict(width=width,request_count=len(requests),target_deeplink_loaded=key,annotation_writes=0))
            ctx.close()
        browser.close()
    assert not errors and not writes
    for name,table in (('gallery','reviews'),('pose','annotations')):
        path=PROJECT/before[name]['database']
        with closing(sqlite3.connect(path.as_uri()+'?mode=ro',uri=True)) as db:
            events=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'))
            assert hashlib.sha256(canonical(events[:before[name]['events']])).hexdigest()==before[name]['events_sha256']
            assert db.execute(f'SELECT COUNT(*) FROM {table}').fetchone()[0]>=before[name]['saved']
    result=dict(state='passed',url=base+'/template-requests/',requests=len(requests),accepted_candidate_count_unchanged=accepted_count,
        public_assets_verified=len(data['assets']),browser_checks=checks,production_annotation_writes=0,
        online_publication_status_normalized=data.get('online_page_normalized',False),frozen_asset_bytes_unchanged=True,
        page_errors=errors,transient_transport_retries=RETRIES)
    output.write_bytes(canonical(result)+b'\n');print(json.dumps(result),flush=True)


def backup():
    import hashlib
    OUT.mkdir(exist_ok=True)
    if (OUT/'before.json').exists():raise ValueError('Preserve existing validation backup')
    records={}
    for name,database,table in [('gallery','outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3','reviews'),
            ('pose','outputs/pallet_pose_human_review_v1/annotations.sqlite3','annotations')]:
        path=PROJECT/database
        with closing(sqlite3.connect(path.as_uri()+'?mode=ro',uri=True)) as db,closing(sqlite3.connect(OUT/(name+'_before.sqlite3'))) as dst:
            db.backup(dst);events=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'))
            records[name]=dict(database=database,saved=db.execute(f'SELECT COUNT(*) FROM {table}').fetchone()[0],
                events=len(events),events_sha256=hashlib.sha256(canonical(events)).hexdigest())
        (OUT/(name+'_before.sqlite3')).chmod(0o600)
    (OUT/'before.json').write_bytes(canonical(records)+b'\n')
    print(json.dumps(dict(state='backup_complete',saved={k:v['saved'] for k,v in records.items()})))


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--output',type=Path,default=OUT)
    parser.add_argument('--stage',choices=['before','after'],default='after')
    args=parser.parse_args();OUT=args.output.resolve()
    if not OUT.is_relative_to(PROJECT/'outputs'):raise ValueError('Expected validation output directory')
    backup() if args.stage=='before' else main()
