"""Publish independently sealed real-save continuation and separate diverse prelabels."""
from datetime import datetime,timezone
import json
import os
from pathlib import Path
import signal
import sys
import tempfile
import time
from urllib.request import urlopen
import xml.etree.ElementTree as ET

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

ROOT=PROJECT/'outputs/pallet_mask_remaining_round5_v1'
TASKS=PROJECT/'outputs/pallet_mask_preannotated_requests_v3'
OUT=PROJECT/'outputs/pallet_mask_remaining_round5_deployment_v1'


def require(value,message):
    if not value:raise ValueError(message)


def read(path):return json.loads(Path(path).read_text())
def write(path,value):
    path=Path(path);temp=path.with_suffix(path.suffix+'.round5.tmp');require(not temp.exists(),'Unresolved publication temporary file')
    temp.write_bytes(canonical(value)+b'\n');temp.replace(path)


def seals():
    m=read(ROOT/'manifest.json');s=read(ROOT/'verification.json');tasks=read(TASKS/'manifest.json');proof=read(TASKS/'verification.json')
    require(s['state']=='passed' and s['publication_version']==m['publication_version']==15 and s['manifest_sha256']==digest(ROOT/'manifest.json') and
        s['proposals_sha256']==digest(ROOT/'proposals.jsonl'),'Matching independently sealed publication15 required')
    require(s['verification_script_sha256']==digest(PROJECT/'scripts/verify_mask_remaining_round5.py'),'Independent gallery verifier changed')
    require(all(digest(PROJECT/n)==h for n,h in m['frozen_code_sha256'].items()),'Frozen generator/engine code changed')
    require(proof['state']=='passed' and proof['preannotations_verified'] is True and proof['request_count']==tasks['request_count'] and
        proof['manifest_sha256']==digest(TASKS/'manifest.json') and proof['requests_sha256']==digest(TASKS/'requests.jsonl') and
        proof['proposals_sha256']==digest(TASKS/'proposals.jsonl') and proof['parent_verification_sha256']==digest(ROOT/'verification.json'),
        'Matching independently audited preannotation pack required')
    require(proof==read(TASKS/'independent_verification.json') and proof['verification_script_sha256']==digest(PROJECT/'scripts/verify_mask_preannotated_requests_v3.py'),
        'Independent task seal/code differs')
    require(read(OUT/'preannotation_editor_synthetic_acceptance.json')['state']=='passed','Isolated save/failure tests required')
    archive=read(ROOT/'delivery_verification.json');require(archive['state']=='passed' and digest(ROOT/archive['archive'])==archive['sha256'],'Verified public archive required')
    return m,s,tasks,proof,archive


