"""Read-only, offline comparison of frozen v4 predictions and geometry evidence.

This module never fits/reselects models and never opens the live annotation DB.
All case selection is explicitly post-hoc, deterministic and exported with rules.
"""
from __future__ import annotations

import argparse
import base64
from collections import Counter
import csv
import hashlib
from html import escape
import io
import json
from pathlib import Path
import re
import shutil
from zipfile import ZipFile, ZIP_DEFLATED

import numpy as np
from PIL import Image

from .cluster_targets import digest, load_dataset, protected_snapshot
from .data.orientation import orient_grid
from .data.pcd import read_pcd
from .fork_geometry import valid_xyz
from .pose_benchmark_v4 import per_error
from .pose_benchmark_v4_data import load, ROOT, PROJECT
from .pose_refinement import atomic_json, decoded, now
from .pose_review_geometry import raster_mask

ASSETS = PROJECT / 'pallet/assets/pose_comparison_report'
PRIMARY = 'pointnext/long_b32'
ARM_NAMES = dict(base='B32 · 80轮',long_b32='B32 · 240轮',long_b64='B64 · 240轮',long_b64_steps='B64 · 400轮')
FAMILY_NAMES = dict(pointnext='PointNeXt',ptv3='PTv3',dgcnn='DGCNN',pointmae='Point-MAE',
                    sonata='Sonata',litept='LitePT',utonia='Utonia',concerto='Concerto')
COLORS = dict(label='#087f79',geometry='#c97916',model='#6757d6')


def title(key):
    family,arm=key.split('/')
    return f'{FAMILY_NAMES[family]} / {ARM_NAMES[arm]}'


def errors(pred,arrays,branch):
    p,a=per_error(pred,arrays['y'])
    distance=p*arrays['width']*1000 if branch=='metric' else p*100
    good=(distance<=(50 if branch=='metric' else 5))&(a<=5)
    return dict(position=distance,angle=a,good=good,
                normalized=p/.05+a/5)


def paired_counts(geometry,model):
    g,m=geometry['good'],model['good']
    return dict(both_pass=int((g&m).sum()),rescued=int((~g&m).sum()),
                regressed=int((g&~m).sum()),both_fail=int((~g&~m).sum()))


def macro(values,rows):
    return float(np.mean([np.mean(values[[r['group_id']==g for r in rows]]) for g in sorted({r['group_id'] for r in rows})]))


def read_cohort(branch,split):
    rows,arrays,all_rows=load(branch,split)
    if len(rows)!=len(all_rows):raise ValueError('This report requires paired preprocessing coverage; do not silently drop failures')
    reports=json.loads((ROOT/'evaluation'/branch/'report.json').read_text())
    geom_pred=np.zeros_like(arrays['y']);geom_pred[:,2]=1
    geometry=errors(geom_pred,arrays,branch);models={};input_hashes={}
    for entry in reports['models']:
        key=entry['family']+'/'+entry['arm'];path=ROOT/'evaluation'/branch/entry['family']/entry['arm']/(split+'.npz')
        with np.load(path,allow_pickle=False) as z:
            assert z['keys'].tolist()==[r['target_key'] for r in rows]
            np.testing.assert_array_equal(z['targets'],arrays['y'])
            np.testing.assert_array_equal(z['widths'],arrays['width'])
            prediction=z['predictions'].copy()
        e=errors(prediction,arrays,branch);frozen=entry['splits'][split]
        expected_position=float(e['position'].mean())/(100 if branch!='metric' else 1)
        np.testing.assert_allclose(expected_position,frozen['position_mean'],rtol=1e-6,atol=1e-7)
        np.testing.assert_allclose(e['angle'].mean(),frozen['angle_mean'],rtol=1e-6,atol=1e-7)
        assert int(e['good'].sum())==frozen['success_count']
        models[key]=dict(prediction=prediction,errors=e,stats=frozen,refit_epoch=entry['refit_epoch'],
                         pair=paired_counts(geometry,e))
        input_hashes[str(path.relative_to(PROJECT))]=digest(path)
    return dict(rows=rows,arrays=arrays,geometry=geometry,models=models,reports=reports,hashes=input_hashes)


