"""Read-only XYZ/decimal/range audit; never infer metric units from magnitudes."""
from __future__ import annotations

import argparse
from collections import Counter,defaultdict
from concurrent.futures import ProcessPoolExecutor
import hashlib
import json
import math
import multiprocessing
from pathlib import Path
import sys

import numpy as np

PROJECT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(PROJECT))
from pallet.data.orientation import orient_grid
from pallet.data.pcd import read_pcd


def sha(path):
    value=hashlib.sha256()
    with Path(path).open('rb') as stream:
        for block in iter(lambda:stream.read(4*1024*1024),b''):value.update(block)
    return value.hexdigest()


def rows(path):
    return [json.loads(line) for line in Path(path).read_text().splitlines() if line]


def valid(xyz):
    return np.isfinite(xyz).all(1)&(np.abs(xyz).max(1)>1e-8)


def xyz_stats(xyz):
    xyz=np.asarray(xyz,dtype=np.float32)
    good=valid(xyz);p=xyz[good].astype(np.float64)
    result=dict(points=len(xyz),valid_points=len(p),nonfinite_points=int((~np.isfinite(xyz).all(1)).sum()),
                finite_zero_or_nearzero_points=int((np.isfinite(xyz).all(1)&~good).sum()))
    if not len(p):return result
    integer=(p==np.rint(p));zero=(p==0);radius=np.linalg.norm(p,axis=1)
    result.update(integer_components=integer.sum(0).tolist(),zero_components=zero.sum(0).tolist(),
        noninteger_components=(~integer).sum(0).tolist(),
        points_with_all_xyz_noninteger=int((~integer).all(1).sum()),
        xyz_min=p.min(0).tolist(),xyz_max=p.max(0).tolist(),xyz_median=np.median(p,axis=0).tolist(),
        distance=dict(x_min=float(p[:,0].min()),x_max=float(p[:,0].max()),x_median=float(np.median(p[:,0])),
            abs_x_median=float(np.median(np.abs(p[:,0]))),x_gt10_points=int((p[:,0]>10).sum()),
            abs_x_gt10_points=int((np.abs(p[:,0])>10).sum()),
            radius_min=float(radius.min()),radius_max=float(radius.max()),radius_median=float(np.median(radius)),
            radius_gt10_points=int((radius>10).sum())))
    # Deterministic raw-valued examples: do not interpret display digits as precision.
    candidates=np.unique(np.r_[0,np.argmin(radius),np.argmax(radius),np.linspace(0,len(p)-1,5,dtype=int)])
    result['examples_xyz']=p[candidates[:8]].tolist()
    return result


def ascii_examples(path,header):
    if header['DATA'][0]!='ascii':return []
    fields=header.get('FIELDS',header.get('FIELD',[]));counts=list(map(int,header.get('COUNT',['1']*len(fields))))
    columns={};offset=0
    for name,count in zip(fields,counts):columns[name]=offset;offset+=count
    result=[]
    with Path(path).open('rb') as stream:
        while line:=stream.readline():
            if line.strip().upper().startswith(b'DATA '):break
        for index,line in enumerate(stream):
            values=line.decode('ascii').split()
            if len(values)!=sum(counts):continue
            raw=[values[columns[c]] for c in ('x','y','z')]
            numbers=np.array([float(v) for v in raw])
            if valid(numbers[None])[0]:
                result.append(dict(source_index=index,xyz_tokens=raw))
                if len(result)==4:break
    return result


