import unittest
import numpy as np
import torch
from data import Table,Preprocessor,build_history
from memory import Reader,EvidenceProvider,reader_fingerprint,pretrain_reader,summarize_torch
from native import Booster,BoostConfig

def table(sem,student=None,x=None,y=None,grade=None):
    sem=np.asarray(sem); n=len(sem)
    y=np.asarray(y if y is not None else np.arange(n)%2,dtype=np.int8)
    return Table(np.asarray(x if x is not None else np.arange(n)[:,None],dtype=float),
                 np.zeros((n,17)),y,np.asarray(grade if grade is not None else np.where(y,3.,7.)),sem,
                 np.asarray(student if student is not None else ['s']*n),np.asarray(['c'+str(i%2) for i in range(n)]),
                 np.zeros(n,dtype=int),np.asarray(['id'+str(i) for i in range(n)]),np.full(n,np.nan),('A',),('x',))

class MemoryTests(unittest.TestCase):
    def setup_provider(self):
        torch.manual_seed(1)
        bank=table([0,1,2,3,4,5]); query=table([6,6],x=[[2.],[5.]],y=[0,1])
        pre=Preprocessor.fit(bank,np.arange(6)); r=Reader(pre.n_courses,hidden=4)
        return EvidenceProvider(pre.transform(bank),pre.transform(query),build_history(bank,query,4),r,path_strength=1.5),r

    def test_own_target_label_does_not_change_evidence(self):
        p,r=self.setup_provider(); initial=p.root_features().copy()
        p.query.table.y[:]=1-p.query.table.y
        np.testing.assert_array_equal(initial,p.features(np.arange(2)))

    def test_torch_numpy_parity_and_ancestor_feedback(self):
        p,r=self.setup_provider(); idx=np.arange(2)
        path=((0,0.,True),)
        b=p.batch(idx); bias=torch.as_tensor(p.path_bias(idx,path),device=p.device)
        m,a=r.evidence(b,bias)
        np.testing.assert_allclose(m.detach().numpy(),p.features(idx,path),atol=2e-5,rtol=2e-5)
        self.assertGreater(np.max(np.abs(p.features(idx,path)-p.features(idx))),1e-5)
        # Faculty predicates are excluded from evidence agreement.
        np.testing.assert_array_equal(p.path_bias(idx,((p.comparable_features,0.,True),)),np.zeros((2,4)))

    def test_empty_and_both_outcomes_mask(self):
        p,r=self.setup_provider()
        m=p.clone('no_memory').root_features()
        self.assertTrue(np.isfinite(m).all()); self.assertTrue((m[:,11]==0).all())
        masked=p.clone('no_outcomes').root_features()
        np.testing.assert_allclose(masked[:,0],masked[:,12],atol=1e-6)
        np.testing.assert_allclose(masked[:,1],masked[:,13],atol=1e-6)
        self.assertTrue((masked[:,9]==0).all())

    def test_stale_pair_rejected_auxiliary_heads_do_not_score(self):
        p,r=self.setup_provider()
        m=Booster(BoostConfig(trees=1,min_leaf=1,min_hessian=0)).fit(p,[0,1])
        expected=m.predict_proba(p)
        with torch.no_grad(): r.failure_head.weight.add_(2.)
        np.testing.assert_array_equal(expected,m.predict_proba(p))
        with torch.no_grad(): r.age_decay.add_(.5)
        with self.assertRaisesRegex(ValueError,'Reader'): m.predict_proba(p)

    def test_retrieval_fingerprint_excludes_heads(self):
        p,r=self.setup_provider(); before=reader_fingerprint(r,False)
        with torch.no_grad(): r.grade_head.weight.add_(10.)
        self.assertEqual(before,reader_fingerprint(r,False))

    def test_single_history_zero_dispersion_has_finite_reader_gradients(self):
        bank=table([0,1,2],y=[0,0,0],grade=[7.,7.,7.]); pre=Preprocessor.fit(bank,np.arange(3))
        r=Reader(pre.n_courses,hidden=4)
        p=EvidenceProvider(pre.transform(bank),pre.transform(bank),build_history(bank,bank,3),r,cache=False)
        logs=pretrain_reader(r,p,np.ones(3),epochs=1,batch_size=3,max_rows=3)
        self.assertTrue(np.isfinite(logs[0]['retrieval_grad_norm']))
        self.assertTrue(all(torch.isfinite(v).all() for v in r.parameters()))

    def test_exact_constant_performance_summary_gradient_is_finite(self):
        p,r=self.setup_provider(); b=p.batch(np.arange(2)); b['h_performance'].fill_(.5)
        logits=torch.zeros_like(b['age'],requires_grad=True)
        evidence,_=summarize_torch(b,logits)
        evidence.sum().backward()
        self.assertTrue(torch.isfinite(logits.grad).all())

    def test_provider_rejects_foreign_student_and_embargo_violation(self):
        p,r=self.setup_provider()
        from data import HistoryIndex
        bank=p.bank; query=p.query
        query.table.student[:]='different'
        with self.assertRaisesRegex(ValueError,'student'):
            EvidenceProvider(bank,query,p.history,r)
        query.table.student[:]='s'
        with self.assertRaisesRegex(ValueError,'embargo'):
            EvidenceProvider(bank,query,p.history,r,embargo=1)

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