def choose_cases(cohort,metadata):
    """Fixed category rules, largest differences + group diversity, never a random showcase."""
    rows=cohort['rows'];g=cohort['geometry'];used=set();counts=Counter();cases=[]
    def pick(category,label,rule,key,mask,score,note,*,diverse=True):
        model=cohort['models'][key]['errors'];ids=np.where(mask)[0].tolist()
        ids.sort(key=lambda i:(-float(score[i]),rows[i]['target_key']))
        if not ids:raise ValueError('Missing case category: '+category)
        # Prefer a not-yet-used target. Diversity is a documented tie-break
        # over the eligible set, not an assertion of population representativeness.
        available=[i for i in ids if rows[i]['target_key'] not in used] or ids
        if diverse:available.sort(key=lambda i:(counts[rows[i]['group_id']],-float(score[i]),rows[i]['target_key']))
        i=available[0];used.add(rows[i]['target_key']);counts[rows[i]['group_id']]+=1
        cases.append(dict(index=i,category=category,label=label,rule=rule,model_key=key,note=note,
                          eligible_count=len(ids),group_diversity_preferred=diverse))
    m=cohort['models'][PRIMARY]['errors'];gp,mp,ga,ma=g['position'],m['position'],g['angle'],m['angle']
    all_=np.ones(len(rows),bool)
    pick('gain','位置大幅改善，但仍不达标','几何位置误差−模型位置误差>20mm，且双方不达标；按位置改善量降序',PRIMARY,
         (gp-mp>20)&~g['good']&~m['good'],gp-mp,
         '这是降低均值误差的贡献样本，不等于成功修正；还需看是否跨过50mm／5°门槛。',diverse=False)
    pick('rescue','几何不达标 → 模型达标','几何不达标、模型达标；按位置改善量降序',PRIMARY,
         ~g['good']&m['good'],gp-mp,'模型把这一例带入门槛，但门槛改善不能外推到所有目标。',diverse=False)
    pick('rescue','位置门槛附近的修正','几何不达标、模型达标、模型位置误差≥20mm；优先不同采集组',PRIMARY,
         ~g['good']&m['good']&(mp>=20),gp-mp,'接近50mm的位置门槛，两种模型之间的小改动可能改变通过计数。')
    pick('regress','几何达标 → 模型退化','几何达标、模型不达标；按位置退化量降序',PRIMARY,
         g['good']&~m['good'],mp-gp,'网络修正可能破坏原本正确的几何参考；不能只看位置均值。',diverse=False)
    pick('regress','退化发生在另一采集组','几何达标、模型不达标；优先未展示采集组，再按位置退化量降序',PRIMARY,
         g['good']&~m['good'],mp-gp,'另一个采集组的反例。实际原因需重新复核人工草稿与点云，图像本身不能证明因果。')
    pick('tradeoff','中心接近了，方向却越过门槛','位置改善>5mm、几何角度≤5°、模型角度>5°',PRIMARY,
         (gp-mp>5)&(ga<=5)&(ma>5),gp-mp,'位置改善和方向退化可以同时出现；联合判据仍不达标。',diverse=False)
    stable=(gp<10)&(mp<10)&(ga<.3)&(ma<.3)
    rank=-np.abs(gp-np.median(gp))-np.abs(mp-np.median(mp))
    pick('stable','双方都好：常规小误差样本','双方位置<10mm、角度<0.3°；按接近总体位置中位数排序，优先不同组',PRIMARY,
         stable,rank,'误差较小时，米级点云上的姿态箭头可能重合；右侧毫米级局部图用于避免视觉误读。')
    pick('failure','双方都失败：大方向偏差','双方不达标；按双方综合误差的较小值降序',PRIMARY,
         ~g['good']&~m['good'],np.minimum(gp/50+ga/5,mp/50+ma/5),
         '共同失败不是网络独有问题；也不能据此断言标签错误。应作为人工复核候选，不自动修改研究标签。',diverse=False)
    fallback=np.array([metadata[r['target_key']]['anchor']=='roi_median_source_forward_fallback' for r in rows])
    pick('fallback','ROI回退：不能归功于网络的覆盖','自动平面不可用、使用ROI回退，且双方不达标；按几何位置误差降序',PRIMARY,
         fallback&~g['good']&~m['good'],gp,
         '橙色此时是ROI中位数＋源前向，不是有效平面几何；模型与同样带回退的基线比较才公平。',diverse=False)
    pick('fallback','ROI回退：50mm附近的反例','ROI回退且几何达标、模型不达标；按位置退化量降序',PRIMARY,
         fallback&g['good']&~m['good'],mp-gp,
         '这一例的差值不足1mm却跨越50mm门槛；不能把净计数当作误差差距的全部。',diverse=False)
    key='pointnext/long_b64_steps';other=cohort['models'][key]['errors']
    pick('secondary','补充：大batch长训练的改善样本','B64／400轮相对B32／240轮位置改善>20mm；按改善量降序',key,
         mp-other['position']>20,mp-other['position'],
         '这是补充配方，不是原train CV选中的最终模型。表中同时列出主模型，不能按test重新选方案。',diverse=False)
    key='ptv3/base';other=cohort['models'][key]['errors']
    pick('secondary','补充：PTv3的角度门槛修正','几何角度>5°、PTv3达标；按角度改善量降序',key,
         (ga>5)&other['good'],ga-other['angle'],
         'PTv3净达标数更高不表示位置均值更低；这一例只是门槛附近的小角度修正。',diverse=False)
    assert len(cases)==12 and len(used)==12
    return cases


def svg_start(width,height,label):
    return [f'<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-label="{escape(label,quote=True)}" viewBox="0 0 {width} {height}">',
            f'<rect width="{width}" height="{height}" rx="12" fill="#f7f9fc"/>']


def svg_text(x,y,text,size=12,fill='#617187',anchor='start'):
    return f'<text x="{x:.2f}" y="{y:.2f}" font-size="{size}" fill="{fill}" text-anchor="{anchor}" font-family="sans-serif">{escape(str(text))}</text>'


def svg_line(x1,y1,x2,y2,color,width=1,dash=''):
    return f'<line x1="{x1:.2f}" y1="{y1:.2f}" x2="{x2:.2f}" y2="{y2:.2f}" stroke="{color}" stroke-width="{width}"'+(f' stroke-dasharray="{dash}"' if dash else '')+'/>'


def arrow(x,y,vx,vy,length,color):
    norm=max(float(np.hypot(vx,vy)),1e-12);dx,dy=vx/norm*length,vy/norm*length
    ex,ey=x+dx,y+dy;ux,uy=dx/length,dy/length
    return (svg_line(x,y,ex,ey,color,2.5)+
        f'<path d="M {ex:.2f} {ey:.2f} L {ex-8*ux+4*uy:.2f} {ey-8*uy-4*ux:.2f} L {ex-8*ux-4*uy:.2f} {ey-8*uy+4*ux:.2f} Z" fill="{color}"/>'+
        f'<circle cx="{x:.2f}" cy="{y:.2f}" r="5" fill="white" stroke="{color}" stroke-width="2.3"/>')