def activate():
    require(not (OUT/'activation.json').exists(),'Preserve completed activation evidence')
    m,s,tasks,proof,archive=seals();before=read(ROOT/'configuration_input_hashes.json')
    require(file_inventory(PROJECT/'configs')==before,'User/source configuration changed; do not overwrite it')
    names=('active_mask_gallery.json','active_mask_template_proposals.json','active_mask_template_requests.json');old={n:read(PROJECT/'configs'/n) for n in names}
    require(old[names[0]]['publication_version']==14,'Expected publication14 baseline')
    taskconfig=dict(old[names[2]],schema='preannotated_mask_worklist_v1',directory=str(TASKS.relative_to(PROJECT)),manifest_sha256=digest(TASKS/'manifest.json'),
        verification_sha256=digest(TASKS/'verification.json'),request_count=tasks['request_count'],completed_request_count=0,requested_classes=tasks['classes'],
        counts_as_completed_annotation=False,user_authorization='完成上批35份实际保存后继续；不同类别先绘制助手掩膜草稿，再交人工复核，不重发已完成、被拒或被保护图像')
    with tempfile.TemporaryDirectory(prefix='round5-publication-preview-',dir='/tmp/opencode') as directory:
        path=Path(directory)/'tasks.json';path.write_bytes(canonical(taskconfig));preview=Gallery(ROOT,requests_config=path)
        require(preview.count==m['proposals'] and len(preview.preannotation_proposals)==tasks['request_count'],'Task drafts must stay separate from counted sources')
        require('已独立核验' in preview.edited_page.decode().split('</h1>')[0] and '尚未发布' not in preview.edited_page.decode().split('</h1>')[0],
            'Verified online heading required without rewriting immutable HTML')
    gallery=dict(old[names[0]],directory=str(ROOT.relative_to(PROJECT)),publication_version=15,manifest_sha256=digest(ROOT/'manifest.json'),verification_sha256=digest(ROOT/'verification.json'),
        previous_directory_preserved=old[names[0]]['directory'],fine_review_template_count=m['generation_templates'])
    sidecar=dict(old[names[1]],version=15,count=m['new_proposals'],proposals=str((ROOT/'new_proposals.jsonl').relative_to(PROJECT)),proposals_sha256=digest(ROOT/'new_proposals.jsonl'),
        manifest=str((ROOT/'manifest.json').relative_to(PROJECT)),manifest_sha256=digest(ROOT/'manifest.json'),verification=str((ROOT/'verification.json').relative_to(PROJECT)),
        verification_sha256=digest(ROOT/'verification.json'),gallery_review_snapshot=str((ROOT/'gallery_reviews_snapshot.sqlite3').relative_to(PROJECT)),
        gallery_review_snapshot_sha256=digest(ROOT/'gallery_reviews_snapshot.sqlite3'),authorization='仅本轮严格通过候选；无通过则为空，不重发旧候选，不加入未保存助手草稿或四点来源')
    for name in names:
        path=OUT/(name+'.before')
        if path.exists():require(digest(path)==digest(PROJECT/'configs'/name),'Configuration backup differs')
        else:path.write_bytes((PROJECT/'configs'/name).read_bytes())
    statepath=PROJECT/'outputs/pallet_mask_gallery_managed_v1/supervisor.json';service=read(statepath);pid=service['app']['pid']
    require(b'pallet.mask_gallery' in Path(f'/proc/{pid}/cmdline').read_bytes().split(b'\0'),'Unexpected gallery app PID')
    for name,value in zip(names,(gallery,sidecar,taskconfig)):write(PROJECT/'configs'/name,value)
    after=dict(before,**{name:digest(PROJECT/'configs'/name) for name in names});require(file_inventory(PROJECT/'configs')==after,'Unrelated configuration changed')
    status=dict(state='activated_pending_public_acceptance',publication_version=15,targets=m['proposals'],new_strict_candidates=m['new_proposals'],preannotated_tasks=tasks['request_count'],
        assistant_drafts_counted_as_completed=False,config_before=before,config_after=after,gallery_verification_sha256=digest(ROOT/'verification.json'),
        preannotation_verification_sha256=digest(TASKS/'verification.json'),production_annotation_writes=0,created_at=datetime.now(timezone.utc).isoformat())
    write(OUT/'activation.json',status);write(OUT/'rollout_status.json',status);os.kill(pid,signal.SIGTERM);deadline=time.monotonic()+100
    while time.monotonic()<deadline:
        try:
            health=json.load(urlopen('http://127.0.0.1:3393/healthz',timeout=3))
            if health['publication_version']==15 and health['targets']==m['proposals'] and health['manual_template_requests']==tasks['request_count'] and health['editing_enabled']:
                now=read(statepath);require(now['pid']==service['pid'] and now['tunnel']['pid']==service['tunnel']['pid'],'Supervisor/tunnel replaced')
                print(json.dumps(dict(state='active_local_health_passed_pending_public_acceptance',health=health)),flush=True);return
        except (OSError,ValueError):pass
        time.sleep(1)
    raise RuntimeError('Gallery reload not ready; preserve all drafts and inspect logs')


