"""Verify ptunnel first, then replace only the two round5 transport supervisors."""
import json
import os
from pathlib import Path
import signal
import subprocess
import sys
import time

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT));sys.path.insert(0,str(PROJECT/'scripts'))
from pallet.cluster_targets import digest
from pallet.mask_model_training_data import read,write,require,jsonl,atomic_json
from pallet.mask_class_note_integration import snapshot_db
from pallet.pallet_review_ptunnel import MIGRATION,profiles,profile_name,ensure_route
from pallet.pallet_description_round5_release import REVIEW_SETS,RELEASE
from serve_structure_review import process_identity
from reload_mask_taxonomy_keyboard_ui import state
from review_http_pool import ReadOnlyHTTP


def prepare():
    require(not MIGRATION.exists(),'Preserve previous transport migration evidence');MIGRATION.mkdir(mode=0o700);before={}
    inventory=profiles()
    for mode,s in REVIEW_SETS.items():
        folder=MIGRATION/mode;folder.mkdir(mode=0o700)
        runtime=read(s['managed']/'supervisor.json');require(runtime['process_identity']==process_identity(runtime['pid']),'Supervisor identity differs')
        snapshot_db(s['reviews']/'mask_reviews.sqlite3',folder/'before.sqlite3')
        before[mode]=dict(supervisor=runtime,public_access=read(s['managed']/'public_access.json'),
            protected={str(p.relative_to(PROJECT)):digest(p) for p in (s['root']/'manifest.json',s['root']/'proposals.jsonl',s['managed']/'runtime.json',RELEASE/mode/'manifest.json')},
            previous_wrapper=(PROJECT/f'scripts/serve_pallet_description_round5_{mode}.py').read_text())
    write(MIGRATION/'before.json',dict(services=before,unrelated_ptunnel_profiles=inventory,user_request='不再采用trycloudflare，而是采用ptunnel提供公网访问',
        scope='active_round5_new3418_and_existing3419_public_transport_only',all_other_services_and_tunnels_not_changed=True))


def provision(mode):
    s=REVIEW_SETS[mode];folder=MIGRATION/mode;require(not (folder/'ptunnel_route.json').exists(),'Do not overwrite provision receipt')
    row=ensure_route(mode,s['port']);write(folder/'ptunnel_route.json',row);print(json.dumps(row),flush=True)


