"""Independent source, actual-K, duplicate votes and majority replay; not type accuracy."""
from collections import Counter,defaultdict
from contextlib import closing
import hashlib
import json
from pathlib import Path
import sys

import cv2
import numpy as np

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest,protected_snapshot
from pallet.mask_model_training_data import read,jsonl,require,write,sha
from pallet.mask_template_refined import readonly
from pallet.mask_quality_recovery import fingerprint,POSE,GALLERY
from pallet.mask_quota_saved_extension import file_inventory,load_formal_evidence
from pallet.pose_review_geometry import canonical,polygon_value

ROOT=PROJECT/'outputs/pallet_mask_class_correction_v1'


def verify():
    require(not (ROOT/'verification.json').exists(),'Preserve structural verification seal')
    m=read(ROOT/'manifest.json');inputs=read(ROOT/'input_manifest.json');rs=jsonl(ROOT/'private/records.jsonl');assignments=read(ROOT/'assignments.json');groups=read(ROOT/'face_groups.json')
    require(len(rs)==len({r['target_key'] for r in rs})==2200 and set(assignments)=={r['target_key'] for r in rs},'Exactly2200 actual human targets required')
    require(digest(ROOT/'private/records.jsonl')==m['source_records_sha256']==inputs['source_records_sha256'] and digest(ROOT/'assignments.json')==m['initial_assignments_sha256']
        and digest(ROOT/'input_manifest.json')==m['input_manifest_sha256'],'Frozen source/assignment binding differs')
    for p,h in inputs['source_fingerprints'].items():require(fingerprint(PROJECT/p)==h,'Human source store/history changed: '+p)
    require(file_inventory(PROJECT/'configs')==inputs['configs'],'Global configs changed')
    for p,h in inputs['old_static_inventories'].items():require(file_inventory(PROJECT/p)==h,'Old data/model/worklist changed: '+p)
    formal,rows,_=load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'));require(protected_snapshot(formal)==inputs['formal_protected'],'Formal labels/GT changed')
    catalogs={r['target_key']:r for r in jsonl(PROJECT/'outputs/pallet_mask_annotation_update_v2/private/source_catalog.jsonl')
        if r['batch'] not in ('model-class-keypoints-v3','model-annotation-update-remaining-v1')}
    refs={};old_events={}
    for path,table in [(POSE,'annotations'),(GALLERY,'reviews'),(PROJECT/'outputs/pallet_mask_nonconforming_reviews_v1/mask_reviews.sqlite3','reviews')]:
        with closing(readonly(path)) as db:
            current={k:(revision,raw) for k,revision,raw in db.execute(f'SELECT target_key,revision,payload FROM {table}')}
            hist=defaultdict(list)
            for key,raw in db.execute('SELECT target_key,payload FROM events'):hist[key].append(raw)
        old_events[str(path)]=(current,hist)
    for key,r in catalogs.items():
        p=POSE if r['origin']=='saved_pose' else GALLERY if r['origin']=='saved_gallery' else PROJECT/'outputs/pallet_mask_nonconforming_reviews_v1/mask_reviews.sqlite3'
        # Resolve the actual producer naming rather than trusting a generic origin.
        if r['origin'] not in ('saved_pose','saved_nonconforming_isolated'):p=GALLERY
        current,hist=old_events[str(p)];revision,raw=current[key];v=json.loads(raw)
        require(v['polygon']==r['polygon'] and revision==r['revision'] and sha(v)==r['payload_sha256'],'Base1559 latest manual polygon differs')
        require(any(hashlib.sha256(s.encode()).hexdigest()==r['event_raw_sha256'] and json.loads(s)['polygon']==r['polygon'] for s in hist[key]),'Base manual raw event provenance missing')
        refs[key]=r
    batchdefs=[('337','pallet_mask_model_requests_v3','pallet_mask_model_reviews_v3'),('145','pallet_mask_annotation_update_requests_v1','pallet_mask_model_reviews_v4'),
        ('9','pallet_mask_annotation_update_requests_v2','pallet_mask_model_reviews_v5'),('150','pallet_mask_quality_override_requests_v1','pallet_mask_model_reviews_v6')]
    from scripts.audit_mask_model_reviews import audit
    audits=read(ROOT/'private/source_audits.json')
    for label,task,store in batchdefs:
        path=PROJECT/'outputs'/store/'mask_reviews.sqlite3';a=audit(PROJECT/'outputs'/task,path)
        require(a['raw_event_hashes']==audits[label]['raw_event_hashes'],'Frozen raw event prefix/current differs')
        with closing(readonly(path)) as db:
            for key,revision,raw in db.execute('SELECT target_key,revision,payload FROM reviews'):
                v=json.loads(raw);require(key not in refs,'Repeated source target');refs[key]=dict(polygon=v['polygon'],revision=revision,event_raw_sha256=hashlib.sha256(raw.encode()).hexdigest(),payload_sha256=sha(v))
    byclass=Counter();units=defaultdict(set);unitfaces=defaultdict(set);facekeys=defaultdict(list);actualK=Counter()
    byimage=defaultdict(list);independent_units={}
    for r in sorted(rs,key=lambda r:r['target_key']):
        key=r['target_key'];row=rows[key];ref=refs[key];require(r['row']==row and r['old_class_id']==row['final_class_id'] and r['polygon']==ref['polygon']
            and r['actual_K']==len(ref['polygon']) and r['source_revision']==ref['revision'] and r['source_payload_sha256']==ref['payload_sha256']
            and r['source_event_raw_sha256']==ref['event_raw_sha256'],'Wrong original class / actual saved polygon / event')
        polygon_value(r['polygon'],*row['size']);require(digest(formal/row['image'])==r['image_sha256']==digest(ROOT/'images'/f'{key}.png'),'Original pixels differ')
        box=row['bbox'];unit=None
        for prior in byimage[r['image_sha256']]:
            b=prior['row']['bbox'];inter=max(0,min(box['x']+box['width'],b['x']+b['width'])-max(box['x'],b['x']))*max(0,min(box['y']+box['height'],b['y']+b['height'])-max(box['y'],b['y']))
            overlap=inter/(box['width']*box['height']+b['width']*b['height']-inter) if inter else 0.
            if overlap>=.9:unit=independent_units[prior['target_key']];break
        independent_units[key]=unit or key;byimage[r['image_sha256']].append(r);require(r['vote_unit']==independent_units[key],'Duplicate vote unit differs')
        face=assignments[key];facekeys[face].append(r);units[r['old_class_id']].add(r['vote_unit']);unitfaces[r['old_class_id'],r['vote_unit']].add(face)
        byclass[r['old_class_id']]+=1;actualK[r['actual_K']]+=1
    support=defaultdict(Counter)
    for (cls,unit),faces in unitfaces.items():
        for face in faces:support[face][cls]+=1/len(faces)
    require(byclass==Counter({c:100 for c in range(1,23)}) and set(groups)==set(facekeys),'Frozen old-class denominator/scope differs')
    for face,rows_ in facekeys.items():
        g=groups[face];ks={r['actual_K'] for r in rows_};require(len(ks)==1 and g['K']==next(iter(ks)) and g['targets']==len(rows_),'Mixed actual K group forbidden')
        votes=support[face];anchors=sorted([c for c,n in votes.items() if n>len(units[c])/2],key=lambda c:(-votes[c],-votes[c]/len(units[c]),c))
        require(g['majority_anchors']==anchors,'Strict old WHOLE class majority replay differs')
        for cls,n in votes.items():
            entry=g['majority_support'][str(cls)];require(abs(entry['support']-n)<1e-9 and entry['denominator']==len(units[cls]) and abs(entry['fraction']-n/len(units[cls]))<1e-12,'Duplicate-safe majority numerator/denominator differs')
        if not anchors:require(g['proposed_class_id']>=23 and g['decision']=='new_class_candidate','No majority must propose a new class')
        elif len(g['tied_majority_anchors'])>1:require(g['proposed_class_id'] is None,'True majority tie must remain manual')
        else:require(g['proposed_class_id']==anchors[0],'Wrong retained majority class')
    proposals=jsonl(ROOT/'proposed_mapping.jsonl');require(len(proposals)==2200 and digest(ROOT/'proposed_mapping.jsonl')==m['proposed_mapping_sha256'],'Mapping scope/bytes differ')
    for p in proposals:
        g=groups[assignments[p['target_key']]];require(p['proposed_class_id']==g['proposed_class_id'] and p['review_status']=='pending_human','Automatic approval forbidden')
    for name,h in m['public_assets'].items():
        path=ROOT/name;require(path.is_file() and not path.is_symlink() and path.resolve().is_relative_to(ROOT) and digest(path)==h,'Public asset/path changed')
    # Source-only replay guarantees identity/K/votes, not that the appearance
    # similarity candidates are true physical pallet face identities.
    receipt=dict(state='passed2200_class_candidates_source_K_majority_not_semantic_accuracy',manifest_sha256=digest(ROOT/'manifest.json'),targets=2200,
        candidate_face_groups=len(groups),proposed_new_class_candidates=sum(not g['majority_anchors'] for g in groups.values()),
        actual_K_hard_partition_verified=True,old_whole_class_strict_majority_verified=True,duplicate_votes_not_inflated=True,
        all_old_human_contours_and_classes_unchanged=True,all_suggestions_pending_human=True,physical_face_classification_accuracy=None,
        no_training=True,other10144_formal_targets_not_reclassified=True,code_sha256=digest(__file__))
    write(ROOT/'verification.json',receipt);print(json.dumps(receipt),flush=True)


if __name__=='__main__':verify()
