"""Tests of protocol 025's tools. Light tests read no export; HEAVY=1 adds the lead-in check on the pilot export."""
import gzip, json, os, sys, tempfile, unittest
import numpy as np
sys.dont_write_bytecode = True
import decide_025 as d, compare_025 as c, make_sequence_025 as m

V1 = {0: 0.0, 7.5: 0.35, 15: 0.6, 22.5: 0.8, 30: 1.0}          # a saturating single-signal response


def instance(v_of=None, scale=5000.0, z0=50 + 200j, k=15):
    """Synthetic analysed steps of seed k's declared sequence; default v: winner-take-all with a hold on ties."""
    v_of = v_of or (lambda a, b: 0.0 if a == b else (-V1[a] if a > b else V1[b]) * (0.8 if a and b else 1.0))
    doc = m.build(k)
    cells = [(s['a'], s['b']) for s in doc['steps'][1:]]
    labels = [s['condition'] for s in doc['steps'][1:]]
    z = [z0 - 1j * scale * v_of(a, b) for a, b in cells]
    return cells, labels, z


class Sequence(unittest.TestCase):
    def test_counts_and_rule(self):
        for k in d.SEEDS:
            doc = m.build(k)
            st = doc['steps']
            self.assertEqual(len(st), 113)
            self.assertEqual(st[0]['condition'], 'warm-up')
            labels = [s['condition'] for s in st[1:]]
            self.assertEqual(len(set(labels)), 25)
            self.assertEqual({l: labels.count(l) for l in ('blank', 'A30', 'B30')}, {'blank': 8, 'A30': 8, 'B30': 8})
            self.assertTrue(all(labels.count(l) in (4, 8) for l in set(labels)))
            self.assertFalse(any(labels[i] == labels[i + 1] == labels[i + 2] for i in range(110)))
            self.assertTrue(all(s['contrast'] + s.get('contrast2', 0) <= 60 for s in st))

    def test_declared_files(self):
        import hashlib
        here = os.path.dirname(os.path.abspath(__file__))
        for k, h in d.SEQUENCES.items():
            p = f'{here}/sequences/sequence-025-s{k}.json'
            self.assertEqual(hashlib.sha256(open(p, 'rb').read()).hexdigest(), h)
            self.assertEqual(json.load(open(p)), json.loads(json.dumps(m.build(k))))

    def test_step_encoding(self):
        self.assertEqual(m.step(7.5, 22.5)['contrast2'], 22.5)
        self.assertEqual(m.step(0.0, 15.0)['orientation_rad'], m.B_RAD)
        self.assertNotIn('orientation2_rad', m.step(15.0, 0.0))


class Rule(unittest.TestCase):
    def test_roles(self):
        self.assertEqual(d.role(30, 0), ('calibration', None))
        self.assertEqual(d.role(7.5, 7.5), ('scored', 'hold'))
        self.assertEqual(d.role(22.5, 7.5), ('scored', 'A'))
        self.assertEqual(d.role(0, 15), ('scored', 'B'))
        self.assertEqual(d.role(15, 7.5), ('transition', None))
        self.assertEqual(d.role(7.5, 0), ('transition', None))

    def test_clean_instance(self):
        r = d.decide(*instance())
        self.assertEqual((r['as_intended'], r['of']), (56, 56))
        self.assertAlmostEqual(r['S'], 5000.0)
        self.assertEqual(r['cells']['A22.5+B7.5']['actions'], {'A': 4, 'hold': 0, 'B': 0})
        self.assertEqual(r['cells']['A7.5+B30']['actions'], {'A': 0, 'hold': 0, 'B': 4})

    def test_relay_circuit_loses_steps(self):
        sat = {0: 0.0, 7.5: 0.6, 15: 0.8, 22.5: 0.9, 30: 1.0}        # strongly saturating singles, plainly added
        r = d.decide(*instance(lambda a, b: sat[b] - sat[a]))
        self.assertEqual(r['cells']['A30+B15']['actions']['hold'], 4)   # -0.2: a relay holds where A should win
        self.assertEqual(r['cells']['A22.5+B7.5']['actions']['hold'], 4)   # -0.3: holds
        self.assertEqual(r['cells']['A30+B7.5']['actions']['A'], 4)     # -0.4: acts
        self.assertEqual(r['as_intended'], 56 - 16)

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

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

    def test_thresholds(self):
        self.assertEqual([d.action(x) for x in (0.33, 0.32, -0.32, -0.33)], ['B', 'hold', 'hold', 'A'])

    def test_outcome(self):
        mk = lambda hits: {f's{15 + i}': {'as_intended': h} for i, h in enumerate(hits)}
        self.assertEqual(d.outcome(mk([56, 56, 56]))['outcome'], 'PASS')
        self.assertEqual(d.outcome(mk([56, 56, 50]))['outcome'], 'FAIL')
        self.assertEqual(d.outcome(mk([56, 53, 51]))['outcome'], 'PASS')      # 160
        self.assertEqual(d.outcome(mk([56, 52, 51]))['outcome'], 'FAIL')      # 159
        self.assertEqual(d.outcome(mk([56, 56]))['outcome'], 'FAIL')          # two instances are not three

    def test_relay_reported_for_two_signal_cells(self):
        r = d.decide(*instance())
        self.assertEqual(len(r['relay_rule']), 16)
        self.assertAlmostEqual(r['relay_rule']['A15+B30']['v_relay'], 0.4)


