"""Extract v3 delivery elsewhere and run only package-local inference code."""
import json
import os
from pathlib import Path
import subprocess
import sys
import tempfile
from zipfile import ZipFile

PROJECT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(PROJECT))
import numpy as np
import torch
from pallet.pose_benchmark import ROOT,load_data,atomic_json
from pallet.pose_benchmark_models import Backbone
from pallet.pose_benchmark_results import load_refit
from pallet.pose_refinement import decoded
from pallet.cluster_targets import load_dataset
from pallet.pose_review_geometry import GeometryEngine,canonical


def main():
    bundle=(ROOT/'deployment').resolve()
    archive=ROOT/'pallet_pose_best_learning_models_v3.zip'
    selected=json.loads((ROOT/'selection_frozen.json').read_text())
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    _,sources=load_dataset(formal)
    engine=GeometryEngine(formal,ROOT/'portable_verification_registration')
    records=[]
    with tempfile.TemporaryDirectory(prefix='pose_v3_portable_',dir='/tmp/opencode') as tmp:
        root=Path(tmp);package=root/'bundle';package.mkdir()
        with ZipFile(archive) as z:
            for name in z.namelist():
                if not (package/name).resolve().is_relative_to(package.resolve()):
                    raise ValueError('Unsafe archive member')
            z.extractall(package)
        jobs=[];expected=[]
        for branch,profile in selected['profiles'].items():
            best=profile['best_learning'];rows,arrays=load_data(branch,route=best['route'])
            model,frozen=load_refit(branch,best)
            backbone=Backbone(best['family']).cuda().eval() if frozen else None
            for index in (0,len(rows)//2):
                row=rows[index];source=sources[row['frame_id']]
                points,mapping=engine.registered(canonical(source).decode())
                cloud=root/(row['target_key']+'.npz')
                np.savez_compressed(cloud,points_xyzi=points,pixel_to_source_index=mapping)
                with torch.no_grad():
                    f=torch.tensor(arrays['f'][index,0],device='cuda')[None]
                    g=torch.tensor(arrays['g'][index,0],device='cuda')[None]
                    prediction=model(torch.cat((backbone(f),g),-1)) if frozen else model(f,g)
                residual=prediction.cpu().numpy()[0]
                value=decoded(residual,arrays['base'][index],arrays['width'][index],arrays['direction'][index])
                expected.append(value)
                jobs.append(dict(cloud=str(cloud),box=[row['bbox'][k] for k in ('x','y','width','height')],
                                 domain=row['domain'],scale_to_m=row['sensor']['scale_to_m']))
                records.append(dict(target_key=row['target_key'],branch=branch,split='train'))
            del model,backbone
            torch.cuda.empty_cache()
        (root/'jobs.json').write_text(json.dumps(jobs))
        code='''import json,numpy as np
from pathlib import Path
import pallet.pose_benchmark_inference as inference
root=Path.cwd()
assert Path(inference.__file__).resolve().is_relative_to(root/'bundle')
predictor=inference.BenchmarkPosePredictor(root/'bundle',allow_native=True)
outputs=[]
for job in json.loads((root/'jobs.json').read_text()):
    with np.load(job['cloud']) as z:
        outputs.append(predictor.pose(z['points_xyzi'],z['pixel_to_source_index'],job['box'],
                       scale_to_m=job['scale_to_m'],domain=job['domain']))
(root/'results.json').write_text(json.dumps(outputs,allow_nan=False))
'''
        env=dict(os.environ,PYTHONPATH=str(package)+':/tmp/opencode/pose_benchmark_small_deps:/tmp/opencode/pose_benchmark_deps',
                 OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='2')
        process=subprocess.run([sys.executable,'-c',code],cwd=root,env=env,text=True,
                               stdout=subprocess.PIPE,stderr=subprocess.STDOUT)
        (ROOT/'portable_process.log').write_text(process.stdout)
        if process.returncode:raise RuntimeError('Extracted inference failed; see portable_process.log')
        outputs=json.loads((root/'results.json').read_text())
        for record,output,value in zip(records,outputs,expected):
            np.testing.assert_allclose([output['x'],output['y']],value[:2],atol=1e-5,rtol=1e-6)
            np.testing.assert_allclose(output['theta_degrees'],np.degrees(np.arctan2(value[3],value[2])) ,atol=1e-4)
            assert output['z'] is None and output['quaternion'] is None
            assert not output['robot_command_eligible'] and output['review_required']
            record['package_local_code_and_raw_cloud_inference_match']=True
    report=dict(state='passed',checks=records,original_labels_available_to_child=False,
                extracted_outside_repository=True,source_database_writes=0)
    atomic_json(ROOT/'portable_inference_verification.json',report)
    print(json.dumps(report),flush=True)


if __name__=='__main__':main()
