"""Post-publication source/configuration/history integrity; no annotation writes."""
from contextlib import closing
from datetime import datetime,timezone
import json
from pathlib import Path
import sqlite3
import sys
from zipfile import ZipFile
import hashlib

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


def read(path):return json.loads(Path(path).read_text())


def check_archive(root,out):
    result=out/'archive_independent_acceptance.json'
    if result.exists():raise ValueError('Preserve completed archive verification')
    delivery=read(root/'delivery_verification.json');archive=root/delivery['archive'];assert digest(archive)==delivery['sha256']
    with ZipFile(archive) as zipped:
        names=zipped.namelist();assert len(names)==len(set(names))==delivery['files']
        checksums=json.loads(zipped.read('checksums.json'));assert set(names)==set(checksums)|{'checksums.json','README_zh.txt'}
        for name,expected in checksums.items():
            path=Path(name);assert not path.is_absolute() and '..' not in path.parts
            assert not any(s in name for s in ('.sqlite','access_key','source_records','all_manual_sources','current_payload_raw'))
            raw=zipped.read(name);assert hashlib.sha256(raw).hexdigest()==expected==digest(root/name)
            if path.suffix in ('.json','.jsonl','.html'):
                assert not any(s in raw for s in (b'current_payload_raw',b'human_event_payload_raw',b'"access_key"'))
        proposals=[json.loads(s) for s in zipped.read('proposals.jsonl').splitlines()]
        manual=[json.loads(s) for s in zipped.read('manual_proposals.jsonl').splitlines()]
        new=[json.loads(s) for s in zipped.read('new_proposals.jsonl').splitlines()]
        manifest=read(root/'manifest.json')
        assert len(proposals)==len({p['source']['frame_id'] for p in proposals})==manifest['proposals']
        assert len(manual)==54 and len(new)==manifest['new_proposals']
        original=[p for p in manual if p.get('original_rectangle_review_only')];assert len(original)==3
        assert all(p['human_edited'] is False and p['propagation_seed_eligible'] is False for p in original)
        assert zipped.testzip() is None
    value=dict(state='passed',archive=str(archive.relative_to(PROJECT)),archive_sha256=delivery['sha256'],entries=len(names),
        source_files_byte_verified=len(checksums),proposals=len(proposals),new_machine=len(new),manual_modified=51,new_original_box_reviews=3,
        private_databases_and_raw_events_excluded=True,source_archive_files_unchanged=True,production_annotation_writes=0)
    result.write_bytes(canonical(value)+b'\n');return value


def check_sources(root,tasks,out):
    result=out/'post_publication_source_integrity.json'
    if result.exists():raise ValueError('Preserve completed source verification')
    manifest=read(root/'manifest.json')
    for folder in (root,tasks):
        for name,expected in read(folder/'artifact_hashes.json').items():assert digest(folder/name)==expected,name
    for name,expected in manifest['frozen_code_sha256'].items():assert digest(PROJECT/name)==expected,name
    formal,rows,_=load_formal_evidence(manifest);protected=protected_snapshot(formal)
    assert len(rows)==12344 and len(protected)==20768 and protected==read(root/'protected_formal_before.json')==read(root/'protected_formal_after.json')
    assert file_inventory(PROJECT/'configs')==read(out/'activation.json')['config_after']
    baseline=read(out/'gallery_deployment_before.json')
    for name,expected in baseline['frozen'].items():assert digest(PROJECT/name)==expected,name
    for name,previous in baseline['services'].items():
        now=read(PROJECT/'outputs'/name/'supervisor.json');assert now['pid']==previous['pid'] and now['tunnel']['pid']==previous['tunnel']['pid']
        if name=='pallet_structure_review_managed_v1':assert now['app']['pid']==previous['app']['pid']
    stores={}
    for name,table,live,snapshot in (
            ('gallery','reviews',PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3',root/'gallery_reviews_snapshot.sqlite3'),
            ('pose','annotations',PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3',root/'reviews_snapshot.sqlite3')):
        with closing(sqlite3.connect(snapshot.resolve().as_uri()+'?mode=ro&immutable=1',uri=True)) as db:
            frozen={key:json.loads(raw) for key,raw in db.execute(f'SELECT target_key,payload FROM {table}')}
            events=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'))
        with closing(sqlite3.connect(live.resolve().as_uri()+'?mode=ro',uri=True)) as db:
            assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
            current={key:json.loads(raw) for key,raw in db.execute(f'SELECT target_key,payload FROM {table}')}
            actual_events=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'))
        assert all(saved_revision_preserved(value,current.get(key)) for key,value in frozen.items()) and event_prefix_preserved(events,actual_events)
        stores[name]=dict(frozen_saved=len(frozen),frozen_events=len(events),current_saved=len(current),current_events=len(actual_events),all_event_bytes_preserved=True)
    value=dict(state='passed',publication_version=12,all_sealed_gallery_and_task_artifact_bytes_verified=True,formal_protected_files=20768,
        fixed_target_denominator=12344,old_publication_files_verified=len(baseline['frozen']),unchanged_unrelated_configuration=True,
        all_supervisors_and_tunnels_preserved=True,human_stores=stores,production_annotation_writes=0,verified_at=datetime.now(timezone.utc).isoformat())
    result.write_bytes(canonical(value)+b'\n');return value


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--stage',choices=('archive','sources'),required=True)
    args=parser.parse_args();root=PROJECT/'outputs/pallet_mask_remaining_round2_v1';out=PROJECT/'outputs/pallet_mask_remaining_round2_deployment_v1'
    tasks=PROJECT/read(PROJECT/'configs/active_mask_template_requests.json')['directory']
    value=check_archive(root,out) if args.stage=='archive' else check_sources(root,tasks,out)
    print(json.dumps(value),flush=True)
