from __future__ import annotations
import numpy as np
import pandas as pd
import torch
from types import SimpleNamespace


def _bundle(n=12):
    rng=np.random.default_rng(0)
    faculty=np.arange(n)%2
    return SimpleNamespace(
        flat=rng.normal(size=(n,8)).astype(np.float32),
        e0_context=rng.normal(size=(n,3)).astype(np.float32),
        fusion_context=np.column_stack([np.arange(n)%4+1,np.arange(n)%7+2,np.arange(n)%5+1,np.zeros(n),np.zeros(n)]).astype(np.float32),
        gate_context=np.column_stack([np.arange(n)%4+1,np.arange(n)%7+2,np.arange(n)%5+1,np.zeros(n),np.zeros(n)]).astype(np.float32),
        e1_context=rng.normal(size=(n,4)).astype(np.float32),e2_context=rng.normal(size=(n,3)).astype(np.float32),e3_context=rng.normal(size=(n,4)).astype(np.float32),e4_context=rng.normal(size=(n,3)).astype(np.float32),
        y=(np.arange(n)%3==0).astype(np.int8),teacher=np.clip(rng.uniform(.05,.7,size=(n,3)),.01,.99).astype(np.float32),
        faculty_idx=faculty.astype(np.int16),faculty_names=['a','b'],blocks=np.repeat(np.arange(1,5),3)[:n].astype(float),row_index=np.arange(n),
        student_id=np.array([f's{i//2}' for i in range(n)]),course_id=np.array([f'c{i%4}' for i in range(n)]),target_semester=np.full(n,20241,np.float32),
        student_seq=rng.normal(size=(n,3,4)).astype(np.float32),student_mask=np.array([[1,1,0]]*n,dtype=bool),
        course_target=rng.normal(size=(n,5)).astype(np.float32),course_neighbors=rng.normal(size=(n,2,5)).astype(np.float32),course_neighbor_mask=np.array([[1,0]]*n,dtype=bool),course_relation_type=np.array([[1,0]]*n,dtype=np.int64),
        relation_events=rng.normal(size=(n,3,7)).astype(np.float32),relation_mask=np.array([[1,1,0]]*n,dtype=bool),relation_type=np.array([[1,2,0]]*n,dtype=np.int64),
        component_events=rng.normal(size=(n,3,6)).astype(np.float32),component_mask=np.array([[1,1,0]]*n,dtype=bool),component_type=np.array([[1,2,0]]*n,dtype=np.int64),
    )


def test_all_view_subsets_are_complete_and_unique():
    from suite15_views import all_view_subsets
    s=all_view_subsets()
    assert len(s)==16
    assert len(set(s))==16
    assert () in s
    assert ('V1','V2','V3','V4') in s


def test_core_views_use_raw_structures_and_exclude_old_specialist_context():
    from suite15_views import ViewMatrixBuilder
    b=_bundle();builder=ViewMatrixBuilder.fit(b,np.ones(len(b.y),bool))
    v1,n1=builder.transform(b,('V1',),include_full_context=False,return_feature_names=True)
    v2,n2=builder.transform(b,('V2',),include_full_context=False,return_feature_names=True)
    v3,n3=builder.transform(b,('V3',),include_full_context=False,return_feature_names=True)
    v4,n4=builder.transform(b,('V4',),include_full_context=False,return_feature_names=True)
    assert v1.shape[0]==len(b.y) and any('student_seq' in x for x in n1) and any('student_mask' in x for x in n1)
    assert any('course_neighbors' in x for x in n2) and any('course_relation_type' in x for x in n2)
    assert any('relation_events' in x for x in n3) and any('course_target' in x for x in n3)
    assert any('component_events' in x for x in n4) and any('component_type' in x for x in n4)
    assert not any('e1_context' in x for x in n1)
    assert not any('e2_context' in x for x in n2)
    assert not any('e3_context' in x for x in n3)
    assert not any('e4_context' in x for x in n4)


def test_full_context_variant_adds_only_requested_specialist_context():
    from suite15_views import ViewMatrixBuilder
    b=_bundle();builder=ViewMatrixBuilder.fit(b,np.ones(len(b.y),bool))
    _,names=builder.transform(b,('V3',),include_full_context=True,return_feature_names=True)
    assert any('e3_context' in x for x in names)
    assert not any('e1_context' in x for x in names)


def test_shared_controls_have_no_absolute_semester_feature():
    from suite15_views import ViewMatrixBuilder
    b=_bundle();builder=ViewMatrixBuilder.fit(b,np.ones(len(b.y),bool))
    _,names=builder.controls(b,return_feature_names=True)
    assert not any('target_semester' in x.lower() or 'semester_ordinal' in x.lower() for x in names)
    assert any('faculty' in x for x in names)
    assert any('history_semesters' in x for x in names)


def test_residual_probe_initializes_to_exact_anchor_identity_and_is_bounded():
    from suite15_models import ConditionalResidualProbe,apply_residual
    m=ConditionalResidualProbe(input_dim=7,hidden=(8,4),residual_bound=1.5,dropout=0.)
    x=torch.randn(5,7);anchor=torch.tensor([-.2,.1,.7,-1.2,2.])
    delta=m(x)
    assert torch.allclose(delta,torch.zeros_like(delta),atol=1e-8)
    assert torch.allclose(apply_residual(anchor,delta),anchor,atol=1e-8)
    with torch.no_grad():m.out.bias.fill_(100.)
    assert torch.max(torch.abs(m(x))).item()<=1.500001


