"""Fresh generic-start cycle2 joint training, using frozen v1 learning primitives."""
from copy import deepcopy
import shutil
import traceback

import cv2
import numpy as np
import torch

from .cluster_targets import digest
from .mask_model_training_data import PROJECT,FALSE_FLAGS,read,write,jsonl,require,gpu_receipt
from .mask_model_training import seed_all
from .mask_taxonomy_cycle2_data import ROOT,verify,sources_current,engine

RUN=ROOT/'run_v1_bfloat16'
learning=engine('pallet/mask_taxonomy_train.py','learning')
CONFIG=deepcopy(learning.CONFIG)
learning.ROOT=ROOT;learning.RUN=RUN;learning.CONFIG=CONFIG
TaxonomyMaskNet=learning.TaxonomyMaskNet
class_tables=learning.class_tables
TRAINING_CODE=('pallet/mask_taxonomy_cycle2_data.py','pallet/mask_taxonomy_cycle2_train.py','pallet/mask_taxonomy_train.py',
    'pallet/mask_model_training.py','pallet/mask_annotation_full_train.py','pallet/mask_model_training_data.py')


def train():
    require(not RUN.exists(),'Preserve prior run; no automatic overwrite/restart')
    _,records=verify();require(sources_current(),'Source review/classification changed before training')
    generic=learning.GENERIC;require(digest(generic).startswith('f37072fd'),'Official generic ImageNet ResNet18 weights required')
    gpu=gpu_receipt('m2');torch.set_num_threads(4);cv2.setNumThreads(1);seed_all();require(torch.cuda.is_bf16_supported(),'BF16 supported device required')
    RUN.mkdir(mode=0o700);snapshots=RUN/'code_snapshot';snapshots.mkdir()
    for name in TRAINING_CODE:shutil.copyfile(PROJECT/name,snapshots/name.replace('/','__'))
    write(RUN/'execution_plan.json',dict(config=CONFIG,gpu=gpu,dataset_manifest_sha256=digest(ROOT/'dataset_manifest.json'),generic_weights_sha256=digest(generic),
        old_pallet_checkpoints_used=False,training_records=len(records),small_sample_training='same_parent_shared_encoder_mask_parent_and_attribute_losses_fine_CE_weight035_no_label_merge',
        evaluation='fixed_inherited_global_component_hash_generic_start_before_full_pool_not_new_blind_prospective_test',
        prior_model_selection_exposure_disclosed=True,thresholds_not_tuned_on_holdout=True,
        model_inputs='original_gray_pixels_in_fixed_original_bbox_context_only_no_class_K_pose_or_ID_features',
        code_sha256={name:digest(PROJECT/name) for name in TRAINING_CODE},**FALSE_FLAGS))
    try:
        model=TaxonomyMaskNet(encoder_weights=generic).cuda();subset=[r for r in records if r['evaluation_branch_split']=='train']
        model,_=learning.run_phase('independent_branch',model,subset,CONFIG['evaluation_epochs'])
        inputs=learning.Inputs(records);held=learning.predictions(model,inputs,[i for i,r in enumerate(records) if r['evaluation_branch_split']=='holdout'])
        write(RUN/'independent_branch/holdout_predictions.jsonl',held,lines=True)
        metrics=dict(scope='generic_start_component_holdout_of_current_reviewed_pool_NOT_new_blind_test',prior_model_selected_new_review_images=True,
            checkpoint_sha256=digest(RUN/'independent_branch/final_ema.pt'),classes_absent_from_training=sorted({r['class_id'] for r in records}-{r['class_id'] for r in subset}),
            **learning.summarize_classification(held))
        write(RUN/'independent_branch/holdout_metrics.json',metrics)
        write(RUN/'independent_branch/coverage_audit.json',dict(holdout_targets=len(held),holdout_components=len({r['component'] for r in held}),
            represented_fine_classes=len({r['class_id'] for r in held}),total_fine_classes=41,not_a_claim_of_all_class_reliability=True,prior_model_review_selection_disclosed=True))
        print(dict(phase='generic_component_holdout_frozen',fine_top1=metrics['fine_top1'],parent_top1=metrics['parent_top1'],targets=len(held)),flush=True)
        del inputs;require(sources_current(),'Sources changed before full-pool training')
        model,inputs=learning.run_phase('full_pool',model,records,CONFIG['full_pool_epochs']);fitted=learning.predictions(model,inputs,list(range(len(records))))
        write(RUN/'full_pool/fit_predictions.jsonl',fitted,lines=True);write(RUN/'full_pool/fit_metrics.json',dict(scope='resubstitution_only_NOT_independent_accuracy',**learning.summarize_classification(fitted)))
        centers=[]
        for cls in range(41):
            vectors=np.array([r['embedding'] for r in fitted if r['fine_index']==cls],np.float32);require(len(vectors)>0,'Every enabled fine class needs actual samples')
            center=vectors.mean(0);center/=max(np.linalg.norm(center),1e-12);centers.append(center.tolist())
        write(RUN/'full_pool/prototypes.json',dict(centers=centers,scope='training_embeddings_only_not_test_accuracy',checkpoint_sha256=digest(RUN/'full_pool/final_ema.pt')))
        require(sources_current(),'Live sources changed during training; cannot publish stale tasks')
        write(RUN/'training_complete.json',dict(state='actual_cycle2_joint_training_complete',independent_branch=digest(RUN/'independent_branch/final_ema.pt'),
            full_pool=digest(RUN/'full_pool/final_ema.pt'),independent_metrics_sha256=digest(RUN/'independent_branch/holdout_metrics.json'),
            fit_metrics_sha256=digest(RUN/'full_pool/fit_metrics.json'),gpu=gpu,config=CONFIG,**FALSE_FLAGS))
        print(dict(state='cycle2_training_complete',checkpoint_sha256=digest(RUN/'full_pool/final_ema.pt')),flush=True)
    except Exception:
        write(RUN/'training_failure.json',dict(traceback=traceback.format_exc(),old_data_models_and_events_preserved=True));raise
