from types import SimpleNamespace
import numpy as np
import pandas as pd


def _bundle(n=8):
    rng=np.random.default_rng(3)
    relation_events=np.zeros((n,4,7),np.float32)
    relation_mask=np.zeros((n,4),bool)
    relation_type=np.zeros((n,4),np.int16)
    for i in range(n):
        relation_mask[i,:2]=True
        relation_events[i,0]=[7+i%2,0,1,1,1,0,0]
        relation_events[i,1]=[4+i%3,0,0,2,0,0,1]
        relation_type[i,1]=4
    course_target=np.zeros((n,17),np.float32)
    course_target[:,0]=3
    course_target[:,12]=20
    course_target[:,13]=6.2
    course_target[:,15]=.15
    course_neighbors=np.zeros((n,3,17),np.float32)
    course_neighbor_mask=np.zeros((n,3),bool)
    course_neighbor_mask[:,:2]=True
    course_relation_type=np.zeros((n,3),np.int16)
    course_relation_type[:,0]=4
    student_seq=np.zeros((n,3,14),np.float32)
    student_mask=np.ones((n,3),bool)
    student_seq[:,:,1]=np.array([6,6.5,7])[None,:]
    student_seq[:,:,10]=np.array([6.2,6.4,6.8])[None,:]
    return SimpleNamespace(
        relation_events=relation_events,relation_mask=relation_mask,relation_type=relation_type,
        course_target=course_target,course_neighbors=course_neighbors,
        course_neighbor_mask=course_neighbor_mask,course_relation_type=course_relation_type,
        student_seq=student_seq,student_mask=student_mask,
    )


def test_relational_ablation_variants_isolate_latent_information():
    from suite17_specialists import build_relational_variant_family
    b=_bundle();latent=np.arange(len(b.relation_events)*8,dtype=np.float32).reshape(len(b.relation_events),8)
    fam=build_relational_variant_family(b,latent)
    assert set(fam)=={'R_RELATION','R_RELATION_CURRICULUM','R_RELATION_LATENT','R_FULL'}
    assert fam['R_RELATION'][0].shape[0]==len(b.relation_events)
    assert fam['R_FULL'][0].shape[1] > fam['R_RELATION'][0].shape[1]
    latent2=latent+10000
    fam2=build_relational_variant_family(b,latent2)
    np.testing.assert_allclose(fam['R_RELATION'][0],fam2['R_RELATION'][0])
    np.testing.assert_allclose(fam['R_RELATION_CURRICULUM'][0],fam2['R_RELATION_CURRICULUM'][0])
    assert not np.allclose(fam['R_RELATION_LATENT'][0],fam2['R_RELATION_LATENT'][0])


def test_temporal_admission_rejects_positive_median_but_negative_recent_mean():
    from suite17_temporal import aggregate_window_stats, stage_admission
    rows=[
        {'faculty_delta_ap':[.01,.01,.01,-.001], 'delta_f1':0.,'delta_f2':0.},
        {'faculty_delta_ap':[.01,.01,.01,-.03], 'delta_f1':0.,'delta_f2':0.},
        {'faculty_delta_ap':[.008,.008,.008,-.05], 'delta_f1':0.,'delta_f2':0.},
    ]
    st=aggregate_window_stats(rows)
    assert st['recent_median_delta_ap']>0
    assert st['recent_mean_delta_ap']<0
    ok,reason=stage_admission(st,min_mean_ap=0.,min_median_ap=0.,min_win_rate=.5,min_recent_mean_ap=0.,min_recent_median_ap=0.,max_recent_window_mean_drop=-.003)
    assert not ok
    assert reason in {'recent_mean_ap','recent_window_downside'}


def test_dense_identity_fallback_never_shrinks_ledger():
    from suite17_training import apply_dense_crossfit_update
    base=np.array([.1,.2,.3,.4,.5],dtype=np.float32)
    corrected=np.array([.15,.25],dtype=np.float32)
    covered=np.array([False,True,False,True,False])
    out,avail=apply_dense_crossfit_update(base,corrected,covered)
    assert len(out)==len(base)
    assert avail.mean()==.4
    np.testing.assert_allclose(out[~covered],base[~covered])
    np.testing.assert_allclose(out[covered],corrected)


