"""Recompute v5 full-denominator metrics, offline report, package and protection audit."""
from __future__ import annotations

from collections import Counter
from contextlib import closing
import base64
import csv
from html import escape
import io
import json
from pathlib import Path
import sqlite3
from zipfile import ZipFile,ZIP_DEFLATED

import numpy as np

from . import pose_paper_data as data
from .cluster_targets import digest,protected_snapshot
from .pose_dataset import read_rows,write_json,protected_write
from .pose_refinement import now

NAMES={
    'geometry_ROI_fallback':'现有几何＋ROI回退',
    'strict_geometry':'现有纯几何（失败不回退）',
    'xiao_plane_template':'Xiao 2017 平面结构模板 · 适配版',
    'pila_geometry':'PILA 2021 固定框几何后端 · 适配版',
    'shao_agwf':'Shao 2023 AGWF配准 · 适配版',
    'fpfh_ablation':'FPFH配准消融（非额外论文）',
    'pointnext_latest':'PointNeXt 最新标签重训',
    'pointnext_v4_frozen_transfer':'PointNeXt v4冻结迁移（非本轮重训）',
}


def evaluate_records(rows,records,widths):
    index={r['target_key']:r for r in records}
    if len(index)!=len(records) or set(index)!={r['target_key'] for r in rows}:
        raise ValueError('Prediction identities/cohort do not match')
    values=[]
    for row in rows:
        key=row['target_key'];record=index[key]
        ok=record['state']=='complete'
        distance=angle=None;success=False;score=data.config()['preprocessing_failure_score']
        if ok:
            p=np.asarray(record['pose'],dtype=float)
            if p.shape!=(3,) or not np.isfinite(p).all():raise ValueError('Invalid predicted XY-yaw')
            distance=float(np.linalg.norm(p[:2]-[row['pose']['x'],row['pose']['y']])*1000)
            angle=float(abs((np.rad2deg(p[2])-row['pose']['theta_degrees']+180)%360-180))
            success=distance<=50 and angle<=5
            score=float(distance/1000/widths[key]/.05+angle/5)
        values.append(dict(target_key=key,group_id=row['group_id'],domain=row['domain'],
            state=record['state'],position_mm=distance,angle_deg=angle,success=success,score=score,
            reason=record.get('reason'),fallback_used=record.get('fallback_used',False),
            seconds=record.get('seconds'),pose=record.get('pose'),robot_command_eligible=False))
    good=[v for v in values if v['state']=='complete']
    pos=np.array([v['position_mm'] for v in good]);ang=np.array([v['angle_deg'] for v in good])
    groups=sorted({v['group_id'] for v in values})
    def stat(a,func):return float(func(a)) if len(a) else None
    runtime=[v['seconds']*1000 for v in values if v['seconds'] is not None]
    summary=dict(total=len(rows),predictions=len(good),coverage=len(good)/max(1,len(rows)),
        success_count=sum(v['success'] for v in values),
        success_rate=sum(v['success'] for v in values)/max(1,len(rows)),
        position_mean_mm=stat(pos,np.mean),position_median_mm=stat(pos,np.median),
        position_P90_mm=stat(pos,lambda x:np.quantile(x,.9)),position_P95_mm=stat(pos,lambda x:np.quantile(x,.95)),
        angle_mean_deg=stat(ang,np.mean),angle_median_deg=stat(ang,np.median),
        angle_P90_deg=stat(ang,lambda x:np.quantile(x,.9)),angle_P95_deg=stat(ang,lambda x:np.quantile(x,.95)),
        macro_group_score=float(np.mean([np.mean([v['score'] for v in values if v['group_id']==g]) for g in groups])),
        runtime_P50_ms=stat(runtime,np.median),runtime_P95_ms=stat(runtime,lambda x:np.quantile(x,.95)),
        failure_reasons=dict(Counter(v['reason'] for v in values if v['state']!='complete')),
        fallback_count=sum(v['fallback_used'] for v in values),
        means_are_conditional_on_output=True,threshold='50mm/5deg',robot_command_eligible=False)
    return summary,values


