"""Publish independently verified refined-mask candidates with exact dependencies."""
from contextlib import closing
import json
import os
from pathlib import Path
import signal
import sqlite3
import sys
import time
from urllib.request import urlopen

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest
from pallet.mask_gallery import Gallery
from pallet.pose_review_geometry import canonical
from pallet.pose_review_masks import MaskSuggestions

OUT=PROJECT/'outputs/pallet_mask_refined_deployment_v1'
BATCH=PROJECT/'outputs/pallet_mask_template_refined_v2'


class ReadOnlyPoseStore:
    def __init__(self):
        with closing(sqlite3.connect((PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3').as_uri()+'?mode=ro',uri=True)) as db:
            self.values={k:json.loads(v) for k,v in db.execute('SELECT target_key,payload FROM annotations')}

    def get(self,key):return self.values.get(key)


def write(path,value):
    tmp=path.with_suffix(path.suffix+'.refined.tmp');tmp.write_bytes(canonical(value)+b'\n');tmp.replace(path)


def main():
    global OUT,BATCH
    import argparse
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output',type=Path,default=OUT);parser.add_argument('--batch',type=Path,default=BATCH)
    args=parser.parse_args();OUT=args.output.resolve();BATCH=args.batch.resolve()
    if not all(p.is_relative_to(PROJECT/'outputs') for p in (OUT,BATCH)):raise ValueError('Expected output directories')
    if (OUT/'publication.json').exists():raise ValueError('Already published; preserve evidence')
    assert (OUT/'gallery_reviews_before.sqlite3').exists() and (OUT/'before_deployment.json').exists()
    verification=json.loads((BATCH/'verification.json').read_text());manifest=json.loads((BATCH/'manifest.json').read_text())
    version=manifest['publication_version'];seeds=manifest['generation_templates'];goal=manifest.get('target_per_class',50)
    classes=sorted({p['class_id'] for p in map(json.loads,(BATCH/'proposals.jsonl').read_text().splitlines())})
    assert verification['state']=='passed' and verification['publication_version']==version
    assert digest(BATCH/'proposals.jsonl')==verification['proposals_sha256']
    gallery=Gallery(BATCH);previous=json.loads((OUT/'active_mask_template_proposals.json.before').read_text())
    # Keep historical/manual-source entries in the cumulative gallery. The pose
    # sidecar contains only this batch's transfers with one snapshot binding.
    proposal_file=BATCH/('new_proposals.jsonl' if version>=5 else 'proposals.jsonl')
    proposal_count=len(proposal_file.read_text().splitlines())
    config=dict(previous,version=version,proposals=str(proposal_file.relative_to(PROJECT)),
        proposals_sha256=digest(proposal_file),count=proposal_count,
        authorization=f'使用{seeds}份直接人工模板按{len(classes)}类各{goal}张计划扩展；不降低门槛或递归传播未复核候选',
        gallery_review_database='outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3',
        gallery_review_snapshot=str((BATCH/'gallery_reviews_snapshot.sqlite3').relative_to(PROJECT)),
        gallery_review_snapshot_sha256=digest(BATCH/'gallery_reviews_snapshot.sqlite3'))
    for name in ('manifest','verification'):
        config[name]=str((BATCH/(name+'.json')).relative_to(PROJECT));config[name+'_sha256']=digest(BATCH/(name+'.json'))
    candidate=OUT/'proposed_mask_config.json';write(candidate,config)
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    suggestions=MaskSuggestions(candidate,formal);values=suggestions.load();assert len(values)==proposal_count
    store=ReadOnlyPoseStore();new=list(map(json.loads,(BATCH/'new_proposals.jsonl').read_text().splitlines()))
    for p in new:
        assert suggestions.get(p['target_key'],store.get(p['target_key']),p['source'],store) is not None,p['target_key']
    with closing(sqlite3.connect((PROJECT/config['gallery_review_database']).as_uri()+'?mode=ro',uri=True)) as db:
        edited=[k for k, in db.execute('SELECT target_key FROM reviews')]
    for key in edited:
        if key in gallery.proposals:
            assert suggestions.get(key,store.get(key),gallery.proposals[key]['source'],store) is None
    if (BATCH/'manual_proposals.jsonl').exists():
        for p in map(json.loads,(BATCH/'manual_proposals.jsonl').read_text().splitlines()):
            assert p['target_key'] not in values
            assert store.get(p['target_key'])['polygon']==p['polygon']
    gallery_config=json.loads((OUT/'active_mask_gallery.json.before').read_text())
    assert version==gallery_config['publication_version']+1
    assert str((PROJECT/manifest['parent']).resolve())==str((PROJECT/gallery_config['directory']).resolve())
    gallery_config.update(publication_version=version,directory=str(BATCH.relative_to(PROJECT)),
        manifest_sha256=digest(BATCH/'manifest.json'),verification_sha256=digest(BATCH/'verification.json'),
        previous_directory_preserved=manifest['parent'],fine_review_template_count=seeds,
        target_per_class=goal,target_classes=classes)
    services={}
    for name,module in (('pallet_mask_gallery_managed_v1','pallet.mask_gallery'),('pallet_pose_review_managed_v1','pallet.pose_review')):
        state=json.loads((PROJECT/'outputs'/name/'supervisor.json').read_text());pid=state['app']['pid']
        cmd=Path(f'/proc/{pid}/cmdline').read_bytes().split(b'\0')
        assert module.encode() in cmd,(name,cmd)
        services[name]=dict(pid=state['pid'],tunnel_pid=state['tunnel']['pid'],old_app_pid=pid)
    write(PROJECT/'configs/active_mask_template_proposals.json',config)
    write(PROJECT/'configs/active_mask_gallery.json',gallery_config)
    write(OUT/'publication.json',dict(state='published_pending_public_acceptance',publication_version=version,
        targets=gallery.count,new=len(new),saved_gallery_targets=len(edited),services=services,
        manifest_sha256=digest(BATCH/'manifest.json'),verification_sha256=digest(BATCH/'verification.json'),
        production_annotation_writes=0))
    for state in services.values():os.kill(state['old_app_pid'],signal.SIGTERM)
    deadline=time.monotonic()+100
    while time.monotonic()<deadline:
        try:
            with urlopen('http://127.0.0.1:3393/healthz',timeout=3) as response:health=json.load(response)
            with urlopen('http://127.0.0.1:3390/healthz',timeout=3) as response:pose_health=json.load(response)
            if health.get('publication_version')==version and health.get('targets')==gallery.count and pose_health.get('status')=='ok':
                print(json.dumps(dict(state='apps_ready',targets=gallery.count,new=len(new),edited=len(edited),tunnels_preserved=True)),flush=True)
                return
        except (OSError,ValueError):pass
        time.sleep(1)
    raise RuntimeError('Publication configured but application startup is not ready; preserve drafts and inspect service logs')


if __name__=='__main__':main()
