"""Label-free v4 inference for the train-CV winner or an explicitly named study arm."""
from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path

import numpy as np
import torch

from . import pose_benchmark_models as architectures
from .pose_benchmark import EndToEnd
from .pose_benchmark_inference import BenchmarkPosePredictor


class V4PosePredictor(BenchmarkPosePredictor):
    def __init__(self,bundle,device='cuda',allow_native=False,*,family=None,arm='base'):
        self.root=Path(bundle).resolve();self.device=device;self.allow_native=allow_native
        self.config=json.loads((self.root/'bundle_config.json').read_text())
        if self.config['schema']!='pose_benchmark_v4':raise ValueError('Expected a v4 model bundle')
        for name,expected in self.config['files'].items():
            path=(self.root/name).resolve()
            if not path.is_relative_to(self.root) or hashlib.sha256(path.read_bytes()).hexdigest()!=expected:
                raise ValueError('Bundle hash mismatch: '+name)
        if family is not None:
            catalog=self.config['model_catalog']
            try:self.config['profiles']={b:catalog[family][b][arm] for b in self.config['profiles']}
            except KeyError as exc:raise ValueError('Unknown model family or continuation arm') from exc
        elif arm!='base':raise ValueError('Specify --family when selecting an explicit --arm')
        architectures.ROOT=self.root;architectures.UPSTREAM=self.root/'upstream';self.models={}
        for branch,spec in self.config['profiles'].items():
            state=torch.load(self.root/spec['checkpoint'],map_location='cpu',weights_only=True)
            if state['frozen_encoder']:
                backbone=architectures.Backbone(spec['family']).to(device).eval()
                weights=state['model'];head=architectures.PoseHead(len(weights['mean']),weights['mean'],weights['std'])
                head.load_state_dict(weights,strict=True);self.models[branch]=(backbone,head.to(device).eval())
            else:
                model=EndToEnd(spec['family'],np.zeros((2,16),np.float32),tune=False)
                model.load_state_dict(state['model'],strict=True);self.models[branch]=(None,model.to(device).eval())

    def pose(self,*args,**kwargs):
        result=super().pose(*args,**kwargs)
        branch='metric' if kwargs.get('scale_to_m') is not None else 'native_unknown'
        spec=self.config['profiles'][branch]
        result.update(study_arm=spec['arm'],training_version=4,
                      deployment_recommendation=spec['deployment_recommendation'])
        return result


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--bundle',required=True,type=Path);parser.add_argument('--cloud',required=True,type=Path)
    parser.add_argument('--box',required=True,nargs=4,type=float,metavar=('X','Y','W','H'))
    parser.add_argument('--domain',required=True);parser.add_argument('--scale-to-m',type=float)
    parser.add_argument('--allow-native',action='store_true');parser.add_argument('--device',default='cuda')
    parser.add_argument('--family');parser.add_argument('--arm',default='base');parser.add_argument('--output',required=True,type=Path)
    args=parser.parse_args()
    predictor=V4PosePredictor(args.bundle,args.device,args.allow_native,family=args.family,arm=args.arm)
    with np.load(args.cloud,allow_pickle=False) as z:
        result=predictor.pose(z['points_xyzi'],z['pixel_to_source_index'],args.box,
                              scale_to_m=args.scale_to_m,domain=args.domain)
    args.output.write_text(json.dumps(result,ensure_ascii=False,indent=2,allow_nan=False)+'\n')


if __name__=='__main__':main()