def paired(reference,other):
    if [r['target_key'] for r in reference]!=[r['target_key'] for r in other]:raise ValueError('Unpaired rows')
    a=np.array([r['success'] for r in reference]);b=np.array([r['success'] for r in other])
    common=[i for i,(r,s) in enumerate(zip(reference,other)) if r['state']==s['state']=='complete']
    groups=sorted({r['group_id'] for r in reference})
    delta=np.array([s['score']-r['score'] for r,s in zip(reference,other)])
    macro=np.array([delta[[r['group_id']==g for r in reference]].mean() for g in groups])
    rng=np.random.default_rng(4242)
    boot=macro[rng.integers(0,len(macro),(10000,len(macro)))].mean(1)
    return dict(both_pass=int((a&b).sum()),rescued=int((~a&b).sum()),regressed=int((a&~b).sum()),
        both_fail=int((~a&~b).sum()),common_outputs=len(common),
        common_position_delta_mm=float(np.mean([other[i]['position_mm']-reference[i]['position_mm'] for i in common])) if common else None,
        common_angle_delta_deg=float(np.mean([other[i]['angle_deg']-reference[i]['angle_deg'] for i in common])) if common else None,
        macro_score_delta=float(macro.mean()),macro_score_delta_95CI=[float(np.quantile(boot,.025)),float(np.quantile(boot,.975))],
        descriptive_group_bootstrap_not_independent_physical_significance=True)


def cohort(split):
    rows,arrays,all_rows=data.load(split=split)
    widths={r['target_key']:float(w) for r,w in zip(rows,arrays['width'])}
    metadata={r['target_key']:r for r in read_rows(data.ROOT/'dataset/features.jsonl')}
    geometry={r['target_key']:dict(target_key=r['target_key'],pose=[float(b[0]),float(b[1]),float(np.arctan2(d[1],d[0]))],
        state='complete',seconds=None,robot_command_eligible=False) for r,b,d in zip(rows,arrays['base'],arrays['direction'])}
    for row in all_rows:
        geometry.setdefault(row['target_key'],dict(target_key=row['target_key'],state='failed',pose=None,reason='preprocessing_failed',seconds=None))
    predictions={'geometry_ROI_fallback':list(geometry.values())}
    strict=[]
    for row in all_rows:
        key=row['target_key'];r=geometry[key].copy()
        if metadata[key].get('anchor')=='roi_median_source_forward_fallback':
            r.update(state='failed',pose=None,reason='no_automatic_front_face')
        strict.append(r)
    predictions['strict_geometry']=strict
    for name in [*data.config()['paper_methods'],'pointnext_latest','pointnext_v4_frozen_transfer']:
        records=json.loads((data.ROOT/'predictions'/name/f'{split}.json').read_text())
        predictions[name]=records
        if name in data.config()['paper_methods']:
            fallback=[]
            for r in records:
                value=dict(r,fallback_used=False)
                if r['state']!='complete':
                    value=dict(geometry[r['target_key']],fallback_used=True,native_failure_reason=r['reason'])
                fallback.append(value)
            predictions[name+'_common_fallback']=fallback
    summaries={};targets={}
    for name,records in predictions.items():
        summary,values=evaluate_records(all_rows,records,widths)
        summaries[name]=summary;targets[name]=values
    for name in summaries:
        summaries[name]['paired_vs_geometry']=paired(targets['geometry_ROI_fallback'],targets[name])
        summaries[name]['domains']={}
        for domain in sorted({r['domain'] for r in all_rows}):
            ids={r['target_key'] for r in all_rows if r['domain']==domain}
            subrows=[r for r in all_rows if r['target_key'] in ids]
            subrecords=[r for r in predictions[name] if r['target_key'] in ids]
            summaries[name]['domains'][domain]=evaluate_records(subrows,subrecords,widths)[0]
        summaries[name]['groups']={}
        for group in sorted({r['group_id'] for r in all_rows}):
            selected=[v for v in targets[name] if v['group_id']==group]
            summaries[name]['groups'][group]=dict(total=len(selected),success_count=sum(v['success'] for v in selected),
                mean_score=float(np.mean([v['score'] for v in selected])))
    return dict(rows=all_rows,summaries=summaries,targets=targets)


