"""Back up live reviews and verify v8 rollout read-only; never delete real targets."""
from __future__ import annotations

import argparse
from contextlib import closing
import hashlib
from http.cookiejar import CookieJar
import json
import os
from pathlib import Path
import sqlite3
import sys
from urllib.error import HTTPError
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_refinement import atomic_json,now
from pallet.pose_review import UI_VERSION
from review_http_retry import open_checked,RETRIES

REVIEWS=PROJECT/'outputs/pallet_pose_human_review_v1'
OUT=PROJECT/'outputs/pallet_pose_review_validation_v8'
TAG='v8'


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


def before():
    OUT.mkdir(parents=True,exist_ok=True);backup=OUT/f'reviews_before_{TAG}.sqlite3'
    if backup.exists() or (OUT/'before_deployment.json').exists():raise ValueError('Do not overwrite the deployment backup')
    with closing(connect()) as src,closing(sqlite3.connect(backup)) as dest:src.backup(dest)
    os.chmod(backup,0o600)
    with closing(sqlite3.connect(backup.resolve().as_uri()+'?mode=ro',uri=True)) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        annotations=dict(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',
        'outputs/pallet_pose_refinement_v2/pallet_pose_annotations_v2.zip','outputs/pallet_pose_refinement_v2/pallet_pose_refined_models_v2.zip',
        'outputs/pallet_pose_benchmark_v3/pallet_pose_best_learning_models_v3.zip',
        'outputs/pallet_pose_benchmark_v4/pallet_pose_models_v4.zip','outputs/pallet_pose_benchmark_v4/pallet_pose_annotations_v4.zip']
    access=json.loads((PROJECT/'outputs/pallet_pose_review_managed_v1/public_access.json').read_text())
    atomic_json(OUT/'before_deployment.json',dict(created_at=now(),annotations=annotations,events=events,
        protected_files={p:digest(PROJECT/p) for p in protected},backup_sha256=digest(backup),
        supervisor_pid=access['pid'],tunnel_pid=access['tunnel']['pid'],public_url=access['public_url'],source_database_test_writes=0))
    print(json.dumps(dict(state='backup_complete',targets=len(annotations),events=len(events))),flush=True)


def after():
    frozen=json.loads((OUT/'before_deployment.json').read_text())
    with closing(connect()) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        current=dict(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 key,revision in frozen['annotations'].items():assert current[key]>=revision
    for event in frozen['events']:assert events[event['target_key'],event['revision']]==event['sha256']
    for path,expected in frozen['protected_files'].items():assert digest(PROJECT/path)==expected,path
    assert digest(OUT/f'reviews_before_{TAG}.sqlite3')==frozen['backup_sha256']
    formal=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(formal)==protected
    access=json.loads((PROJECT/'outputs/pallet_pose_review_managed_v1/public_access.json').read_text())
    recovered=(OUT/'service_recovery.json').exists()
    if recovered:
        evidence=json.loads((OUT/'stopped_services_evidence.json').read_text())['pallet_pose_review_managed_v1']
        assert evidence['all_previous_pids_absent'] and evidence['port_free']
        assert evidence['previous']['pid']==frozen['supervisor_pid'] and evidence['previous']['tunnel']['pid']==frozen['tunnel_pid']
        recovery=json.loads((OUT/'service_recovery.json').read_text());assert recovery['state']=='recovered'
        expected=recovery['services']['pallet_pose_review_managed_v1']
        assert access['pid']==expected['pid'] and access['tunnel']['pid']==expected['tunnel']['pid'] and access['public_url']==expected['public_url']
    else:
        assert access['pid']==frozen['supervisor_pid'] and access['tunnel']['pid']==frozen['tunnel_pid']
        assert access['public_url']==frozen['public_url']
    checks=[]
    for base in (access['local_url'],access['public_url']):
        opener=build_opener(HTTPCookieProcessor(CookieJar()))
        def get(path):return open_checked(base+path,opener=opener,timeout=60)
        assert json.load(get('/healthz'))['version']==UI_VERSION
        try:get('/api/bootstrap');raise AssertionError('Unauthenticated access')
        except HTTPError as exc:assert exc.code==401
        key=(REVIEWS/'access_key.txt').read_text().strip()
        open_checked(Request(base+'/api/login',data=json.dumps(dict(key=key)).encode(),headers={'Content-Type':'application/json','X-Review-Request':'1'}),opener=opener,timeout=60).read()
        boot=json.load(get('/api/bootstrap'));stats=boot['stats'];assert stats['total']==12344
        queue=json.load(get('/api/queue?state=all'));deleted=json.load(get('/api/queue?state=deleted'))
        # The live user may be annotating during the check; do not freeze saved
        # counts or assume deletions cannot happen between independent requests.
        assert len(queue['keys'])<=12344 and len(deleted['keys'])<=12344
        if queue['keys']:
            detail=json.load(get('/api/targets/'+queue['keys'][0]))
            assert detail['target']['target_key'] in {o['target_key'] for o in detail['frame_objects']}
        html=get('/').read().decode();js=get('/app.js').read().decode()
        assert UI_VERSION in html and UI_VERSION in js
        assert all(f'id="{name}"' in html for name in ('deleteObject','restoreObject','objectDialog','objectReason','objectConfirm','frameObjects'))
        checks.append(dict(url=base,ui_version=boot['ui_version'],stats=stats,default_queue=len(queue['keys']),
            deleted_queue=len(deleted['keys']),read_only_HTTP_checks=True,annotation_or_object_mutation_requests=0))
    assert json.load(urlopen('http://127.0.0.1:3389/healthz',timeout=10))['status']=='ok'
    result=dict(state='passed',created_at=now(),checks=checks,old_human_targets_preserved=len(frozen['annotations']),
        old_events_payloads_preserved=len(frozen['events']),formal_protected_files_unchanged=len(protected),
        old_active_entries_and_archives_unchanged=True,tunnel_and_supervisor_unchanged=not recovered,
        recovered_stopped_services=recovered,recovered_tunnels_preserved_during_publication=recovered,
        transient_transport_retries=RETRIES,
        original_structure_service_healthy=True,source_database_test_writes=0)
    atomic_json(OUT/'deployment_verification.json',result);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);parser.add_argument('--version-tag',default=TAG)
    args=parser.parse_args();OUT=args.output.resolve();TAG=args.version_tag
    if not TAG.isalnum():raise ValueError('Invalid deployment version tag')
    before() if args.stage=='before' else after()
