"""Independent audit of explicitly drawn new-image drafts, not transfer acceptance or human edits."""
from collections import Counter,defaultdict
from contextlib import closing
from datetime import datetime,timezone
import hashlib
import json
from pathlib import Path
import sqlite3
import sys

import numpy as np
from PIL import Image

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_preannotation import FALSE_FLAGS,validate_preannotation
from pallet.mask_remaining_classes import original_rectangle
from pallet.mask_template_refined import QUARANTINE,read_jsonl
from pallet.pose_review_geometry import canonical,raster_mask
from scripts.build_mask_template_requests import database_fingerprint,native_quality


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


def read(path):return json.loads(Path(path).read_text())
def sha(value):return hashlib.sha256(canonical(value)).hexdigest()


def audit(root,parent):
    manifest=read(root/'manifest.json');inputs=read(root/'input_manifest.json');seal=read(parent/'verification.json')
    require(seal['state']=='passed' and seal['publication_version']==13 and seal['manifest_sha256']==digest(parent/'manifest.json')
        and seal['proposals_sha256']==digest(parent/'proposals.jsonl'),'Matching independent publication13 required')
    require(manifest['parent_verification_sha256']==digest(parent/'verification.json') and
        manifest['parent_manifest_sha256']==digest(parent/'manifest.json') and manifest['parent_proposals_sha256']==seal['proposals_sha256'],
        'Preannotation parent binding differs')
    formal,rows,evidence=load_formal_evidence(read(parent/'manifest.json'));parent_before=file_inventory(parent)
    frozen=protected_snapshot(formal);require(len(frozen)==20768 and len(rows)==12344 and frozen==inputs['formal_protected'],
        'Protected formal files/denominator changed')
    require(file_inventory(PROJECT/'configs')==inputs['configuration_sha256'],'Original active configurations changed before audit')
    require(manifest['input_manifest_sha256']==digest(root/'input_manifest.json') and
        manifest['decisions_sha256']==digest(root/'internal/build_decisions.json'),'Inspected source/decision hashes differ')
    for n,h in inputs['database_fingerprints'].items():require(database_fingerprint(PROJECT/n)==h,'Human source changed since inspection')
    with closing(sqlite3.connect((PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3').as_uri()+'?mode=ro',uri=True)) as db:
        current={k:json.loads(raw) for k,raw in db.execute('SELECT target_key,payload FROM annotations')}
        history=defaultdict(list)
        for key,raw in db.execute('SELECT target_key,payload FROM events ORDER BY id'):history[key].append(json.loads(raw))
    with closing(sqlite3.connect((PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3').as_uri()+'?mode=ro',uri=True)) as db:
        reviewed={k for k, in db.execute('SELECT target_key FROM reviews')}|{k for k, in db.execute('SELECT target_key FROM events')}
    canonical_props=read_jsonl(parent/'proposals.jsonl');keys={p['target_key'] for p in canonical_props}
    forbidden=set(QUARANTINE)|reviewed|keys
    for path in (PROJECT/'outputs').rglob('requests.jsonl'):
        if path.is_relative_to(root):continue
        forbidden.update(p['target_key'] for p in read_jsonl(path))
    confirmation=('human_mask_confirmed','human_pose_confirmed','metric_pose_confirmed','human_confirmed',
        'ground_truth_eligible','automatic_training_eligible','robot_command_eligible','full_six_dof')
    for key in set(current)|set(history):
        if key in history and key not in current:forbidden.add(key)
        for value in history[key]+([current[key]] if key in current else []):
            if (value.get('state') in ('deleted','deferred','confirmed') or not original_rectangle(value.get('polygon'),rows[key]) or
                    any(value.get(f,False) is not False or (value.get('pose') or {}).get(f,False) is not False for f in confirmation)):
                forbidden.add(key)
    forbidden_frames={rows[k]['frame_id'] for k in forbidden}
    proposals=read_jsonl(root/'proposals.jsonl');tasks=read_jsonl(root/'requests.jsonl')
    require(manifest['proposals_sha256']==digest(root/'proposals.jsonl') and manifest['requests_sha256']==digest(root/'requests.jsonl'),
        'Explicit contour/task inventory differs')
    require(len(proposals)==len(tasks)==manifest['request_count'] and len(proposals)==len({p['target_key'] for p in proposals})
        ==len({p['source']['frame_id'] for p in proposals}),'Duplicate/unpaired preannotation images')
    require([p['target_key'] for p in proposals]==[r['target_key'] for r in tasks],'Task/draft order differs')
    decisions=read(root/'internal/build_decisions.json')['decisions'];selected={p['target_key'] for p in proposals}
    shortlist=read_jsonl(root/'internal/shortlist.jsonl')
    require(digest(root/'internal/shortlist.jsonl')==inputs['shortlist_sha256'] and selected<=set(decisions),
        'Inspected shortlist changed')
    for record in shortlist:
        decision=decisions.get(record['target_key'],{})
        require(decision.get('crop_inspected') is True and decision.get('full_image_inspected') is True and decision.get('note_zh'),
            'Every staged source requires a true full/crop inspection decision')
    public={'report_zh.html','report-font.otf','FONT_LICENSE.txt'}
    for p,task in zip(proposals,tasks):
        key=p['target_key'];row=rows[key];decision=decisions[key];image_sha=digest(formal/row['image'])
        require(key not in forbidden and row['frame_id'] not in forbidden_frames,'Already counted/saved/modified/protected image requested again')
        require(p['source']==row and p['class_id']==row['final_class_id'],'Preannotation formal identity/class/split/view differs')
        require(decision.get('approved') is True and decision.get('polygon')==p['polygon'] and decision['note_zh']==p['preannotation']['note_zh'],
            'Published polygon was not the explicitly drawn inspected contour')
        validate_preannotation(p,manifest['formal_manifest_sha256'],image_sha)
        require(not p.get('metrics') and not p.get('template') and all(p[f] is False for f in FALSE_FLAGS),
            'Assistant direct annotation must not claim a transfer pass or human save')
        require(task['assistant_polygon']==p['polygon'] and task['status']=='preannotated_awaiting_human_review'
            and task['counts_as_completed_annotation'] is False and task['preserve_existing_pose_until_intentional_human_edit'] is True,
            'Task is not genuinely preannotated or protected')
        value=current.get(key);require((value['revision'] if value else 0)==p['target_expected_revision']
            and (sha(value) if value else None)==p['target_snapshot_payload_sha256'],'Protected current pose changed')
        if value:require(original_rectangle(value['polygon'],row) and all(original_rectangle(v['polygon'],row) for v in history[key]),
            'Modified pose history must not be overwritten')
        quality,reason=native_quality(row,evidence);require(reason is None and quality==task['image_quality'],'Original native-image quality gate differs')
        require(digest(root/f'images/{key}.png')==image_sha,'Native image bytes changed')
        with Image.open(root/f'masks/{key}.png') as mask:
            require(np.array_equal(np.asarray(mask),raster_mask(p['polygon'],*row['size']).astype(np.uint8)*255),'Preannotation mask pixels differ')
        labelme=read(root/f'labelme/{key}.json')
        require(len(labelme['shapes'])==1 and labelme['shapes'][0]['points']==p['polygon'] and
            labelme['imagePath']==f'../images/{key}.png' and labelme['flags']['human_confirmed'] is False,
            'Single-target LabelMe contour/image/confirmation differs')
        for folder,ext in (('images','png'),('cases','png'),('masks','png'),('labelme','json')):public.add(f'{folder}/{key}.{ext}')
    counts=Counter(p['class_id'] for p in proposals);parent_counts=Counter(p['class_id'] for p in canonical_props)
    require(all(c in (4,5,7,14,22) and n<=min(10,100-parent_counts[c]) for c,n in counts.items()),'Preannotation request exceeds real per-class gap')
    require({str(k):v for k,v in counts.items()}==manifest['class_counts'],'Preannotation count table differs')
    require(set(manifest['public_assets'])==public and all(digest(root/n)==h for n,h in manifest['public_assets'].items()),
        'Preannotation public allowlist/hash differs')
    require(not any(p.suffix in ('.sqlite','.sqlite3','.db') for p in root.rglob('*')),'Task pack must not copy private databases')
    page=(root/'report_zh.html').read_text()
    require(all(f'id="target-{p["target_key"]}"' in page for p in proposals) and '已预标注' in page and '保存前' in page,
        'Task cards must show preannotation before human review without counting completion')
    require(not any(t in page for t in ('existing_pose_current_payload','current_payload_raw','human_event_payload_raw','access_key')),'Private payload exposed')
    from fontTools.ttLib import TTFont
    with TTFont(root/'report-font.otf') as font:require({ord(c) for c in page if '\u3400'<=c<='\u9fff'}<=set(font.getBestCmap()),'Report Chinese glyph missing')
    require(file_inventory(parent)==parent_before and protected_snapshot(formal)==frozen and file_inventory(PROJECT/'configs')==inputs['configuration_sha256'],
        'Protected inputs changed during independent audit')
    for n,h in inputs['database_fingerprints'].items():require(database_fingerprint(PROJECT/n)==h,'Human source changed during independent audit')
    return dict(state='passed',request_count=len(proposals),class_counts=dict(counts),public_assets=manifest['public_assets'],
        proposals_sha256=manifest['proposals_sha256'],requests_sha256=manifest['requests_sha256'],manifest_sha256=digest(root/'manifest.json'),
        preannotations_verified=True,formal_manifest_sha256=manifest['formal_manifest_sha256'],
        parent_proposals_sha256=seal['proposals_sha256'],parent_verification_sha256=digest(parent/'verification.json'),
        assistant_direct_annotation_not_template_transfer=True,original_rectangle_not_used_as_preannotation=True,
        original_native_quality_gates_unchanged=True,all_actual_polygons_before_publication=True,protected_formal_files=20768,
        assistant_drafts_not_counted_as_completed=True,production_annotation_writes=0,human_events_created=0,
        verification_script_sha256=digest(__file__),verified_at=datetime.now(timezone.utc).isoformat())


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--directory',type=Path,default=PROJECT/'outputs/pallet_mask_preannotated_requests_v1')
    parser.add_argument('--parent',type=Path,default=PROJECT/'outputs/pallet_mask_remaining_round3_v1');args=parser.parse_args()
    root=args.directory.resolve();parent=args.parent.resolve()
    require(root.parent==PROJECT/'outputs' and root.name.startswith('pallet_mask_preannotated_requests_v'),'Use a separate preannotation task output')
    require(not (root/'verification.json').exists() and not (root/'independent_verification.json').exists(),'Preserve independent task seals')
    value=audit(root,parent);raw=canonical(value)+b'\n'
    for name in ('verification.json','independent_verification.json'):(root/name).write_bytes(raw)
    print(json.dumps({k:v for k,v in value.items() if k!='public_assets'}),flush=True)