def label(name):
    if name.endswith('_common_fallback'):return NAMES[name.removesuffix('_common_fallback')]+'＋共同几何回退'
    return NAMES.get(name,name)


def number(value,digits=3):return '—' if value is None else f'{value:.{digits}f}'


def table(headers,rows):
    return '<div class="scroll"><table><thead><tr>'+''.join('<th>'+escape(str(h))+'</th>' for h in headers)+'</tr></thead><tbody>'+''.join('<tr>'+''.join('<td>'+escape(str(c))+'</td>' for c in row)+'</tr>' for row in rows)+'</tbody></table></div>'


def choose_cases(c,primary):
    g=c['targets']['geometry_ROI_fallback'];m=c['targets'][primary]
    used=set();result=[]
    native=c['targets'][primary.removesuffix('_common_fallback')]
    categories=[('挽回',lambda i:not g[i]['success'] and m[i]['success']),
        ('新增退化',lambda i:g[i]['success'] and not m[i]['success']),
        ('双方失败',lambda i:not g[i]['success'] and not m[i]['success']),
        ('原生失败／回退',lambda i:native[i]['state']!='complete'),
        ('位置改善',lambda i:m[i]['position_mm'] is not None and g[i]['position_mm'] is not None and m[i]['position_mm']<g[i]['position_mm']),
        ('位置退化',lambda i:m[i]['position_mm'] is not None and g[i]['position_mm'] is not None and m[i]['position_mm']>g[i]['position_mm'])]
    for category,predicate in categories:
        candidates=[i for i in range(len(g)) if i not in used and predicate(i)]
        candidates.sort(key=lambda i:(-abs((m[i]['position_mm'] or 0)-(g[i]['position_mm'] or 0)),g[i]['target_key']))
        for i in candidates[:2]:used.add(i);result.append(dict(index=i,category=category))
    for i in sorted(range(len(g)),key=lambda i:g[i]['target_key']):
        if len(result)>=12:break
        if i not in used:used.add(i);result.append(dict(index=i,category='其余稳定／失败对照'))
    return result


def case_cards(c,primary):
    from PIL import Image,ImageDraw
    from .pose_comparison_report import xy_plot
    from .pose_paper_benchmark import roi
    formal,_,sources=data.formal_data()
    cards=[];case_info=[]
    out=data.ROOT/'report/cases';out.mkdir(parents=True,exist_ok=True)
    for item in choose_cases(c,primary):
        i=item['index'];row=c['rows'][i];key=row['target_key']
        g=c['targets']['geometry_ROI_fallback'][i];m=c['targets'][primary][i]
        xyz,_=roi(key)
        gt=row['pose'];poses={'label':np.r_[gt['x'],gt['y'],np.cos(np.deg2rad(gt['theta_degrees'])),np.sin(np.deg2rad(gt['theta_degrees']))]}
        for name,value in [('geometry',g),('model',m)]:
            if value['pose'] is not None:
                x,y,a=value['pose'];poses[name]=np.r_[x,y,np.cos(a),np.sin(a)]
        if len(poses)<3:poses['model']=poses['geometry'].copy()
        with np.load(data.ROOT/'dataset/features'/(key+'.npz'),allow_pickle=False) as feature:
            automatic_width=float(feature['width'])
        svg,info=xy_plot(xyz,poses,automatic_width,zoom=False)
        zoom,zinfo=xy_plot(xyz,poses,automatic_width,zoom=True)
        image=Image.open(formal/sources[row['frame_id']]['image']).convert('RGB')
        draw=ImageDraw.Draw(image);b=row['bbox'];draw.rectangle((b['x'],b['y'],b['x']+b['width'],b['y']+b['height']),outline='#e8a832',width=2)
        stream=io.BytesIO();image.save(stream,format='PNG');raw=stream.getvalue()
        protected_write(out/(key+'.png'),raw);protected_write(out/(key+'.svg'),svg.encode());protected_write(out/(key+'_zoom.svg'),zoom.encode())
        encoded=base64.b64encode(raw).decode()
        cards.append('<article><h3>'+escape(item['category'])+' · '+escape(key)+'</h3><p>'+escape(row['group_id'])+'</p><img alt="原强度图及原检测框，未投影姿态" src="data:image/png;base64,'+encoded+'">'+svg+zoom+
            table(['方案','位置mm','方向°','达标'],[['几何',number(g['position_mm']),number(g['angle_deg']),g['success']],
                ['论文适配方法＋共同回退',number(m['position_mm']),number(m['angle_deg']),m['success']]])+'</article>')
        case_info.append(dict(**item,target_key=key,source_pcd_sha256=row['source_pcd_sha256'],
            image_sha256=digest(formal/sources[row['frame_id']]['image']),plots=[info,zinfo],
            geometry=g,paper=m,posthoc_deterministic_not_random_representative=True))
    return ''.join(cards),case_info