def test_forward_choice_uses_best_admitted_specialist_not_fixed_order():
    from suite17_training import ForwardCandidate, choose_forward_candidate
    cands=[
        ForwardCandidate('R',True,{'score':.004,'mean_delta_ap':.004}),
        ForwardCandidate('M',True,{'score':.011,'mean_delta_ap':.009}),
        ForwardCandidate('L',True,{'score':.007,'mean_delta_ap':.006}),
    ]
    chosen=choose_forward_candidate(cands)
    assert chosen.name=='M'


def test_logit_alignment_preserves_ranking_and_matches_committee_moments():
    from suite17_alignment import align_scores_to_committee
    final=np.array([.02,.11,.3,.8,.95],dtype=float)
    committee=np.array([.05,.15,.35,.6,.85],dtype=float)
    aligned,meta=align_scores_to_committee(final,committee)
    assert np.array_equal(np.argsort(final),np.argsort(aligned))
    lf=np.log(np.clip(aligned,1e-6,1-1e-6)/(1-np.clip(aligned,1e-6,1-1e-6)))
    lc=np.log(committee/(1-committee))
    assert abs(lf.mean()-lc.mean())<1e-5
    assert abs(lf.std()-lc.std())<1e-5
    assert meta['scale']>0


def test_local_evidence_is_dense_and_future_rows_do_not_change_earlier_crossfit_predictions():
    from suite17_local import build_faculty_local_evidence
    rng=np.random.default_rng(12)
    blocks=np.repeat(np.arange(1,9),60)
    faculty=np.tile(np.repeat([0,1],30),8)
    x=rng.normal(size=(len(blocks),5)).astype(np.float32)
    y=((x[:,0]+.4*x[:,1]+.15*blocks+rng.normal(scale=.7,size=len(blocks)))>1.0).astype(np.int8)
    committee=1/(1+np.exp(-(.2*x[:,0])))
    teacher=np.column_stack([committee,np.clip(committee+.02,0,1),np.clip(committee-.02,0,1)]).astype(np.float32)
    tx=rng.normal(size=(40,5)).astype(np.float32);tf=np.repeat([0,1],20);tc=np.full(40,.3,np.float32);tt=np.column_stack([tc,tc,tc]).astype(np.float32)
    a=build_faculty_local_evidence(x,teacher,y,committee,faculty,blocks,tx,tt,tc,tf,recent_blocks=2,min_train_rows=40,min_failures=3,max_iter=10,seed=7)
    assert len(a.hist_features)==len(y)
    assert np.isfinite(a.hist_features).all() and np.isfinite(a.target_features).all()
    assert a.hist_available.shape==(len(y),2)
    # append a future block: already-produced features for old rows must stay unchanged
    x2=np.vstack([x,rng.normal(size=(60,5)).astype(np.float32)])
    b2=np.concatenate([blocks,np.full(60,9)])
    f2=np.concatenate([faculty,np.repeat([0,1],30)])
    y2=np.concatenate([y,rng.integers(0,2,size=60,dtype=np.int8)])
    c2=np.concatenate([committee,np.full(60,.4)])
    t2=np.vstack([teacher,np.full((60,3),.4,np.float32)])
    b=build_faculty_local_evidence(x2,t2,y2,c2,f2,b2,tx,tt,tc,tf,recent_blocks=2,min_train_rows=40,min_failures=3,max_iter=10,seed=7)
    np.testing.assert_allclose(a.hist_features,b.hist_features[:len(y)],atol=1e-6)


def test_local_evidence_does_not_expose_raw_flat_features_directly():
    from suite17_local import LOCAL_FEATURE_NAMES
    forbidden={'flat_0','raw_0','x0'}
    assert not (set(LOCAL_FEATURE_NAMES)&forbidden)
    assert 'local_global_minus_committee' in LOCAL_FEATURE_NAMES
    assert 'local_recent_minus_committee' in LOCAL_FEATURE_NAMES

