"""Read-only deployment checks for refined-template masks and preserved edits."""
from concurrent.futures import ThreadPoolExecutor
from contextlib import closing
from hashlib import sha256
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 HTTPCookieProcessor,Request,build_opener,urlopen
from urllib.parse import urlsplit,unquote

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest
from pallet.mask_gallery import Gallery,active_directory
from pallet.pose_review_geometry import canonical
from pallet.mask_review_preservation import saved_revision_preserved,event_prefix_preserved
from review_http_retry import open_checked,RETRIES

OUT=PROJECT/'outputs/pallet_mask_refined_deployment_v1'
DB=PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3'


def refresh_service_metadata():
    # The preserved supervisor predates editor support. Its running process may
    # still emit historical static metadata after an app restart; record the
    # successful health check without restarting its tunnel.
    health=json.load(urlopen('http://127.0.0.1:3393/healthz',timeout=10))
    version=json.loads((PROJECT/'configs/active_mask_gallery.json').read_text())['publication_version']
    assert health['editing_enabled'] and health['publication_version']==version
    from datetime import datetime,timezone
    state_dir=PROJECT/'outputs/pallet_mask_gallery_managed_v1'
    for name in ('public_access.json','supervisor.json'):
        path=state_dir/name;value=json.loads(path.read_text())
        value.update(state='connected',updated_at=datetime.now(timezone.utc).isoformat(),read_only=False,
            editing_enabled=True,authentication_required_for_editing=True,editor_version=health['editor_version'],
            publication_version=version,targets=health['targets'],gallery_config='configs/active_mask_gallery.json',
            gallery=str(active_directory().relative_to(PROJECT))+'/report_zh.html',
            review_directory='outputs/pallet_mask_gallery_reviews_v1')
        tmp=path.with_suffix('.refined.tmp');tmp.write_text(json.dumps(value,ensure_ascii=False,indent=2)+'\n');tmp.replace(path)


def backup():
    OUT.mkdir(exist_ok=True);destination=OUT/'gallery_reviews_before.sqlite3'
    if destination.exists():raise ValueError('Preserve existing deployment backup')
    with closing(sqlite3.connect(DB.as_uri()+'?mode=ro',uri=True)) as source,closing(sqlite3.connect(destination)) as dest:source.backup(dest)
    destination.chmod(0o600)
    for name in ('active_mask_gallery.json','active_mask_template_proposals.json'):
        (OUT/(name+'.before')).write_bytes((PROJECT/'configs'/name).read_bytes())
    frozen={str(p.relative_to(PROJECT)):digest(p) for p in active_directory().rglob('*')
        if p.is_file() and not p.name.endswith(('-wal','-shm'))}
    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')}
    (OUT/'gallery_deployment_before.json').write_bytes(canonical(dict(frozen=frozen,services=services))+b'\n')
    print(json.dumps(dict(state='backed_up',frozen_files=len(frozen))))


