import unittest
import pandas as pd
import numpy as np
from pace import data


def sources():
    cal=pd.DataFrame({'semester':['a','b','c','d'], 'order':[1,2,3,4], 'origin_at':['2020-01-01','2020-07-01','2021-01-01','2021-07-01'], 'labels_available_at':['2020-06-01','2020-12-01','2021-06-01','2021-12-01']})
    ev=pd.DataFrame({'event_id':['e1','e2','e3','e4'], 'student_id':['001']*4,'course_id':['01','02','03','04'], 'semester':['a','b','c','a'],'grade':[7.,3.,9.,np.nan],'credits':[3]*4,'available_at':['2020-06-01','2021-02-01','2021-06-01','2020-06-01']})
    return cal,ev

class DataTests(unittest.TestCase):
    def test_prefix_excludes_late_grade_and_current_semester(self):
        cal,ev=sources(); corpus=data.EventCorpus(ev,cal)
        fit=corpus.before('2021-01-01'); self.assertEqual(fit.event_id.tolist(),['e1'])
        store=data.SequenceStore(corpus,{'01':3,'02':4},max_semesters=4,max_courses=4)
        rows=pd.DataFrame({'student_id':['001','absent'],'semester':['c','c'],'course_id':['10','10'],'origin_at':['2021-01-01']*2})
        b,diag=store.for_rows(rows)
        self.assertEqual(b['event_mask'].sum(),1)
        self.assertEqual(diag.n_history.tolist(),[1,0])
        self.assertEqual(b['course'][0,0,0],3)
        self.assertEqual(corpus.audit['missing_grades_excluded'],1)
    def test_conflicting_event_identity_rejected(self):
        cal,ev=sources(); extra=ev.iloc[[0]].copy();extra['grade']=2
        with self.assertRaisesRegex(ValueError,'conflict'):
            data.EventCorpus(pd.concat([ev,extra]),cal)
    def test_duplicate_exact_records_deduplicated(self):
        cal,ev=sources(); c=data.EventCorpus(pd.concat([ev,ev]),cal)
        self.assertEqual(c.audit['duplicates_removed'],4)
    def test_summary_is_prefix_only_and_target_conditioned(self):
        cal,ev=sources();corpus=data.EventCorpus(ev,cal);store=data.SequenceStore(corpus,{'01':3})
        rows=pd.DataFrame({'student_id':['001'],'semester':['c'],'course_id':['01'],'origin_at':['2021-01-01']})
        x,names=store.summaries(rows)
        self.assertEqual(float(x[0,names.index('hist_grade_mean')]),7)
        self.assertEqual(float(x[0,names.index('target_course_attempts')]),1)
    def test_transform_fits_only_training_and_preserves_missing(self):
        p=data.NumericPreprocessor();x=p.fit_transform(np.array([[1,np.nan],[3,np.nan]]))
        y=p.transform(np.array([[100,9]]))
        self.assertEqual(x.shape,(2,4));self.assertTrue(np.isfinite(y).all())
        self.assertEqual(p.median.tolist(),[2.,0.])
    def test_invalid_calendar_and_grade_rejected(self):
        cal,ev=sources();cal.loc[1,'order']=1
        with self.assertRaises(ValueError):data.EventCorpus(ev,cal)
        cal,ev=sources();ev.loc[0,'grade']=-1
        with self.assertRaises(ValueError):data.EventCorpus(ev,cal)
    def test_no_history_shape_truncation_and_oov(self):
        cal,ev=sources(); c=data.EventCorpus(ev,cal)
        store=data.SequenceStore(c,{},max_semesters=1,max_courses=1)
        r=pd.DataFrame({'student_id':['001'],'semester':['d'],'course_id':['04'],'origin_at':['2021-07-01']})
        b,d=store.for_rows(r)
        self.assertEqual(b['course'].shape,(1,1,1));self.assertEqual(d.iloc[0].truncated_events,2)
        self.assertEqual(d.iloc[0].oov_rate,1)

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

class InputMatrixTests(unittest.TestCase):
    def test_fold_numbers_must_follow_global_chronology(self):
        from pace.demo import create_demo
        import tempfile,json
        from pathlib import Path
        with tempfile.TemporaryDirectory() as td:
            p=create_demo(td);cfg=json.loads(Path(p).read_text())
            cfg['folds']['1'],cfg['folds']['6']=cfg['folds']['6'],cfg['folds']['1']
            with self.assertRaisesRegex(ValueError,'(?i)fold.*chronolog|chronolog.*fold'):
                data.load_inputs(cfg,Path(p).parent)
    def test_stable_row_id_cannot_change_label_across_snapshots(self):
        # Fold exports may retain different feature snapshots, but identity/labels are immutable.
        from pace.demo import create_demo
        import tempfile,json
        from pathlib import Path
        with tempfile.TemporaryDirectory() as td:
            p=create_demo(td);cfg=json.loads(Path(p).read_text());c,entries,_=data.load_inputs(cfg,Path(p).parent)
            a=entries[0];b=entries[2]
            b['train'].loc[b['train'].index[0],'label']=1-int(a['train'].iloc[0].label)
            with self.assertRaisesRegex(ValueError,'identity|label'):
                data.validate_matrix(c,entries)


