"""Validate a portable RGB-only release without the processing stack."""
from pathlib import Path
import sys,json,hashlib,argparse,subprocess
sys.dont_write_bytecode=True
import cv2
import numpy as np
import polars as pl

def validate(root):
    root=Path(root).resolve();sys.path.insert(0,str(root))
    from observation_reader import ObservationDataset,camera_points
    import pyarrow.parquet as pq
    ds=ObservationDataset(root)
    assert ds.info['capture_mode']=='rgb_only' and ds.info['license']=='cc-by-4.0'
    assert ds.episodes
    report={'status':'passed','scope':'Full video decode, displayed PTS, frame identity tables, missing modalities, segment bounds, embedded preview schema and all checksums. No annotation accuracy or model training evaluation.','episodes':[]}
    for key,e in ds.episodes.items():
        mapping=ds.table(key,'frame_mapping');n=e['frame_count']
        assert mapping.height==n and mapping['rgb_frame_index'].to_list()==list(range(n))
        source=mapping['source_frame_index'].to_numpy()
        assert np.all(np.diff(source)==1) and source[0]==e['source']['selection']['first_source_frame'] and source[-1]==e['source']['selection']['last_source_frame']
        ts=mapping['t_s'].to_numpy();assert ts[0]==0 and np.all(np.isfinite(ts)) and np.all(np.diff(ts)>0)
        assert np.max(np.abs(np.diff(mapping['source_pts_s'].to_numpy())-np.diff(ts)))<1e-6
        assert mapping['rgb_decodable'].all()
        probe=json.loads(subprocess.check_output(['ffprobe','-v','error','-show_streams','-show_packets','-of','json',str(root/e['video'])]))
        assert len(probe['streams'])==1
        stream=probe['streams'][0]
        assert stream['codec_name']=='h264' and stream['pix_fmt']=='yuv420p' and stream['color_transfer']=='bt709'
        pts=sorted(float(p['pts_time']) for p in probe['packets'] if 'pts_time' in p and 'D' not in p.get('flags',''))
        assert len(pts)==n and np.max(np.abs(np.array(pts)-mapping['video_pts_s'].to_numpy()))<2e-6
        cap=cv2.VideoCapture(str(root/e['video']));decoded=0
        try:
            while True:
                ok,frame=cap.read()
                if not ok:break
                assert frame.shape==(e['height'],e['width'],3)
                decoded+=1
        finally:cap.release()
        assert decoded==n,(key,decoded,n)
        indices=sorted({0,n//4,n//2,3*n//4,n-1})
        for index in indices:
            frame=ds.frame(key,index)
            assert frame['source_frame_index']==int(source[index]) and frame['timestamp_s']==ts[index]
            assert all(frame[k] is None for k in ('depth_m','depth_valid','confidence','K_rgb','camera_pose_xyzw','sensor_timestamp_s'))
            assert not any(v for k,v in frame['modalities'].items() if k!='rgb')
            try:camera_points(frame)
            except ValueError:pass
            else:raise AssertionError('RGB-only geometry must be unavailable')
        for name in ('hand_pose_raw','hand_pose'):
            if name not in e['signals']:continue
            hand=ds.table(key,name)
            assert all(hand[k].null_count()==hand.height for k in ('z','wx','wy','wz'))
            assert ds.annotations_near(key,name,1e6).height==0
        assert hashlib.file_digest((root/e['video']).open('rb'),'sha256').hexdigest()==e['video_sha256']
        report['episodes'].append({'capture_id':key,'decoded_frames':decoded,'timestamp_rows':n,'random_access_indices':indices,'metric_channels_absent':True})
        print(key,decoded,'decoded frames and timestamps verified',flush=True)
    segments=pl.read_parquet(root/'annotations/action_segments.parquet')
    for row in segments.to_dicts():
        assert row['capture_id'] in ds.episodes
        assert 0<=row['start_s']<row['end_s']<=ds.episodes[row['capture_id']]['duration_s']
        assert row['annotation_source']=='assistant_visual_review' and row['boundary_precision_s']==2.0
    catalog=pq.read_table(root/'data/episodes.parquet')
    features=json.loads(catalog.schema.metadata[b'huggingface'])['info']['features']
    assert features['video']['_type']=='Video' and catalog.num_rows==len(ds.episodes)
    for row in catalog.to_pylist():
        assert row['video']['bytes']==(root/ds.episodes[row['capture_id']]['preview']).read_bytes()
    seen=set()
    for line in (root/'checksums.sha256').read_text().splitlines():
        expected,rel=line.split('  ',1);target=(root/rel).resolve()
        assert target.is_relative_to(root) and rel not in seen
        assert hashlib.file_digest(target.open('rb'),'sha256').hexdigest()==expected,rel
        seen.add(rel)
    actual={p.relative_to(root).as_posix() for p in root.rglob('*') if p.is_file() and p.name!='checksums.sha256' and '__pycache__' not in p.parts and '.cache' not in p.parts}
    assert actual==seen,(actual-seen,seen-actual)
    report.update(verified_artifact_hashes=len(seen),action_segments=segments.height,huggingface_video_rows=catalog.num_rows,total_decoded_frames=sum(e['decoded_frames'] for e in report['episodes']))
    return report

if __name__=='__main__':
    p=argparse.ArgumentParser(description=__doc__);p.add_argument('root',type=Path);p.add_argument('--write-report',action='store_true');args=p.parse_args()
    report=validate(args.root)
    if args.write_report:(args.root/'validation.json').write_text(json.dumps(report,indent=2),encoding='utf-8')
    print(json.dumps(report,indent=2))