import sys,unittest
from pathlib import Path
import numpy as np
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'src'))
from contracts import (laplacian,kron,relative_spectrum,scalar_gate,
    completion_rounds,weighted_response_bounds,conductance,energy_weights)
from contract_genome import capsule,compile_grid,access_from_root,seal_ready
from contract_growth import Config,manufacture,delivery_time
from recovery import recoverability,posterior,reserve_birth,joint_value


class ResearchChecks(unittest.TestCase):
    def test_kron_star_response(self):
        D=kron(laplacian(4,[[0,3],[1,3],[2,3]],[1,1,1]),[0,1,2])
        np.testing.assert_allclose(D,np.eye(3)-np.ones((3,3))/3,atol=1e-14)

    def test_seal_margin_covers_both_extremes(self):
        for m in np.linspace(.8,1.2,301):
            if scalar_gate(m,.01,.08,.015):
                for noise in [-.01,.01]:
                    for drift in [-.015,.015]:
                        self.assertLessEqual(abs((m+noise)*(1+drift)-1),.08+1e-12)

    def test_seed_tree_is_local_and_bounded(self):
        net=compile_grid(capsule(6,3))
        for i in range(1,len(net['parent'])):
            self.assertEqual(np.abs(net['coordinates'][i]-net['coordinates'][net['parent'][i]]).sum(),1)
        self.assertEqual(len(net['parent']),216)

    def test_postorder_preserves_all_unfinished_paths(self):
        net=compile_grid(capsule(5,3)); rng=np.random.default_rng(716)
        ready=np.zeros(len(net['parent']),bool); sealed=np.zeros_like(ready)
        for _ in range(100):
            ready |= rng.random(len(ready))<.12
            sealed=seal_ready(ready,sealed,net['children'])
            access=access_from_root(net['parent'],sealed)
            self.assertTrue(np.all(access[~ready]))

    def test_delivery_includes_bottleneck_and_material(self):
        parent=np.array([-1,0,1,1]); demand=np.array([0.,0.,0.,2.])
        total,flow=delivery_time(demand,parent,2.,.1,np.array([0,1,2,2]))
        self.assertAlmostEqual(flow,4.) # leaf capacity .5, demand 2
        self.assertAlmostEqual(total,4.2)

    def test_no_sensor_no_recovery_dividend(self):
        self.assertEqual(recoverability(np.eye(4),np.zeros((4,4)),100*np.eye(4))['dividend'],0)

    def test_no_actuator_no_recovery_dividend(self):
        self.assertEqual(recoverability(np.eye(4),np.eye(4),np.zeros((4,2)))['dividend'],0)

    def test_matched_direction_requirement(self):
        E=np.diag([1.,0.,0.]); B=np.array([[0.],[1.],[0.]])
        self.assertEqual(recoverability(np.eye(3),E,B)['dividend'],0.)

    def test_joint_reserve_birth_inherited_law(self):
        self.assertAlmostEqual(reserve_birth(1,1),8.)
        self.assertAlmostEqual(joint_value(1,1,8),0.)
        self.assertGreater(joint_value(1,1,9),0.)

    def test_single_probe_can_miss_large_response_error(self):
        D0=laplacian(3,[[0,1],[0,2],[1,2]],[1,1,1]).toarray()
        D1=laplacian(3,[[0,1],[0,2],[1,2]],[1,1,0]).toarray()
        np.testing.assert_allclose((D1-D0)@np.array([1,0,0]),0)
        self.assertLess(relative_spectrum(D1,D0)[0],.4)

    def test_weighted_bound_equal_uniform_damage(self):
        lo,hi=weighted_response_bounds(np.array([.1,.3,.6]),np.full(3,.7))
        self.assertAlmostEqual(lo,.7);self.assertAlmostEqual(hi,.7)

    def test_limited_actuator_can_fail_honestly(self):
        r,_=manufacture(Config(n=4,seed=9841,reserve_ratio=0.),'contract')
        self.assertFalse(r['complete']);self.assertFalse(r['false_certificate'])

    def test_conventional_joint_policy_ties(self):
        cfg=Config(n=4,dim=3,seed=1235)
        a,sa=manufacture(cfg,'contract');b,sb=manufacture(cfg,'conventional_joint')
        np.testing.assert_array_equal(sa['final'],sb['final'])
        self.assertEqual(a['total_time'],b['total_time'])
        self.assertEqual(a['supplied_material'],b['supplied_material'])

    def test_small_integrated_function_and_ledger(self):
        r,_=manufacture(Config(n=4,dim=3,seed=7231),'contract')
        self.assertTrue(r['complete']);self.assertTrue(r['all_local_contracts'])
        self.assertTrue(r['completed_function_ok']);self.assertEqual(r['closure_violations'],0)
        self.assertAlmostEqual(r['mass_balance_residual'],0.)
        self.assertGreaterEqual(r['total_time'],r['supplied_material']/r['config']['root_material_rate'])

    def test_completion_union_bound(self):
        rounds=completion_rounds(10**6,.6,.01)
        self.assertLessEqual(10**6*.4**rounds,.01)

    def test_constructive_repair_under_bounded_adversarial_noise(self):
        rng=np.random.default_rng(32576)
        eta,beta,w=.08,.01,.01
        low=(1-eta)/(1-beta); high=(1+eta)/(1+beta)
        hmin,hmax=.01,.04
        self.assertLessEqual(hmax,high-low-4*w)
        for case in range(300):
            x=float(rng.uniform(.05,high-2*w)); initial=x
            capacity=max(0.,low+2*w-x)+hmax; used=0.
            limit=1+int(np.ceil(max(0.,low+2*w-x)/hmin))
            accepted=False
            for step in range(limit+1):
                measured=x+w*(-1 if (step+case)%2 else 1)
                if scalar_gate(measured,w,eta,beta):
                    accepted=True;break
                self.assertLess(measured,low+w)
                increment=float(rng.uniform(hmin,hmax))
                self.assertLessEqual(used+increment,capacity+1e-12)
                used+=increment;x+=increment
            self.assertTrue(accepted,(case,initial,x,capacity))


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