"""Read-only protected-source audit, continuation bindings and extracted inference."""
from __future__ import annotations

from concurrent.futures import ThreadPoolExecutor
from contextlib import closing
import hashlib
import json
import os
from pathlib import Path
import sqlite3
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.cluster_targets import digest, load_dataset, protected_snapshot
from pallet.pose_benchmark_v4_data import ROOT, CONFIG, config, load
from pallet.pose_benchmark_v4 import trial_root
from pallet.pose_benchmark_inference import automatic_input
from pallet.pose_benchmark_v4_inference import V4PosePredictor
from pallet.pose_dataset import read_rows
from pallet.pose_review_geometry import GeometryEngine, canonical
from pallet.pose_refinement import atomic_json, decoded, now


def verify_sources():
    snapshot=json.loads((ROOT/'snapshot/manifest.json').read_text())
    assert digest(CONFIG)==snapshot['config_sha256']
    assert digest(ROOT/'snapshot/reviews.sqlite3')==snapshot['database_sha256']
    assert digest(ROOT/'snapshot/eligible.jsonl')==snapshot['eligible_sha256']
    formal=Path(json.loads((PROJECT/config()['formal_config']).read_text())['dataset'])
    assert digest(formal/'manifest.json')==snapshot['formal_manifest_sha256']
    assert protected_snapshot(formal)==json.loads((ROOT/'snapshot/protected_formal.json').read_text())
    for name,expected in snapshot['immutable_files'].items():assert digest(PROJECT/name)==expected,name
    _,sources=load_dataset(formal)
    def check(source):
        assert digest(source['source_paths']['pcd'])==source['source_anchor_hash']
        assert digest(formal/source['image'])==source['files'][source['image']]
    with ThreadPoolExecutor(max_workers=8) as pool:list(pool.map(check,sources.values()))
    live_path=(PROJECT/config()['review_directory']/'annotations.sqlite3').resolve()
    with closing(sqlite3.connect(live_path.as_uri()+'?mode=ro',uri=True)) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        events={(k,r):hashlib.sha256(p.encode()).hexdigest() for k,r,p in db.execute('SELECT target_key,revision,payload FROM events')}
        live=dict(db.execute('SELECT target_key,revision FROM annotations'))
    old_events=read_rows(ROOT/'snapshot/event_fingerprints.jsonl')
    for row in old_events:assert events[(row['target_key'],row['revision'])]==row['payload_sha256']
    reviews=read_rows(ROOT/'snapshot/source_reviews.jsonl')
    for row in reviews:assert live[row['target_key']]>=row['revision']
    features={r['target_key']:r for r in read_rows(ROOT/'dataset/features.jsonl')}
    labels=read_rows(ROOT/'snapshot/eligible.jsonl');by_split={}
    for row in labels:
        for field in ('group_id','source_pcd_sha256'):
            key=(field,row[field]);assert by_split.setdefault(key,row['split'])==row['split']
        meta=features[row['target_key']]
        assert meta['effective_scale_to_m']==row['sensor']['scale_to_m']
        if row['source_branch']!=row['branch']:
            assert not meta['reused_v3_numerical_inputs']
            assert row['sensor']['scale_to_m']==1 and row['source_sensor']['scale_to_m'] is None
        assert digest(ROOT/'snapshot/support'/(row['target_key']+'.npz'))==row['support_sha256']
        assert not row['robot_command_eligible']
    return dict(protected_formal_files_unchanged=snapshot['protected_files'],all_source_frames_rehashed=len(sources),
        original_human_targets_preserved=len(reviews),original_human_events_preserved=len(old_events),
        current_human_targets=len(live),current_human_events=len(events),
        unit_reclassifications=len(snapshot['converted_user_confirmed_target_keys']),writes_to_live_database=0)


