import unittest
import torch
from s34_model import IPMVCL, parameter_count, matched_width


class ModelTests(unittest.TestCase):
    def test_unknown_interaction_is_rejected(self):
        m = IPMVCL(3, dict(student=[0], course=[1], history=[2]), "A2",
                    dict(backbone_width=8, view_dim=4, interaction_rank=3))
        with self.assertRaises(ValueError):
            m(torch.ones(2, 3), zero_interactions=("unknown",))

    def test_shapes_finite_gradients_and_matching(self):
        views = dict(student=[0, 1], course=[2, 3], history=[4, 5])
        cfg = dict(backbone_width=16, residual_blocks=1, view_dim=8,
                   interaction_rank=4, dropout=0.0)
        counts = {}
        for arm in ["A0", "A0M", "A1", "A2", "P1", "A3"]:
            c = dict(cfg)
            if arm == "A0M":
                c["matched_width"] = matched_width(8, views, cfg)
            torch.manual_seed(29)
            m = IPMVCL(8, views, arm, c)
            x = torch.randn(5, 8, requires_grad=True)
            logit, details = m(x, return_details=True)
            self.assertEqual(logit.shape, (5,))
            loss = logit.square().mean()
            if arm == "A3":
                loss += sum(v.square().mean() for v in details["aux"].values())
            loss.backward()
            self.assertTrue(torch.isfinite(x.grad).all())
            self.assertGreater(x.grad[:, 7].abs().sum().item(), 0)
            self.assertTrue(all(torch.isfinite(p.grad).all() for p in m.parameters() if p.grad is not None))
            if arm in ["A2", "P1", "A3"]:
                self.assertGreater(m.projections["student"].weight.grad.abs().sum().item(), 0)
            if arm == "A3":
                self.assertTrue(all(h.weight.grad is not None for h in m.aux_heads.values()))
            counts[arm] = parameter_count(m)
        self.assertEqual(counts["A1"], counts["A2"])
        self.assertEqual(counts["P1"], counts["A2"])
        self.assertLess(abs(counts["A0M"]/counts["A2"]-1), .05)

    def test_additive_and_multiplicative_initial_weights_identical(self):
        v = dict(student=[0], course=[1], history=[2])
        cfg = dict(backbone_width=8, residual_blocks=1, view_dim=4, interaction_rank=3, dropout=0)
        torch.manual_seed(7)
        a = IPMVCL(3, v, "A1", cfg)
        torch.manual_seed(7)
        b = IPMVCL(3, v, "A2", cfg)
        self.assertTrue(all(torch.equal(a.state_dict()[k], b.state_dict()[k]) for k in a.state_dict()))
        z = torch.randn(6, 3)
        self.assertFalse(torch.equal(a(z), b(z)))