def xy_plot(xyz,poses,width_m,*,zoom=False):
    """Equal physical axis scales. Offset zoom is in mm, never a fake image projection."""
    width,height=600,370;left,right,top,bottom=64,20,24,48
    origin=poses['label'][:2];unit=1000 if zoom else 1
    xy=(xyz[:,:2]-origin if zoom else xyz[:,:2])*unit
    positions=np.array([(p[:2]-origin if zoom else p[:2])*unit for p in poses.values()])
    if zoom:
        radius=max(12.,float(np.max(np.abs(positions)))*1.35);xmin,xmax,ymin,ymax=-radius,radius,-radius,radius
    else:
        lo,hi=np.quantile(xy,[.005,.995],axis=0)
        lo=np.minimum(lo,positions.min(0));hi=np.maximum(hi,positions.max(0));padding=max(float(np.max(hi-lo))*.08,.03)
        xmin,xmax=lo[0]-padding,hi[0]+padding;ymin,ymax=lo[1]-padding,hi[1]+padding
    # Horizontal=source Y; vertical=source X, positive upwards.
    scale=min((width-left-right)/(ymax-ymin),(height-top-bottom)/(xmax-xmin))
    xm,ym=(xmin+xmax)/2,(ymin+ymax)/2
    def pixel(x,y):return (left+(width-left-right)/2+(y-ym)*scale,top+(height-top-bottom)/2-(x-xm)*scale)
    out=svg_start(width,height,'XY center offsets in mm' if zoom else 'Registered original-box point cloud in source XY metres')
    for t in np.linspace(xmin,xmax,5):
        x1,y1=pixel(t,ymin);x2,y2=pixel(t,ymax);out.append(svg_line(x1,y1,x2,y2,'#e0e6ef'))
        out.append(svg_text(left-7,y1+4,f'{t:.0f}' if zoom else f'{t:.2f}',10,anchor='end'))
    for t in np.linspace(ymin,ymax,5):
        x1,y1=pixel(xmin,t);x2,y2=pixel(xmax,t);out.append(svg_line(x1,y1,x2,y2,'#e0e6ef'))
        out.append(svg_text(x1,height-25,f'{t:.0f}' if zoom else f'{t:.2f}',10,anchor='middle'))
    out.append(svg_text(15,18,'dX [mm]' if zoom else 'X [m]',11))
    out.append(svg_text(width-20,height-6,'dY [mm]' if zoom else 'Y [m]',11,anchor='end'))
    clip=(xy[:,0]>=xmin)&(xy[:,0]<=xmax)&(xy[:,1]>=ymin)&(xy[:,1]<=ymax)
    ids=np.flatnonzero(clip);visible=len(ids)
    if len(ids)>2400:ids=np.sort(np.random.default_rng(42).choice(ids,2400,replace=False))
    if not zoom:
        for i in ids:
            px,py=pixel(*xy[i]);out.append(f'<circle cx="{px:.1f}" cy="{py:.1f}" r="1.25" fill="#8396ae" opacity=".45"/>')
    else:
        cx,cy=pixel(0,0)
        out.append(svg_line(cx-8,cy,cx+8,cy,COLORS['label'],1,'3 2'))
        out.append(svg_line(cx,cy-8,cx,cy+8,COLORS['label'],1,'3 2'))
    for name in ('geometry','model','label'):
        p=poses[name];point=(p[:2]-origin if zoom else p[:2])*unit;px,py=pixel(*point)
        if zoom:
            cx,cy=pixel(0,0);out.append(svg_line(cx,cy,px,py,COLORS[name],1.4,'4 3'))
        else:
            # Width reference is the common automatic width, not a human width.
            half=min(width_m*.35,.45);d=p[2:];t=np.array([-d[1],d[0]])
            q1,q2=p[:2]-half*t,p[:2]+half*t
            out.append(svg_line(*pixel(*q1),*pixel(*q2),COLORS[name],1.3,'5 3'))
        out.append(arrow(px,py,p[3],-p[2],48 if zoom else 42,COLORS[name]))
    out.append(svg_text(width-18,18,'equal scale; direction arrows = fixed visual length',10,anchor='end'))
    out.append('</svg>')
    return ''.join(out),dict(total_valid_ROI_points=len(xyz),points_inside_display_bounds=visible,
                             points_drawn=0 if zoom else len(ids),axis_scale_equal=True,unit='mm_offset' if zoom else 'm')


def image_svg(image,box,*,crop=False):
    x,y,w,h=(box[k] for k in ('x','y','width','height'))
    if crop:
        pad=max(w*.1,h*.5,8);left=max(0,int(x-pad));top=max(0,int(y-pad));right=min(image.width,int(np.ceil(x+w+pad)));bottom=min(image.height,int(np.ceil(y+h+pad)))
        image=image.crop((left,top,right,bottom));x-=left;y-=top
    stream=io.BytesIO();image.save(stream,format='PNG');uri='data:image/png;base64,'+base64.b64encode(stream.getvalue()).decode()
    iw,ih=image.size
    return (f'<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-label="Original formal image with original detection box" viewBox="0 0 {iw} {ih}">'
            f'<image width="{iw}" height="{ih}" href="{uri}"/>'
            f'<rect x="{x:.3f}" y="{y:.3f}" width="{w:.3f}" height="{h:.3f}" fill="none" stroke="#47e4ef" stroke-width="{max(iw/220,1):.2f}"/>'
            '</svg>')


