import unittest
import torch
from stqd_model import STQDNet, VARIANTS


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

    def make(self, b=2):
        torch.manual_seed(101)
        x=torch.randn(b,320,58)
        s=torch.randn(b,320,2,3)
        s[:,:,1,2]=-s[:,:,0,2]
        return x,s

    def test_all_variants_and_swap(self):
        x,s=self.make()
        for name in VARIANTS:
            with self.subTest(name=name):
                net=STQDNet(name)
                net.eval()
                y=net(x,s)
                swapped=net(x,s.flip(2))
                self.assertEqual(tuple(y.shape),(2,))
                self.assertTrue(torch.allclose(y, -swapped,atol=1e-6,rtol=1e-5))
                self.assertTrue(torch.isfinite(y).all())

    def test_differentiable(self):
        x,s=self.make()
        net=STQDNet()
        y=net(x,s)
        loss=torch.nn.functional.binary_cross_entropy_with_logits(y,torch.tensor([1.,0.]))
        loss.backward()
        self.assertIsNotNone(net.cross.q.weight.grad)
        self.assertIsNotNone(net.eeg.inp[0].weight.grad)
        self.assertIsNotNone(net.speech.parts[0][0].weight.grad)
        self.assertTrue(torch.isfinite(net.cross.q.weight.grad).all())

    def test_spatial_and_speech_shapes(self):
        x,s=self.make()
        model=STQDNet()
        with torch.no_grad():
            e=model.eeg(x)
            a=model.speech(s)
            z=model.cross(a,e)
        self.assertEqual(tuple(e.shape),(2,80,64))
        self.assertEqual(tuple(a.shape),(2,2,80,64))
        self.assertEqual(tuple(z.shape),(2,2,80,64))
        self.assertEqual(model.readout,72)

    def test_no_lookahead_outside_window(self):
        # The model consumes only its supplied window, and produces a single target-index logit.
        # This is not a substitute for a full preprocessing/export leakage audit.
        model=STQDNet()
        x,s=self.make(1)
        self.assertEqual(model.window,320)
        self.assertEqual(model.readout,72)
        with self.assertRaises(ValueError):
            model(x[:,:-1],s)


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