"""Source/API and synthetic orchestration tests; never actual CUDA sampling."""
import copy
import hashlib
import importlib.util
import json
from pathlib import Path
import sys
import tempfile
import types
import unittest
from unittest.mock import patch

import numpy as np
import boundary_sampler as S


class SamplerTests(unittest.TestCase):
    def test_actual_frozen_dependency_pins(self):
        for name,sha in S.PINS.items():
            with self.subTest(name=name):self.assertEqual(S.A.digest(S.LAB/name),sha)

    def test_real_sampler_signature_lazy_GPU_and_request_window(self):
        raw=(S.LAB/'conditioning_inputs.py').read_bytes()
        module=types.ModuleType('_ci_cpu_fixture');exec(compile(raw,str(S.LAB/'conditioning_inputs.py'),'exec'),module.__dict__)
        import inspect
        self.assertEqual(list(inspect.signature(module.generate_cs_requests).parameters),
            ['targets','rates_hz','seed','steps','cs_start_tick','cs_stop_tick','device','max_uniform_draws','dt_ms'])
        targets=np.array([5,2],np.int32);forced=np.ones((1200,2),np.bool_)
        result=module.requests_from_forced(forced,targets,cs_start_tick=0,cs_stop_tick=1000)
        self.assertEqual(len(result['requests']['tick']),2000)
        self.assertEqual(int(result['requests']['tick'].max()),999)
        self.assertTrue(np.array_equal(result['requests']['neuron_idx'][:2],np.array([2,5],np.int32)))

    def run_fixture(self,*,mutate_seed=False):
        """Fake sampler is intentionally NOT a stochastic or neural validation."""
        with tempfile.TemporaryDirectory() as td:
            root=Path(td).resolve();(root/'protocol').mkdir();(root/'inputs/static').mkdir(parents=True);(root/'runs').mkdir()
            regfile=root/'protocol/preregistered.json';full=root/'full.json';full.write_text('{}')
            plan=S.PLAN.build_plan();tables={};streams={};calls=[]
            for cue in ('A','B'):
                tables[cue]=dict(targets=np.array([5,2],np.int32),rates_hz=np.array([10.,20.],np.float32))
                with (root/f'inputs/static/{cue}-rates.npz').open('wb') as f:np.savez(f,**tables[cue])
                stream=copy.deepcopy(plan['evaluation_streams'][cue]);stream['semantic_key']=stream.pop('key')
                if mutate_seed and cue=='B':stream['seed']+=1
                streams[(S.PLAN.BLOCK,cue)]=stream
            reg=dict(schema='conditioning-execution-registration-v1',plan=plan,source_sha256={},prepared_file_sha256={},
                input_sha256={str(S.LAB/n):sha for n,sha in S.PINS.items()},original_full_plan=S.A.pin(full))
            regfile.write_text(json.dumps(reg))
            ci=types.ModuleType('conditioning_inputs');i=types.ModuleType('conditioning_preflight_inputs');ep=types.ModuleType('evaluation_plan')
            i.load_rate_tables=lambda root:dict(tables=tables)
            ep._streams=lambda full:streams
            def generate(targets,rates,**kw):
                calls.append(kw)
                self.assertEqual(kw['steps'],1200);self.assertEqual(kw['cs_start_tick'],0)
                self.assertEqual(kw['cs_stop_tick'],1000);self.assertEqual(kw['max_uniform_draws'],2400)
                return dict(requests=dict(tick=np.array([0,999],np.int32),neuron_idx=np.array([2,5],np.int32)),audit={'synthetic_fixture':True})
            ci.generate_cs_requests=generate
            real_import=__import__
            def intercepted(name,*args,**kwargs):
                if name in ('conditioning_inputs','conditioning_preflight_inputs','evaluation_plan'):
                    return {'conditioning_inputs':ci,'conditioning_preflight_inputs':i,'evaluation_plan':ep}[name]
                return real_import(name,*args,**kwargs)
            old_path=list(sys.path)
            try:
                with patch('builtins.__import__',side_effect=intercepted):
                    result=S.run(regfile,S.A.digest(regfile),root/'runs/generated')
                self.assertEqual(len(calls),2);self.assertNotEqual(calls[0]['seed'],calls[1]['seed'])
                self.assertEqual(result['uniform_draws'],4800);self.assertFalse(result['brain_executed'])
                self.assertFalse(result['reuse_executed_here']);self.assertFalse(result['US_added'])
                self.assertEqual(set(result['files_sha256']),{'A-requests.npz','A-sampler.json','B-requests.npz','B-sampler.json'})
                with patch('builtins.__import__',side_effect=intercepted):
                    with self.assertRaisesRegex(ValueError,'Exclusive new sampler'):S.run(regfile,S.A.digest(regfile),root/'runs/generated')
                return result
            finally:sys.path[:]=old_path

    def test_only_two_fixed_batches_and_honest_scope(self):self.run_fixture()

    def test_wrong_full_semantic_seed_rejected(self):
        with self.assertRaisesRegex(ValueError,'Evaluation semantic stream differs'):self.run_fixture(mutate_seed=True)


if __name__=='__main__':unittest.main()