class SourceValidationTests(unittest.TestCase):
    def test_nonfinite_credits_and_fractional_attempt_or_calendar_rejected(self):
        cal,ev=sources();ev['credits']=ev.credits.astype(float);ev.loc[0,'credits']=np.inf
        with self.assertRaisesRegex(ValueError,'finite'):
            data.EventCorpus(ev,cal)
        cal,ev=sources();ev['attempt']=1.5
        with self.assertRaises(ValueError):data.EventCorpus(ev,cal)
        cal,ev=sources();cal['order']=[1,2.5,3,4]
        with self.assertRaises(ValueError):data.EventCorpus(ev,cal)

class FreezeAvailabilityTests(unittest.TestCase):
    def test_development_labels_must_be_available_before_retrospective_origin(self):
        from pace.demo import create_demo
        import tempfile,json
        from pathlib import Path
        with tempfile.TemporaryDirectory() as td:
            p=create_demo(td);cfg=json.loads(Path(p).read_text());c,entries,_=data.load_inputs(cfg,Path(p).parent)
            e=next(e for e in entries if e['fold']==5)
            ids=set(e['test'].row_id)
            for entry in entries:
                for frame in (entry['train'],entry['test']):
                    frame.loc[frame.row_id.isin(ids),'label_available_at']=pd.Timestamp('2030-01-01',tz='UTC')
            with self.assertRaisesRegex(ValueError,'freeze'):
                data.validate_matrix(c,entries)

class AQMemoryTests(unittest.TestCase):
    def test_repeated_prefix_storage_and_frozen_encoding_stay_unique(self):
        import torch
        from pace.runner import encode
        cal,ev=sources();corpus=data.EventCorpus(ev,cal)
        rows=pd.DataFrame({'student_id':['001','absent']*50,'semester':['c']*100,'course_id':['01']*100,'origin_at':['2021-01-01']*100})
        batch,_=data.SequenceStore(corpus,{'01':3}).for_rows(rows)
        self.assertIsInstance(batch,data.IndexedHistory)
        self.assertEqual(batch.n_rows,100)
        self.assertEqual(len(batch.unique['course']),2)
        class CountingEncoder(torch.nn.Module):
            dim=1
            def __init__(self):super().__init__();self.rows=0
            def forward(self,b):
                self.rows+=len(b['course'])
                return b['course'].float().sum((1,2)).reshape(-1,1)
        encoder=CountingEncoder();emb=encode(encoder,batch,'cpu',16)
        self.assertEqual(encoder.rows,2)
        self.assertEqual(emb.shape,(100,1))
        self.assertTrue((emb[::2]==3).all())
        self.assertTrue((emb[1::2]==0).all())
    def test_history_padding_compacts_to_observed_semesters_and_courses(self):
        cal,ev=sources();corpus=data.EventCorpus(ev,cal)
        rows=pd.DataFrame({'student_id':['001','absent','001'],'semester':['c']*3,'course_id':['01','10','02'],'origin_at':['2021-01-01']*3})
        store=data.SequenceStore(corpus,{'01':3},max_semesters=16,max_courses=32)
        b,d=store.for_rows(rows)
        self.assertEqual(b['course'].shape,(3,1,1))
        np.testing.assert_array_equal(b['course'][0],b['course'][2])
        self.assertEqual(d.n_history.tolist(),[1,0,1])

class SemesterOrderTests(unittest.TestCase):
    def test_native_semester_mode_admits_only_earlier_terms_without_real_calendar(self):
        calendar=pd.DataFrame({'semester':['20201','20202','20203'],'order':[6060,6061,6062]})
        calendar['origin_at']=pd.Timestamp('1900-01-01',tz='UTC')+pd.to_timedelta(calendar['order'],unit='D')
        calendar['labels_available_at']=calendar.origin_at+pd.Timedelta(hours=12)
        ev=pd.DataFrame({'event_id':['a','b'],'student_id':['s','s'],'course_id':['c','d'],'semester':['20201','20202'],'grade':[7,0],'credits':[3,3],'available_at':calendar.labels_available_at.iloc[:2].to_list(),'faculty':['A','B'],'faculty_memberships':['["A","B"]','["B"]']})
        corpus=data.EventCorpus(ev,calendar,availability_mode='semester_order')
        self.assertEqual(corpus.before(calendar.origin_at.iloc[1]).event_id.tolist(),['a'])
        self.assertEqual(corpus.before(calendar.origin_at.iloc[2],faculty='A').event_id.tolist(),['a'])
        self.assertEqual(corpus.describe_origin(calendar.origin_at.iloc[2]),'20203')
        self.assertIn('assum',corpus.audit['availability_assumption'].lower())