def test_walk_forward_splits_use_strictly_prior_blocks():
    from suite15_training import walk_forward_splits
    blocks=np.array([1,1,2,2,3,3,4,4],float)
    splits=walk_forward_splits(blocks,min_prior_blocks=2)
    assert [x['predict_block'] for x in splits]==[3.,4.]
    for s in splits:
        assert np.max(blocks[s['train_idx']]) < s['predict_block']
        assert np.max(blocks[s['val_idx']]) < s['predict_block']
        assert set(s['train_idx']).isdisjoint(set(s['val_idx']))
        assert set(s['train_idx']).isdisjoint(set(s['pred_idx']))
        assert set(s['val_idx']).isdisjoint(set(s['pred_idx']))


def test_crossfit_coverage_explicitly_leaves_early_blocks_uncovered():
    from suite15_training import crossfit_coverage_mask
    blocks=np.array([1,1,2,2,3,3,4,4],float)
    m=crossfit_coverage_mask(blocks,min_prior_blocks=2)
    assert np.array_equal(m,np.array([0,0,0,0,1,1,1,1],dtype=bool))


def test_exact_shapley_recovers_additive_view_values():
    from suite15_information import exact_shapley
    vals={'V1':.01,'V2':.02,'V3':.03,'V4':.04}
    perf={}
    from itertools import combinations
    views=tuple(vals)
    for r in range(5):
        for s in combinations(views,r):perf[s]=.5+sum(vals[v] for v in s)
    phi=exact_shapley(perf,views)
    for v,x in vals.items():assert abs(phi[v]-x)<1e-10


def test_pairwise_synergy_detects_positive_interaction():
    from suite15_information import pairwise_synergy
    perf={():.5,('V1',):.51,('V2',):.52,('V1','V2'):.56}
    syn=pairwise_synergy(perf,('V1','V2'))
    assert abs(syn[('V1','V2')]-.03)<1e-10


def test_absorption_index_interpretation():
    from suite15_information import absorption_index
    assert abs(absorption_index(.02,.005)-.75)<1e-12
    assert np.isnan(absorption_index(0.,.01))


def test_cluster_bootstrap_resamples_student_clusters_not_rows():
    from suite15_information import cluster_bootstrap_delta_ap
    y=np.array([0,1,0,1,0,1,0,1]);base=np.array([.1,.4,.8,.3,.7,.6,.2,.5]);cand=np.array([.1,.9,.2,.8,.3,.75,.4,.7]);clusters=np.array(['a','a','b','b','c','c','d','d'])
    out=cluster_bootstrap_delta_ap(y,base,cand,clusters,reps=40,seed=3,return_cluster_draws=True)
    assert len(out['samples'])==40
    assert out['mean']>0
    assert all(all(x in {'a','b','c','d'} for x in draw) for draw in out['cluster_draws'])
    assert all(len(draw)==4 for draw in out['cluster_draws'])


def test_optimal_threshold_metrics_finds_perfect_f1_and_f2_when_separable():
    from suite15_information import optimal_threshold_metrics
    y=np.array([0,0,1,1]);s=np.array([.1,.2,.8,.9])
    a=optimal_threshold_metrics(y,s,beta=1.);b=optimal_threshold_metrics(y,s,beta=2.)
    assert a['f1']==1.0 and b['fbeta']==1.0


def test_view_verdict_thresholds():
    from suite15_information import classify_view_verdict
    assert classify_view_verdict(.012,10,14,ci_low=.003)=='STRONG_INCREMENTAL'
    assert classify_view_verdict(.006,9,14,ci_low=.001)=='MEANINGFUL_INCREMENTAL'
    assert classify_view_verdict(.001,5,14,ci_low=-.003)=='WEAK_OR_REDUNDANT'


def test_tree_probe_pair_detects_incremental_signal():
    from suite15_training import tree_probe_pair
    rng=np.random.default_rng(1);n=1200
    control=rng.normal(size=(n,2));view=rng.normal(size=(n,1));y=(view[:,0]+.2*rng.normal(size=n)>0).astype(int)
    tr=np.arange(800);va=np.arange(800,1200)
    out=tree_probe_pair(control[tr],view[tr],y[tr],control[va],view[va],y[va],max_iter=40,seed=1)
    assert out['view_ap']>out['control_ap']+.20


def test_launcher_points_to_existing_suite15_trainer():
    from pathlib import Path
    root=Path(__file__).resolve().parents[1]
    expected='train_suite15_conditional_information_audit.py'
    sh=root/'run_suite15.sh'
    assert sh.exists()
    text=sh.read_text()
    assert expected in text
    assert (root/expected).exists()

def test_suite15_prepare_utility_has_no_stale_suite14_banner():
    from pathlib import Path
    root=Path(__file__).resolve().parents[1]
    text=(root/'prepare_suite15_structured_cache.py').read_text()
    assert 'SUITE14 STRUCTURED CACHE' not in text
    assert 'SUITE15 STRUCTURED CACHE' in text