def case_assets(case,cohort,metadata,sources,formal,out):
    i=case['index'];row=cohort['rows'][i];a=cohort['arrays'];source=sources[row['frame_id']]
    path=Path(source['source_paths']['pcd']);assert digest(path)==row['source_pcd_sha256']
    image_path=formal/row['image'];assert digest(image_path)==source['files'][row['image']]
    _,points=read_pcd(path);w,h=source['size'];mapping=orient_grid(np.arange(len(points),dtype=np.int32).reshape(h,w),source['sensor_policy'])
    b=row['bbox'];x,y,bw,bh=(b[k] for k in ('x','y','width','height'))
    mask=raster_mask([[x,y],[x+bw,y],[x+bw,y+bh],[x,y+bh]],w,h)
    ids=mapping[mask];ids=ids[valid_xyz(points[ids,:3])]
    xyz=points[ids,:3].astype(float)*row['sensor']['scale_to_m']
    gpred=np.array([0.,0.,1.,0.]);pred=cohort['models'][case['model_key']]['prediction'][i]
    poses=dict(label=np.r_[row['pose']['x'],row['pose']['y'],np.cos(np.deg2rad(row['pose']['theta_degrees'])),np.sin(np.deg2rad(row['pose']['theta_degrees']))],
        geometry=decoded(gpred,a['base'][i],a['width'][i],a['direction'][i]),
        model=decoded(pred,a['base'][i],a['width'][i],a['direction'][i]))
    cloud,cloud_info=xy_plot(xyz,poses,float(a['width'][i]))
    zoom,zoom_info=xy_plot(xyz,poses,float(a['width'][i]),zoom=True)
    with Image.open(image_path) as img:
        image=image_svg(img.convert('RGB'),b);crop=image_svg(img.convert('RGB'),b,crop=True)
    (out/'assets'/f"{row['target_key']}_original.png").write_bytes(image_path.read_bytes())
    for suffix,svg in [('image',image),('crop',crop),('xy',cloud),('zoom',zoom)]:
        (out/'assets'/f"{row['target_key']}_{suffix}.svg").write_text(svg)
    numbers={}
    for key in ('geometry',PRIMARY,'pointnext/long_b64','pointnext/long_b64_steps','ptv3/base'):
        e=cohort['geometry'] if key=='geometry' else cohort['models'][key]['errors']
        numbers[key]=dict(position_mm=float(e['position'][i]),angle_degrees=float(e['angle'][i]),passed=bool(e['good'][i]))
    result={k:v for k,v in case.items() if k!='index'}
    result.update(target_key=row['target_key'],target_id=row['target_id'],frame_id=row['frame_id'],group_id=row['group_id'],
        image=row['image'],pcd_name=path.name,split=row['split'],domain=row['domain'],bbox=b,
        source_pcd_sha256=row['source_pcd_sha256'],source_image_sha256=digest(image_path),
        feature_sha256=digest(ROOT/'dataset/features'/(row['target_key']+'.npz')),
        sensor_scale_to_m=row['sensor']['scale_to_m'],unit_evidence=row['unit_evidence'],review_revision=row['review_revision'],
        geometry_anchor=metadata[row['target_key']]['anchor'],metrics=numbers,
        poses={k:dict(x=float(v[0]),y=float(v[1]),theta_degrees=float(np.degrees(np.arctan2(v[3],v[2])))) for k,v in poses.items()},
        cloud_display=cloud_info,zoom_display=zoom_info,robot_command_eligible=False)
    return result,dict(image=image,crop=crop,cloud=cloud,zoom=zoom)


def delta(value,digits=3):
    klass='better' if value<0 else 'worse' if value>0 else 'neutral'
    return f'<span class="{klass}">{value:+.{digits}f}</span>'


def table(headers,rows,*,sortable=False):
    attrs=' class="sortable"' if sortable else ''
    return '<div class="table-wrap"><table'+attrs+'><thead><tr>'+''.join('<th scope="col">'+h+'</th>' for h in headers)+'</tr></thead><tbody>'+''.join('<tr>'+''.join('<td>'+str(c)+'</td>' for c in r)+'</tr>' for r in rows)+'</tbody></table></div>'


def model_table(cohort,branch):
    g=cohort['geometry'];n=len(cohort['rows']);unit='mm' if branch=='metric' else '%自动宽度'
    rows=[['<b>几何＋ROI回退</b>',f'{g["position"].mean():.3f}',f'{g["angle"].mean():.3f}',
           f'{int(g["good"].sum())}/{n}','—','—','—','—','—']]
    strict=cohort['reports']['baselines'][cohort['rows'][0]['split']].get('strict_geometry')
    if strict:
        rows.append(['纯几何 <small>非同覆盖</small>',f'{strict["position_mean"]*(100 if branch!="metric" else 1):.3f}',f'{strict["angle_mean"]:.3f}',
                     f'{strict["success_count"]}/{n}',f'输出{strict["predictions"]}/{n}','—','—','—','—'])
    for key,entry in cohort['models'].items():
        e=entry['errors'];pair=entry['pair'];pos=float(e['position'].mean());ang=float(e['angle'].mean());success=int(e['good'].sum())
        badge=' <span class="badge">train CV选定</span>' if (branch=='metric' and key==PRIMARY) or (branch=='native_unknown' and key=='pointnext/base') else ''
        rows.append([escape(title(key))+badge,f'{pos:.3f}',f'{ang:.3f}',f'{success}/{n}',
            delta(pos-g['position'].mean()),delta(ang-g['angle'].mean()),f'{success-int(g["good"].sum()):+d}',
            str(pair['rescued']),str(pair['regressed'])])
    return table(['方案',f'位置均值↓ ({unit})','角度均值↓ (°)','联合达标','Δ位置↓','Δ角度↓','Δ达标↑','挽回','新增退化'],rows,sortable=True)