def verify_trials():
    cfg=config();protocol=json.loads((ROOT/'protocol.json').read_text());selection=json.loads((ROOT/'selection_frozen.json').read_text())
    top=selection['top_two'];folds_checked=0;continuations=0;actual_batches={}
    labels={r['target_key']:r for r in read_rows(ROOT/'snapshot/eligible.jsonl')}
    for branch,p in protocol['branches'].items():
        seen=[]
        for fold in p['folds']:
            ti,vi=fold['fit_keys'],fold['validation_keys']
            assert not ({labels[k]['group_id'] for k in ti}&{labels[k]['group_id'] for k in vi})
            assert all(labels[k]['split']=='train' and labels[k]['branch']==branch for k in ti+vi)
            seen.extend(vi)
        assert len(seen)==len(set(seen))==p['train_samples']
        for family in cfg['families']:
            seeds=cfg['seeds'] if family in top else [42]
            arms=['base']+([r['name'] for r in cfg['continuation']] if family in top else [])
            for seed in seeds:
                for arm in arms:
                    trial=trial_root(family,branch,seed,arm);record=json.loads((trial/'completed.json').read_text())
                    with np.load(trial/'out_of_fold.npz',allow_pickle=False) as z:
                        assert z['keys'].tolist()==[r['target_key'] for r in read_rows(ROOT/'snapshot/eligible.jsonl') if r['branch']==branch and r['split']=='train']
                        assert np.isfinite(z['predictions']).all()
                    recipe=next((r for r in cfg['continuation'] if r['name']==arm),None)
                    total=recipe['total_epochs'] if recipe else cfg['base_epochs']
                    batch=recipe['batch'] if recipe else cfg['base_batch']
                    for number,fold in enumerate(p['folds']):
                        path=trial/f'fold_{number}';spec=json.loads((path/'specification.json').read_text())
                        assert spec['fit_keys']==fold['fit_keys'] and spec['validation_keys']==fold['validation_keys']
                        assert spec['protocol_sha256']==digest(ROOT/'protocol.json')
                        assert spec['batch']==batch and spec['total_epochs']==total
                        assert any(uuid.removeprefix('GPU-') in spec['gpu'] for uuid in cfg['preferred_gpu_uuids'])
                        history=json.loads((path/'history.json').read_text())
                        assert [v['epoch'] for v in history]==list(range(1,total+1))
                        n=len(fold['fit_keys']);base_steps=(n+cfg['base_batch']-1)//cfg['base_batch']
                        steps=(n+batch-1)//batch
                        expected=cfg['base_epochs']*base_steps+(total-cfg['base_epochs'])*steps
                        assert record['folds'][number]['optimizer_steps']==expected
                        assert history[-1]['optimizer_steps']==expected
                        assert record['folds'][number]['last_sha256']==digest(path/'last.pt')
                        assert record['folds'][number]['selected_sha256']==digest(path/'selected.pt')
                        best=min(history,key=lambda h:h['validation']['macro_group_selection_score'])
                        assert record['folds'][number]['selected_epoch']==best['epoch']
                        chunks=np.array_split(np.arange(n),steps)
                        actual_batches.setdefault(branch+'/'+arm,set()).update(map(len,chunks))
                        if arm!='base':
                            parent=trial_root(family,branch,seed)/f'fold_{number}'
                            binding=json.loads((path/'continuation_binding.json').read_text())
                            assert binding['parent_last_sha256']==digest(parent/'last.pt')
                            assert binding['parent_selected_sha256']==digest(parent/'selected.pt')
                            assert binding['start_epoch']==cfg['base_epochs']
                            assert binding['start_optimizer_steps']==cfg['base_epochs']*base_steps
                            assert binding['optimizer_and_rng_restored']
                            assert history[:cfg['base_epochs']]==json.loads((parent/'history.json').read_text())
                            continuations+=1
                        folds_checked+=1
    return dict(trial_fold_runs_checked=folds_checked,continuation_bindings_checked=continuations,
                actual_training_batch_sizes={k:sorted(v) for k,v in actual_batches.items()},
                all_model_recipe_choices_frozen_before_val_test=not selection['val_test_used'])