def inspect(job):
    source,targets,labels,support_root=job
    path=Path(source['source_paths']['pcd'])
    if sha(path)!=source['source_anchor_hash']:raise ValueError('PCD source hash mismatch: '+str(path))
    header,points=read_pcd(path);xyz=points[:,:3];w,h=source['size']
    if len(points)!=w*h:raise ValueError('Grid size mismatch')
    mapping=orient_grid(np.arange(len(points),dtype=np.int32).reshape(h,w),source['sensor_policy'])
    fields=header.get('FIELDS',header.get('FIELD',[]))
    types=header.get('TYPE',['F']*len(fields));sizes=header.get('SIZE',['4']*len(fields))
    frame=dict(frame_id=source['frame_id'],domain=source['domain'],split=source['split'],
        registered_depth_axis=source['sensor_policy'].get('depth_axis'),
        pcd=str(path),pcd_sha256=source['source_anchor_hash'],pcd_mode=header['DATA'][0],
        xyz_storage={c:dict(type=types[fields.index(c)],size=int(sizes[fields.index(c)])) for c in ('x','y','z')},
        scene=xyz_stats(xyz),ascii_token_examples=ascii_examples(path,header))
    output=[]
    for target in targets:
        box=target['bbox'];x,y,bw,bh=(box[k] for k in ('x','y','width','height'))
        x0,x1=max(0,math.ceil(x-.5)),min(w,math.ceil(x+bw-.5))
        y0,y1=max(0,math.ceil(y-.5)),min(h,math.ceil(y+bh-.5))
        ids=mapping[y0:y1,x0:x1].ravel()
        record=dict(target_key=target['target_key'],frame_id=source['frame_id'],domain=source['domain'],split=source['split'],
                    original_box=box,original_box_roi=xyz_stats(xyz[ids]))
        label=labels.get(target['target_key'])
        if label:
            support=Path(support_root)/(target['target_key']+'.npz')
            if sha(support)!=label['support_sha256']:raise ValueError('Frozen support hash mismatch')
            with np.load(support,allow_pickle=False) as z:ids=z['selected_source_indices'].copy()
            if len(ids)!=label['selected_measured_points']:raise ValueError('Frozen support count mismatch')
            record.update(frozen_selected_face=xyz_stats(xyz[ids]),
                          frozen_pose_xy=[label['pose']['x'],label['pose']['y']],
                          frozen_forward_axis=label['sensor']['forward_axis'])
        output.append(record)
    return frame,output


def aggregate_stats(items):
    if not items:return dict(records=0)
    result=dict(records=len(items),valid_records=sum(bool(s['valid_points']) for s in items),
        points=sum(s['points'] for s in items),valid_points=sum(s['valid_points'] for s in items),
        nonfinite_points=sum(s['nonfinite_points'] for s in items),
        finite_zero_or_nearzero_points=sum(s['finite_zero_or_nearzero_points'] for s in items))
    items=[s for s in items if s['valid_points']]
    if not items:return result
    result.update(integer_components=np.sum([s['integer_components'] for s in items],axis=0).tolist(),
        zero_components=np.sum([s['zero_components'] for s in items],axis=0).tolist(),
        noninteger_components=np.sum([s['noninteger_components'] for s in items],axis=0).tolist(),
        points_with_all_xyz_noninteger=sum(s['points_with_all_xyz_noninteger'] for s in items),
        records_all_xyz_noninteger=sum(s['points_with_all_xyz_noninteger']==s['valid_points'] for s in items),
        records_any_integer_component=sum(any(s['integer_components']) for s in items),
        records_no_noninteger_components=sum(not any(s['noninteger_components']) for s in items),
        xyz_min=np.min([s['xyz_min'] for s in items],axis=0).tolist(),
        xyz_max=np.max([s['xyz_max'] for s in items],axis=0).tolist())
    distances=[s['distance'] for s in items]
    result['distances']=dict(
        x_median_min=min(d['x_median'] for d in distances),x_median_max=max(d['x_median'] for d in distances),
        radius_median_min=min(d['radius_median'] for d in distances),radius_median_max=max(d['radius_median'] for d in distances),
        x_median_gt10_records=sum(d['x_median']>10 for d in distances),
        abs_x_median_gt10_records=sum(d['abs_x_median']>10 for d in distances),
        radius_median_gt10_records=sum(d['radius_median']>10 for d in distances),
        x_gt10_points=sum(d['x_gt10_points'] for d in distances),radius_gt10_points=sum(d['radius_gt10_points'] for d in distances),
        maximum_radius=max(d['radius_max'] for d in distances),
        maximum_x=max(d['x_max'] for d in distances))
    return result


