import unittest
import torch
from stqd_model import STQDNet, VARIANTS

class ModelTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        torch.set_num_threads(2)

    @staticmethod
    def data(batch=2):
        torch.manual_seed(123)
        X=torch.randn(batch,320,58)
        S=torch.randn(batch,320,2,3)
        S[:,:,1,2]=-S[:,:,0,2]    # relative dominance convention
        return X,S

    def test_shapes_swaps_and_time(self):
        X,S=self.data()
        self.assertEqual(set(VARIANTS),{'v2_full','v2_cosine','v2_no_time_bias','v2_cbramod_full','v2_cbramod_cosine'})
        for variant in VARIANTS:
            with self.subTest(variant=variant):
                net=STQDNet(variant)
                net.eval()
                with torch.no_grad():
                    mem=net.eeg(X)
                    speech=net.speech(S)
                    logit=net(X,S)
                    swap=net(X,S.flip(2))
                self.assertEqual(tuple(mem.shape),(2,80,64))
                self.assertEqual(tuple(speech.shape),(2,2,80,64))
                self.assertEqual(tuple(logit.shape),(2,))
                self.assertEqual(net.readout,72)
                self.assertTrue(torch.isfinite(logit).all())
                self.assertTrue(torch.allclose(logit,-swap,atol=1e-5,rtol=1e-5))

    def test_vlaai_backbone_and_gradients(self):
        X,S=self.data()
        net=STQDNet('v2_full')
        self.assertEqual(net.eeg.backbone.nb_blocks,3)
        z=net(X,S)
        loss=torch.nn.functional.binary_cross_entropy_with_logits(z,torch.tensor([1.,0.]))
        loss.backward()
        for p in [net.eeg.backbone.proj.weight,net.eeg.backbone.block[3].weight,
                  net.speech.parts[0][0].weight,net.cross.q.weight]:
            self.assertIsNotNone(p.grad)
            self.assertTrue(torch.isfinite(p.grad).all())

    def test_bad_window(self):
        X,S=self.data(1)
        net=STQDNet()
        with self.assertRaises(ValueError):net(X[:,:-1],S)

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