def test_hgb_dense_crossfit_preserves_identity_for_uncovered_warmup():
    from suite17_training import select_hgb_stage,stage_crossfit_hgb_dense
    from suite17_temporal import stage_admission
    rng=np.random.default_rng(42);n=1000
    blocks=np.repeat(np.arange(1,11),100).astype(float);fac=np.tile(np.arange(4),250)
    x=rng.normal(size=(n,2)).astype(np.float32);y=(x[:,0]+.2*rng.normal(size=n)>0).astype(int);base=np.full(n,.5,np.float32)
    sel=select_hgb_stage(x,y,base,fac,[str(i) for i in range(4)],blocks,eta_grid=(0.,.1,.2),iter_candidates=(20,),n_windows=2,min_prior_blocks=3,min_faculties=3,min_failures=10,min_rows=100,max_rows=0,seed=9)
    ok,_=stage_admission(sel.stats,min_mean_ap=.001,min_median_ap=0.,min_win_rate=.5,min_recent_mean_ap=0.,min_recent_median_ap=0.,max_recent_window_mean_drop=-.01,max_f1_drop=-1,max_f2_drop=-1)
    assert ok
    out,cov,_,_=stage_crossfit_hgb_dense(x,y,base,fac,[str(i) for i in range(4)],blocks,sel,min_prior_blocks=3,min_faculties=3,min_failures=10,min_rows=100,max_rows=0,seed=10)
    assert len(out)==n and len(cov)==n
    np.testing.assert_allclose(out[~cov],base[~cov])
    assert cov.any() and (~cov).any()


def test_forward_selection_can_choose_mastery_before_relational():
    from types import SimpleNamespace
    from train_suite17_robust_forward_specialist_boosting import run_forward_selection
    rng=np.random.default_rng(123);n=1200;nt=200
    blocks=np.repeat(np.arange(1,13),100).astype(float);fac=np.tile(np.arange(4),300);fn=[f'f{i}' for i in range(4)]
    m=rng.normal(size=(n,1)).astype(np.float32);r=rng.normal(size=(n,1)).astype(np.float32);l=rng.normal(size=(n,1)).astype(np.float32)
    logits=1.8*m[:,0]+.7*r[:,0]+rng.normal(scale=.7,size=n);y=(logits>0).astype(np.int8);base=np.full(n,.5,np.float32);teacher=np.column_stack([base,base,base])
    mt=rng.normal(size=(nt,1)).astype(np.float32);rt=rng.normal(size=(nt,1)).astype(np.float32);lt=rng.normal(size=(nt,1)).astype(np.float32);yt=(1.8*mt[:,0]+.7*rt[:,0]+rng.normal(scale=.7,size=nt)>0).astype(np.int8);bt=np.full(nt,.5,np.float32);tt=np.column_stack([bt,bt,bt]);ft=np.tile(np.arange(4),50)
    hist=SimpleNamespace(y=y,teacher=teacher,faculty_idx=fac,faculty_names=fn,blocks=blocks)
    target=SimpleNamespace(y=yt,teacher=tt,faculty_idx=ft,faculty_names=fn)
    views={'hist':{'R_RELATION':r,'M':m},'target':{'R_RELATION':rt,'M':mt},'names':{'R_RELATION':['r'],'M':['m']}}
    local={'hist':l,'target':lt,'names':['l']}
    args=SimpleNamespace(seed=1,eta_grid=(0.,.1,.2,.3),hgb_iter_candidates=(20,),meta_windows=3,meta_min_prior_blocks=3,window_min_faculties=3,window_min_failures=10,window_min_rows=100,hgb_max_leaf_nodes=7,hgb_lr=.08,hgb_l2=1.,correction_bound=2.,hgb_max_rows=0,sampling_beta=.9999,crossfit_min_prior_blocks=3,admit_min_mean_ap=.001,admit_min_median_ap=0.,admit_min_win_rate=.5,admit_min_recent_mean_ap=0.,admit_min_recent_median_ap=0.,admit_max_recent_window_mean_drop=-.01,admit_max_f1_drop=-1.,admit_max_f2_drop=-1.,max_deploy_stages=1,deploy_third_stage=False,third_admit_min_mean_ap=.01,third_admit_min_median_ap=.005,third_admit_min_win_rate=.7,third_admit_min_recent_mean_ap=.001,third_admit_min_recent_median_ap=.001,third_admit_max_recent_window_mean_drop=0.)
    _,_,_,stages,_,_,accepted=run_forward_selection(hist,target,views,local,'R_RELATION',args,1)
    assert accepted and accepted[0]=='M'
    assert stages[0]['selected_specialist']=='M'


def test_alignment_preserves_average_precision_exactly():
    from suite17_alignment import align_scores_to_committee
    from sklearn.metrics import average_precision_score
    rng=np.random.default_rng(55);s=rng.uniform(.01,.99,400);c=rng.uniform(.02,.98,400);y=rng.integers(0,2,400)
    a,_=align_scores_to_committee(s,c)
    assert abs(average_precision_score(y,s)-average_precision_score(y,a))<1e-12
