import numpy as np
import torch

from suite7_shared_private_moe import SharedPrivateResidualMoE
from suite9_competitive_responsibility_moe import (
    CompetitiveResponsibilityResidualMoE,
    sparse_competitive_responsibilities,
    competitive_specialist_loss,
    load_suite7_initialization,
)


def test_null_gets_all_mass_when_no_expert_beats_committee():
    y=torch.tensor([1.,0.])
    q=torch.tensor([0.8,0.2])
    # Both counterfactuals are worse than q for both rows.
    p=torch.tensor([[0.6,0.7],[0.4,0.3]])
    r,u,_=sparse_competitive_responsibilities(y,q,p,temperature=.1,top_k=2,min_expert_utility=0.0)
    assert torch.allclose(r[:,0],torch.ones(2))
    assert torch.allclose(r[:,1:],torch.zeros_like(r[:,1:]))
    assert torch.all(u <= 0)


def test_topk_responsibility_is_sparse_and_normalized():
    y=torch.tensor([1.])
    q=torch.tensor([0.2])
    p=torch.tensor([[0.8,0.6,0.5,0.4]])
    r,u,_=sparse_competitive_responsibilities(y,q,p,temperature=.1,top_k=2,min_expert_utility=0.0)
    assert torch.allclose(r.sum(dim=1),torch.ones(1),atol=1e-6)
    assert int((r[0]>0).sum()) <= 2
    assert r[0,1] > 0  # best expert must receive responsibility
    assert u[0,0] == torch.max(u[0])


def test_competitive_loss_only_updates_experts_with_nonzero_responsibility():
    torch.manual_seed(3)
    model=CompetitiveResponsibilityResidualMoE(
        input_dim=5,n_faculties=1,n_experts=2,faculty_dim=2,
        encoder_hidden=8,representation_dim=6,expert_hidden=4,dropout=0.0,
    )
    # Break Suite7 zero-output symmetry so expert gradients are observable.
    for ex in model.experts:
        torch.nn.init.normal_(ex.net[-1].weight,std=.02)
    x=torch.randn(4,5);fi=torch.zeros(4,dtype=torch.long);q=torch.full((4,),.2);y=torch.ones(4)
    out=model(x,fi,q)
    resp=torch.zeros(4,3);resp[:,1]=1.0  # only expert 1 owns rows
    loss=competitive_specialist_loss(out,y,q,responsibilities=resp,magnitude_lambda=0.0,view_entropy_lambda=0.0,view_balance_lambda=0.0)['total']
    loss.backward()
    g1=sum(float(p.grad.abs().sum()) for p in model.experts[0].parameters() if p.grad is not None)
    g2=sum(float(p.grad.abs().sum()) for p in model.experts[1].parameters() if p.grad is not None)
    assert g1 > 0
    assert g2 == 0


def test_suite7_checkpoint_initialization_preserves_all_shared_private_parameters(tmp_path):
    torch.manual_seed(11)
    base=SharedPrivateResidualMoE(
        input_dim=5,n_faculties=2,n_experts=2,faculty_dim=2,
        encoder_hidden=8,representation_dim=6,expert_hidden=4,dropout=0.0,
        adapter_dim=3,
    )
    path=tmp_path/'shared_private_model.pt'
    torch.save({'state_dict':base.state_dict(),'faculties':['a','b']},path)
    torch.manual_seed(99)
    m=CompetitiveResponsibilityResidualMoE(
        input_dim=5,n_faculties=2,n_experts=2,faculty_dim=2,
        encoder_hidden=8,representation_dim=6,expert_hidden=4,dropout=0.0,
        adapter_dim=3,
    )
    info=load_suite7_initialization(m,path,expected_faculties=['a','b'])
    assert info['missing_keys']==['view_logits']
    assert info['unexpected_keys']==[]
    bsd=base.state_dict();msd=m.state_dict()
    for key,val in bsd.items():
        assert torch.allclose(msd[key],val), key
    assert 'view_logits' in msd
