"""Read-only replay of the all-human dataset and eventual real worker results."""
from collections import Counter
from contextlib import closing
import argparse
import hashlib
import json
from pathlib import Path
import sqlite3
import sys

import cv2
import numpy as np

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.mask_model_training_data import read,jsonl,write,require,sha,letterbox
from pallet.mask_quota_saved_extension import load_formal_evidence,file_inventory
from pallet.mask_dataset_update import exception_snapshot
from pallet.mask_model_improvement_data import preservation
from pallet.pose_review_geometry import raster_mask
from pallet.cluster_targets import digest

ROOT=PROJECT/'outputs/pallet_mask_annotation_full_v1'


def verify_dataset():
    from pycocotools import mask as mu
    m=read(ROOT/'dataset_manifest.json');rs=jsonl(ROOT/'private/training_records.jsonl')
    require(m['state']=='immutable_all_manual_annotation_training_dataset' and len(rs)==m['records']==1559,'All1559 required')
    require(m['all_components_in_train'] and m['old_val_test_training_authorized'] and not m['blind'],'No fake independent heldout claim')
    for name,value in m['files'].items():require(digest(ROOT/name)==value,'Data hash differs: '+name)
    binding=read(ROOT/'private/source_binding.json');source=PROJECT/binding['standard']['source']
    refs=jsonl(source/'private/source_catalog.jsonl')
    formal,rows,_=load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'))
    isolated,only,events=exception_snapshot(ROOT/'private/isolated_snapshot.sqlite3',rows,formal)
    require(len(isolated)==7 and not only,'All7 actual human redraws required')
    refs={r['target_key']:r for r in refs+isolated};require(len(refs)==1559,'Repeated source key')
    groups=read(ROOT/'private/global_components.json')['by_target'];counts=Counter();seenframes=set();seenpixels=set()
    coco=read(ROOT/'dataset/train/_annotations.coco.json');sq=read(ROOT/'dataset_rfdetr/train/_annotations.coco.json')
    require(len(coco['images'])==len(coco['annotations'])==len(sq['images'])==len(sq['annotations'])==1559,'Paired source inventories must be complete')
    for r,image,ann,sann in zip(rs,coco['images'],coco['annotations'],sq['annotations']):
        row=rows[r['target_key']];ref=refs[r['target_key']];filehash=digest(formal/row['image'])
        require(row['frame_id'] not in seenframes and filehash not in seenpixels,'Duplicate raw image')
        seenframes.add(row['frame_id']);seenpixels.add(filehash);counts[row['final_class_id']]+=1
        require(r['polygon']==ref['polygon'] and r['source_event_raw_sha256']==ref['event_raw_sha256'] and r['source_revision']==ref['revision'],'Exact real source differs')
        require(r['component']==groups[r['target_key']] and r['development_split']=='train' and r['former_formal_split']==row['split'],'Lost component/former identity')
        # Independently repeat the label-independent crop rule.
        import math
        b=row['bbox'];dx=max(48,.2*b['width']);dy=max(16,.6*b['height'])
        roi=[max(0,math.floor(b['x']-dx)),max(0,math.floor(b['y']-dy)),min(row['size'][0],math.ceil(b['x']+b['width']+dx)),min(row['size'][1],math.ceil(b['y']+b['height']+dy))]
        require(roi==r['roi'],'Crop used information unavailable at inference')
        x1,y1,x2,y2=roi;native=cv2.imread(str(formal/row['image']),0)[y1:y2,x1:x2]
        full=raster_mask(ref['polygon'],*row['size']).astype(np.uint8);mask=full[y1:y2,x1:x2]
        require(int(mask.sum())==int(full.sum()),'Human contour clipped')
        def decode(a):
            v=a['segmentation'];return mu.decode(dict(size=v['size'],counts=v['counts'].encode()))
        require(np.array_equal(cv2.imread(str(ROOT/r['image'])),np.repeat(native[:,:,None],3,axis=2))
            and np.array_equal(cv2.imread(str(ROOT/r['native_mask']),0)>0,mask) and np.array_equal(decode(ann),mask),'Native model source/labels/RLE differ')
        valid=cv2.imread(str(ROOT/r['valid_mask']),0)>0;require(valid[mask>0].all(),'Manual positives wrongly ignored')
        square,label,_,_=letterbox(native,mask,(576,576))
        require(np.array_equal(label,decode(sann)) and np.array_equal(square,cv2.imread(str(ROOT/'dataset_rfdetr/train'/image['file_name']),0)),'Aspect-preserving export differs')
    require(len(counts)==22 and min(counts.values())>=50 and len({r['component'] for r in rs})==194,'Not all classes/components retained')
    for directory,pins in read(ROOT/'private/previous_versions_inventory.json').items():require(file_inventory(PROJECT/directory)==pins,'Historical model/data artifacts changed')
    require(file_inventory(PROJECT/'outputs/pallet_mask_dataset_update_v1')==read(ROOT/'private/previous_update_inventory.json'),'Old294 data changed')
    require(preservation(formal)==read(ROOT/'private/preservation_before.json'),'Historical static/formal/config files changed')
    return dict(state='passed_all1559_real_sources_all194components22classes_and_exports_not_blind_accuracy',records=1559,components=194,
        class_counts=dict(counts),former_split_counts=dict(Counter(r['former_formal_split'] for r in rs)),
        user_quality_approved7_included=True,old_artifacts_unchanged=True,source_flags_not_rewritten=True,
        manifest_sha256=digest(ROOT/'dataset_manifest.json'))