def report():
    frozen=json.loads((data.ROOT/'selection_frozen.json').read_text())
    for p,h in frozen['choices'].items():
        if digest(data.ROOT/p)!=h:raise ValueError('Frozen choices changed')
    cohorts={split:cohort(split) for split in ('val','test')}
    paper=json.loads((data.ROOT/'paper_selection.json').read_text())
    learning=json.loads((data.ROOT/'learning_selection.json').read_text())
    primary=min(paper['selected'],key=lambda m:paper['selected'][m]['score'])+'_common_fallback'
    summary=dict(created_at=frozen['created_at'],snapshot=json.loads((data.ROOT/'snapshot/manifest.json').read_text()),
        paper_CV=paper,learning_CV=learning,primary_paper_method=primary,
        evaluation={s:c['summaries'] for s,c in cohorts.items()},
        exact_author_reproductions=False,author_code_used_for_paper_methods=False,
        previous_test_seen_not_blind=True,robot_command_eligible=False)
    output=data.ROOT/'report';output.mkdir(parents=True,exist_ok=True)
    write_json(data.ROOT/'final_results.json',summary)
    stream=io.StringIO();fields=['split','method','target_key','group_id','domain','state','position_mm','angle_deg','success','score','reason','fallback_used','seconds']
    writer=csv.DictWriter(stream,fieldnames=fields,extrasaction='ignore');writer.writeheader()
    for split,c in cohorts.items():
        for method,values in c['targets'].items():
            for row in values:writer.writerow(dict(split=split,method=method,**row))
    csv_raw=stream.getvalue().encode('utf-8-sig');protected_write(output/'target_metrics.csv',csv_raw)
    write_json(output/'comparison_data.json',summary)
    headers=['方案','位置均值mm↓*','中位数mm↓','P90mm↓','P95mm↓','方向均值°↓*','方向P90°↓','输出/总数','达标/总数','挽回','新增退化','共同输出Δ位置mm']
    tables={}
    markdown=['# 最新标注托盘论文方法适配对比 v5','',f"快照：{summary['snapshot']['created_at']}；有效{summary['snapshot']['eligible']}条。",'',
        '**论文独立适配实现，不是作者代码复现，也不是原论文传感器/数据上的数值复现。**',
        '原train采集组三折选参数和模板；原val/test不回流。此前test已看过，不称新盲测。','',
        '## 原train CV','', '|方法|组等权综合分↓|平面阈值m|', '|---|---:|---:|']
    for name,value in paper['selected'].items():markdown.append(f"|{label(name)}|{value['score']:.6f}|{value['threshold_m']}|")
    markdown+=['',f"PointNeXt三种子CV：{learning['CV_scores']}；全train重拟合epoch={learning['refit_epoch']}。",'']
    for split,c in cohorts.items():
        values=[]
        markdown+=['## '+split,'','|方案|位置均值mm*|角度均值°*|输出/总数|达标/总数|挽回|退化|','|---|---:|---:|---:|---:|---:|---:|']
        for name,m in c['summaries'].items():
            pair=m['paired_vs_geometry']
            values.append([label(name),number(m['position_mean_mm']),number(m['position_median_mm']),number(m['position_P90_mm']),number(m['position_P95_mm']),
                number(m['angle_mean_deg']),number(m['angle_P90_deg']),f"{m['predictions']}/{m['total']}",f"{m['success_count']}/{m['total']}",
                pair['rescued'],pair['regressed'],number(pair['common_position_delta_mm'])])
            markdown.append(f"|{label(name)}|{number(m['position_mean_mm'])}|{number(m['angle_mean_deg'])}|{m['predictions']}/{m['total']}|{m['success_count']}/{m['total']}|{pair['rescued']}|{pair['regressed']}|")
        tables[split]=table(headers,values)
    cards,cases=case_cards(cohorts['test'],primary);write_json(output/'cases.json',cases)
    caveats='''
    <h2>复现与解释边界</h2><ul>
    <li>Xiao：有序点云法向邻域生长、平面局部占据模板滑动匹配。模板由各折原train自动ROI建立，不使用人工多边形。未取得本次可读全文，不能称逐公式忠实复现。</li>
    <li>PILA：固定原框的前面拟合、边界直线和宽度中心求解；不复现RGB检测器。原论文三角形中心规则未完整核实，采用分层边界线最小二乘，必须标作几何后端适配。</li>
    <li>AGWF：已保存可核对全文；实现§2.2–2.4的测量点体素、ISS、[dp,2dp]五个候选半径最小特征熵、Gaussian权重SPFH聚合、SAC-IA和刚体ICP。最少邻点4、sigma下限1e-6、传感器朝向法向、正X/+Z候选过滤、1,024点上限属于显式工程适配。未另测该实现与作者未公开代码的等价性。</li>
    <li>FPFH与AGWF共用模板、ISS、匹配及ICP，仅切换固定半径/逆距权重与自适应半径/Gaussian权重。为本实现消融，不等于PCL官方FPFH数值等价测试。</li>
    <li>各折模板参考坐标来自训练位姿标签，形状来自自动原框ROI。推理仅接收XYZ与像素邻接；不按目标ID、组ID或GT选择模板。模板库与输入尺寸自动匹配。</li>
    <li>*误差均值只针对有输出目标；覆盖不同不能直接比较非配对均值。达标使用完整分母，失败计不通过；另列共同输出的配对差值与统一回退。</li>
    <li>输出XY及叉入方向；高度、roll/pitch、完整旋转、机器人外参保持未知。研究草稿含几何初值偏倚，不是独立物理测量，不证明实机叉取成功率。</li>
    <li>CPU耗时包含文件读取和缓存准备；配准缓存准备同时计算两类描述子，是共享准备成本而非单方法独立实时性能。神经模型延迟未专项测量，不填0或借用旧数值。</li>
    <li>典型案例采用公开、确定性的事后类别筛选，含改善、退化、失败与回退，不称随机或无偏代表，也不用于重选模型。原图仅画原检测框，不虚构相机投影姿态；俯视图使用原始ROI实测点、等比例XY。</li>
    </ul>'''
    cv=table(['原train CV候选','阈值m','组等权分↓','失败数'],[[label(v['method']),v['threshold_m'],number(v['score'],6),v['failures']] for v in paper['entries']])
    intervals=table(['test方案','组等权Δ综合分','描述性95%区间'],[[label(name),number(m['paired_vs_geometry']['macro_score_delta'],6),str(m['paired_vs_geometry']['macro_score_delta_95CI'])] for name,m in cohorts['test']['summaries'].items()])
    runtimes=table(['test方案','共享准备/推理P50ms*','P95ms*'],[[label(n),number(m['runtime_P50_ms']),number(m['runtime_P95_ms'])] for n,m in cohorts['test']['summaries'].items()])
    failures=table(['test原生方法','失败原因','数量'],[[label(name),reason,count] for name,m in cohorts['test']['summaries'].items() for reason,count in m['failure_reasons'].items()])
    splits=summary['snapshot']['counts']
    html='''<!doctype html><html lang="zh-CN"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data:; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'none'">
    <title>托盘论文方法对比 v5</title><style>body{font:16px/1.65 system-ui,sans-serif;max-width:1440px;margin:auto;padding:24px;color:#223348;background:#f3f6f8}h1,h2,h3{line-height:1.3}h1{font-size:32px}.note,article{background:white;border-radius:12px;padding:20px;margin:16px 0}.scroll{overflow-x:auto;width:100%;background:white}table{border-collapse:collapse;min-width:700px;width:100%;font-size:14px}th,td{padding:10px;border-bottom:1px solid #dde3e9;text-align:left}th{background:#e6edf3;cursor:pointer}img{max-width:100%;image-rendering:auto}article svg{max-width:100%;height:auto}a{color:#006f86}code{overflow-wrap:anywhere}@media(max-width:600px){body{padding:12px}h1{font-size:26px}article{padding:12px}}@media print{body{background:white;padding:0;max-width:none;font-size:10px}button{display:none}.scroll{overflow:visible}table{min-width:0;font-size:8px}th,td{padding:3px}article{break-inside:avoid;border:1px solid #ccc}article img{max-height:160px}article svg{max-height:260px}}</style>
    <h1>托盘专用论文方法 · 最新标注对比 v5</h1>'''
    html+='<p>冻结时间 '+escape(summary['snapshot']['created_at'])+f' · train {splits["train"]} / val {splits["val"]} / test {splits["test"]}</p>'
    html+='<div class="note"><strong>独立论文适配实现，不冒充作者原实现。</strong> 主对照输入相同：原检测框内有序XYZ；无人工选面、标尺或掩膜输入。全部输出不可下发机器人。</div>'
    for name,raw,mime in [('target_metrics.csv',csv_raw,'text/csv'),('comparison_data.json',json.dumps(summary,ensure_ascii=False,allow_nan=False).encode(),'application/json')]:
        html+=f'<a download="{name}" href="data:{mime};base64,{base64.b64encode(raw).decode()}">下载 {name}</a>　'
    html+='<h2>原train分组CV</h2>'+cv+'<h2>冻结后的test完整分母</h2>'+tables['test']+'<h2>val补充</h2>'+tables['val']+'<h2>配对差值与区间</h2>'+intervals
    html+='<h2>原生失败原因</h2>'+failures+'<h2>运行成本（非独立实时基准）</h2>'+runtimes+caveats
    html+='<h2>典型案例：'+escape(label(primary))+'</h2><p>绿色=研究标签，橙色=几何，紫色=论文适配方法；原方法失败时紫色代表共同回退。箭头方向按真实数值绘制。</p>'+cards
    html+='''<script>document.querySelectorAll('th').forEach((h)=>{h.tabIndex=0;h.setAttribute('role','button');let sort=()=>{let t=h.closest('table'),b=t.tBodies[0],i=[...h.parentNode.children].indexOf(h),s=h.dataset.s==='1'?-1:1;h.dataset.s=String(s);h.setAttribute('aria-sort',s===1?'ascending':'descending');[...b.rows].sort((a,c)=>{let x=a.cells[i].textContent,y=c.cells[i].textContent,n=Number(x),m=Number(y);return (Number.isFinite(n)&&Number.isFinite(m)?n-m:x.localeCompare(y,undefined,{numeric:true}))*s;}).forEach(r=>b.appendChild(r));};h.addEventListener('click',sort);h.addEventListener('keydown',e=>{if(e.key==='Enter'||e.key===' '){e.preventDefault();sort();}});});</script></html>'''
    protected_write(output/'index.html',html.encode())
    markdown+=['','## 限制','',
        '- 独立适配版，不是作者代码或原论文数值的忠实复现；特别是PILA中心规则存在未取得全文的限制。',
        '- 原生与共同回退分别报告；*误差均值只对有输出目标，不能把不同覆盖均值直接相减。',
        '- 模板只从原train各折建立；保留来源与哈希，标注仅用于训练模板参考系，不是推理输入。',
        '- 非盲研究草稿，不证明独立物理精度或机器人任务成功；全部robot_command_eligible=false。',
        '- HTML：report/index.html；逐目标CSV：report/target_metrics.csv；完整指标：final_results.json。','']
    protected_write(data.ROOT/'REPORT_zh.md','\n'.join(markdown).encode())
    package()
    verify_html()
    print(json.dumps(dict(stage='report_written',output=str(output/'index.html'))),flush=True)
    return summary


