import numpy as np
import pytest


def test_student_dynamics_excludes_absolute_levels():
    from suite16_specialists import build_student_dynamics
    seq=np.zeros((1,4,14),np.float32); mask=np.ones((1,4),bool)
    seq[0,:,0]=[5.,6.,7.,8.]
    seq[0,:,1]=[6.,6.5,7.,7.5]
    x,names=build_student_dynamics(seq,mask,return_names=True)
    assert x.shape[0]==1
    assert not any(name in {'latest_DTBHK','latest_DTBTLHK'} for name in names)
    assert any('delta1_DTBHK' in name for name in names)
    # Level shift leaves pure difference/slope features unchanged.
    shifted=seq.copy(); shifted[0,:,:12]+=10.
    x2=build_student_dynamics(shifted,mask)
    np.testing.assert_allclose(x,x2,atol=1e-5)


def test_temporal_windows_are_contiguous_and_prospective():
    from suite16_temporal import build_temporal_windows
    blocks=np.repeat(np.arange(1,13),20).astype(float)
    y=np.tile(np.r_[np.ones(5),np.zeros(15)],12)
    fac=np.tile(np.arange(10)%5,48)[:len(blocks)]
    ws=build_temporal_windows(blocks,y,fac,n_windows=3,min_prior_blocks=3,min_faculties=3,min_failures=10,min_rows=30)
    assert len(ws)==3
    for w in ws:
        assert np.max(blocks[w.train_idx]) < np.min(blocks[w.val_idx])
        vals=np.unique(blocks[w.val_idx]); assert np.all(np.diff(vals)==1)


def test_newton_target_is_logistic_residual():
    from suite16_hgb import logistic_newton_target
    y=np.array([1.,0.]); p=np.array([.8,.2])
    r,h=logistic_newton_target(y,p)
    np.testing.assert_allclose(h,[.16,.16],atol=1e-6)
    np.testing.assert_allclose(r,[1.25,-1.25],atol=1e-5)


def test_apply_stage_eta_zero_is_exact_identity():
    from suite16_hgb import apply_stage_delta
    base=np.array([-.3,1.2]); d=np.array([2.,-4.])
    np.testing.assert_array_equal(apply_stage_delta(base,d,0.),base)


def test_grande_style_forward_is_hard_but_has_gradients():
    torch=pytest.importorskip('torch')
    from suite16_grande import StraightThroughTreeEnsemble
    m=StraightThroughTreeEnsemble(3,n_estimators=4,depth=2,correction_bound=2.,seed=3)
    x=torch.tensor([[1.,-1.,.5],[0.,2.,-1.]],requires_grad=True)
    out=m(x)
    assert out.shape==(2,)
    out.sum().backward()
    assert m.feature_logits.grad is not None
    assert torch.isfinite(m.feature_logits.grad).all()


def test_stage_admission_rejects_negative_recent_window():
    from suite16_temporal import aggregate_window_stats,stage_admission
    stats=aggregate_window_stats([
        {'delta_ap':.01,'delta_f1':.002,'delta_f2':.003,'wins':9,'faculties':14},
        {'delta_ap':.008,'delta_f1':.001,'delta_f2':.002,'wins':9,'faculties':14},
        {'delta_ap':-.01,'delta_f1':0.,'delta_f2':0.,'wins':5,'faculties':14},
    ])
    ok,reason=stage_admission(stats,min_mean_ap=.002,min_median_ap=0.,min_win_rate=.55,min_recent_ap=-.002)
    assert not ok and 'recent' in reason