def finish():
    import torch
    from pallet.mask_model_training import native_metrics,summarize
    from pycocotools import mask as mu
    data=verify_dataset();plan=read(ROOT/'execution_plan.json');runs={};errors=[]
    for route in ('m1','m2'):
        out=ROOT/route
        try:
            require((out/'completion.json').exists() and not (out/'failure.json').exists(),'Missing completion or explicit failure')
            c=read(out/'completion.json');exposure=read(out/'exposure_audit.json')
            require(c['actual_optimizer_updates']==plan['optimizer_updates'][route] and c['checkpoint_sha256']==digest(out/c['checkpoint']),'Step/checkpoint receipt differs')
            ckpt=torch.load(out/c['checkpoint'],map_location='cpu',weights_only=True)
            require(ckpt['step']==c['actual_optimizer_updates'],'Checkpoint step differs');del ckpt
            require(len(exposure['by_target'])==1559 and min(exposure['by_target'].values())>0 and len(exposure['by_component'])==194,'Not all sources trained')
            preds=jsonl(out/'fit_predictions.jsonl');rs={r['target_key']:r for r in jsonl(ROOT/'private/training_records.jsonl')}
            require(len(preds)==1559 and {p['target_key'] for p in preds}==rs.keys(),'Incomplete training-fit diagnostic')
            for p in preds:
                rle=p['native_prediction_rle'];pred=mu.decode(dict(size=rle['size'],counts=rle['counts'].encode())).astype(bool)
                target=cv2.imread(str(ROOT/rs[p['target_key']]['native_mask']),0)>0;metrics=native_metrics(pred,target)
                require(all((v==p[k] if v is None or isinstance(v,bool) else abs(v-p[k])<1e-10) for k,v in metrics.items()),'Fit RLE metrics differ')
                require(p['trained_on_this_image'] is True and p['blind'] is False,'Training diagnostic mislabeled independent')
            runs[route]=dict(state='verified_fixed_budget_fullpool_fit',steps=c['actual_optimizer_updates'],checkpoint_sha256=c['checkpoint_sha256'],
                training_fit_only=summarize(preds),validation_accuracy=None,exposed_components=194)
        except Exception as e:
            runs[route]=dict(state='failed_or_incomplete_not_all_completed',error=str(e));errors.append(route+': '+str(e))
    result=dict(state='verified_both_fullpool_training_completed_no_quality_release' if not errors else 'partial_or_failed_fullpool_training',
        dataset=data,runs=runs,errors=errors,independent_accuracy=None,production_activated=False,
        followup='Only new unprocessed images can assess annotation edit effort; no automatic label promotion',code_sha256=digest(__file__))
    write(ROOT/'FINAL_HANDOFF.json',result);print(json.dumps(result),flush=True)


if __name__=='__main__':
    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--finish',action='store_true');p.add_argument('--wait-pid',type=int,action='append',default=[]);a=p.parse_args()
    if a.wait_pid:
        sys.path.insert(0,str(PROJECT/'scripts'))
        from verify_mask_model_training_history_v2 import wait_for_process_exit
        for pid in a.wait_pid:wait_for_process_exit(pid)
    if a.finish:finish()
    else:
        result=verify_dataset();write(ROOT/'readonly_dataset_verification.json',result);print(json.dumps(result),flush=True)
