import sys,unittest
from pathlib import Path
import numpy as np
import torch
sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
from suite29_model import EnrollmentSetNet,masked_bce
from suite29_data import EnrollmentDataset,collate_groups,global_chronological_split
from suite25_data import RetrievalBundle

class Suite29Tests(unittest.TestCase):
    def setUp(self):
        torch.manual_seed(29)
        self.net=EnrollmentSetNet(5,2,width=32,heads=4,dropout=0.).eval()
        self.x=torch.randn(2,4,5)
        self.mask=torch.tensor([[1,1,1,0],[1,1,0,0]],dtype=torch.bool)
        self.fac=torch.zeros(2,4,dtype=torch.long)
        self.sem=torch.zeros(2,4)
    def predict(self,x=None,mask=None,mode="set"):
        return self.net(self.x if x is None else x,self.mask if mask is None else mask,
                        self.fac,self.sem,mode)
    def test_permutation_equivariance(self):
        perm=torch.tensor([2,0,3,1])
        with torch.no_grad():
            a=self.predict()
            b=self.net(self.x[:,perm],self.mask[:,perm],self.fac[:,perm],self.sem[:,perm],"set")
        self.assertTrue(torch.allclose(a[:,perm],b,atol=1e-5))
    def test_padding_invariance(self):
        altered=self.x.clone();altered[~self.mask]=1000
        with torch.no_grad(): a=self.predict();b=self.predict(x=altered)
        self.assertTrue(torch.allclose(a[self.mask],b[self.mask],atol=1e-5))
    def test_singleton_equivalence(self):
        m=torch.tensor([[1,0,0,0],[1,0,0,0]],dtype=torch.bool)
        with torch.no_grad():a=self.predict(mask=m);b=self.predict(mask=m,mode="self_only")
        self.assertTrue(torch.allclose(a[m],b[m],atol=1e-6))
    def test_self_only_independent_of_peers(self):
        altered=self.x.clone();altered[:,1:,:]=altered[:,1:,:]*100
        with torch.no_grad():
            a=self.predict(mode="self_only");b=self.predict(x=altered,mode="self_only")
        self.assertTrue(torch.allclose(a[:,0],b[:,0],atol=1e-6))
    def test_peer_attention_nonzero(self):
        with torch.no_grad():
            _,a=self.net(self.x,self.mask,self.fac,self.sem,"set",True)
            _,b=self.net(self.x,self.mask,self.fac,self.sem,"self_only",True)
        self.assertGreater(a["peer_mass"].item(),0)
        self.assertEqual(b["peer_mass"].item(),0.)
    def test_gradients(self):
        self.net.train()
        y=torch.randint(0,2,(2,4)).float()
        for mode in ("self_only","set"):
            self.net.zero_grad()
            loss=masked_bce(self.predict(mode=mode),y,self.mask)
            loss.backward()
            self.assertTrue(torch.isfinite(loss))
            self.assertIsNotNone(self.net.qkv.weight.grad)
    def test_grouping_identity(self):
        ids=np.array(["s1","s1","s1","s2","s2","s1"])
        semester=np.array([20251,20251,20252,20251,20251,20251],float)
        fac=np.array([0,0,0,0,0,1])
        n=len(ids)
        b=RetrievalBundle(np.zeros((n,5),np.float32),np.zeros(n),np.zeros(n),
           fac,np.zeros(n),semester,np.zeros(n),semester,ids,np.array(list("abcdef")),
           np.arange(n),["a","b"])
        ds=EnrollmentDataset(b)
        self.assertEqual(sorted(len(g) for g in ds.groups),[1,1,2,2])
        bt=collate_groups([ds[0],ds[1]])
        self.assertEqual(bt["valid"].sum().item(),3)

    def test_cross_faculty_temporal_cutoff(self):
        # Old per-faculty splits can validate faculty A at 20222 while
        # training on faculty B outcomes at 20223. One shared cutoff cannot.
        n=6
        sem=np.array([20221,20222,20221,20223,20221,20223],float)
        from suite25_common import semester_ordinal
        ords=np.array([semester_ordinal(v) for v in sem],float)
        faculties=np.array([0,0,1,1,0,1])
        bundle=RetrievalBundle(np.zeros((n,5),np.float32),np.zeros(n),np.zeros(n),
          faculties,np.zeros(n),ords,np.zeros(n),sem,np.array([f's{i}' for i in range(n)]),
          np.array(list('abcdef')),np.arange(n),['a','b'])
        tr,va,info=global_chronological_split(bundle,2)
        self.assertLess(np.max(ords[tr]),np.min(ords[va]))
        self.assertEqual(set(sem[va]),{20222,20223})
        self.assertEqual(info['train_rows'],3)

    def test_global_split_requires_history(self):
        sem=np.array([20221,20221],float)
        bundle=RetrievalBundle(np.zeros((2,5),np.float32),np.zeros(2),np.zeros(2),
          np.array([0,1]),np.zeros(2),sem,np.zeros(2),sem,np.array(['a','b']),
          np.array(['x','y']),np.arange(2),['a','b'])
        with self.assertRaises(ValueError):global_chronological_split(bundle,3)

    def test_stratified_attention_sums(self):
        from train_suite29 import attention_strata
        n=4;ids=np.array(['s1','s1','s2','s2'])
        sem=np.full(n,20221.,float)
        bundle=RetrievalBundle(np.zeros((n,5),np.float32),np.array([0,1,1,0]),
          np.zeros(n),np.zeros(n,int),np.zeros(n),sem,np.zeros(n),sem,
          ids,np.array(list('abcd')),np.arange(n),['a'])
        att={'_per_row':{'self':np.full(n,.2), 'peer':np.full(n,.5), 'null':np.full(n,.3)}}
        rows=attention_strata(bundle,att,1,29,'suite29_set')
        self.assertEqual(sum(r['rows'] for r in rows),n)
        self.assertTrue(all(r['size_bin']=='2-3' for r in rows))
        self.assertTrue(all(abs(r['mean_self_mass']+r['mean_peer_mass']+
            r['mean_null_mass']-1)<1e-6 for r in rows))

    def test_group_batch_consistency(self):
        # Individual group predictions match predictions with other groups
        # in a padded batch, regardless of unequal course counts.
        self.net.eval()
        with torch.no_grad():
            joint=self.predict()
            for j in range(2):
                n=int(self.mask[j].sum())
                single=self.net(self.x[j:j+1,:n],self.mask[j:j+1,:n],
                   self.fac[j:j+1,:n],self.sem[j:j+1,:n],'set')
                self.assertTrue(torch.allclose(joint[j,:n],single[0],atol=1e-5))

    def test_history_group_partial_coverage_detected(self):
        import tempfile
        import joblib
        import pandas as pd
        from train_suite29 import audit_history_group_completeness
        with tempfile.TemporaryDirectory() as td:
            joblib.dump(dict(
                train_frame=pd.DataFrame({'IDSV':['a','a','b','b'],
                                          'target_NHHK':[20221]*4}),
                cf_covered_mask=np.array([1,0,1,1],dtype=bool),
                cf_probabilities=np.full((4,2),.2)),
                Path(td)/'faculty_a_fold_1.joblib')
            report=audit_history_group_completeness(td,['faculty_a'],1)[0]
            self.assertEqual(report['partial_groups'],1)
            self.assertEqual(report['rows_in_partial_groups'],1)
            with self.assertRaises(ValueError):
                audit_history_group_completeness(td,['faculty_a'],1,strict=True)

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