def scatter_svg(cohort,key):
    g=cohort['geometry'];m=cohort['models'][key]['errors'];w,h=720,420;pad=60;plotw=w-pad-28;ploth=h-pad-35
    maximum=max(float(g['position'].max()),float(m['position'].max()),100)*1.08
    bound=np.log1p(maximum)
    def xy(gp,mp):return pad+np.log1p(gp)/bound*plotw,h-pad-np.log1p(mp)/bound*ploth
    s=svg_start(w,h,'Paired position errors: geometry horizontal, model vertical, logarithmic log1p axes')
    for t in (0,1,5,10,50,100,500):
        if t>maximum:continue
        x,y=xy(t,t);s.append(svg_line(pad,y,w-28,y,'#e0e6ef'));s.append(svg_line(x,35,x,h-pad,'#e0e6ef'))
        s.append(svg_text(pad-8,y+4,t,11,anchor='end'));s.append(svg_text(x,h-pad+20,t,11,anchor='middle'))
    s.append(svg_line(*xy(0,0),*xy(maximum,maximum),'#9cabc1',1.5,'5 4'))
    x50,y50=xy(50,50);s.append(svg_line(x50,35,x50,h-pad,'#c97916',1,'3 3'));s.append(svg_line(pad,y50,w-28,y50,'#6757d6',1,'3 3'))
    for i in range(len(cohort['rows'])):
        x,y=xy(g['position'][i],m['position'][i]);c=COLORS['model'] if m['good'][i] and not g['good'][i] else '#d55b55' if g['good'][i] and not m['good'][i] else '#7994b5'
        s.append(f'<circle cx="{x:.2f}" cy="{y:.2f}" r="3.2" fill="{c}" opacity=".7"><title>{escape(cohort["rows"][i]["target_key"])}: {g["position"][i]:.2f} / {m["position"][i]:.2f} mm</title></circle>')
    s.append(svg_text(w-28,h-8,'Geometry position error [mm], log1p',12,anchor='end'))
    s.append(svg_text(14,20,'Model position error [mm], log1p',12));s.append('</svg>')
    return ''.join(s)


def category_summary(cohort):
    g=cohort['geometry'];m=cohort['models'][PRIMARY]['errors']
    results=[]
    for field,tolerance,label in [('position',1.,'位置（差值±1mm内算近似持平）'),('angle',.05,'角度（差值±0.05°内算近似持平）')]:
        d=m[field]-g[field];results.append([label,str(int((d< -tolerance).sum())),str(int((np.abs(d)<=tolerance).sum())),str(int((d>tolerance).sum()))])
    return table(['主模型相对几何','改善','近似持平','退化'],results)


def grouped_summary(cohort,field):
    g=cohort['geometry'];m=cohort['models'][PRIMARY]['errors'];result=[]
    for value in sorted({r[field] for r in cohort['rows']}):
        ix=[i for i,r in enumerate(cohort['rows']) if r[field]==value];n=len(ix)
        result.append(dict(name=value,n=n,geometry_position=float(g['position'][ix].mean()),model_position=float(m['position'][ix].mean()),
            delta_position=float((m['position'][ix]-g['position'][ix]).mean()),
            delta_angle=float((m['angle'][ix]-g['angle'][ix]).mean()),
            delta_success=int(m['good'][ix].sum())-int(g['good'][ix].sum()),
            weighted_position_contribution_mm=float((m['position'][ix]-g['position'][ix]).sum()/len(cohort['rows']))))
    return result


def csv_targets(cohorts):
    fields=['branch','split','target_key','frame_id','group_id','domain','model','position_error','position_unit','angle_error_deg',
            'geometry_position_error','geometry_angle_error_deg','delta_position_error','delta_angle_error_deg','passed','geometry_passed','geometry_anchor']
    stream=io.StringIO(newline='');writer=csv.DictWriter(stream,fieldnames=fields);writer.writeheader()
    records=[]
    features={r['target_key']:r for r in map(json.loads,(ROOT/'dataset/features.jsonl').read_text().splitlines())}
    for (branch,split),cohort in cohorts.items():
        g=cohort['geometry']
        for key,m in cohort['models'].items():
            e=m['errors']
            for i,row in enumerate(cohort['rows']):
                record=dict(branch=branch,split=split,target_key=row['target_key'],frame_id=row['frame_id'],group_id=row['group_id'],domain=row['domain'],
                    model=key,position_error=float(e['position'][i]),position_unit='mm' if branch=='metric' else 'percent_automatic_width',angle_error_deg=float(e['angle'][i]),
                    geometry_position_error=float(g['position'][i]),geometry_angle_error_deg=float(g['angle'][i]),
                    delta_position_error=float(e['position'][i]-g['position'][i]),delta_angle_error_deg=float(e['angle'][i]-g['angle'][i]),
                    passed=bool(e['good'][i]),geometry_passed=bool(g['good'][i]),geometry_anchor=features[row['target_key']]['anchor'])
                writer.writerow(record);records.append(record)
    return '\ufeff'+stream.getvalue(),records