class Compare(unittest.TestCase):
    def export(self, tmp, name, run, t=1.0, spike=10.0):
        ex = {'run_seconds': t, 'argv': ['nest', '4', 'pynn_seed', '15', run], 'resolved': {'pynn_seed': 15},
              'segments': [{'sheet': 'X', 'stimulus': {}, 'spikes': {'1': [1.0, spike], '2': []}}]}
        p = os.path.join(tmp, name)
        with gzip.open(p, 'wt') as f:
            json.dump(ex, f)
        return p

    def test_agree_and_disagree(self):
        with tempfile.TemporaryDirectory() as tmp:
            a = self.export(tmp, 'a.json.gz', 'm25-s15-a1', 1.0)
            b = self.export(tmp, 'b.json.gz', 'm25-s15-a2', 2.0)
            x = self.export(tmp, 'x.json.gz', 'm25-s15-a3', 2.0, spike=10.01)
            same = self.export(tmp, 's.json.gz', 'm25-s15-a1', 3.0)
            self.assertTrue(c.compare(a, b)['agree'])
            r = c.compare(a, x)
            self.assertFalse(r['agree'])
            self.assertEqual(r['first_difference']['at'], '/segments/0/spikes/1/1')
            self.assertFalse(c.compare(a, same)['agree'])             # the same run name is never a pair


class Leadin(unittest.TestCase):
    def test_reference_hash(self):
        import hashlib
        root = __file__.rsplit('/work/', 1)[0] if '/work/' in __file__ else os.getcwd().rsplit('/work/', 1)[0]
        self.assertEqual(hashlib.sha256(open(f'{root}/{d.LEADIN[0]}', 'rb').read()).hexdigest(), d.LEADIN[1])

    @unittest.skipUnless(os.environ.get('HEAVY'), 'reads the pilot export')
    def test_pilot_matches_and_a_changed_train_is_caught(self):
        root = os.path.abspath(__file__).rsplit('/work/', 1)[0]
        ref = json.load(open(f'{root}/{d.LEADIN[0]}'))
        ex = json.load(gzip.open(f'{root}/work/controller-022/plaids/pilot/exports/intact.json.gz', 'rt'))
        self.assertIsNone(d.leadin_problem(ex, ref))
        seg = next(s for s in ex['segments'] if s['sheet'] == 'X_OFF' and 'sequence' in s['stimulus'])
        i = next(i for i, t in seg['spikes'].items() if t and float(t[0]) < 504)
        seg['spikes'][i] = [float(seg['spikes'][i][0]) + 0.01] + list(seg['spikes'][i][1:])
        self.assertIn('lead-in trains identical', d.leadin_problem(ex, ref))


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