def verify_html():
    import os
    import subprocess
    import sys
    path=data.ROOT/'logs/browser_validation.log';path.parent.mkdir(parents=True,exist_ok=True)
    with path.open('a') as log:
        subprocess.run([sys.executable,'-u',str(data.PROJECT/'scripts/verify_pose_paper_html_v5.py')],
            cwd=data.PROJECT,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),
            stdout=log,stderr=subprocess.STDOUT,check=True,timeout=240)


def package():
    output=data.ROOT/'pallet_pose_paper_comparison_v5.zip'
    files=[]
    for folder in ('report','templates','paper_sources'):
        files+=list((data.ROOT/folder).rglob('*'))
    files+=[data.ROOT/p for p in ('final_results.json','REPORT_zh.md','protocol.json','paper_protocol.json',
        'selection_frozen.json','paper_selection.json','learning_selection.json','learning_evaluation.json','source_provenance.json',
        'snapshot/manifest.json','snapshot/eligible.jsonl','snapshot/rejected.jsonl','snapshot/event_fingerprints.jsonl',
        'dataset/manifest.json','dataset/features.jsonl')]
    code=[p for p in (data.PROJECT/'pallet').rglob('*') if p.is_file() and
        (p.suffix in ('.py','.html','.css','.js') or 'LICENSE' in p.name)]
    code += [data.CONFIG,data.PROJECT/'scripts/run_pose_paper_benchmark_v5.py',
        data.PROJECT/'scripts/verify_pose_paper_html_v5.py',data.PROJECT/'docs/pallet_pose_paper_benchmark_v5.md',
        data.PROJECT/'tests/test_pose_paper_benchmark.py',data.PROJECT/'pyproject.toml']
    # Carry the original training implementation and pinned PointNeXt source,
    # without changing their historical paths or copying unrelated data.
    code += [data.PROJECT/p for p in ('pallet/pose_benchmark_v4.py','pallet/pose_benchmark_models.py','pallet/pose_benchmark.py',
        'pallet/pose_refinement.py','pallet/pose_model.py','pallet/pose_dataset.py','pallet/pose_review_geometry.py',
        'pallet/pose_review_units.py','configs/pallet_pose_review_units_v1.json')]
    upstream=data.PROJECT/'outputs/pallet_pose_benchmark_v3/upstream/pointnext'
    code += [p for p in upstream.rglob('*') if p.is_file() and '.git' not in p.parts and (p.suffix in ('.py','.yaml','.yml') or 'LICENSE' in p.name)]
    choice=json.loads((data.ROOT/'learning_selection.json').read_text())
    files.append(data.ROOT/'refit/pointnext/epochs'/f"{choice['refit_epoch']}.pt")
    members={}
    for p in files:
        if p.is_file():members[str(p.relative_to(data.ROOT))]=p
    for p in code:
        if p.is_file():members['source/'+str(p.relative_to(data.PROJECT))]=p
    if output.exists():
        with ZipFile(output) as z:
            if set(z.namelist())!=set(members):raise ValueError('Refusing to overwrite existing archive')
            import hashlib
            for name,p in members.items():
                if hashlib.sha256(z.read(name)).hexdigest()!=digest(p):raise ValueError('Existing archive differs')
    else:
        with ZipFile(output,'x',compression=ZIP_DEFLATED,compresslevel=6) as z:
            for name,p in sorted(members.items()):z.write(p,name)
    write_json(data.ROOT/'delivery_manifest.json',dict(archive=output.name,sha256=digest(output),bytes=output.stat().st_size,
        members={name:digest(p) for name,p in sorted(members.items())},
        raw_PCD_not_redistributed=True,live_database_not_packaged=True,robot_command_eligible=False))


