import numpy as np
import torch

from suite8_true_specialist_moe import (
    TrueSpecialistSharedPrivateResidualMoE,
    ownership_diagnostics,
    suite8_residual_moe_loss,
)


def _model(view_init_std=0.0):
    return TrueSpecialistSharedPrivateResidualMoE(
        input_dim=10,n_faculties=3,n_experts=4,faculty_dim=3,
        encoder_hidden=16,representation_dim=12,expert_hidden=8,
        delta_max=2.0,dropout=0.0,router_temperature=1.0,
        adapter_dim=4,adapter_dropout=0.0,adapter_scale=1.0,
        view_temperature=1.0,view_strength=0.5,view_init_std=view_init_std,
    )


def test_suite8_starts_exactly_at_committee():
    torch.manual_seed(9)
    m=_model(view_init_std=0.01)
    x=torch.randn(7,10);f=torch.tensor([0,1,2,0,1,2,1]);q=torch.tensor([.1,.2,.3,.4,.5,.6,.7])
    out=m(x,f,q)
    assert torch.allclose(out['final_prob'],q,atol=1e-6)


def test_uniform_ownership_is_identity_view():
    torch.manual_seed(9)
    m=_model(view_init_std=0.0)
    own=m.view_ownership()
    scales=m.view_scales()
    assert torch.allclose(own,torch.full_like(own,.25),atol=1e-7)
    assert torch.allclose(scales,torch.ones_like(scales),atol=1e-7)
    h=torch.randn(5,12)
    views=m.apply_expert_views(h)
    for k in range(4):
        assert torch.allclose(views[:,k,:],h,atol=1e-7)


def test_ownership_columns_sum_to_one_and_load_is_balanced_at_uniform():
    m=_model(view_init_std=0.0)
    own=m.view_ownership()
    assert torch.allclose(own.sum(dim=0),torch.ones(own.shape[1]),atol=1e-7)
    d=ownership_diagnostics(own.detach().cpu().numpy())
    assert np.isclose(d['normalized_ownership_entropy'],1.0)
    assert np.isclose(d['ownership_load_imbalance'],0.0)


def test_suite8_loss_has_view_terms_and_is_finite():
    torch.manual_seed(12);m=_model(view_init_std=0.01)
    x=torch.randn(16,10);f=torch.tensor([0,1,2,0]*4);q=torch.full((16,),.2);y=torch.tensor([0.,1.]*8)
    out=m(x,f,q)
    ls=suite8_residual_moe_loss(out,y,q,view_entropy_lambda=.02,view_balance_lambda=.02)
    assert {'view_entropy','view_balance','total'} <= set(ls)
    assert torch.isfinite(ls['total'])


def test_view_logits_wake_up_after_optimization():
    torch.manual_seed(17);m=_model(view_init_std=0.01)
    before=m.view_logits.detach().clone()
    opt=torch.optim.AdamW(m.parameters(),lr=1e-2,weight_decay=0.0)
    f=torch.tensor([0,1]*16);q=torch.full((32,),.2);y=torch.tensor([0.,1.]*16)
    for _ in range(3):
        x=torch.randn(32,10);opt.zero_grad();out=m(x,f,q)
        loss=suite8_residual_moe_loss(out,y,q,view_entropy_lambda=.05,view_balance_lambda=.02)['total']
        loss.backward();opt.step()
    assert not torch.allclose(before,m.view_logits.detach())


def test_suite8_preserves_suite7_module_initialization_before_views():
    from suite7_shared_private_moe import SharedPrivateResidualMoE
    kwargs=dict(input_dim=10,n_faculties=3,n_experts=4,faculty_dim=3,encoder_hidden=16,
                representation_dim=12,expert_hidden=8,delta_max=2.0,dropout=0.0,
                router_temperature=1.0,adapter_dim=4,adapter_dropout=0.0,adapter_scale=1.0)
    torch.manual_seed(123);s7=SharedPrivateResidualMoE(**kwargs)
    torch.manual_seed(123);s8=TrueSpecialistSharedPrivateResidualMoE(**kwargs,view_init_std=0.01)
    s7_named=dict(s7.named_parameters());s8_named=dict(s8.named_parameters())
    for name,p in s7_named.items():
        assert name in s8_named
        assert torch.equal(p,s8_named[name]),name
