import sys,tempfile,unittest
from pathlib import Path
import numpy as np,pandas as pd,joblib
sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
sys.path.insert(0,str(Path(__file__).resolve().parent))
from make_synthetic import create,FACULTIES
from s32_data import load_fold,frame_matrix,feature_schema,semester_ordinal
from s32_model import fit_weighted,predict
from s32_policy import candidate_policy,trial_origins,language_donors,select_final
from s32_metrics import score,at_rate,paired

class Suite32Tests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.tmp=tempfile.TemporaryDirectory(prefix='aq_s32_')
        cls.cache,cls.struct=create(cls.tmp.name)
        cls.data=load_fold(cls.cache,cls.struct,FACULTIES,1)
    @classmethod
    def tearDownClass(cls):cls.tmp.cleanup()

    def test_semester_and_feature_count(self):
        self.assertLess(semester_ordinal(20231),semester_ordinal(20232))
        self.assertEqual(len(self.data.common_names),8)
        t=FACULTIES[0];matrix,names=feature_schema(self.data,t,'native')
        self.assertEqual(len(names),8+17+3)
        self.assertTrue(np.isnan(matrix(self.data.history[FACULTIES[1]])[:,-3:]).all())
        self.assertTrue(np.isfinite(matrix(self.data.history[t])[:,-3:]).all())

    def test_missing_indicator_is_not_zero_indicator(self):
        t=FACULTIES[0];m1,_=feature_schema(self.data,t,'common',True,'observed')
        m2,_=feature_schema(self.data,t,'common',True,'naive_zero')
        x=m1(self.data.history[t]);z=m2(self.data.history[t])
        self.assertFalse(np.array_equal(x[:,25:],z[:,25:]))
        self.assertEqual(x.shape,z.shape)

    def test_future_history_fails_globally(self):
        f=FACULTIES[1];p=Path(self.cache)/f'{f}_fold_1.joblib'
        original=joblib.load(p)
        try:
            broken=joblib.load(p);broken['train_frame'].loc[0,'target_NHHK']=20241
            joblib.dump(broken,p)
            with self.assertRaises(ValueError):load_fold(self.cache,self.struct,FACULTIES,1)
        finally:joblib.dump(original,p)

    def test_structured_index_mismatch_fails(self):
        f=FACULTIES[0];p=Path(self.struct)/f'{f}_fold_1.joblib';original=joblib.load(p)
        try:
            bad=joblib.load(p);bad['train_row_index']=bad['train_row_index'][::-1];joblib.dump(bad,p)
            with self.assertRaises(ValueError):load_fold(self.cache,self.struct,FACULTIES,1)
        finally:joblib.dump(original,p)

    def test_learners_and_source_mass(self):
        target=FACULTIES[0];origin=semester_ordinal(20231)
        m,fn,d=fit_weighted(self.data,target,origin,[(FACULTIES[1],2.),(FACULTIES[2],1.)],rho=.25,
             representation='native',max_donor_rows=40,max_iter=5,min_samples_leaf=5)
        self.assertAlmostEqual(sum(d['source_mass'].values()),1.)
        self.assertAlmostEqual(d['source_mass'][target],.75)
        self.assertLessEqual(d['n_donor'],80)
        self.assertLess(d['positive_weight_ess'],d['weight_ess'])
        p=predict(m,fn,self.data.target[target]);self.assertEqual(len(p),len(self.data.target[target]))
        self.assertTrue(((p>=0)&(p<=1)).all())

    def test_policy_no_oracle_and_faculty_language(self):
        t=FACULTIES[0];z=pd.DataFrame([
          {'target':t,'source':FACULTIES[1],'origin':1,'delta_ap':.02},
          {'target':t,'source':FACULTIES[1],'origin':2,'delta_ap':.03},
          {'target':t,'source':FACULTIES[2],'origin':1,'delta_ap':-.01},
          {'target':t,'source':FACULTIES[2],'origin':2,'delta_ap':-.02}])
        self.assertEqual(candidate_policy(z,t,[1,2],max_donors=2)[0][0],FACULTIES[1])
        self.assertEqual(candidate_policy(z,t,[1]),[])
        self.assertEqual(language_donors(FACULTIES[1],FACULTIES),[FACULTIES[2]])

    def test_admission_uses_historical_replay(self):
        from types import SimpleNamespace
        t=FACULTIES[0]
        z=pd.DataFrame([{'target':t,'source':FACULTIES[1], 'origin':u,'delta_ap':.02} for u in (1,2,3,4)])
        cfg=SimpleNamespace(min_origins=3,min_delta=.001,min_win_rate=.5,max_selected=2,
                            min_replays=1,min_replay_delta=0.,max_replay_harm=.01)
        good=pd.DataFrame({'delta_ap':[.02,.01]})
        self.assertEqual(select_final(self.data,t,z,[1,2,3,4],good,cfg)[0][0][0],FACULTIES[1])
        bad=pd.DataFrame({'delta_ap':[-.02]})
        self.assertEqual(select_final(self.data,t,z,[1,2,3,4],bad,cfg)[0],[])

    def test_scoring_and_paired(self):
        y=np.array([0,0,1,0,1]);p=np.array([.1,.2,.8,.4,.9])
        v=score(y,p);self.assertGreater(v['ap'],.9)
        self.assertEqual(at_rate(y,p,.2).sum(),1)
        m=pd.DataFrame([{'fold':6,'faculty':'a','model':'a','ap':.5,'auc':.8,'f2_at_20':.4},
                         {'fold':6,'faculty':'a','model':'b','ap':.4,'auc':.7,'f2_at_20':.3}])
        self.assertAlmostEqual(paired(m,'a','b',[6])['mean_delta_ap'],.1)

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