"""Tests of decide_024.py on synthetic steps (no export is read)."""
import sys, unittest
import numpy as np
sys.dont_write_bytecode = True
import decide_024 as d

REPEATS = {'blank': 8, '45@15': 8, '135@15': 8, '45@30': 8, '135@30': 8, '45@60': 4, '135@60': 4,
           '45@15+135@15': 8, '45@30+135@30': 8, '45@30+135@15': 8, '45@15+135@30': 8,
           '90@15': 4, '90@30': 4, '135@30+90@15': 4, '135@15+90@30': 4}
V = {'blank': 0, '45@15': -.6, '135@15': .6, '45@30': -1, '135@30': 1, '45@60': -1.3, '135@60': 1.3,
     '45@15+135@15': 0, '45@30+135@30': 0, '45@30+135@15': -.8, '45@15+135@30': .7,
     '90@15': 0, '90@30': 0, '135@30+90@15': .7, '135@15+90@30': 0}


def steps(v=V, scale=5000.0, z0=100 + 300j, noise=0.0, seed=1):
    rng = np.random.default_rng(seed)
    cond = [c for c, n in REPEATS.items() for _ in range(n)]
    z = [z0 + scale * (-1j * v[c] + noise * (rng.normal() + 1j * rng.normal())) for c in cond]
    order = rng.permutation(len(cond))
    return [cond[i] for i in order], [z[i] for i in order]


class Rule(unittest.TestCase):
    def test_action_thresholds(self):
        self.assertEqual([d.action(x) for x in (0.33, 0.32, 0, -0.32, -0.33)], ['B', 'hold', 'hold', 'hold', 'A'])

    def test_clean_instance_all_intended(self):
        r = d.decide(*steps())
        self.assertEqual((r['as_intended'], r['of']), (56, 56))
        self.assertAlmostEqual(r['S'], 5000.0)
        self.assertAlmostEqual(r['z0'][1], 300.0)

    def test_orientation_signs(self):
        r = d.decide(*steps())
        self.assertEqual(r['conditions']['45@15']['actions'], {'A': 8, 'hold': 0, 'B': 0})
        self.assertEqual(r['conditions']['135@60']['actions'], {'A': 0, 'hold': 0, 'B': 4})

    def test_a_relay_like_circuit_is_caught(self):
        v = dict(V, **{'45@30+135@15': -.2, '45@15+135@30': .2})          # weak unequal plaids: 16 steps held
        r = d.decide(*steps(v))
        self.assertEqual(r['as_intended'], 40)

    def test_biased_equal_plaid_is_caught(self):
        r = d.decide(*steps(dict(V, **{'45@30+135@30': -.5})))
        self.assertEqual(r['as_intended'], 48)
        self.assertEqual(r['conditions']['45@30+135@30']['actions']['A'], 8)

    def test_relay_rule_reported(self):
        r = d.decide(*steps())
        self.assertAlmostEqual(r['relay_rule']['45@15+135@30']['v_relay'], 0.4)
        self.assertEqual(r['relay_rule']['45@30+135@30']['relay_action'], 'hold')

    def test_small_scale_refused(self):
        with self.assertRaises(d.Refusal):
            d.decide(*steps(scale=1000.0))

    def test_inverted_scale_refused(self):
        with self.assertRaises(d.Refusal):
            d.decide(*steps(scale=-5000.0))

    def test_missing_calibration_refused(self):
        c, z = steps()
        i = c.index('blank')
        with self.assertRaises(d.Refusal):
            d.decide(c[:i] + c[i + 1:], z[:i] + z[i + 1:])

    def test_outcome_rule(self):
        mk = lambda hits: {f's{k}': {'as_intended': h} for k, h in enumerate(hits)}
        self.assertEqual(d.outcome(mk([56] * 6))['outcome'], 'PASS')
        self.assertEqual(d.outcome(mk([56, 56, 56, 56, 56, 50]))['outcome'], 'FAIL')      # one instance under 51
        self.assertEqual(d.outcome(mk([53] * 6))['outcome'], 'FAIL')                      # 318 pooled, under 320
        self.assertEqual(d.outcome(mk([54, 54, 53, 53, 53, 53]))['outcome'], 'PASS')      # 320 pooled
        self.assertEqual(d.outcome(mk([54, 53, 53, 53, 53, 53]))['outcome'], 'FAIL')      # 319 pooled
        self.assertEqual(d.outcome(mk([56] * 5 + [51]))['outcome'], 'PASS')               # one instance at exactly 51

    def test_scale_boundary(self):
        self.assertAlmostEqual(d.decide(*steps(scale=1500.0))['S'], 1500.0)
        with self.assertRaises(d.Refusal):
            d.decide(*steps(scale=1499.0))

    def test_read_steps_equals_the_frozen_analysis_on_the_pilot(self):
        import json
        root = __file__.rsplit('/work/', 1)[0]
        frozen = [root + '/outputs/felisyn-research/protocol-022/controller', root + '/outputs/felisyn-research/protocol-017/controller']
        res = json.load(open(root + '/outputs/felisyn-research/plaids-022/results/results.json'))
        for run in ('intact', 'lesion'):
            cond, z = d.read_steps(f'{root}/work/controller-022/plaids/pilot/exports/{run}.json.gz', frozen)
            pub = [complex(a, b) for a, b in res['measures'][run]['per_step']['z_D']]
            self.assertEqual(cond, res['sequence']['conditions'])
            self.assertEqual(z, pub)

    def test_frozen_code_pinned(self):
        import hashlib
        root = __file__.rsplit('/work/', 1)[0]
        for name, h in d.FROZEN.items():
            proto, f = name.split('/')
            self.assertEqual(hashlib.sha256(open(f'{root}/outputs/felisyn-research/{proto}/controller/{f}', 'rb').read()).hexdigest(), h)

    def test_noise_changes_little(self):
        r = d.decide(*steps(noise=0.05))
        self.assertGreaterEqual(r['as_intended'], 54)

    def test_declared_exports_complete(self):
        self.assertEqual(sorted(d.DECLARED), ['s10', 's11', 's12', 's13', 's14', 's8'])
        self.assertTrue(all(isinstance(h, str) and len(h) == 64 for h in d.DECLARED.values()))


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