def test_latent_factor_features_ignore_future_grades(tmp_path):
    import pandas as pd
    from suite16_specialists import LatentFactorStore
    hp=pd.DataFrame({
        'IDSV':['s1','s1','s2','s2'], 'IDMH':['c1','c2','c1','c2'],
        'NHHK':[1,3,1,1], 'DiemHP':[8.,0.,6.,7.], 'DiemHPCalc':[np.nan]*4,
    })
    s=LatentFactorStore.from_frame(hp,tmp_path/'latent',dim=2,seed=1)
    a=s.features_for_rows(np.array(['s1']),np.array(['c2']),np.array([2.]))
    hp2=hp.copy(); hp2.loc[1,'DiemHP']=10.
    s2=LatentFactorStore.from_frame(hp2,tmp_path/'latent2',dim=2,seed=1)
    b=s2.features_for_rows(np.array(['s1']),np.array(['c2']),np.array([2.]))
    np.testing.assert_allclose(a,b,atol=1e-6)


def test_compatibility_features_capture_prerequisite_readiness():
    from types import SimpleNamespace
    from suite16_specialists import build_student_curriculum_compatibility
    rel=np.zeros((2,3,7),np.float32); mask=np.zeros((2,3),bool); typ=np.zeros((2,3),int)
    # Row0: prerequisite passed with grade 8. Row1: prerequisite failed with grade 3.
    rel[:,0,6]=1.; rel[0,0,0]=8.; rel[0,0,2]=1.; rel[1,0,0]=3.; rel[1,0,2]=0.; rel[:,0,3]=1.; mask[:,0]=1; typ[:,0]=4
    seq=np.zeros((2,2,14),np.float32); sm=np.ones((2,2),bool);seq[:,-1,1]=7.
    ct=np.zeros((2,17),np.float32);ct[:,13]=6.;ct[:,15]=.2
    cn=np.zeros((2,2,17),np.float32);cm=np.zeros((2,2),bool);crt=np.zeros((2,2),int);cm[:,0]=1;crt[:,0]=4
    b=SimpleNamespace(relation_events=rel,relation_mask=mask,relation_type=typ,student_seq=seq,student_mask=sm,course_target=ct,course_neighbors=cn,course_neighbor_mask=cm,course_relation_type=crt,y=np.array([0,1]))
    x,n=build_student_curriculum_compatibility(b,latent_features=np.zeros((2,0),np.float32),return_names=True)
    idx=n.index('prereq_mean_grade')
    assert x[0,idx] > x[1,idx]
    assert 'prereq_coverage' in n


def test_relative_mastery_peer_stats_are_prior_only(tmp_path):
    import pandas as pd
    from suite16_specialists import RelativeMasteryStore
    comp=pd.DataFrame({
        'IDSV':['a','b','a'], 'IDMH':['c1','c1','c1'], 'NHHK':[1,1,3],
        'DiemTP':[6.,8.,0.], 'PhTrMH':[.5,.5,.5], 'DatTP':[1,1,0], 'KyHieuTP':['CK','CK','CK']
    })
    store=RelativeMasteryStore.from_frame(comp,tmp_path/'mastery',min_peer_count=2)
    f1=store.features_for_rows(np.array(['a']),np.array(['c2']),np.array([2.]))
    comp2=comp.copy();comp2.loc[2,'DiemTP']=10.
    store2=RelativeMasteryStore.from_frame(comp2,tmp_path/'mastery2',min_peer_count=2)
    f2=store2.features_for_rows(np.array(['a']),np.array(['c2']),np.array([2.]))
    np.testing.assert_allclose(f1,f2,atol=1e-6)

def test_hgb_newton_stage_can_correct_simple_missing_signal():
    from suite16_hgb import NewtonHGBStage,logit,sigmoid
    rng=np.random.default_rng(3);x=rng.normal(size=(500,1)).astype(np.float32);y=(x[:,0]>0).astype(int);base=np.full(len(y),.5)
    m=NewtonHGBStage(max_iter=40,max_leaf_nodes=7,learning_rate=.1,seed=2).fit(x,y,base)
    score=sigmoid(logit(base)+.2*m.predict_delta(x))
    from sklearn.metrics import average_precision_score
    assert average_precision_score(y,score) > .9