def verify_public(mode,phase):
    s=REVIEW_SETS[mode];folder=MIGRATION/mode;row=profiles()[profile_name(mode)]
    key=(PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip();props=jsonl(s['root']/'proposals.jsonl');details=[]
    with ReadOnlyHTTP(row['url'],attempts=4) as http:
        http.get('/api/review/catalog',expected=401)
        # Exact browser Origin validates the tunnel's Host forwarding, without
        # writing a real/synthetic annotation to production.
        session=http.session();session.headers.update({'Origin':row['url']})
        login=http.login(key,gallery=True)
        require(any(c.name==f'pallet_joint_description_{mode}' and c.has_nonstandard_attr('HttpOnly') for c in login.cookies),'Authentication cookie missing/changed')
        health=http.get('/healthz').json();catalog=http.get('/api/review/catalog').json()
        require(health['publication_version']==s['namespace'] and health['targets']==len(props),'Wrong public upstream')
        require({p['target_key'] for p in catalog['targets']}=={p['target_key'] for p in props},'Wrong task catalog')
        for cls in sorted({p['class_id'] for p in props}):
            p=next(p for p in props if p['class_id']==cls);detail=http.get('/api/review/targets/'+p['target_key']).json()
            require(detail['proposal']==p and detail['binding']==digest(s['root']/'manifest.json') and detail['source_current'],'Wrong target/source binding')
            details.append(p['target_key'])
        import hashlib
        for n,h in read(RELEASE/mode/'manifest.json')['assets'].items():require(hashlib.sha256(http.get('/'+n).content).hexdigest()==h,'Public assets changed')
        for path in ('/proposals.jsonl','/mask_reviews.sqlite3','/access_key.txt'):http.get(path,expected=404)
    write(folder/f'public_{phase}.json',dict(state='ptunnel_public_login_origin_cookie_catalog_images_and_perclass_readback_passed',
        public_url=row['url'],profile=row['id'],targets=len(props),sampled_target_keys=details,namespace=s['namespace'],
        origin_same_as_public_host=True,production_annotation_POSTs=0,old_and_new_browser_origins_differ=True,
        unsaved_local_drafts_remain_in_old_browser_origin=True,manifest_sha256=digest(s['root']/'manifest.json')))
    print(dict(mode=mode,phase=phase,url=row['url'],targets=len(props),sampled=len(details)),flush=True)


def cutover(mode):
    s=REVIEW_SETS[mode];folder=MIGRATION/mode;require(not (folder/'cutover.json').exists(),'Preserve cutover receipt')
    require(read(folder/'public_before.json')['state']=='ptunnel_public_login_origin_cookie_catalog_images_and_perclass_readback_passed','Working authenticated ptunnel route required before shutting old tunnel')
    import xml.etree.ElementTree as ET
    suites=ET.parse(MIGRATION/'regressions.xml').getroot().findall('testsuite')
    require(sum(int(v.attrib['tests']) for v in suites)>=16 and not sum(int(v.attrib.get(k,0)) for v in suites for k in ('errors','failures','skipped')),'Passing transport regressions required')
    before=read(s['managed']/'supervisor.json');pid=before['pid'];app=before['app']['pid'];tunnel=before['tunnel']['pid']
    require(before['process_identity']==process_identity(pid),'Supervisor PID reused')
    expected=PROJECT/f'scripts/serve_pallet_description_round5_{mode}.py'
    for child,command in ((pid,b'run'),(app,b'app')):
        args=Path(f'/proc/{child}/cmdline').read_bytes().split(b'\0')
        require(len(args)>=3 and Path(os.fsdecode(args[1])).resolve()==expected and args[2]==command,'Refuse unrelated app/supervisor signal')
    require(int(Path(f'/proc/{app}/stat').read_text().split(') ',1)[1].split()[1])==pid,'App parent identity differs')
    tunnel_args=Path(f'/proc/{tunnel}/cmdline').read_bytes().split(b'\0')
    require(Path(os.fsdecode(tunnel_args[0])).name=='cloudflared' and f'http://127.0.0.1:{s["port"]}'.encode() in tunnel_args,'Refuse unrelated tunnel migration')
    snapshot_db(s['reviews']/'mask_reviews.sqlite3',folder/'before_cutover.sqlite3');metadata,events,_=state(folder/'before_cutover.sqlite3')
    pointer=s['managed']/'transport.json';require(not pointer.exists(),'Do not overwrite another transport configuration')
    write(pointer,dict(provider='ptunnel',profile=profile_name(mode),port=s['port'],allow_cloudflare_fallback=False,
        migration_evidence=str(MIGRATION.relative_to(PROJECT))))
    os.kill(pid,signal.SIGTERM)
    deadline=time.monotonic()+45
    while process_identity(pid) or process_identity(app) or process_identity(tunnel):
        require(time.monotonic()<deadline,'Old supervisor not stopped; inspect without force killing unrelated work');time.sleep(.2)
    with (folder/'ptunnel_start.log').open('xb') as log:
        result=subprocess.run([sys.executable,str(expected),'start','--timeout','180'],cwd=PROJECT,stdout=log,stderr=subprocess.STDOUT,timeout=205)
    require(result.returncode==0,'ptunnel supervisor startup failed; preserve logs, no Cloudflare fallback')
    after=read(s['managed']/'supervisor.json');require(after['transport_provider']=='ptunnel' and after['tunnel_connected'],'New ptunnel supervisor not connected')
    require(not process_identity(tunnel),'Old targeted Cloudflare tunnel still alive')
    current_meta,current_events,current_reviews=state(s['reviews']/'mask_reviews.sqlite3')
    require(current_meta==metadata and current_events[:len(events)]==events and {k:(rev,raw) for _,k,rev,raw in current_events}==current_reviews,'Review history/current rows altered')
    protected=read(MIGRATION/'before.json')['services'][mode]['protected']
    require(all(digest(PROJECT/n)==h for n,h in protected.items()),'Task/runtime/namespace changed')
    write(folder/'cutover.json',dict(state='round5_ptunnel_active_cloudflare_stopped',old_supervisor_pid=pid,old_app_pid=app,old_cloudflare_pid=tunnel,
        new_supervisor_pid=after['pid'],new_app_pid=after['app']['pid'],public_url=after['public_url'],
        history_prefix_preserved=True,events_before=len(events),events_after=len(current_events),protected=protected,
        production_annotation_POSTs=0,no_cloudflare_fallback=True,other_processes_or_ptunnel_profiles_not_stopped=True))
    print(dict(mode=mode,state='ptunnel_active',public_url=after['public_url']),flush=True)


def finish_cutover(mode):
    """Record a resumed startup without repeating a signal or recreating routes."""
    s=REVIEW_SETS[mode];folder=MIGRATION/mode;require(not (folder/'cutover.json').exists(),'Preserve completed receipt')
    before=read(MIGRATION/'before.json')['services'][mode]['supervisor'];after=read(s['managed']/'supervisor.json')
    require(after.get('transport_provider')=='ptunnel' and after.get('tunnel_connected'),'ptunnel not connected')
    require(after['process_identity']==process_identity(after['pid']),'New supervisor identity differs')
    require(not any(process_identity(p) for p in (before['pid'],before['app']['pid'],before['tunnel']['pid'])),'Old targeted Cloudflare supervisor still active')
    pm,pe,_=state(folder/'before_cutover.sqlite3');cm,ce,cr=state(s['reviews']/'mask_reviews.sqlite3')
    require(pm==cm and ce[:len(pe)]==pe and {k:(rev,raw) for _,k,rev,raw in ce}==cr,'History/current rows changed')
    protected=read(MIGRATION/'before.json')['services'][mode]['protected']
    require(all(digest(PROJECT/n)==h for n,h in protected.items()),'Frozen task/runtime/presentation changed')
    write(folder/'cutover.json',dict(state='round5_ptunnel_active_cloudflare_stopped',old_supervisor_pid=before['pid'],old_app_pid=before['app']['pid'],old_cloudflare_pid=before['tunnel']['pid'],
        new_supervisor_pid=after['pid'],new_app_pid=after['app']['pid'],public_url=after['public_url'],history_prefix_preserved=True,events_before=len(pe),events_after=len(ce),
        protected=protected,production_annotation_POSTs=0,no_cloudflare_fallback=True,other_processes_or_ptunnel_profiles_not_stopped=True,
        startup_retry_reason='TIME_WAIT_false_positive_fixed_by_HTTPServer_matching_SO_REUSEADDR',initial_start_log_preserved=True))


if __name__=='__main__':
    import argparse
    p=argparse.ArgumentParser();p.add_argument('phase',choices=('prepare','provision','verify-before','cutover','verify-after','finish'));p.add_argument('mode',choices=REVIEW_SETS,nargs='?');a=p.parse_args()
    if a.phase=='prepare':prepare()
    else:
        require(a.mode is not None,'Mode required')
        if a.phase=='provision':provision(a.mode)
        elif a.phase=='cutover':cutover(a.mode)
        elif a.phase=='finish':finish_cutover(a.mode)
        else:verify_public(a.mode,a.phase.split('-')[1])