def summarize(frames,targets,label_keys):
    groups={}
    for domain in sorted({f['domain'] for f in frames}):
        fs=[f for f in frames if f['domain']==domain];ts=[t for t in targets if t['domain']==domain]
        groups[domain]=dict(frames=len(fs),targets=len(ts),storage_modes=dict(Counter(f['pcd_mode'] for f in fs)),
            scene=aggregate_stats([f['scene'] for f in fs]),
            original_box_roi=aggregate_stats([t['original_box_roi'] for t in ts]),
            frozen_selected_face=aggregate_stats([t['frozen_selected_face'] for t in ts if 'frozen_selected_face' in t]))
    frozen=[t for t in targets if t['target_key'] in label_keys]
    return dict(frames=len(frames),targets=len(targets),frozen_research_targets=len(frozen),
        scene=aggregate_stats([f['scene'] for f in frames]),
        original_box_roi=aggregate_stats([t['original_box_roi'] for t in targets]),
        frozen_selected_face=aggregate_stats([t['frozen_selected_face'] for t in frozen]),
        domains=groups,
        frozen_face_radius_median_gt10=[dict(target_key=t['target_key'],frame_id=t['frame_id'],domain=t['domain'],
            distance=t['frozen_selected_face'].get('distance')) for t in frozen
            if t['frozen_selected_face'].get('distance',{}).get('radius_median',0)>10],
        target_roi_radius_median_gt10=[dict(target_key=t['target_key'],frame_id=t['frame_id'],domain=t['domain'],
            distance=t['original_box_roi'].get('distance')) for t in targets
            if t['original_box_roi'].get('distance',{}).get('radius_median',0)>10])


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--scope',choices=['benchmark','all'],default='benchmark')
    parser.add_argument('--output',type=Path,default=PROJECT/'outputs/pallet_pose_native_units_audit_v1')
    parser.add_argument('--workers',type=int,default=4)
    args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True)
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    snapshot=PROJECT/'outputs/pallet_pose_refinement_v2/snapshot'
    labels={r['target_key']:r for r in rows(snapshot/'eligible.jsonl') if r['branch']=='native_unknown'}
    sources={r['frame_id']:r for r in rows(formal/'frames.jsonl')}
    annotations=rows(formal/'annotations/frames.jsonl')
    if args.scope=='benchmark':
        targets=defaultdict(list)
        for row in labels.values():targets[row['frame_id']].append(row)
    else:
        from pallet.cluster_targets import target_key
        targets={r['frame_id']:[dict(target_key=target_key(r['frame_id'],i),bbox=box) for i,box in enumerate(r['boxes'])]
                 for r in annotations if sources[r['frame_id']]['sensor_policy'].get('scale_to_mm') is None}
    for frame in targets:
        if sources[frame]['sensor_policy'].get('scale_to_mm') is not None:raise ValueError('Not an unknown-unit source')
    jobs=[(sources[frame],ts,{t['target_key']:labels[t['target_key']] for t in ts if t['target_key'] in labels},str(snapshot/'support'))
          for frame,ts in targets.items()]
    frames=[];records=[]
    with ProcessPoolExecutor(max_workers=args.workers,mp_context=multiprocessing.get_context('spawn')) as pool:
        for i,(frame,values) in enumerate(pool.map(inspect,jobs),1):
            frames.append(frame);records.extend(values)
            if i==1 or i%500==0:print(json.dumps(dict(scope=args.scope,completed=i,total=len(jobs))),flush=True)
    for name,values in [('frames',frames),('targets',records)]:
        (args.output/(args.scope+'_'+name+'.jsonl')).write_text(''.join(json.dumps(v,ensure_ascii=False,allow_nan=False)+'\n' for v in values))
    summary=summarize(frames,records,set(labels))
    summary.update(scope=args.scope,all_source_pcd_hashes_verified=True,source_database_writes=0,
        coordinate_unit='unverified_native_no_scale_applied',distance_threshold=10,
        distance_definition='raw_X_and_euclidean_norm_XYZ; target_distance_uses_median_of_valid_ROI_or_frozen_human_selected_points',
        valid_definition='all_XYZ_finite_and_max_abs_component_gt_1e-8; manufacturer_invalid_sentinels_not_inferred',
        decimal_definition='exact_noninteger_of_declared_float32_XYZ; no_claim_about_physical_measurement_accuracy',
        note='ROI_counts_repeat_points_if_boxes_overlap; scene_counts_once_per_frame; no_metric_unit_inference',
        frozen_eligible_sha256=sha(snapshot/'eligible.jsonl'))
    (args.output/(args.scope+'_summary.json')).write_text(json.dumps(summary,ensure_ascii=False,indent=2,allow_nan=False)+'\n')
    print(json.dumps(dict(state='passed',scope=args.scope,frames=summary['frames'],targets=summary['targets'],
        selected_face=summary['frozen_selected_face'],output=str(args.output/(args.scope+'_summary.json'))),ensure_ascii=False),flush=True)


if __name__=='__main__':main()