def test_multiwindow_selection_keeps_zero_candidate_when_signal_is_noise():
    from suite16_training import select_hgb_stage
    rng=np.random.default_rng(4);n=1200;x=rng.normal(size=(n,3)).astype(np.float32);y=rng.binomial(1,.2,size=n);base=np.full(n,.2);fac=np.tile(np.arange(4),n//4)
    blocks=np.repeat(np.arange(1,13),100).astype(float)
    sel=select_hgb_stage(x,y,base,fac,[str(i) for i in range(4)],blocks,eta_grid=(0.,.2),iter_candidates=(10,),n_windows=2,min_prior_blocks=3,min_faculties=3,min_failures=10,min_rows=100,max_rows=0,seed=3)
    assert sel.eta in (0.,.2)
    # Identity is always represented and can win; no candidate is allowed to be worse than identity in selected robust score.
    assert sel.stats['score'] >= -1e-12

def test_grande_multiwindow_selector_runs_and_preserves_identity_candidate():
    from suite16_training import select_grande_stage
    rng=np.random.default_rng(5);n=600;x=rng.normal(size=(n,4)).astype(np.float32);y=(x[:,0]+.2*rng.normal(size=n)>0).astype(int);base=np.full(n,.5);fac=np.tile(np.arange(3),n//3);blocks=np.repeat(np.arange(1,13),50).astype(float)
    sel=select_grande_stage(x,y,base,fac,['a','b','c'],blocks,eta_grid=(0.,.2),max_epochs=1,n_windows=2,min_prior_blocks=3,min_faculties=2,min_failures=5,min_rows=50,n_estimators=6,depth=2,selected_variables=1.,batch_size=64,samples_per_epoch=300,seed=7,device='cpu')
    assert sel.eta in (0.,.2)
    assert sel.complexity in (0,1)
    assert sel.stats['score'] >= -1e-12

def test_hgb_crossfit_accept_path_improves_weak_anchor():
    from suite16_training import select_hgb_stage,stage_crossfit_hgb
    from suite16_temporal import stage_admission
    from sklearn.metrics import average_precision_score
    rng=np.random.default_rng(77);n=1200;x=rng.normal(size=(n,2)).astype(np.float32);y=(x[:,0]+.15*rng.normal(size=n)>0).astype(int);base=np.full(n,.5);fac=np.tile(np.arange(4),n//4);blocks=np.repeat(np.arange(1,13),100).astype(float)
    sel=select_hgb_stage(x,y,base,fac,[str(i) for i in range(4)],blocks,eta_grid=(0.,.2,.5),iter_candidates=(20,),n_windows=3,min_prior_blocks=3,min_faculties=3,min_failures=10,min_rows=100,max_rows=0,seed=7)
    ok,_=stage_admission(sel.stats,min_mean_ap=.001,min_median_ap=0.,min_win_rate=.5,min_recent_ap=-.001,max_f1_drop=-1,max_f2_drop=-1)
    assert ok and sel.eta>0
    score,cov,_,_=stage_crossfit_hgb(x,y,base,fac,[str(i) for i in range(4)],blocks,np.ones(n,bool),sel,min_prior_blocks=3,min_faculties=3,min_failures=10,min_rows=100,max_rows=0,seed=8)
    assert cov.sum()>0
    assert average_precision_score(y[cov],score[cov]) > average_precision_score(y[cov],base[cov])+.1

def test_grande_crossfit_accept_path_runs():
    from suite16_training import select_grande_stage,stage_crossfit_grande
    rng=np.random.default_rng(91);n=600;x=rng.normal(size=(n,3)).astype(np.float32);y=(x[:,0]>0).astype(int);base=np.full(n,.5);fac=np.tile(np.arange(3),n//3);blocks=np.repeat(np.arange(1,13),50).astype(float)
    sel=select_grande_stage(x,y,base,fac,['a','b','c'],blocks,eta_grid=(0.,.2),max_epochs=1,n_windows=2,min_prior_blocks=3,min_faculties=2,min_failures=5,min_rows=50,n_estimators=6,depth=2,selected_variables=1.,batch_size=64,samples_per_epoch=300,seed=3,device='cpu')
    assert sel.eta>0
    score,cov,_,_=stage_crossfit_grande(x,y,base,fac,['a','b','c'],blocks,np.ones(n,bool),sel,'cpu',min_prior_blocks=3,min_faculties=2,min_failures=5,min_rows=50,n_estimators=6,depth=2,selected_variables=1.,batch_size=64,samples_per_epoch=300,seed=4)
    assert cov.sum()>0 and np.all(np.isfinite(score[cov]))

def test_grande_standardizer_handles_float16_overflow_scale_and_nonfinite_values():
    from suite16_training import Standardizer
    x=np.array([
        [100000.0, 1.0, np.nan, np.inf],
        [200000.0, 2.0, 3.0, -np.inf],
        [300000.0, 3.0, 6.0, 4.0],
    ],dtype=np.float32)
    sc=Standardizer.fit(x)
    assert np.all(np.isfinite(sc.mean))
    assert np.all(np.isfinite(sc.scale))
    z=sc.transform(x)
    assert z.dtype==np.float32
    assert np.all(np.isfinite(z))
    assert np.max(np.abs(z)) <= 20.0 + 1e-6
    # A large but legitimate feature must remain informative rather than becoming inf/zero.
    assert z[0,0] < z[1,0] < z[2,0]


def test_suite16_view_cache_signature_invalidates_float16_v3_cache():
    from types import SimpleNamespace
    from train_suite16_conditional_tree_boosting import feature_signature
    args=SimpleNamespace(latent_dim=12,mastery_max_events=48,mastery_min_peer_count=5)
    hist=SimpleNamespace(y=np.zeros(3)); target=SimpleNamespace(y=np.zeros(2))
    sig=feature_signature(args,1,hist,target)
    assert sig['version'] >= 4
    assert sig['view_dtype'] == 'float32'

def test_compatibility_prerequisite_coverage_is_bounded_when_expected_graph_is_missing():
    from types import SimpleNamespace
    from suite16_specialists import build_student_curriculum_compatibility
    rel=np.zeros((1,1,7),np.float32); mask=np.ones((1,1),bool); typ=np.array([[4]])
    rel[0,0,0]=8.; rel[0,0,2]=1.; rel[0,0,6]=1.  # observed prerequisite event
    seq=np.zeros((1,1,14),np.float32); sm=np.ones((1,1),bool)
    ct=np.zeros((1,17),np.float32)
    # No curriculum-neighbor prerequisite is encoded for the target course.
    b=SimpleNamespace(relation_events=rel,relation_mask=mask,relation_type=typ,student_seq=seq,student_mask=sm,course_target=ct,course_neighbors=np.zeros((1,1,17),np.float32),course_neighbor_mask=np.zeros((1,1),bool),course_relation_type=np.zeros((1,1),int))
    x,names=build_student_curriculum_compatibility(b,latent_features=np.zeros((1,0),np.float32),return_names=True)
    for name in ('prereq_coverage','direct_prereq_coverage'):
        v=float(x[0,names.index(name)])
        assert 0.0 <= v <= 1.0

def test_newton_hgb_stage_disables_sklearn_auto_early_stopping_for_checkpoint_grid():
    """Suite16 selects exact HGB checkpoints (20/40/60/80), so sklearn must not stop early."""
    from suite16_hgb import NewtonHGBStage
    rng=np.random.default_rng(123)
    n=12000  # >10k activates sklearn's early_stopping='auto' default
    x=rng.normal(size=(n,4)).astype(np.float32)
    y=rng.binomial(1,.2,size=n)
    base=np.full(n,.2)
    m=NewtonHGBStage(max_iter=80,max_leaf_nodes=15,learning_rate=.05,seed=1).fit(x,y,base)
    assert m.model.n_iter_ == 80
    assert sum(1 for _ in m.model.staged_predict(x[:64])) == 80
