"""Frozen-choice v4 refits, full-denominator holdout comparisons and reports."""
from __future__ import annotations

import argparse
from collections import Counter
import json
from pathlib import Path

import numpy as np
import torch

from .pose_benchmark_v4_data import ROOT, PROJECT, config, load
from .pose_benchmark_v4 import (train, embeddings, make_model, predict, per_error,
                               metrics, trial_root)
from .pose_benchmark_models import PRETRAINED
from .pose_refinement import atomic_json, decoded
from .pose_dataset import read_rows
from .cluster_targets import digest


def entries_for(family,branch):
    return [r for r in json.loads((ROOT/'selection_frozen.json').read_text())['profiles'][branch]['entries'] if r['family']==family]


def refit_root(family,branch,arm='base'):
    return ROOT/'refit'/family/branch/arm


def refit(family,branch):
    entries=entries_for(family,branch);rows,arrays,all_rows=load(branch)
    x=embeddings(family,branch,'train',rows,arrays) if family in PRETRAINED else None
    cfg=config();base=refit_root(family,branch)
    # Capture each predeclared CV-derived refit epoch during one full 80-epoch
    # baseline. The epoch80 last state remains the shared continuation parent.
    epochs=sorted({e['refit_epoch'] for e in entries if e['refit_epoch']<=cfg['base_epochs']})
    train(family,branch,42,arrays,rows,all_rows,np.arange(len(rows)),[],base,x=x,checkpoint_epochs=epochs)
    for entry in entries:
        if entry['arm']=='base':continue
        train(family,branch,42,arrays,rows,all_rows,np.arange(len(rows)),[],refit_root(family,branch,entry['arm']),
              x=x,arm=entry['arm'],resume=base,checkpoint_epochs=[entry['refit_epoch']])
    profiles=[]
    for entry in entries:
        path=refit_root(family,branch,entry['arm'])/'epochs'/f"{entry['refit_epoch']}.pt"
        if not path.exists():raise ValueError('CV-derived refit epoch artifact missing: '+str(path))
        profiles.append(dict(**entry,checkpoint=str(path.relative_to(ROOT)),checkpoint_sha256=digest(path),
                             train_samples=len(rows),train_groups=len({r['group_id'] for r in rows}),
                             training_domains=sorted({r['domain'] for r in rows})))
    atomic_json(ROOT/'refit'/family/branch/'profiles.json',profiles)
    return profiles


def stats(pred,rows,arrays,all_rows):
    pos,angle=per_error(pred,arrays['y'])
    metric=rows[0]['branch']=='metric';distance=pos*arrays['width']*1000 if metric else pos
    success=(distance<=50 if metric else distance<=.05)&(angle<=5)
    return dict(total=len(all_rows),predictions=len(rows),failed_preprocessing=len(all_rows)-len(rows),
        coverage=len(rows)/len(all_rows),position_unit='mm' if metric else 'automatic_width_fraction',
        position_mean=float(distance.mean()),position_median=float(np.median(distance)),
        position_p90=float(np.quantile(distance,.9)),angle_mean=float(angle.mean()),angle_p90=float(np.quantile(angle,.9)),
        success_count=int(success.sum()),full_denominator_success_rate=float(success.sum()/len(all_rows)),
        threshold='50mm/5deg' if metric else '5pct_width/5deg',normalized=metrics(pred,arrays['y'],rows,all_rows))


def baseline_scores(branch,split):
    rows,arrays,all_rows=load(branch,split)
    base=np.zeros_like(arrays['y']);base[:,2]=1
    records={r['target_key']:r for r in read_rows(ROOT/'dataset/features.jsonl')}
    planar=[i for i,r in enumerate(rows) if records[r['target_key']]['anchor']!='roi_median_source_forward_fallback']
    if not planar:return dict(geometry_plus_ROI_fallback=stats(base,rows,arrays,all_rows))
    subset={k:v[planar] for k,v in arrays.items()}
    return dict(geometry_plus_ROI_fallback=stats(base,rows,arrays,all_rows),
                strict_geometry=stats(base[planar],[rows[i] for i in planar],subset,all_rows))


