"""Backup/audit jump UI rollout using read-only production DB access, never test saves."""
import argparse
import hashlib
from http.cookiejar import CookieJar
import json
from pathlib import Path
import sqlite3
import sys
from urllib.error import HTTPError
from urllib.parse import urlencode
from urllib.request import build_opener,HTTPCookieProcessor,Request,urlopen

PROJECT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest,protected_snapshot
from pallet.pose_review import UI_VERSION

OUT=PROJECT/'outputs/pallet_pose_review_validation_v6'
REVIEWS=PROJECT/'outputs/pallet_pose_human_review_v1'


def connect():
    return sqlite3.connect((REVIEWS/'annotations.sqlite3').resolve().as_uri()+'?mode=ro',uri=True)


def before():
    OUT.mkdir(exist_ok=True)
    path=OUT/'before_deployment.json'
    if path.exists():raise ValueError('Before-deployment audit already exists; do not overwrite historical evidence')
    with connect() as db,sqlite3.connect(OUT/'reviews_before_v6.sqlite3') as dest:db.backup(dest)
    with sqlite3.connect((OUT/'reviews_before_v6.sqlite3').resolve().as_uri()+'?mode=ro',uri=True) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        annotations={k:r for k,r in db.execute('SELECT target_key,revision FROM annotations')}
        events=[dict(target_key=k,revision=r,sha256=hashlib.sha256(v.encode()).hexdigest())
                for k,r,v in db.execute('SELECT target_key,revision,payload FROM events')]
    protected=['configs/active_pose_annotations.json','configs/active_pose_refinement.json',
               'configs/active_formal_dataset.json','configs/active_pose_review.json',
               'outputs/pallet_pose_human_review_v1/access_key.txt']
    result=dict(annotations=annotations,events=events,protected_files={p:digest(PROJECT/p) for p in protected},
                backup_sha256=digest(OUT/'reviews_before_v6.sqlite3'),source_database_writes=0)
    path.write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
    print(json.dumps(dict(state='backup_complete',targets=len(annotations),events=len(events),source_database_writes=0)),flush=True)


def after():
    frozen=json.loads((OUT/'before_deployment.json').read_text())
    with connect() as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        annotations={k:r for k,r in db.execute('SELECT target_key,revision FROM annotations')}
        events={(k,r):hashlib.sha256(v.encode()).hexdigest() for k,r,v in db.execute('SELECT target_key,revision,payload FROM events')}
    for k,r in frozen['annotations'].items():assert annotations[k]>=r
    for item in frozen['events']:assert events[(item['target_key'],item['revision'])]==item['sha256']
    for path,expected in frozen['protected_files'].items():assert digest(PROJECT/path)==expected
    assert digest(OUT/'reviews_before_v6.sqlite3')==frozen['backup_sha256']
    dataset=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    protected=json.loads((REVIEWS/'protected_formal_snapshot.json').read_text())
    assert protected_snapshot(dataset)==protected
    access=json.loads((PROJECT/'outputs/pallet_pose_review_managed_v1/public_access.json').read_text())
    key=(REVIEWS/'access_key.txt').read_text().strip();checks=[]
    for base in (access['local_url'],access['public_url']):
        opener=build_opener(HTTPCookieProcessor(CookieJar()))
        def get(path):return opener.open(base+path,timeout=60)
        assert json.load(get('/healthz'))['version']==UI_VERSION
        try:get('/api/locate?mode=position&value=1');raise AssertionError('Unauthenticated lookup was allowed')
        except HTTPError as exc:assert exc.code==401
        request=Request(base+'/api/login',data=json.dumps({'key':key}).encode(),headers={
            'Content-Type':'application/json','X-Review-Request':'1'})
        assert json.load(opener.open(request,timeout=60))['ok']
        boot=json.load(get('/api/bootstrap'));assert boot['stats']['total']==12344
        queue=json.load(get('/api/queue?state=all'))
        first=json.load(get('/api/locate?mode=position&value=1'))['matches'][0]
        last=json.load(get('/api/locate?mode=position&value=12344'))['matches'][0]
        assert first['target_key']==queue['keys'][0] and last['target_key']==queue['keys'][-1]
        image=json.load(get('/api/locate?'+urlencode(dict(mode='image',value=first['target_key']))))
        assert image['matches'][0]['target_key']==first['target_key']
        latest=json.load(get('/api/locate?mode=latest'))
        latest_key=latest['matches'][0]['target_key']
        assert latest['total']==1 and latest_key in queue['keys']
        assert json.load(get('/api/targets/'+latest_key))['review'] is not None
        assets=get('/app.js').read().decode();html=get('/').read().decode()
        assert UI_VERSION in assets and UI_VERSION in html and 'id="jumpButton"' in html and 'id="jumpLatest"' in html
        checks.append(dict(url=base,ui_version=boot['ui_version'],first_last_positions_verified=True,
                           image_ID_lookup_verified=True,global_denominator=boot['stats']['total'],
                           latest_saved_lookup_verified=True,
                           saved=boot['stats']['saved'],complete=boot['stats']['complete'],
                           unauthenticated_lookup_denied=True,source_annotation_POSTs=0))
    with urlopen('http://127.0.0.1:3389/healthz',timeout=10) as response:assert json.load(response)['status']=='ok'
    result=dict(state='passed',checks=checks,old_human_targets_preserved=len(frozen['annotations']),
                old_events_payloads_preserved=len(frozen['events']),current_human_targets=len(annotations),
                formal_labels_metadata_unchanged=len(protected),existing_structure_service_healthy=True,
                source_database_test_writes=0,old_active_models_unchanged=True)
    (OUT/'deployment_verification.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
    print(json.dumps(result,ensure_ascii=False),flush=True)


if __name__=='__main__':
    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 args.stage=='before':before()
    else:after()
