import sys,pathlib
sys.path.insert(0,str(pathlib.Path(__file__).resolve().parents[1]))
import numpy as np,torch
from suite28_model import ReadinessModel,ordinal_probabilities,ordinal_score_fisher
from suite28_data import Rows,CourseBank,semester_ordinal,context_audit
from suite28_engine import prepare,batches,device_batch,train_epoch,evaluate_model

def fake_rows():
    fac=['FacultyA','FacultyB'];N=96
    student=np.array([f's{i//6}' for i in range(N)]);sem=np.array([6061+(i//3)%2 for i in range(N)],dtype=np.int32)
    # group by student+semester, shared context
    x=np.array([[i//6/10.,float(i//6%3)] for i in range(N)],np.float32)
    static=np.stack([np.ones(N)*2.]+[np.ones(N)*.5 for _ in range(11)],1).astype(np.float32)
    return Rows(x,static,np.array([i%7==0 for i in range(N)],np.int8),np.array([3. if i%7==0 else 7. for i in range(N)],np.float32),student,
                np.array([f'c{i%6}' for i in range(N)]),np.array([i//48 for i in range(N)],np.int16),sem,np.arange(N),np.ones(N)*.1,fac,['prev_semester_gpa10','prev_failed_credits'])

def test_ordinal_normalized_and_failure_consistent():
    u=torch.tensor([3.,-2.]);k=torch.tensor([[0.,.8,1.6,2.4,3.2],[0.,.8,1.6,2.4,3.2]])
    p=ordinal_probabilities(u,k);assert torch.allclose(p.sum(-1),torch.ones(2),atol=1e-5)
    assert torch.allclose(p[:,0],torch.sigmoid(-u))
    grad,fish=ordinal_score_fisher(u,k,torch.tensor([float('nan'),4.]),torch.tensor([0.,1.]))
    assert torch.isfinite(grad).all() and (fish>=0).all()

def test_readiness_correct_sign():
    for kind in ('bottleneck','mirt'):
        m=ReadinessModel(4,30,2,12,k=4,kind=kind)
        cp=torch.zeros(2,3,4 if kind=='bottleneck' else 5)
        if kind=='mirt':cp[:,:,:4]=1.;cp[:,:,-1]=-3.
        a=m.score(torch.zeros(2,1,4),cp)
        b=m.score(torch.ones(2,1,4),cp)
        assert torch.all(b>a),kind
        assert torch.all(torch.sigmoid(-b)<torch.sigmoid(-a))

def test_course_asof_excludes_same_semester():
    d=fake_rows();cb=CourseBank(d);query=d.take(np.arange(20));h,count,cid=cb.query(query)
    # Every course's prior count is strictly less than its total number of rows.
    assert np.all(count<16)
    for i in range(len(query)):
        m=(d.faculty==query.faculty[i])&(d.course==query.course[i])&(d.semester<query.semester[i])
        assert count[i]==m.sum()

def test_student_semester_shared():
    d=fake_rows();audit=context_audit(d);assert audit['allowed']==d.raw_names

def test_end_to_end_prequential_and_history_off():
    d=fake_rows();tr=d.take(np.arange(75));te=d.take(np.arange(75,96))
    prep,pp,cb=prepare(tr,fit=True);pquery,_,_=prepare(tr,te,processor=pp,course_bank=cb)
    model=ReadinessModel(prep.x.shape[1],30,2,cb.vocab_size,k=4)
    opt=torch.optim.AdamW(model.parameters(),lr=.001)
    loss=train_epoch(model,prep,opt,device='cpu',batch_students=16,seed=1,max_steps=2)
    assert np.isfinite(loss['total_loss'])
    a,_=evaluate_model(model,pquery,batch_students=16,device='cpu')
    assert len(a)==len(te) and np.isfinite(a).all() and np.all((a>0)&(a<1))
    modified=__import__('copy').copy(pquery);modified.update=pquery.update.copy();modified.update[:len(tr)]=False
    b,_=evaluate_model(model,modified,batch_students=16,device='cpu')
    assert len(b)==len(te)

def test_semester_parse():
    assert semester_ordinal('20261')<semester_ordinal('20262')
    try:semester_ordinal('6059');assert False
    except ValueError:pass

def test_update_is_semester_order_invariant():
    m=ReadinessModel(4,30,1,8,k=4)
    mu=torch.zeros(2,4);cov=torch.eye(4).unsqueeze(0).expand(2,-1,-1).clone()
    cp=torch.tensor([[[-2.,-2.,-2.,-2.],[-1.,-1.5,-2.,-2.5]],
                     [[-2.,-2.,-2.,-2.],[-1.,-1.5,-2.,-2.5]]])
    kappa=m.thresholds(torch.tensor([0,0])).unsqueeze(1).expand(-1,2,-1)
    grades=torch.tensor([[3.,8.],[3.,8.]])
    y=torch.tensor([[1.,0.],[1.,0.]])
    avail=torch.ones(2,2,dtype=torch.bool)
    a=m.assimilate(mu,cov,cp,kappa,grades,y,avail)
    b=m.assimilate(mu,cov,cp.flip(1),kappa,grades.flip(1),y.flip(1),avail)
    assert torch.allclose(a[0],b[0],atol=1e-5)
    assert torch.allclose(a[1],b[1],atol=1e-5)
    assert (torch.linalg.eigvalsh(a[1])>0).all()

def test_unexpected_failure_lowers_readiness():
    m=ReadinessModel(4,30,1,8,k=4)
    mu=torch.zeros(1,4);cov=torch.eye(4).unsqueeze(0)
    cp=torch.full((1,1,4),-3.)
    kappa=m.thresholds(torch.tensor([0])).unsqueeze(1)
    on=torch.ones(1,1,dtype=torch.bool)
    failed=m.assimilate(mu,cov,cp,kappa,torch.tensor([[float('nan')]]),torch.tensor([[1.]]),on)[0]
    passed=m.assimilate(mu,cov,cp,kappa,torch.tensor([[float('nan')]]),torch.tensor([[0.]]),on)[0]
    assert torch.all(failed<mu) and torch.all(passed>mu)

def test_target_outcome_not_exposed_to_model():
    d=fake_rows();tr=d.take(np.arange(70));q=d.take(np.arange(70,96))
    train,pp,cb=prepare(tr,fit=True)
    out,_,_=prepare(tr,q,processor=pp,course_bank=cb)
    assert np.all(out.y[len(tr):]==0) and np.isnan(out.grade[len(tr):]).all()
    q.y=1-q.y;q.grade[:]=0
    changed,_,_=prepare(tr,q,processor=pp,course_bank=cb)
    assert np.array_equal(out.x,changed.x)
    assert np.array_equal(out.meta,changed.meta)
    assert np.array_equal(out.y,changed.y)
    assert np.array_equal(out.cid,changed.cid)

def test_deterministic_checkpoint_roundtrip(tmp_path):
    d=fake_rows();tr=d.take(np.arange(70));q=d.take(np.arange(70,96))
    _,pp,cb=prepare(tr,fit=True);out,_,_=prepare(tr,q,processor=pp,course_bank=cb)
    m=ReadinessModel(4,30,2,cb.vocab_size,k=4)
    a,_=evaluate_model(m,out,device='cpu')
    torch.save(m.state_dict(),tmp_path/'model.pt')
    n=ReadinessModel(4,30,2,cb.vocab_size,k=4)
    n.load_state_dict(torch.load(tmp_path/'model.pt',map_location='cpu',weights_only=True))
    b,_=evaluate_model(n,out,device='cpu')
    assert np.array_equal(a,b)

def test_identifier_normalization_fail_closed():
    from suite28_data import _normal_ids
    assert _normal_ids(['00123','123.0','x-5'], 'IDSV').tolist()==['00123','123','x-5']
    try:_normal_ids(['123',None], 'IDSV');assert False
    except ValueError:pass