def endpoints(branch):
    """Describe last-state generalization too; never use it to reselect a model."""
    selection=json.loads((ROOT/'selection_frozen.json').read_text())
    protocol=json.loads((ROOT/'protocol.json').read_text())
    rows,arrays,all_rows=load(branch);bykey={r['target_key']:i for i,r in enumerate(rows)};records=[]
    for family in selection['top_two']:
        x=embeddings(family,branch,'train',rows,arrays) if family in PRETRAINED else None
        for arm in ['base']+[r['name'] for r in config()['continuation']]:
            values=[]
            for seed in config()['seeds']:
                path=trial_root(family,branch,seed,arm);prediction=np.zeros_like(arrays['y']);sizes=[]
                elapsed=0.;updates=0;continued_updates=0;selected_epochs=[]
                for number,fold in enumerate(protocol['branches'][branch]['folds']):
                    ti=[bykey[k] for k in fold['fit_keys']];vi=[bykey[k] for k in fold['validation_keys']]
                    fold_path=path/f'fold_{number}';model=make_model(family,arrays,np.asarray(ti),x)
                    last=torch.load(fold_path/'last.pt',map_location='cpu',weights_only=False)
                    model.load_state_dict(last['model'],strict=True)
                    prediction[vi]=predict(model,arrays,vi,x)
                    done=json.loads((fold_path/'completed.json').read_text())
                    elapsed+=done['seconds_this_run'];updates+=done['optimizer_steps'];selected_epochs.append(done['selected_epoch'])
                    parent_steps=0
                    if arm!='base':
                        parent_steps=json.loads((fold_path/'continuation_binding.json').read_text())['start_optimizer_steps']
                    continued_updates+=done['optimizer_steps']-parent_steps
                    batch=last['specification']['batch']
                    sizes.extend(map(len,np.array_split(np.arange(len(ti)),max(1,(len(ti)+batch-1)//batch))))
                    del model,last;torch.cuda.empty_cache()
                values.append(dict(seed=seed,last_epoch_metrics=metrics(prediction,arrays['y'],rows,all_rows),
                    optimizer_steps_all_folds=updates,additional_optimizer_steps=continued_updates,
                    seconds_sum_folds=elapsed,actual_minibatch_sizes=sorted(set(sizes)),selected_epochs=selected_epochs))
            records.append(dict(family=family,arm=arm,seed_results=values,
                last_epoch_CV_mean=float(np.mean([v['last_epoch_metrics']['macro_group_selection_score'] for v in values])),
                last_epoch_CV_std=float(np.std([v['last_epoch_metrics']['macro_group_selection_score'] for v in values])),
                last_epoch_position_width_fraction=float(np.mean([v['last_epoch_metrics']['position_width_fraction'] for v in values])),
                last_epoch_angle_mean=float(np.mean([v['last_epoch_metrics']['angle_mae_degrees'] for v in values])),
                selection_changed=False))
    result=dict(branch=branch,selection_sha256=digest(ROOT/'selection_frozen.json'),records=records,
                selection_changed=False,train_OOF_only=True)
    atomic_json(ROOT/'endpoint_comparison'/branch/'report.json',result)
    return result


def evaluate(branch):
    selection=json.loads((ROOT/'selection_frozen.json').read_text())
    cfg=config();report=dict(branch=branch,selection_sha256=digest(ROOT/'selection_frozen.json'),
        holdout_metrics_used_for_selection=False,previous_test_seen_not_blind=True,baselines={},models=[])
    for split in ('val','test'):report['baselines'][split]=baseline_scores(branch,split)
    for family in cfg['families']:
        profiles=json.loads((ROOT/'refit'/family/branch/'profiles.json').read_text())
        training_rows,training_arrays,_=load(branch)
        for profile in profiles:
            model_path=ROOT/profile['checkpoint']
            if digest(model_path)!=profile['checkpoint_sha256']:raise ValueError('Model checkpoint hash changed')
            state=torch.load(model_path,map_location='cpu',weights_only=True)
            if family in PRETRAINED:
                x=embeddings(family,branch,'train',training_rows,training_arrays)
                model=make_model(family,training_arrays,np.arange(len(training_rows)),x)
            else:model=make_model(family,training_arrays,np.arange(len(training_rows)))
            model.load_state_dict(state['model'],strict=True);results={}
            for split in ('val','test'):
                rows,arrays,all_rows=load(branch,split)
                x=embeddings(family,branch,split,rows,arrays) if family in PRETRAINED else None
                prediction=predict(model,arrays,np.arange(len(rows)),x)
                results[split]=stats(prediction,rows,arrays,all_rows)
                seen_domains=set(profile['training_domains'])
                results[split]['targets_in_training_domains']=sum(r['domain'] in seen_domains for r in rows)
                accepted=[i for i,r in enumerate(rows) if r['domain'] in seen_domains]
                results[split]['deployment_domain_guard_full_denominator']=(
                    stats(prediction[accepted],[rows[i] for i in accepted],
                          {k:v[accepted] for k,v in arrays.items()},all_rows) if accepted else
                    dict(total=len(all_rows),predictions=0,success_count=0,full_denominator_success_rate=0.))
                results[split]['deployment_domain_guard_full_denominator'].update(
                    failed_preprocessing=len(all_rows)-len(rows),domain_guard_rejected=len(rows)-len(accepted))
                path=ROOT/'evaluation'/branch/family/profile['arm'];path.mkdir(parents=True,exist_ok=True)
                np.savez_compressed(path/(split+'.npz'),predictions=prediction,targets=arrays['y'],
                    keys=[r['target_key'] for r in rows],widths=arrays['width'])
                values=decoded(prediction,arrays['base'],arrays['width'],arrays['direction'])
                atomic_json(path/(split+'_poses.json'),[dict(target_key=r['target_key'],x=float(p[0]),y=float(p[1]),
                    theta_degrees=float(np.degrees(np.arctan2(p[3],p[2]))),z=None,quaternion=None,
                    position_unit='m' if branch=='metric' else 'native_unknown',robot_command_eligible=False)
                    for r,p in zip(rows,values)])
            report['models'].append(dict(family=family,arm=profile['arm'],refit_epoch=profile['refit_epoch'],splits=results))
            del model;torch.cuda.empty_cache()
    atomic_json(ROOT/'evaluation'/branch/'report.json',report)
    return report


def report():
    cfg=config();snapshot=json.loads((ROOT/'snapshot/manifest.json').read_text())
    selection=json.loads((ROOT/'selection_frozen.json').read_text())
    baseline={};evidence={};endpoint_evidence={}
    for branch in selection['profiles']:
        rows,arrays,all_rows=load(branch);p=np.zeros_like(arrays['y']);p[:,2]=1
        baseline[branch]=metrics(p,arrays['y'],rows,all_rows)
        evidence[branch]=json.loads((ROOT/'evaluation'/branch/'report.json').read_text())
        endpoint_evidence[branch]=json.loads((ROOT/'endpoint_comparison'/branch/'report.json').read_text())
    summary=dict(selection=selection,baselines_train_CV=baseline,evaluation=evidence,
                 endpoint_comparisons=endpoint_evidence,
                 live_annotations_modified=False,active_machine_labels_modified=False)
    atomic_json(ROOT/'final_results.json',summary)
    lines=['# 最新托盘位姿标注重训与batch/时长对照 v4','',
        f"冻结时间：{snapshot['created_at']}；{snapshot['saved_targets']}个人工保存目标、{snapshot['events']}条事件，{snapshot['eligible']}条有效研究标签，隔离{snapshot['rejected']}条。",
        '仅原train训练和分组选模；原val/test不回流。全部模型和配方先冻结，再查看固定holdout结果。',
        '这些标签是用户授权的非盲草稿，不是独立机器人精度/成功率证明。','',
        '## 数据集与单位','',
        '|分支|train|val|test|独立train组|CV|','|---|---:|---:|---:|---|']
    protocol=json.loads((ROOT/'protocol.json').read_text())
    for branch,p in protocol['branches'].items():
        counts=snapshot['counts'];lines.append(f"|{branch}|{counts.get('train/'+branch,0)}|{counts.get('val/'+branch,0)}|{counts.get('test/'+branch,0)}|{p['train_groups']}|{len(p['folds'])}折按组|")
    lines+=['','先前确认的823个目标按1原单位=1米并入metric；仅更新本研究版本的单位解释，不改坐标数值、真实人工库或原始传感器注册表。',
        '其他单位未确认目标保持独立native_unknown。其train仅两个采集组时采用两组留一验证，结果不作为部署充分证据。','',
        '## 八模型重训初筛（80轮，batch32，种子42）','',
        '|分支|模型|组等权综合误差↓|位置/宽度|角度MAE|','|---|---|---:|---:|---:|']
    for branch in protocol['branches']:
        records=[json.loads((trial_root(family,branch)/'completed.json').read_text()) for family in cfg['families']]
        for r in sorted(records,key=lambda r:r['metrics']['macro_group_selection_score']):
            m=r['metrics'];lines.append(f"|{branch}|{r['family']}|{m['macro_group_selection_score']:.6f}|{m['position_width_fraction']:.6f}|{m['angle_mae_degrees']:.6f}°|")
    lines+=['',f"仅依据metric原train初筛选出的两个模型：**{'、'.join(selection['top_two'])}**。",'',
        '## 两模型加大batch及延长训练对照','',
        '各继续训练组从同种子/同折的epoch80末尾模型、AdamW状态、NumPy及CPU/CUDA随机数状态恢复；不从早停最佳权重伪装续训。',
        'base=batch32/80轮；long_b32=batch32/总240轮；long_b64=batch64/总240轮；long_b64_steps=batch64/总400轮。',
        '最后一组让继续训练的优化器步数近似匹配batch32/240轮组；真实步数、耗时及曲线逐折记录。',
        '不按test重调学习率，延续原学习率以尽量隔离batch/时长影响；不声称此配方穷尽了最优训练调度。','',
        '|分支|模型|配方|三种子CV均值±标准差|相对相同种子base差值95%区间|CV选定重拟合轮数|',
        '|---|---|---|---:|---|---:|']
    for branch,p in selection['profiles'].items():
        for family in selection['top_two']:
            for e in [v for v in p['entries'] if v['family']==family]:
                d=e['delta_vs_same_seed_base']
                lines.append(f"|{branch}|{family}|{e['arm']}|{e['mean_score']:.6f} ± {e['std_score']:.6f}|[{d['lower']:.6f}, {d['upper']:.6f}]|{e['refit_epoch']}|")
    lines+=['','区间是同采集组配对bootstrap的选模后描述性结果；负值为改善，跨0不能称稳定提升。继续训练配方的最佳checkpoint允许保留base最佳epoch，因此它也可能完全没有额外收益。','',
        '### 末轮检查点（未按其重选）与实际计算量','',
        '|分支|模型|配方|末轮CV均值±标准差↓|实际每步样本数|三种子各自新增更新步数（所有折合计）|',
        '|---|---|---|---:|---|---|']
    for branch,data in endpoint_evidence.items():
        for e in data['records']:
            sizes=sorted({s for v in e['seed_results'] for s in v['actual_minibatch_sizes']})
            steps=[v['additional_optimizer_steps'] for v in e['seed_results']]
            lines.append(f"|{branch}|{e['family']}|{e['arm']}|{e['last_epoch_CV_mean']:.6f} ± {e['last_epoch_CV_std']:.6f}|{sizes}|{steps}|")
    lines+=['','小样本未知单位分支的单折训练样本不足32，设置64并不增加实际batch；该分支只能观察延长训练，不能作为大batch有效性的证据。',
        '大batch的实际步数取决于每折样本数，batch64/400轮只近似匹配batch32/240轮新增步数；详见逐种子真实计数。','',
        '## 冻结后的固定test复测（全分母）','',
        '|分支|方案|位置均值|角度均值|输出/总数|阈值通过/总数|部署域检查后通过/总数|',
        '|---|---|---:|---:|---:|---:|---:|']
    for branch,data in evidence.items():
        values=[(name,r) for name,r in data['baselines']['test'].items()]
        for r in data['models']:
            values.append((r['family']+'/'+r['arm'],r['splits']['test']))
        for name,m in values:
            guarded=m.get('deployment_domain_guard_full_denominator')
            guard=f"{guarded['success_count']}/{m['total']}" if guarded else '不适用'
            lines.append(f"|{branch}|{name}|{m['position_mean']:.6f} {m['position_unit']}|{m['angle_mean']:.6f}°|{m['predictions']}/{m['total']}|{m['success_count']}/{m['total']}|{guard}|")
    lines+=['','## 结论（仅以原train CV选模）','']
    for branch,p in selection['profiles'].items():
        best=p['best_learning'];lines.append(f"- {branch}：{best['family']} / {best['arm']}，综合分{best['mean_score']:.6f}；建议：{p['recommendation']}。")
    lines+=['','## 边界与交付','',
        '- 统一完整原框ROI输入，自动叉取面为可选参考；平面失败时ROI中位数回退，单独列出纯几何与几何＋回退基线，避免将流程收益归功于神经网络。',
        '- 512点，3个确定性点序变体；端到端训练另加0.003个参考宽度的坐标扰动，冻结编码器的位姿头训练不重编码抖动点云。',
        '- 预训练模型训练冻结官方编码器后的位姿头，继续训练也不改变冻结策略；PointNeXt/PTv3/DGCNN端到端训练。这不是所有架构都经过充分微调的能力上限。',
        '- 只有两块非3090显卡被调度；每折specification及日志可核验。',
        '- 没有自动替换上线机器建议，也没有覆盖旧数据集、包或实验。正式检测框与划分、旧GT和实时人工修订保留。',
        '- v4单位解释、样本量及点序配方与v3不同，不能将跨版本分数变化直接归因于模型或batch；因果比较仅用本轮相同数据的配对实验。',
        '- 数据：dataset/；快照：snapshot/；官方来源：protocol.json；续训绑定：trials/*/*/*/*/fold_*/continuation_binding.json。',
        '- 推理包和训练结果清单：delivery_manifest.json；最终保护及等价审计：final_acceptance.json。','']
    (ROOT/'REPORT_zh.md').write_text('\n'.join(lines))
    return summary


if __name__=='__main__':
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--stage',choices=['refit','evaluate','endpoints','report'],required=True)
    parser.add_argument('--family');parser.add_argument('--branch',choices=['metric','native_unknown'])
    args=parser.parse_args()
    if args.stage=='refit':refit(args.family,args.branch)
    elif args.stage=='evaluate':evaluate(args.branch)
    elif args.stage=='endpoints':endpoints(args.branch)
    else:report()
