"""Synthetic array-only comparator tests: no backend or scientific inputs."""
from pathlib import Path
import copy
import sys
import unittest

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import compare_timing as compare


def traces(delay, steps, width=3):
    generated = np.arange(steps * width, dtype=np.float32).reshape(steps, width) * np.float32(.125)
    full = np.concatenate((np.zeros((delay, width), dtype=np.float32), generated))
    return generated, full[:steps].copy(), full[steps:].copy()


def sequence_result(generated, applied, pending, delay):
    checks, differences = {}, {}
    compare._timing_sequence_checks(generated, applied, pending, delay, 'test', checks, differences)
    return checks, differences


def metadata_run(delay, steps, cpu=False):
    generated, applied, pending = traces(delay, steps, 4064)
    state = np.tile(np.array([.25, 1.125], np.float32), (steps, 1))
    timing = dict(apl_delay_steps=delay, steps=steps, pending_generated_count=min(steps, delay),
                  generated_rows=steps, applied_generated_rows=max(steps-delay, 0), pending_shape=[delay, 4064],
                  pending_initial_zero_prefix=max(delay-steps, 0),
                  pending_application_tick_start=steps, pending_application_tick_stop_exclusive=steps+delay,
                  pending_generated_tick_start=max(steps-delay, 0), pending_generated_tick_stop_exclusive=steps,
                  pending_raw_sha256=compare.raw_hash(pending, '<f4'),
                  final_apl_state_float32=state[-1].tolist(),
                  final_apl_state_u32_bits=state[-1].view(np.uint32).tolist(), final_apl_state_nonzero=True,
                  brain_tail_advanced=False, future_apl_decay_or_feedback_generated=False,
                  finite_generated_sequence_only=True, closed_loop_branch_integrals_claimed_equal=False,
                  biological_delay_measurement_claimed=False, brain_steps_after_window=0,
                  APL_generation_steps_after_window=0, future_generated_decay_tail_included=False)
    summary = dict(apl_timing=copy.deepcopy(timing), pending_generated_count=min(steps, delay),
                   pending_initial_zero_prefix=max(delay-steps, 0), pending_tail_shape=[delay, 4064],
                   future_generated_decay_tail_included=False, APL_worker_ticks=steps)
    return dict(apl={'inhibition': generated, 'applied': applied, 'state': state}, pending=pending,
                timing=timing, summary=summary)


