import unittest
from types import SimpleNamespace
import numpy as np
import pandas as pd
import torch
from suite30_model import (JointPortfolioRisk,poisson_binomial_pmf,
                           objective,joint_log_prob)
from suite30_data import (build_groups,EnrollmentDataset,collate_groups,
                          matched_peer_placebo,global_chronological_split)
from suite30_utils import count_binary_failures,validate_suite29_reference

class Suite30ModelTests(unittest.TestCase):
    def setUp(self):
        torch.manual_seed(7)
        self.net=JointPortfolioRisk(25,3,width=32,heads=4,dropout=0.).eval()
        self.x=torch.randn(3,5,25)
        self.valid=torch.tensor([[1,1,1,1,0],[1,1,1,1,1],[1,0,0,0,0]],dtype=torch.bool)
        self.faculty=torch.zeros(3,5,dtype=torch.long)
        self.time=torch.zeros(3,5)
    def forward(self,mode="joint"):
        return self.net(self.x,self.valid,self.faculty,self.time,mode=mode)
    def test_permutation_equivariance(self):
        perm=torch.tensor([2,0,4,1,3])
        inv=torch.argsort(perm)
        with torch.no_grad():
            original=self.forward()["prob"]
            shuffled=self.net(self.x[:,perm],self.valid[:,perm],
                  self.faculty[:,perm],self.time[:,perm])["prob"][:,inv]
        self.assertTrue(torch.allclose(original[self.valid],shuffled[self.valid],atol=1e-6))
    def test_padding_invariance(self):
        with torch.no_grad():
            baseline=self.forward()
            new=self.net(torch.cat([self.x,torch.randn(3,3,25)],1),
                torch.cat([self.valid,torch.zeros(3,3,dtype=torch.bool)],1),
                torch.cat([self.faculty,torch.zeros(3,3,dtype=torch.long)],1),
                torch.cat([self.time,torch.zeros(3,3)],1))
        self.assertTrue(torch.allclose(baseline["prob"][self.valid],
                                      new["prob"][:,:5][self.valid],atol=1e-6))
    def test_singleton_peer_zero(self):
        with torch.no_grad():r=self.forward()
        self.assertAlmostEqual(float(r["peer_mass"][-1,0]),0.)
        self.assertAlmostEqual(float(r["peer_gate"][-1,0]),0.)
    def test_pmf_normalized_and_expected_count(self):
        with torch.no_grad():r=self.forward()
        self.assertTrue(torch.allclose(r["count_pmf"].sum(1),torch.ones(3),atol=1e-6))
        count=(r["count_pmf"]*torch.arange(6)[None]).sum(1)
        self.assertTrue(torch.allclose(count,r["expected_count"],atol=1e-5))
    def test_joint_nontrivial_positive_dependence(self):
        with torch.no_grad():r=self.forward()
        p0,p1=r["p_low"][0,:2],r["p_high"][0,:2]
        pi=r["mixture"][0]
        cov=pi*(1-pi)*(p1[0]-p0[0])*(p1[1]-p0[1])
        self.assertGreater(float(cov),0.)
    def test_masked_pmf_matches_independent(self):
        x=torch.tensor([[.1,.2,.9]])
        mask=torch.tensor([[True,True,False]])
        out=poisson_binomial_pmf(x,mask)
        self.assertTrue(torch.allclose(out,torch.tensor([[.72,.26,.02,0.]]),atol=1e-6))
    def test_marginal_consistency(self):
        with torch.no_grad():r=self.forward()
        pi=r["mixture"][:,None]
        p=(1-pi)*r["p_low"]+pi*r["p_high"]
        self.assertTrue(torch.allclose(p,r["prob"]))
    def test_gradients_joint_and_peer(self):
        self.net.train()
        r=self.forward()
        y=torch.tensor([[0,1,0,0,0],[0,0,1,0,0],[1,0,0,0,0]]).float()
        loss=objective(r,y,self.valid,self.time,0,epoch=3,
                       warmup_epochs=0,ramp_epochs=2)
        loss["total"].backward()
        self.assertGreater(float(self.net.state_head.weight.grad.abs().sum()),0.)
        self.assertGreater(float(self.net.peer_effect[-1].weight.grad.abs().sum()),0.)
    def test_no_context_equals_course_only(self):
        with torch.no_grad():
            r=self.net(self.x,self.valid,self.faculty,self.time,mode="joint",
                        intervention="no_context")["prob"]
            course=self.forward("course_only")["prob"]
        self.assertTrue(torch.allclose(r[ self.valid],course[self.valid],atol=1e-7))
    def test_placebo_no_labels_passed_forward(self):
        with torch.no_grad():
            z=torch.randn(3,5,17)
            out=self.net(self.x,self.valid,self.faculty,self.time,
                         intervention="placebo",context_override=z)
        self.assertTrue(torch.isfinite(out["prob"][self.valid]).all())

    def test_calibration_keeps_joint_probabilities_coherent(self):
        with torch.no_grad():
            cal=torch.full((3,5),-.7)
            r=self.net(self.x,self.valid,self.faculty,self.time,
                       calibration_bias=cal)
        self.assertTrue(torch.allclose(r["count_pmf"].sum(1),
                                       torch.ones(3),atol=1e-6))
        expected=(r["prob"]*self.valid).sum(1)
        self.assertTrue(torch.allclose(r["expected_count"],expected))
    def test_historical_intercept_uses_only_supplied_history_rows(self):
        from train_suite30 import fit_historical_calibration
        n=120
        p0=np.full(n,.10,np.float32)
        p1=np.full(n,.25,np.float32)
        mix=np.full(n,.15,np.float32)
        rng=np.random.default_rng(7)
        y=(rng.random(n)<.05).astype(np.int8)
        b=SimpleNamespace(y=y,faculty_idx=np.zeros(n,np.int16),
                          faculty_names=["faculty_a"])
        aux={"p_low":p0,"p_high":p1,"mixture":mix}
        scores=(1-mix)*p0+mix*p1
        mask=np.ones(n,bool)
        biases,rows=fit_historical_calibration(b,scores,aux,mask,1,29,
                                                 "joint",1000)
        self.assertEqual(len(rows),1)
        self.assertLess(float(biases[0]),0.)

    def test_unsupported_and_empty(self):
        with self.assertRaises(ValueError):
            self.net(self.x,self.valid,self.faculty,self.time,intervention="placebo")
        with self.assertRaises(ValueError):
            self.net(self.x,torch.zeros_like(self.valid),self.faculty,self.time)
    def test_invalid_binary_labels(self):
        r=self.forward()
        y=torch.zeros(3,5);y[0,0]=2
        with self.assertRaises(ValueError):
            objective(r,y,self.valid,self.time,0,epoch=2)

