import unittest

import torch

from pace.models import HistoryEncoder, MaskedEventModel


def history_fixture(n=3):
    torch.manual_seed(7)
    event_mask = torch.ones(n, 3, 4, dtype=torch.bool)
    event_mask[-1] = False
    return {
        "course": torch.where(event_mask, torch.randint(3, 9, (n, 3, 4)), 0),
        "grade_band": torch.where(event_mask, torch.randint(3, 8, (n, 3, 4)), 0),
        "numeric": torch.rand(n, 3, 4, 3) * event_mask.unsqueeze(-1),
        "event_mask": event_mask,
        "semester_mask": event_mask.any(-1),
        "gaps": torch.arange(3).float().expand(n, -1).clone(),
    }


class HistoryEncoderTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        torch.set_num_threads(1)

    def test_events_are_permutation_invariant_in_every_architecture(self):
        batch = history_fixture()
        order = torch.tensor([2, 0, 3, 1])
        reordered = {
            k: (v[:, :, order] if k in {"course", "grade_band", "numeric", "event_mask"} else v)
            for k, v in batch.items()
        }
        for arch in ("mlp", "gru", "transformer"):
            with self.subTest(arch=arch):
                model = HistoryEncoder(9, arch, dim=16, heads=4, dropout=0).eval()
                torch.testing.assert_close(model(batch), model(reordered), atol=1e-6, rtol=1e-5)

    def test_mlp_history_is_invariant_to_semester_order(self):
        batch = history_fixture()
        permuted = {k: v[:, [2, 0, 1]] for k, v in batch.items()}
        encoder = HistoryEncoder(9, "mlp", dim=16, dropout=0).eval()
        torch.testing.assert_close(encoder(batch), encoder(permuted), atol=1e-6, rtol=1e-5)

    def test_transformer_context_cannot_see_future_semesters(self):
        batch = history_fixture()
        changed = {k: v.clone() for k, v in batch.items()}
        changed["course"][:, 2] = 3
        changed["grade_band"][:, 2] = 3
        changed["numeric"][:, 2] = 999
        encoder = HistoryEncoder(9, "transformer", dim=16, heads=4, dropout=0).eval()
        _, old_context = encoder.encode_events(batch)
        _, new_context = encoder.encode_events(changed)
        torch.testing.assert_close(old_context[:, :2], new_context[:, :2], atol=1e-6, rtol=1e-5)

    def test_empty_history_is_finite_and_learned_with_gradients(self):
        batch = history_fixture(2)
        for arch in ("mlp", "gru", "transformer"):
            with self.subTest(arch=arch):
                encoder = HistoryEncoder(9, arch, dim=16, heads=4, dropout=0)
                output = encoder(batch)
                self.assertEqual(tuple(output.shape), (2, 16))
                self.assertTrue(torch.isfinite(output).all())
                output[-1].sum().backward()
                self.assertIsNotNone(encoder.empty_history.grad)
                self.assertGreater(encoder.empty_history.grad.abs().sum().item(), 0)

    def test_zero_length_history_axis_is_supported(self):
        batch = history_fixture()
        batch = {k: v[:, :0] for k, v in batch.items()}
        for arch in ("mlp", "gru", "transformer"):
            encoder = HistoryEncoder(9, arch, dim=16, heads=4, dropout=0)
            self.assertTrue(torch.isfinite(encoder(batch)).all())

    def test_gru_sees_calendar_gaps_but_mlp_ignores_them(self):
        batch = history_fixture()
        changed = {k: v.clone() for k, v in batch.items()}
        changed["gaps"][:, 1:] += 5
        for arch in ("mlp", "gru"):
            encoder = HistoryEncoder(9, arch, dim=16, dropout=0).eval()
            if arch == "mlp":
                torch.testing.assert_close(encoder(batch), encoder(changed), atol=0, rtol=0)
            else:
                self.assertGreater((encoder(batch) - encoder(changed)).abs().max().item(), 1e-5)

    def test_ssl_heads_project_only_selected_tokens_and_skip_inactive_course_head(self):
        batch = history_fixture()
        model = MaskedEventModel(HistoryEncoder(10000, "mlp", dim=8, dropout=0)).eval()
        grade_mask = torch.zeros_like(batch["event_mask"])
        course_mask = torch.zeros_like(grade_mask)
        grade_mask[0, 0, 0] = True
        projected = []
        grade_hook = model.grade_head.register_forward_pre_hook(lambda _, args: projected.append(args[0].shape[0]))
        course_hook = model.course_head.register_forward_pre_hook(lambda _, args: self.fail("inactive course head executed"))
        output = model(batch, grade_mask=grade_mask, course_mask=course_mask)
        self.assertEqual(output["grade"].shape, (1, 5))
        self.assertEqual(output["course"].shape, (0, 9997))
        self.assertEqual(projected, [1])
        grade_hook.remove()
        course_hook.remove()


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