"""Bind the unchanged v4 training engine to the independent v5 cohort in memory."""
from __future__ import annotations

import json
from pathlib import Path

import numpy as np

from . import pose_paper_data as data
from .cluster_targets import digest
from .pose_dataset import write_json
from .pose_model import group_folds
from .pose_refinement import now


def engine():
    # No frozen v4 file is edited; path/config bindings are process-local.
    from . import pose_benchmark_v4 as b
    b.ROOT,b.CONFIG,b.config,b.load=data.ROOT,data.CONFIG,data.config,data.load
    return b


def freeze():
    data.snapshot()
    rows,_,all_rows=data.load()
    folds=[]
    for ti,vi in group_folds(rows,data.config()['folds'],data.config()['fold_seed']):
        folds.append(dict(fit_keys=[rows[i]['target_key'] for i in ti],
            validation_keys=[rows[i]['target_key'] for i in vi],
            fit_groups=sorted({rows[i]['group_id'] for i in ti}),
            validation_groups=sorted({rows[i]['group_id'] for i in vi})))
    code=['pallet/pose_benchmark_v4.py','pallet/pose_benchmark_models.py','pallet/pose_benchmark.py',
          'pallet/pose_refinement.py','pallet/pose_paper_data.py','pallet/pose_paper_learning.py']
    path=data.ROOT/'protocol.json'
    value=dict(created_at=now(),config=data.config(),config_sha256=digest(data.CONFIG),
        snapshot_sha256=digest(data.ROOT/'snapshot/manifest.json'),
        dataset_manifest_sha256=digest(data.ROOT/'dataset/manifest.json'),
        source_files={p:digest(data.PROJECT/p) for p in code},
        branches={'metric':dict(train_samples=len(rows),full_train_samples=len(all_rows),
            train_groups=len({r['group_id'] for r in rows}),folds=folds)},
        holdout_used_for_selection=False,previous_test_seen_not_blind=True,robot_command_eligible=False)
    if path.exists():value['created_at']=json.loads(path.read_text())['created_at']
    write_json(path,value)
    return value


def trial(seed):
    import torch
    if not torch.cuda.is_available():raise ValueError('GPU required')
    uuid=str(torch.cuda.get_device_properties(0).uuid)
    if not any(uuid in preferred for preferred in data.config()['preferred_gpu_uuids']):
        raise ValueError('Not an authorized non-3090 GPU: '+uuid)
    return engine().trial('pointnext','metric',seed,'base')


def select():
    b=engine();records=[];epochs=[]
    for seed in data.config()['seeds']:
        value=json.loads((b.trial_root('pointnext','metric',seed)/'completed.json').read_text())
        records.append(value)
        epochs.extend(f['selected_epoch'] for f in value['folds'])
    result=dict(created_at=now(),protocol_sha256=digest(data.ROOT/'protocol.json'),
        seeds=data.config()['seeds'],refit_seed=42,refit_epoch=max(1,int(np.median(epochs))),
        CV_scores=[r['metrics']['macro_group_selection_score'] for r in records],
        selected_epochs=epochs,holdout_used=False,source='original_train_group_CV_only')
    path=data.ROOT/'learning_selection.json'
    if path.exists():result['created_at']=json.loads(path.read_text())['created_at']
    write_json(path,result)
    return result


def refit():
    b=engine();selection=json.loads((data.ROOT/'learning_selection.json').read_text())
    rows,arrays,all_rows=data.load()
    return b.train('pointnext','metric',42,arrays,rows,all_rows,np.arange(len(rows)),[],
        data.ROOT/'refit/pointnext',checkpoint_epochs=[selection['refit_epoch']])


def infer_checkpoint(path,split,output):
    import torch
    from .pose_refinement import decoded
    b=engine();rows,arrays,_=data.load(split=split)
    state=torch.load(path,map_location='cpu',weights_only=True)
    model=b.make_model('pointnext',arrays,np.arange(len(rows)))
    model.load_state_dict(state['model'],strict=True)
    prediction=b.predict(model,arrays,np.arange(len(rows)))
    poses=decoded(prediction,arrays['base'],arrays['width'],arrays['direction'])
    result=[dict(target_key=r['target_key'],pose=[float(p[0]),float(p[1]),float(np.arctan2(p[3],p[2]))],
        state='complete',seconds=None,robot_command_eligible=False) for r,p in zip(rows,poses)]
    write_json(output,result)
    del model;torch.cuda.empty_cache()
    return result


def evaluate():
    # Both CPU-paper and learning choices must exist before any holdout evaluation.
    if not (data.ROOT/'selection_frozen.json').exists():raise ValueError('Global selection is not frozen')
    choice=json.loads((data.ROOT/'learning_selection.json').read_text())
    path=data.ROOT/'refit/pointnext/epochs'/f"{choice['refit_epoch']}.pt"
    profiles=json.loads((data.PROJECT/'outputs/pallet_pose_benchmark_v4/refit/pointnext/metric/profiles.json').read_text())
    old=next(p for p in profiles if p['arm']=='long_b32')
    old_path=data.PROJECT/'outputs/pallet_pose_benchmark_v4'/old['checkpoint']
    if digest(old_path)!=old['checkpoint_sha256']:raise ValueError('Old frozen model changed')
    for split in ('val','test'):
        infer_checkpoint(path,split,data.ROOT/'predictions/pointnext_latest'/f'{split}.json')
        infer_checkpoint(old_path,split,data.ROOT/'predictions/pointnext_v4_frozen_transfer'/f'{split}.json')
    write_json(data.ROOT/'learning_evaluation.json',dict(new_checkpoint=str(path.relative_to(data.ROOT)),
        new_checkpoint_sha256=digest(path),old_checkpoint_sha256=digest(old_path),
        old_model_is_transfer_not_retrained=True,robot_command_eligible=False))


if __name__=='__main__':
    import argparse
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--stage',choices=['freeze','trial','select','refit','evaluate'],required=True)
    parser.add_argument('--seed',type=int,default=42)
    args=parser.parse_args()
    {'freeze':freeze,'trial':lambda:trial(args.seed),'select':select,'refit':refit,'evaluate':evaluate}[args.stage]()