class Suite30DataTests(unittest.TestCase):
    def sample(self):
        ids=np.array(["a","a","b","b","c","c","d","d"])
        sem=np.array([6066]*8,dtype=np.float32)
        fac=np.zeros(8,np.int16)
        current=np.arange(8*25,dtype=np.float32).reshape(8,25)
        return SimpleNamespace(y=np.array([0,1,0,0,0,0,0,1],np.int8),
          current=current,student_id=ids,target_semester=sem,
          semester_ordinal=sem,faculty_idx=fac,
          faculty_names=["faculty_0"],semester_z=np.zeros(8,np.float32))
    def test_grouping(self):
        b=self.sample()
        groups=build_groups(b)
        self.assertEqual([len(g) for g in groups],[2,2,2,2])
    def test_matched_peer_placebo(self):
        b=self.sample()
        context,coverage=matched_peer_placebo(b,42)
        self.assertEqual(coverage["matched_groups"],4)
        self.assertEqual(coverage["matched_rows"],8)
        self.assertTrue(any(np.any(context[i]!=b.current[i,-17:]) for i in range(8)))
    def test_exact_calendar_cutoff(self):
        b=self.sample()
        b.semester_ordinal=np.array([6060,6060,6060,6060,6061,6061,6061,6061],
                                     np.float32)
        tr,va,_=global_chronological_split(b,1)
        self.assertEqual(int(tr.sum()),4)
        self.assertEqual(int(va.sum()),4)
    def test_reject_bad_row_alignment(self):
        b=self.sample()
        b.course_id=np.array(["c1","c2","c3","c4","c5","c6","c7","c8"])
        b.row_index=np.arange(8)
        df=pd.DataFrame(dict(faculty=["faculty_0"]*8,student_id=b.student_id,
          course_id=b.course_id,semester=b.target_semester,
          row_index=b.row_index,actual=b.y))
        validate_suite29_reference(df,b,1,29)
        df.loc[1,"course_id"]="WRONG"
        with self.assertRaises(ValueError):
            validate_suite29_reference(df,b,1,29)
    def test_binary_count_int8_no_overflow(self):
        self.assertEqual(count_binary_failures(np.ones(270,np.int8)),270)

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