#!/usr/bin/env python3
"""Independent BOP/image/pose/keypoint checks for a local BlenderProc layout."""
import argparse
import hashlib
import json
from pathlib import Path
import cv2
import numpy as np


def sha(path):
    h=hashlib.sha256()
    with path.open('rb') as f:
        for b in iter(lambda:f.read(8*1024*1024),b''):h.update(b)
    return h.hexdigest()


def audit(root,keypoints):
    scene=json.loads((root/'scene_record.json').read_text());receipt=json.loads((root/'render_receipt.json').read_text())
    bop=root/'bop_data/handal/train_pbr/000000';gt=json.loads((bop/'scene_gt.json').read_text());camera=json.loads((bop/'scene_camera.json').read_text());info=json.loads((bop/'scene_gt_info.json').read_text())
    frames=scene['frames'];expected={str(i) for i in range(frames)}
    count_tolerance=0 if (root/'visible_count_canonicalization.json').exists() else 2
    if set(gt)!=expected or set(camera)!=expected or set(info)!=expected:raise ValueError('incomplete BOP metadata')
    world={r['id']:np.asarray(r['matrix']) for r in scene['object_world_poses_m'] if r['dataset']=='handal'}
    points=np.asarray(json.loads(keypoints.read_text())['keypoints_3d'])
    if points.shape!=(64,3) or not np.isfinite(points).all():raise ValueError('bad keypoints')
    target=scene['target_id'];rot_error=[];translation_error=[];pixel_error=[];visible=[];sizes=[];mask_count_deltas=[]
    for frame in range(frames):
        key=str(frame);img=cv2.imread(str(bop/'rgb'/f'{frame:06d}.jpg'));depth=cv2.imread(str(bop/'depth'/f'{frame:06d}.png'),cv2.IMREAD_UNCHANGED)
        if img is None or img.shape[:2]!=(1440,1920) or depth is None or depth.shape!=img.shape[:2] or depth.dtype!=np.uint16:raise ValueError('bad RGB/depth output')
        if len(gt[key])!=20 or len(info[key])!=20:raise ValueError('expected 20 HANDAL instances')
        K=np.asarray(camera[key]['cam_K']).reshape(3,3)
        c2w=np.asarray(scene['camera_world_poses_m'][frame]);w2cv=np.linalg.inv(c2w@np.diag([1,-1,-1,1]))
        for i,(pose,statistics) in enumerate(zip(gt[key],info[key])):
            oid=pose['obj_id'];H=world[oid];scale=np.linalg.norm(H[:3,:3],axis=0)
            if not np.allclose(scale,scale[0],rtol=1e-5):raise ValueError('anisotropic scale')
            R=w2cv[:3,:3]@(H[:3,:3]/scale)
            t=(w2cv[:3,:3]@H[:3,3]+w2cv[:3,3])*1000
            stored_R=np.asarray(pose['cam_R_m2c']).reshape(3,3);stored_t=np.asarray(pose['cam_t_m2c'])
            rot_error.append(float(np.abs(R-stored_R).max()));translation_error.append(float(np.linalg.norm(t-stored_t)))
            mask=cv2.imread(str(bop/'mask'/f'{frame:06d}_{i:06d}.png'),0);vis=cv2.imread(str(bop/'mask_visib'/f'{frame:06d}_{i:06d}.png'),0)
            if mask is None or vis is None or mask.shape!=img.shape[:2] or vis.shape!=mask.shape:raise ValueError('missing/wrong-size masks')
            count_delta=abs(int((vis>0).sum())-statistics['px_count_visib']);mask_count_deltas.append(count_delta)
            # BOPWriter rasterizes masks and info separately. The first native
            # smoke showed 1–2-pixel edge-count differences, zero outside-mask pixels.
            # Keep a tight explicit bound, record it, and never rewrite GT metadata.
            if np.any((vis>0)&(mask==0)) or count_delta>count_tolerance:
                raise ValueError(f'visible-mask/info mismatch beyond {count_tolerance} raster pixels')
            if oid==target:
                p1=(R@(points*1000).T).T+t;p2=(stored_R@(points*1000).T).T+stored_t
                good=(p1[:,2]>0)&(p2[:,2]>0);u1=p1[good]@K.T;u2=p2[good]@K.T
                if good.any():pixel_error.append(float(np.linalg.norm(u1[:,:2]/u1[:,2:]-u2[:,:2]/u2[:,2:],axis=1).max()))
                visible.append(statistics['visib_fract']);sizes.append(statistics['bbox_obj'][2:])
                overlay=img.copy();contours,_=cv2.findContours(vis,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE);cv2.drawContours(overlay,contours,-1,(0,255,0),2)
                for uv in u2[:,:2]/u2[:,2:]:
                    x,y=np.rint(uv).astype(int)
                    if 0<=x<img.shape[1] and 0<=y<img.shape[0]:cv2.circle(overlay,(x,y),3,(0,0,255),-1)
                if frame<8:
                    (root/'audit_overlays').mkdir(exist_ok=True);cv2.imwrite(str(root/'audit_overlays'/f'{frame:06d}.jpg'),overlay)
    if max(rot_error)>1e-4 or max(translation_error)>.1 or not pixel_error or max(pixel_error)>.1:raise ValueError('independent frame/unit/projection check failed')
    if not any(v>0 for v in visible):raise ValueError('target is never visible')
    files={str(p.relative_to(root)):{'sha256':sha(p),'bytes':p.stat().st_size} for p in (root/'bop_data').rglob('*') if p.is_file()}
    result={'ok':True,'target_id':target,'frames':frames,'image_size':[1920,1440],
        'max_rotation_entry_error':max(rot_error),'max_translation_error_mm':max(translation_error),
        'max_keypoint_reprojection_error_px':max(pixel_error),'target_visibility':visible,'target_bbox_sizes':sizes,
        'max_mask_info_count_difference_pixels':max(mask_count_deltas),'mask_info_count_tolerance_pixels':count_tolerance,
        'keypoints_sha256':sha(keypoints),'render_seconds':receipt['render_seconds'],'total_seconds':receipt['total_seconds'],
        'bop_bytes':sum(v['bytes'] for v in files.values()),'files':files,'distribution_approved':False}
    (root/'AUDITED.json').write_text(json.dumps(result,indent=2)+'\n')
    print(json.dumps({k:v for k,v in result.items() if k!='files'},indent=2),flush=True)
    return result


def main():
    p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--keypoints',type=Path,required=True)
    a=p.parse_args();audit(a.root,a.keypoints)


if __name__=='__main__':main()