def case_card(number,case,visuals):
    rows=[]
    for key,m in case['metrics'].items():
        name='几何＋ROI回退' if key=='geometry' else title(key)
        if key==case['model_key']:name='<b>'+escape(name)+'</b>'
        else:name=escape(name)
        rows.append([name,f'{m["position_mm"]:.3f}',f'{m["angle_degrees"]:.3f}','✓ 达标' if m['passed'] else '✕ 未达标'])
    g=case['metrics']['geometry'];m=case['metrics'][case['model_key']]
    anchor='ROI中位数回退（无有效自动平面）' if case['geometry_anchor']=='roi_median_source_forward_fallback' else '自动叉取面参考'
    return f'''<article class="case-card" data-category="{case['category']}" id="case-{number:02d}" data-search="{escape(case['target_key']+' '+case['frame_id']+' '+case['group_id'],quote=True)}">
      <div class="case-heading"><span class="case-number">{number:02d}</span><div><h3>{escape(case['label'])}</h3><p>{escape(title(case['model_key']))} · Δ位置 {delta(m['position_mm']-g['position_mm'])} mm · Δ角度 {delta(m['angle_degrees']-g['angle_degrees'])}°</p></div></div>
      <p class="case-note">{escape(case['note'])}</p>
      <div class="visual-grid"><figure><div class="image-frame">{visuals['image']}</div><figcaption>原图＋原检测框（仅框线叠加，未投影姿态）</figcaption></figure>
      <figure><div class="image-frame">{visuals['crop']}</div><figcaption>原框邻域放大；显示裁剪不影响模型输入</figcaption></figure>
      <figure>{visuals['cloud']}<figcaption>原框有效点XY俯视图；X向上、Y向右，单位米。<br>显示{case['cloud_display']['points_drawn']}/{case['cloud_display']['total_valid_ROI_points']}点；0.5%–99.5%视窗并纳入全部姿态中心。</figcaption></figure>
      <figure>{visuals['zoom']}<figcaption>相对人工研究中心的毫米级局部图，X/Y等比例。<br>箭头固定视觉长度、方向未夸大；虚线连接中心误差。</figcaption></figure></div>
      <div class="legend"><span class="label-key">● 人工研究标签</span><span class="geom-key">● 几何／ROI回退</span><span class="model-key">● 本例模型</span></div>
      {table(['方案','位置误差 (mm)','角度误差 (°)','50mm／5°'],rows)}
      <details><summary>选择规则与溯源 · {escape(case['target_key'])}</summary><dl class="metadata">
      <dt>选例规则</dt><dd>{escape(case['rule'])}；候选{case['eligible_count']}例；{'先优先不同采集组，再按数值排序' if case['group_diversity_preferred'] else '不加组多样性优先'}。</dd>
      <dt>目标／帧</dt><dd><code>{escape(case['target_id'])}</code><br><code>{escape(case['frame_id'])}</code></dd>
      <dt>采集组</dt><dd><code>{escape(case['group_id'])}</code></dd><dt>原PCD</dt><dd>{escape(case['pcd_name'])}</dd>
      <dt>原图／域</dt><dd>{escape(case['image'])}<br>{escape(case['domain'])}</dd>
      <dt>参考与单位</dt><dd>{anchor}；scale_to_m={case['sensor_scale_to_m']}；{escape(case['unit_evidence'])}；人工快照修订{case['review_revision']}。</dd>
      <dt>原PCD SHA-256</dt><dd><code>{case['source_pcd_sha256']}</code></dd>
      <dt>位置姿态</dt><dd><pre>{escape(json.dumps(case['poses'],ensure_ascii=False,indent=2))}</pre></dd>
      </dl></details></article>'''


def download_link(name,content,mime,label):
    raw=content.encode() if isinstance(content,str) else content
    return f'<a class="button secondary" download="{name}" href="data:{mime};base64,{base64.b64encode(raw).decode()}">{label}</a>'