def inference_checks():
    cfg=config();formal=Path(json.loads((PROJECT/cfg['formal_config']).read_text())['dataset']);_,sources=load_dataset(formal)
    engine=GeometryEngine(formal,ROOT/'verification_registration')
    delivery=json.loads((ROOT/'delivery_manifest.json').read_text())
    for entry in (delivery['models'],delivery['annotations']):assert digest(PROJECT/entry['archive'])==entry['sha256']
    checks=[]
    with tempfile.TemporaryDirectory(prefix='pose_v4_extract_',dir='/tmp/opencode') as folder:
        extracted=Path(folder)/'bundle';extracted.mkdir()
        with ZipFile(PROJECT/delivery['models']['archive']) as z:z.extractall(extracted)
        predictor=V4PosePredictor(extracted,allow_native=True)
        # Include reused/native, recomputed/user-confirmed and normal/fallback
        # original-train inputs. No holdout is used to select test examples.
        records={r['target_key']:r for r in read_rows(ROOT/'dataset/features.jsonl')}
        cli_checks=[]
        for branch in ('metric','native_unknown'):
            rows,arrays,_=load(branch);indices=set(np.linspace(0,len(rows)-1,4,dtype=int).tolist())
            for predicate in (lambda r:r['source_branch']!=r['branch'],
                              lambda r:records[r['target_key']]['anchor']=='roi_median_source_forward_fallback',
                              lambda r:records[r['target_key']]['reused_v3_numerical_inputs']):
                indices.update(next(([i] for i,r in enumerate(rows) if predicate(r)),[]))
            for i in sorted(indices):
                row=rows[i];source=sources[row['frame_id']]
                points,mapping=engine.registered(canonical(source).decode())
                box=[row['bbox'][k] for k in ('x','y','width','height')]
                f,g,base,width,direction=automatic_input(points,mapping,box,row['sensor']['scale_to_m'],'roi')
                np.testing.assert_allclose(f,arrays['f'][i,0],rtol=1e-6,atol=1e-6)
                np.testing.assert_allclose(g,arrays['g'][i,0],rtol=1e-6,atol=1e-6)
                np.testing.assert_allclose(base,arrays['base'][i],atol=1e-8)
                np.testing.assert_allclose(width,arrays['width'][i],atol=1e-8)
                np.testing.assert_allclose(direction,arrays['direction'][i],atol=1e-8)
                p=predictor.residual(arrays['f'][i,0],arrays['g'][i,0],branch)
                expected=decoded(p,arrays['base'][i],arrays['width'][i],arrays['direction'][i])
                pose=predictor.pose(points,mapping,box,scale_to_m=row['sensor']['scale_to_m'],domain=row['domain'])
                np.testing.assert_allclose([pose['x'],pose['y']],expected[:2],rtol=1e-5,atol=1e-5)
                np.testing.assert_allclose(pose['theta_degrees'],np.degrees(np.arctan2(expected[3],expected[2])),atol=1e-3)
                assert pose['z'] is None and pose['quaternion'] is None and not pose['robot_command_eligible']
                checks.append(dict(target_key=row['target_key'],branch=branch,split='train',passed=True))
                if not any(v['branch']==branch for v in cli_checks):
                    cloud=Path(folder)/(branch+'.npz');np.savez_compressed(cloud,points_xyzi=points,pixel_to_source_index=mapping)
                    cli_checks.append(dict(branch=branch,cloud=cloud,box=box,scale=row['sensor']['scale_to_m'],domain=row['domain'],expected=pose))
        for branch in ('metric','native_unknown'):
            row=next(r for r in read_rows(ROOT/'snapshot/eligible.jsonl') if r['branch']==branch and r['split']=='train')
            try:predictor.pose(np.zeros((1,4)),np.zeros((1,1),int),[0,0,1,1],scale_to_m=row['sensor']['scale_to_m'],domain='uncovered-domain')
            except ValueError as exc:assert 'Domain not covered' in str(exc)
            else:raise AssertionError('Domain guard bypassed')
        del predictor;torch.cuda.empty_cache()
        for item in cli_checks:
            output=Path(folder)/(item['branch']+'.json')
            command=[sys.executable,'-m','pallet.pose_benchmark_v4_inference','--bundle',str(extracted),
                '--cloud',str(item['cloud']),'--box',*map(str,item['box']),'--domain',item['domain'],'--output',str(output)]
            command+=(['--scale-to-m',str(item['scale'])] if item['scale'] is not None else ['--allow-native'])
            env=dict(os.environ,PYTHONPATH=str(extracted)+':'+os.environ.get('PYTHONPATH',''),PYTHONDONTWRITEBYTECODE='1')
            subprocess.run(command,cwd=extracted,env=env,check=True,capture_output=True,text=True)
            actual=json.loads(output.read_text())
            np.testing.assert_allclose([actual[k] for k in ('x','y','theta_degrees')],
                                       [item['expected'][k] for k in ('x','y','theta_degrees')],rtol=1e-5,atol=1e-3)
            assert not actual['robot_command_eligible']
    return dict(portable_GPU_inference_checks=checks,isolated_extracted_archive_CLI_checks=len(cli_checks),
                domain_guards_passed=True,raw_PCDreregistration_equivalence_passed=True)


def main():
    result=dict(state='passed',created_at=now(),**verify_sources(),**verify_trials(),**inference_checks())
    source_paths=['configs/pallet_pose_benchmark_v4.json','pallet/pose_benchmark_v4_data.py',
        'pallet/pose_benchmark_v4.py','pallet/pose_benchmark_v4_results.py','pallet/pose_benchmark_v4_inference.py',
        'pallet/pose_benchmark_models.py','pallet/pose_benchmark.py','pallet/pose_benchmark_inference.py',
        'pallet/pose_refinement.py','pallet/pose_review_geometry.py','pallet/fork_geometry.py',
        'scripts/run_pose_benchmark_v4.py','scripts/deliver_pose_benchmark_v4.py','scripts/verify_pose_benchmark_v4.py',
        'tests/test_pose_benchmark_v4.py']
    atomic_json(ROOT/'final_source_manifest.json',{name:digest(PROJECT/name) for name in source_paths})
    atomic_json(ROOT/'final_acceptance.json',result);print(json.dumps(result),flush=True)


if __name__=='__main__':main()