def finalize():
    require(not (OUT/'final_acceptance.json').exists(),'Preserve completed final acceptance')
    m,s,tasks,proof,archive=seals();require(file_inventory(PROJECT/'configs')==read(OUT/'activation.json')['config_after'],'Active configuration changed')
    names=('public_acceptance.json','public_ui_acceptance.json','preannotation_public_ui_acceptance.json','saved_gallery_source_ui_acceptance.json','pose_sidecar_acceptance.json',
        'deployment_verification.json','post_publication_source_integrity.json','preannotation_editor_synthetic_acceptance.json','archive_independent_acceptance.json',
        'preannotation_visual_acceptance.json','frozen_layout_acceptance.json','review_completion_preflight.json','surface_compatibility_guards.json','online_heading_acceptance.json')
    evidence={}
    for name in names:require(read(OUT/name)['state']=='passed','Incomplete acceptance: '+name);evidence[name]=digest(OUT/name)
    tests={}
    for name in ('integration_pytest.xml','pipeline_final_pytest.xml','release_guard_pytest.xml'):
        suites=list(ET.parse(OUT/name).getroot().iter('testsuite'))
        require(suites and not any(int(s.get(f,'0')) for s in suites for f in ('failures','errors')),'Failed regression suite')
        tests[name]=sum(int(s.get('tests','0')) for s in suites);evidence[name]=digest(OUT/name)
    public=read(OUT/'public_acceptance.json');require(public['targets']==m['proposals'] and public['new']==m['new_proposals'] and public['saved_gallery_manual_sources_preserved']==35 and
        public['separately_preannotated_tasks_verified']==tasks['request_count'],'Public counts/source category differ')
    from scripts.check_mask_refined_public import refresh_service_metadata
    refresh_service_metadata();base=read(PROJECT/'outputs/pallet_mask_gallery_managed_v1/public_access.json')['public_url']
    value=dict(state='passed',publication_version=15,total_distinct_images=m['proposals'],new_strict_candidates=m['new_proposals'],preannotated_new_image_tasks=tasks['request_count'],
        preannotated_class_counts=tasks['class_counts'],preannotated_topologies=proof['topology_counts'],every_new_task_preannotated_before_publication=True,
        preannotations_separate_from_strict_registration=True,assistant_drafts_counted_as_completed=False,actual_completed_preannotation_saves=35,preannotations_changed=35,
        preannotations_saved_unchanged=0,completed_preannotations_are_gallery_not_pose_saves=True,pending_original_rectangle_saves_not_counted=2,old_original_rectangle_reviews_preserved=5,
        saved_human_contours=1458,templates=m['generation_templates'],registration_attempts_independently_replayed=m['registration_attempts'],
        class_shortfalls={c:v['missing'] for c,v in m['classes'].items()},remaining_shortfall=sum(v['missing'] for v in m['classes'].values()),
        class19_capacity=m['classes']['19']['capacity_matching_distinct_frames'],class19_new_data_shortfall_at_least=m['class19_additional_new_distinct_images_required_at_least'],
        ground_truth_eligible=False,automatic_training_eligible=False,robot_command_eligible=False,thresholds_relaxed=False,production_annotation_writes=0,fixed_target_denominator=12344,
        protected_formal_files=20768,all_human_history_preserved=True,all_old_publications_preserved=True,gallery_url=base+'/?revision=15#new-batch',
        preannotated_task_url=base+'/template-requests/?batch=preannotated-v3',public_gallery_assets_verified=public['public_assets_verified'],public_task_routes_verified=public['public_task_routes_verified'],
        archive=str((ROOT/archive['archive']).relative_to(PROJECT)),archive_sha256=archive['sha256'],tests=tests,test_suites_overlap_not_additive=True,evidence=evidence,
        real_iPhone_Safari_tested=False,verification_sha256=digest(ROOT/'verification.json'),preannotation_verification_sha256=digest(TASKS/'verification.json'),
        statistics_basis='independently_verified_immutable_snapshot_not_live_completion',publication_code_sha256={n:digest(PROJECT/n) for n in (
            'scripts/publish_mask_remaining_round5.py','pallet/mask_gallery.py','pallet/mask_gallery_review.py','pallet/mask_gallery_view.py','pallet/mask_template_requests.py',
            'pallet/mask_preannotation.py','pallet/assets/mask_gallery/editor.js','scripts/check_mask_public_pool.py')},accepted_at=datetime.now(timezone.utc).isoformat())
    write(OUT/'final_acceptance.json',value);write(OUT/'rollout_status.json',dict(value,state='published_acceptance_passed',goal_state='waiting_for_actual_new_preannotation_reviews'))
    print(json.dumps(value,ensure_ascii=False),flush=True)


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--stage',choices=('activate','finalize'),required=True);args=parser.parse_args()
    activate() if args.stage=='activate' else finalize()