def render_html(cohorts,cases,visuals,summary,csv_text):
    metric=cohorts['metric','test'];g=metric['geometry'];m=metric['models'][PRIMARY]['errors'];selection=json.loads((ROOT/'selection_frozen.json').read_text())
    p=selection['profiles']['metric'];base=next(e for e in p['entries'] if e['family']=='pointnext' and e['arm']=='base');best=p['best_learning']
    improvement=(base['mean_score']-best['mean_score'])/base['mean_score']*100
    n=len(metric['rows']);pair=paired_counts(g,m)
    cards=''.join(case_card(i,c,v) for i,(c,v) in enumerate(zip(cases,visuals),1))
    cvrows=[];costrows=[]
    endpoint={r['family']+'/'+r['arm']:r for r in json.loads((ROOT/'endpoint_comparison/metric/report.json').read_text())['records']}
    for family in selection['top_two']:
        for e in [v for v in p['entries'] if v['family']==family]:
            k=family+'/'+e['arm'];d=e['delta_vs_same_seed_base'];dg=e['delta_vs_ROI_geometry'];last=endpoint[k]
            cvrows.append([escape(title(k)),f'{e["mean_score"]:.6f} ± {e["std_score"]:.6f}',
                f'[{d["lower"]:+.6f}, {d["upper"]:+.6f}]',f'[{dg["lower"]:+.6f}, {dg["upper"]:+.6f}]',
                f'{last["last_epoch_CV_mean"]:.6f}',str(e['refit_epoch'])])
            seeds=last['seed_results'];sizes=sorted({s for r in seeds for s in r['actual_minibatch_sizes']})
            costrows.append([escape(title(k)),'／'.join(map(str,sizes)),str(seeds[0]['additional_optimizer_steps']),
                f'{np.mean([r["seconds_sum_folds"] for r in seeds])/60:.1f}'])
    groups=summary['metric_test_group_deltas'];ordered=sorted(groups,key=lambda r:r['delta_position'])
    group_rows=[]
    for r in ordered[:4]+ordered[-4:]:
        group_rows.append([escape(r['name']),r['n'],f'{r["geometry_position"]:.3f}',f'{r["model_position"]:.3f}',delta(r['delta_position']),delta(r['delta_angle']),f'{r["delta_success"]:+d}'])
    domains=summary['metric_test_domain_deltas']
    domain_rows=[[escape(r['name']),r['n'],f'{r["geometry_position"]:.3f}',f'{r["model_position"]:.3f}',delta(r['delta_position']),f'{r["delta_success"]:+d}'] for r in domains]
    main_stats=metric['models'][PRIMARY]['stats'];geo_stats=metric['reports']['baselines']['test']['geometry_plus_ROI_fallback']
    quantiles=table(['方案','位置中位数 (mm)','位置P90 (mm)','角度P90 (°)','输出覆盖'],[
        ['几何＋ROI回退',f'{geo_stats["position_median"]:.3f}',f'{geo_stats["position_p90"]:.3f}',f'{geo_stats["angle_p90"]:.3f}',f'{n}/{n}'],
        ['PointNeXt / B32 · 240轮',f'{main_stats["position_median"]:.3f}',f'{main_stats["position_p90"]:.3f}',f'{main_stats["angle_p90"]:.3f}',f'{n}/{n}']])
    payload=json.dumps(dict(cases=cases,summary=summary),ensure_ascii=False,indent=2,allow_nan=False)
    template=(ASSETS/'index.html').read_text()
    replacements=dict(CREATED=escape(summary['created_at']),N=n,GEOMETRY_POSITION=f'{g["position"].mean():.3f}',MODEL_POSITION=f'{m["position"].mean():.3f}',
        CV_GAIN=f'{improvement:.2f}',RESCUED=pair['rescued'],REGRESSED=pair['regressed'],BOTH_PASS=pair['both_pass'],BOTH_FAIL=pair['both_fail'],
        TEST_TABLE=model_table(metric,'metric'),VAL_TABLE=model_table(cohorts['metric','val'],'metric'),NATIVE_TABLE=model_table(cohorts['native_unknown','test'],'native_unknown'),
        CV_TABLE=table(['方案','三种子CV均值±标准差↓','Δ相同种子base · 95%区间','Δ几何 · 95%区间','真正末轮CV↓','重拟合epoch'],cvrows),
        COST_TABLE=table(['方案','实际每步样本数','新增优化步数／种子（3折合计）','平均GPU分钟／种子（3折合计）'],costrows),
        GROUP_TABLE=table(['采集组（4个改善／4个退化端点）','n','几何位置mm','模型位置mm','Δ位置mm','Δ角度°','Δ达标'],group_rows),
        DOMAIN_TABLE=table(['输入域','n','几何位置mm','模型位置mm','Δ位置mm','Δ达标'],domain_rows),
        SCATTER=scatter_svg(metric,PRIMARY),CATEGORY_TABLE=category_summary(metric),QUANTILES=quantiles,CASES=cards,
        DATA_DOWNLOAD=download_link('comparison_data.json',payload,'application/json','下载案例与汇总 JSON'),
        CSV_DOWNLOAD=download_link('target_comparison.csv',csv_text,'text/csv;charset=utf-8','下载全部逐目标 CSV'),
        CSS=(ASSETS/'report.css').read_text(),JS=(ASSETS/'report.js').read_text(),FONT_CSS='')
    for k,v in replacements.items():template=template.replace('{{'+k+'}}',str(v))
    assert not re.search(r'\{\{[A-Z_]+\}\}',template)
    return template


def embed_font(html,out,font_path):
    if not font_path or not font_path.exists():return html,dict(embedded=False,reason='font_file_unavailable')
    from fontTools import subset
    from fontTools.ttLib import TTFont
    font=TTFont(font_path);license_text=[]
    for name in font['name'].names:
        if name.nameID in (0,13,14):
            try:license_text.append(name.toUnicode())
            except UnicodeError:pass
    options=subset.Options();options.flavor='woff';options.name_IDs=['*']
    sub=subset.Subsetter(options=options);sub.populate(text=re.sub('<[^>]+>',' ',html)+'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ±Δ°✓✕↓↑')
    sub.subset(font)
    # Derivative uses a non-reserved family name; carry the original license.
    for name in font['name'].names:
        if name.nameID in (1,4,6):name.string='PoseComparisonReport'.encode('utf-16-be') if name.isUnicode() else b'PoseComparisonReport'
    font.flavor='woff';stream=io.BytesIO();font.save(stream);raw=stream.getvalue()
    (out/'assets/report-font.woff').write_bytes(raw)
    (out/'FONT_LICENSE.txt').write_text('\n'.join(dict.fromkeys(license_text))+'\n\n'+(PROJECT/'pallet/assets/FONT_LICENSE.txt').read_text())
    css="@font-face{font-family:ReportCJK;src:url(data:font/woff;base64,"+base64.b64encode(raw).decode()+") format('woff');font-display:swap}"
    return html.replace('/* EMBEDDED_REPORT_FONT */',css),dict(embedded=True,bytes=len(raw),source_sha256=digest(font_path))