def audit():
    import hashlib
    data.snapshot()
    formal,_,sources=data.formal_data()
    if protected_snapshot(formal)!=json.loads((data.ROOT/'snapshot/protected_formal.json').read_text()):
        raise ValueError('Formal files changed')
    protocol=json.loads((data.ROOT/'protocol.json').read_text())
    paper_protocol=json.loads((data.ROOT/'paper_protocol.json').read_text())
    for binding in (protocol['source_files'],paper_protocol['sources']):
        for path,expected in binding.items():
            if digest(data.PROJECT/path)!=expected:raise ValueError('Frozen implementation changed: '+path)
    provenance=json.loads((data.ROOT/'source_provenance.json').read_text())
    for path,expected in provenance['upstream_files'].items():
        if digest(data.PROJECT/path)!=expected:raise ValueError('Pinned PointNeXt code changed: '+path)
    train_keys={r['target_key'] for r in read_rows(data.ROOT/'snapshot/eligible.jsonl') if r['split']=='train'}
    for i,fold in enumerate(protocol['branches']['metric']['folds']):
        if set(fold['fit_groups'])&set(fold['validation_groups']):raise ValueError('CV group leakage')
        manifest=json.loads((data.ROOT/'templates'/f'fold_{i}'/'manifest.json').read_text())
        if set(manifest['fit_keys'])!=set(fold['fit_keys']):raise ValueError('Template CV cohort mismatch')
        if any(t['source_train_target'] not in fold['fit_keys'] for t in manifest['templates']):raise ValueError('Template leakage')
    full=json.loads((data.ROOT/'templates/full_train/manifest.json').read_text())
    if set(full['fit_keys'])!=train_keys:raise ValueError('Full template bank is not train-only')
    labels=read_rows(data.ROOT/'snapshot/eligible.jsonl')
    for row in labels:
        if digest(sources[row['frame_id']]['source_paths']['pcd'])!=row['source_pcd_sha256']:raise ValueError('Raw PCD changed')
    # Historic event prefix must survive ongoing user annotation; new events are fine.
    live=(data.PROJECT/data.config()['review_directory']/'annotations.sqlite3').resolve()
    with closing(sqlite3.connect(live.as_uri()+'?mode=ro',uri=True)) as db:
        db.execute('BEGIN')
        events=[dict(target_key=k,revision=r,payload_sha256=hashlib.sha256(v.encode()).hexdigest())
            for k,r,v in db.execute('SELECT target_key,revision,payload FROM events ORDER BY id')]
    original=read_rows(data.ROOT/'snapshot/event_fingerprints.jsonl')
    if events[:len(original)]!=original:raise ValueError('Old human events changed')
    recomputed={s:cohort(s)['summaries'] for s in ('val','test')}
    result=json.loads((data.ROOT/'final_results.json').read_text())
    if recomputed!=result['evaluation']:raise ValueError('Reported metrics do not reproduce')
    delivery=json.loads((data.ROOT/'delivery_manifest.json').read_text());archive=data.ROOT/delivery['archive']
    if digest(archive)!=delivery['sha256']:raise ValueError('Archive hash mismatch')
    with ZipFile(archive) as z:
        if set(z.namelist())!=set(delivery['members']):raise ValueError('Archive members differ')
        for name,h in delivery['members'].items():
            if hashlib.sha256(z.read(name)).hexdigest()!=h:raise ValueError('Archive member hash mismatch')
            if name.startswith('source/') and digest(data.PROJECT/name.removeprefix('source/'))!=h:
                raise ValueError('Packaged implementation changed after report generation')
    browser=json.loads((data.ROOT/'report_validation/validation.json').read_text())
    if browser['state']!='passed' or browser['html_sha256']!=digest(data.ROOT/'report/index.html'):
        raise ValueError('Browser validation is missing or stale')
    result=dict(completed_at=now(),passed=True,metric_summaries_recomputed=sum(len(v) for v in recomputed.values()),
        protected_formal_files=len(json.loads((data.ROOT/'snapshot/protected_formal.json').read_text())),
        original_events_preserved=len(original),additional_live_events=len(events)-len(original),
        raw_PCD_hashes_verified=len(labels),train_only_template_banks=4,
        snapshot_and_previous_archives_unchanged=True,browser_checks=browser['count'],
        live_database_writes=0,robot_command_eligible=False)
    write_json(data.ROOT/'final_acceptance.json',result)
    print(json.dumps(result,ensure_ascii=False),flush=True)


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--stage',choices=['report','audit'],required=True)
    args=parser.parse_args()
    report() if args.stage=='report' else audit()