class TimingComparisonTests(unittest.TestCase):
    def test_delay_zero_and_18_partition(self):
        for delay in (0, 18):
            for steps in (1, 7, 18, 19, 54):
                with self.subTest(delay=delay, steps=steps):
                    checks, differences = sequence_result(*traces(delay, steps), delay)
                    self.assertTrue(all(checks.values()), differences)

    def test_one_tick_shift_rejected_independently(self):
        generated, applied, pending = traces(18, 40)
        applied[18:] = generated[1:23]
        checks, _ = sequence_result(generated, applied, pending, 18)
        self.assertFalse(checks['test.fixed_delay_applied.bitwise_exact'])

    def test_pending_wrong_chronology_rejected(self):
        generated, applied, pending = traces(18, 40)
        checks, _ = sequence_result(generated, applied, pending[::-1].copy(), 18)
        self.assertFalse(checks['test.fixed_delay_pending.bitwise_exact'])

    def test_initial_zero_must_be_positive_bits(self):
        generated, applied, pending = traces(18, 4)
        pending.view(np.uint32)[0, 0] = 0x80000000
        checks, _ = sequence_result(generated, applied, pending, 18)
        self.assertFalse(checks['test.fixed_delay_pending.bitwise_exact'])
        generated, applied, pending = traces(18, 22)
        applied.view(np.uint32)[0, 0] = 0x80000000
        checks, _ = sequence_result(generated, applied, pending, 18)
        self.assertFalse(checks['test.fixed_delay_applied.bitwise_exact'])

    def test_generated_signed_zero_preserved(self):
        generated, applied, pending = traces(0, 1)
        generated.view(np.uint32)[0, 0] = 0x80000000
        applied[:] = generated
        checks, _ = sequence_result(generated, applied, pending, 0)
        self.assertTrue(all(checks.values()))
        applied.view(np.uint32)[0, 0] = 0
        checks, _ = sequence_result(generated, applied, pending, 0)
        self.assertFalse(checks['test.fixed_delay_applied.bitwise_exact'])

    def test_schema_and_delay_fail_closed(self):
        generated, applied, pending = traces(18, 4)
        for delay in (True, 1, 18.0):
            with self.assertRaises(ValueError):
                sequence_result(generated, applied, pending, delay)
        with self.assertRaises(ValueError):
            sequence_result(generated.astype(np.float64), applied, pending, 18)
        with self.assertRaises(ValueError):
            sequence_result(generated, applied, pending[-4:], 18)

    def test_nonfinite_or_negative_generated_fails_even_if_shift_matches(self):
        for value in (np.inf, np.nan, -1):
            generated, applied, pending = traces(0, 2)
            generated[0, 0] = value
            applied[:] = generated
            checks, _ = sequence_result(generated, applied, pending, 0)
            self.assertFalse(checks['test.timing_finite_nonnegative'])

    def test_both_backend_metadata_valid(self):
        for role in ('gpu', 'cpu', 'first_gpu', 'second_gpu'):
            for delay, steps in ((0, 25), (18, 7), (18, 25)):
                run = metadata_run(delay, steps, cpu=role == 'cpu')
                checks = {}
                compare._timing_metadata_checks(run, role, delay, steps, checks)
                self.assertTrue(all(checks.values()), checks)

    def test_metadata_rejects_wrong_count_tail_advance_and_final_state(self):
        for role in ('gpu', 'cpu'):
            for change in ('count', 'tail', 'final', 'prefix', 'hash'):
                run = metadata_run(18, 25, cpu=role == 'cpu')
                if change == 'count':
                    run['timing']['pending_generated_count'] = 17
                elif change == 'tail':
                    run['timing']['brain_steps_after_window' if role == 'cpu' else 'brain_tail_advanced'] = 1
                elif change == 'final':
                    run['timing']['final_apl_state_u32_bits'][0] += 1
                elif change == 'prefix':
                    run['timing']['pending_initial_zero_prefix'] = False
                else:
                    run['timing']['pending_raw_sha256'] = '0' * 64
                checks = {}
                compare._timing_metadata_checks(run, role, 18, 25, checks)
                self.assertFalse(all(checks.values()), (role, change))

    def test_g_write_uses_applied_and_is_unconditional_during_ref(self):
        nodes, kc = np.array([10, 12], np.int32), np.array([10], np.int32)
        v = np.full((3, 2), -.06, np.float64)
        ref = np.array([[22, 0], [21, 0], [20, 0]], np.int32)
        before = np.array([[0, -.001], [-0., .001], [.002, -.003]], np.float64)
        applied = np.array([[.25], [0], [1]], np.float32)
        after = before.copy()
        after[:, 0] -= applied[:, 0].astype(np.float64) * np.float64(.001)
        run = dict(pre={'v': v, 'g': before, 'ref': ref}, histories={'v': v.copy(), 'g': after, 'ref': ref.copy()},
                   apl={'applied': applied, 'inhibition': np.full((3, 1), 99, np.float32)})
        checks, differences = {}, {}
        compare._check_apl_application(run, 'test', nodes, kc, checks, differences)
        self.assertTrue(all(checks.values()), differences)
        run['histories']['g'] = before.copy()  # Hypothetical refractory guard must fail.
        checks, differences = {}, {}
        compare._check_apl_application(run, 'test', nodes, kc, checks, differences)
        self.assertFalse(checks['test.apl_unconditional_g_write.bitwise_exact'])

    def test_pair_comparison_includes_applied_and_pending(self):
        def output():
            generated, applied, pending = traces(18, 20)
            return dict(state={'step': np.empty(0, np.int32), 'neuron_idx': np.empty(0, np.int32),
                               'counts': np.zeros(1, np.int32), 'ref': np.zeros(1, np.int32),
                               'v': np.zeros(1, np.float64), 'g': np.zeros(1, np.float64)},
                        apl={'drive': np.zeros((20, 2), np.float32), 'state': np.zeros((20, 2), np.float32),
                             'inhibition': np.pad(generated, ((0, 0), (0, 4061))),
                             'applied': np.pad(applied, ((0, 0), (0, 4061)))},
                        pending=np.pad(pending, ((0, 0), (0, 4061))),
                        hashes=[], queues=[], requests=[], component={}, histories={}, pre={})
        left, right = output(), output()
        right['apl']['applied'][0, 0] = 1
        right['pending'][0, 0] += 1
        checks, differences = {}, {}
        compare._pair_outputs(left, right, checks, differences, 1, 20, False)
        self.assertFalse(checks['apl.applied.bitwise_exact'])
        self.assertFalse(checks['apl.pending.bitwise_exact'])


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