def build(output,font):
    output=Path(output).resolve()
    if output.exists() and any(output.iterdir()):raise ValueError('Output is not empty; choose a new directory to preserve prior report')
    output.mkdir(parents=True,exist_ok=True);(output/'assets').mkdir();(output/'evidence').mkdir()
    frozen_files=json.loads((ROOT/'final_source_manifest.json').read_text())
    frozen_files.update(json.loads((ROOT/'snapshot/manifest.json').read_text())['immutable_files'])
    for name in ('final_results.json','selection_frozen.json','protocol.json','delivery_manifest.json','dataset/manifest.json','dataset/features.jsonl','snapshot/eligible.jsonl'):
        frozen_files[str((ROOT/name).relative_to(PROJECT))]=digest(ROOT/name)
    for name,expected in frozen_files.items():assert digest(PROJECT/name)==expected,name
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    before=protected_snapshot(formal)
    assert before==json.loads((ROOT/'snapshot/protected_formal.json').read_text())
    cohorts={(b,s):read_cohort(b,s) for b in ('metric','native_unknown') for s in ('test','val')}
    metadata={r['target_key']:r for r in map(json.loads,(ROOT/'dataset/features.jsonl').read_text().splitlines())}
    selected=choose_cases(cohorts['metric','test'],metadata);_,sources=load_dataset(formal)
    cases=[];visuals=[]
    for case in selected:
        record,views=case_assets(case,cohorts['metric','test'],metadata,sources,formal,output);cases.append(record);visuals.append(views)
    cohort=cohorts['metric','test']
    summary=dict(created_at=now(),schema='pose_v4_geometry_comparison_html_v1',primary_model=PRIMARY,
        primary_selection='original_train_three_seed_group_CV_previously_frozen_not_changed_by_this_report',
        case_policy='posthoc_extremes_plus_threshold_and_stable_examples_not_unbiased_sample',
        metric_test_total=len(cohort['rows']),metric_test_pairs=paired_counts(cohort['geometry'],cohort['models'][PRIMARY]['errors']),
        metric_test_group_deltas=grouped_summary(cohort,'group_id'),metric_test_domain_deltas=grouped_summary(cohort,'domain'),
        source_label_kind='user_authorized_nonblind_research_drafts',robot_command_eligible=False,
        cases=len(cases),unique_case_targets=len({c['target_key'] for c in cases}),source_annotation_writes=0)
    csv_text,_=csv_targets(cohorts);html=render_html(cohorts,cases,visuals,summary,csv_text)
    html,font_info=embed_font(html,output,Path(font) if font else None)
    (output/'index.html').write_text(html)
    (output/'target_comparison.csv').write_text(csv_text)
    atomic_json(output/'comparison_data.json',dict(summary=summary,cases=cases))
    for name in ('REPORT_zh.md','selection_frozen.json','final_acceptance.json','delivery_manifest.json'):
        shutil.copyfile(ROOT/name,output/'evidence'/name)
    for branch in ('metric','native_unknown'):
        shutil.copyfile(ROOT/'evaluation'/branch/'report.json',output/'evidence'/(branch+'_evaluation.json'))
    hashes=dict(frozen_files)
    for c in cohorts.values():hashes.update(c['hashes'])
    atomic_json(output/'evidence/source_hashes.json',hashes)
    for name,expected in hashes.items():assert digest(PROJECT/name)==expected,'Frozen input modified: '+name
    assert protected_snapshot(formal)==before
    self_contained_checks=dict(external_scripts=bool(re.search(r'<script[^>]+src=',html)),external_styles=bool(re.search(r'<link[^>]+href=',html)),
        external_images=bool(re.search(r'(?:href|src)=["\']https?://',html)))
    assert not any(self_contained_checks.values())
    acceptance=dict(state='passed',created_at=now(),paired_metric_targets=len(cohort['rows']),case_targets=len(cases),
        recomputed_model_split_reports=len(cohorts)*len(cohort['models']),frozen_inputs_rehashed=len(hashes),
        protected_files_unchanged=len(before),live_annotation_DB_opened=False,model_or_label_updates=False,
        all_case_PCDrgb_hashes_verified=True,offline_self_contained=True,font=font_info,**self_contained_checks,
        index_html_sha256=digest(output/'index.html'))
    atomic_json(output/'acceptance.json',acceptance)
    package=output.parent/(output.name+'.zip')
    if package.exists():raise ValueError('Refusing to overwrite an existing report archive')
    entries=sorted(p for p in output.rglob('*') if p.is_file())
    with ZipFile(package.with_suffix('.tmp'),'w',ZIP_DEFLATED,compresslevel=6) as z:
        for path in entries:z.write(path,str(path.relative_to(output)))
    package.with_suffix('.tmp').replace(package)
    with ZipFile(package) as z:
        for path in entries:assert hashlib.sha256(z.read(str(path.relative_to(output)))).hexdigest()==digest(path)
    atomic_json(output.parent/(output.name+'_delivery.json'),dict(html=str(output/'index.html'),zip=str(package),
        zip_sha256=digest(package),bytes=package.stat().st_size,members_verified=len(entries),acceptance=acceptance))
    print(json.dumps(dict(html=str(output/'index.html'),zip=str(package),cases=len(cases),bytes=package.stat().st_size),ensure_ascii=False),flush=True)


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output',type=Path,default=ROOT/'comparison_html')
    parser.add_argument('--font',type=Path,default=Path('/tmp/opencode/pallet_pose_design/NotoSansCJKsc-Regular.otf'))
    args=parser.parse_args();build(args.output,args.font)


if __name__=='__main__':main()