def check():
    path=OUT/'public_acceptance.json'
    if path.exists():raise ValueError('Preserve completed acceptance evidence')
    root=active_directory();gallery=Gallery(root)
    manifest=json.loads((root/'manifest.json').read_text());version=manifest['publication_version']
    proposals=gallery.proposals;new=list(map(json.loads,(root/'new_proposals.jsonl').read_text().splitlines()))
    with closing(sqlite3.connect((OUT/'gallery_reviews_before.sqlite3').as_uri()+'?mode=ro',uri=True)) as db:
        saved={k:json.loads(p) for k,p in db.execute('SELECT target_key,payload FROM reviews')}
        historical=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'))
    manual=list(map(json.loads,(root/'manual_proposals.jsonl').read_text().splitlines())) if (root/'manual_proposals.jsonl').exists() else []
    with closing(sqlite3.connect((root/'gallery_reviews_snapshot.sqlite3').as_uri()+'?mode=ro',uri=True)) as db:
        snapshot_saved={k:json.loads(p) for k,p in db.execute('SELECT target_key,payload FROM reviews')}
    assert len(snapshot_saved)==manifest.get('gallery_snapshot_saved',manifest['generation_templates'])
    assert all(saved_revision_preserved(value,snapshot_saved.get(key)) for key,value in saved.items())
    assert len(new)+len(manual)+manifest['previous_proposals']==len(proposals)
    base=json.loads((PROJECT/'outputs/pallet_mask_gallery_managed_v1/public_access.json').read_text())['public_url']
    def get(url):
        with open_checked(url) as r:return r.read()
    health=json.loads(get(base+'/healthz'))
    assert health['targets']==len(proposals) and health['publication_version']==version and health['editing_enabled']
    def asset(item):
        route,(_,_,expected)=item
        assert sha256(get(base+route)).hexdigest()==expected,route
        return route
    # The HTML response contains the editor overlay, so its verified base remains
    # separately checked by Gallery; static public image/JSON/font bytes are exact.
    assets=[item for item in gallery.assets.items() if item[0]!='/report_zh.html']
    with ThreadPoolExecutor(max_workers=4) as pool:checked=list(pool.map(asset,assets))
    for route in ('/mask_reviews.sqlite3','/gallery_reviews_snapshot.sqlite3','/reviews_snapshot.sqlite3','/access_key.txt'):
        try:get(base+route);raise AssertionError('Private source exposed')
        except HTTPError as exc:assert exc.code==404
    key=new[0]['target_key'] if new else next(iter(saved))
    try:get(base+'/api/review/targets/'+key);raise AssertionError('Private API accessible anonymously')
    except HTTPError as exc:assert exc.code==401
    opener=build_opener(HTTPCookieProcessor(CookieJar()))
    login=Request(base+'/api/review/login',data=json.dumps(dict(key=(PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip())).encode(),
        headers={'Content-Type':'application/json','X-Review-Request':'1'})
    with open_checked(login,opener=opener,timeout=60) as r:
        assert 'HttpOnly' in r.headers['Set-Cookie'] and 'Secure' in r.headers['Set-Cookie']
    for k,old in snapshot_saved.items():
        with open_checked(base+'/api/review/targets/'+k,opener=opener,timeout=60) as r:d=json.load(r)
        assert saved_revision_preserved(old,d['review']),k
    newly_saved_during_acceptance=[]
    for p in new:
        with open_checked(base+'/api/review/targets/'+p['target_key'],opener=opener,timeout=60) as r:d=json.load(r)
        assert d['proposal_polygon']==p['polygon'] and not d['proposal_dependency_stale']
        if d['review'] is not None:
            assert d['review']['human_edited'] and d['review']['target_key']==p['target_key']
            assert d['review']['source_binding']==d['source_binding']
            newly_saved_during_acceptance.append(p['target_key'])
    for p in manual:
        with open_checked(base+'/api/review/targets/'+p['target_key'],opener=opener,timeout=60) as r:d=json.load(r)
        assert (d['saved_pose_manual_source'] or d.get('saved_pose_review_source')) and d['proposal_polygon']==p['polygon']
        if d['review'] is not None:
            assert d['review']['human_edited'] and d['review']['source_binding']==d['source_binding']
        assert not d['proposal_dependency_stale']
    (OUT/'public_http_acceptance.json').write_bytes(canonical(dict(state='passed',public_url=base,
        publication_version=version,assets_verified=len(checked),saved_targets_verified=len(saved),
        generation_snapshot_saved_targets_verified=len(snapshot_saved),
        new_targets_verified=len(new),saved_pose_sources_verified=len(manual),transport_retries=RETRIES))+b'\n')
    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=[];browser_checks=[]
    def wait(page,condition):
        end=time.monotonic()+90
        while time.monotonic()<end:
            if page.evaluate(condition):return
            time.sleep(.1)
        raise AssertionError(condition)
    with sync_playwright() as pw:
        # Chromium needs proxy credentials as separate fields; embedding them in
        # inherited HTTPS_PROXY produces ERR_INVALID_AUTH_CREDENTIALS.
        proxy_url=os.environ.get('HTTPS_PROXY') or os.environ.get('https_proxy')
        launch={}
        if proxy_url:
            proxy=urlsplit(proxy_url);launch['proxy']=dict(server=f'{proxy.scheme}://{proxy.hostname}:{proxy.port}',bypass='127.0.0.1,localhost')
            if proxy.username is not None:launch['proxy']['username']=unquote(proxy.username)
            if proxy.password is not None:launch['proxy']['password']=unquote(proxy.password)
        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/review/annotations/**',deny)
            page.goto(base+f'/?revision={version}#new-batch',wait_until='domcontentloaded',timeout=90000)
            wait(page,f'window.maskGalleryDiagnostics && document.querySelectorAll(".mg-edit-button[data-key]").length==={len(proposals)}')
            initially_new_only=page.locator('#only-new').is_checked()
            expected_visible=len(new) if initially_new_only else len(proposals)
            assert page.locator('article:visible').count()==expected_visible
            for cls in sorted({p['class_id'] for p in proposals.values()}):
                page.locator('#filter').select_option(str(cls))
                expected_class=sum(p['class_id']==cls for p in (new if initially_new_only else proposals.values()))
                assert page.locator('article:visible').count()==expected_class
            page.locator('#filter').select_option('')
            if not new:page.locator('#only-new').uncheck()
            page.locator(f'.mg-edit-button[data-key="{key}"]').click();wait(page,'document.querySelector("#mgLogin").open')
            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')
            initial=page.evaluate('maskGalleryDiagnostics()');assert not initial['dirty']
            page.locator('#mgZoomIn').click();page.locator('#mgZoomOut').click()
            assert page.evaluate('maskGalleryDiagnostics().polygon')==initial['polygon']
            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}.png'))
            page.locator('#mgClose').click()
            assert not page.evaluate('maskGalleryDiagnostics().open')
            browser_checks.append(dict(width=width,filter_counts_correct=True,editor_loaded=True,no_overflow=True))
            ctx.close()
        browser.close()
    assert not errors and not writes
    with closing(sqlite3.connect(DB.as_uri()+'?mode=ro',uri=True)) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        current=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'))
        assert event_prefix_preserved(historical,current)
        latest={k:json.loads(v) for k,v in db.execute('SELECT target_key,payload FROM reviews')}
        assert all(saved_revision_preserved(value,latest.get(key)) for key,value in saved.items())
    before=json.loads((OUT/'gallery_deployment_before.json').read_text())
    for file,h in before['frozen'].items():assert digest(PROJECT/file)==h,file
    recovery_path=OUT/'service_recovery.json';recovered=recovery_path.exists()
    if recovered:
        evidence=json.loads((OUT/'stopped_services_evidence.json').read_text())
        recovery=json.loads(recovery_path.read_text());assert recovery['state']=='recovered'
        for name,old in before['services'].items():
            assert evidence[name]['previous']==old and evidence[name]['all_previous_pids_absent'] and evidence[name]['port_free']
        expected_services=recovery['services']
    else:expected_services=before['services']
    for name,old in expected_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_structure_review_managed_v1':assert now['app']['pid']==old['app']['pid']
    result=dict(state='passed',public_url=base+f'/?revision={version}#new-batch',targets=len(proposals),new=len(new),
        saved_human_targets_preserved=len(saved),historical_events_preserved=len(historical),
        generation_snapshot_saved_targets_verified=len(snapshot_saved),
        public_assets_verified=len(checked),browser_checks=browser_checks,page_errors=errors,
        production_annotation_writes=0,all_tunnels_and_supervisors_preserved=not recovered,
        saved_pose_sources_preserved=len(manual),
        user_saved_new_candidates_observed=newly_saved_during_acceptance,
        transient_transport_retries=RETRIES,
        recovered_stopped_services=recovered,recovered_tunnels_preserved_during_publication=recovered,old_gallery_files_unchanged=True)
    refresh_service_metadata()
    path.write_bytes(canonical(result)+b'\n');print(json.dumps(result),flush=True)


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