import numpy as np
import torch

from suite7_shared_private_moe import (
    FacultyAdapter,
    SharedPrivateResidualMoE,
    adapter_diagnostics,
)


def test_adapter_starts_as_exact_identity_residual():
    torch.manual_seed(7)
    a=FacultyAdapter(12,4,dropout=0.0)
    h=torch.randn(6,12)
    out=a(h)
    assert torch.count_nonzero(a.down.weight).item()>0
    assert torch.count_nonzero(a.up.weight).item()==0
    assert torch.count_nonzero(a.up.bias).item()==0
    assert torch.equal(out,torch.zeros_like(out))


def test_suite7_starts_at_committee_and_adapter_representation_is_shared():
    torch.manual_seed(9)
    m=SharedPrivateResidualMoE(
        input_dim=10,n_faculties=3,n_experts=4,faculty_dim=3,
        encoder_hidden=16,representation_dim=12,expert_hidden=8,
        adapter_dim=4,dropout=0.0,delta_max=2.0,router_temperature=1.0,
    )
    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)
    assert torch.allclose(out['adapter_output'],torch.zeros_like(out['adapter_output']))
    assert torch.allclose(out['shared_representation'],out['adapted_representation'])


def test_faculty_adapters_are_private():
    torch.manual_seed(11)
    m=SharedPrivateResidualMoE(
        input_dim=5,n_faculties=2,n_experts=2,faculty_dim=2,
        encoder_hidden=8,representation_dim=6,expert_hidden=4,
        adapter_dim=3,dropout=0.0,
    )
    # Make faculty 0 adapter active while faculty 1 remains exact zero.
    with torch.no_grad():
        m.adapters[0].up.weight.fill_(0.25)
        m.adapters[0].up.bias.fill_(0.1)
    x=torch.randn(2,5)
    # duplicate input so difference comes from faculty path (embedding also differs,
    # therefore compare private adapter output directly rather than h).
    x[1]=x[0]
    q=torch.tensor([.2,.2])
    out=m(x,torch.tensor([0,1]),q)
    assert out['adapter_output'][0].abs().sum().item()>0
    assert torch.allclose(out['adapter_output'][1],torch.zeros_like(out['adapter_output'][1]))


def test_adapter_diagnostics_reports_identity_at_initialization():
    h=np.array([[1.,0.],[0.,2.]])
    a=np.zeros_like(h)
    hf=h.copy()
    d=adapter_diagnostics(h,a,hf)
    assert d['mean_adapter_norm']==0.0
    assert d['mean_relative_adapter_norm']==0.0
    assert np.isclose(d['mean_representation_cosine'],1.0)


def test_zero_up_adapter_wakes_up_after_shared_residual_path_learns():
    from suite7_shared_private_moe import residual_moe_loss
    torch.manual_seed(17)
    m=SharedPrivateResidualMoE(
        input_dim=5,n_faculties=2,n_experts=2,faculty_dim=2,
        encoder_hidden=8,representation_dim=6,expert_hidden=4,
        adapter_dim=3,dropout=0.0,adapter_dropout=0.0,
    )
    opt=torch.optim.AdamW(m.parameters(),lr=1e-2,weight_decay=0.0)
    f=torch.tensor([0,1]*8)
    q=torch.full((16,),0.2)
    y=torch.tensor([0.,1.]*8)
    # First minibatch teaches the zero-initialized residual output layers.
    x=torch.randn(16,5);opt.zero_grad();out=m(x,f,q);loss=residual_moe_loss(out,y,q)['total'];loss.backward();opt.step()
    assert sum(a.up.weight.abs().sum().item() for a in m.adapters)>0
    # On the next minibatch, the now-active up projection propagates gradient
    # into the adapter's down projection.
    x=torch.randn(16,5);opt.zero_grad();out=m(x,f,q);loss=residual_moe_loss(out,y,q)['total'];loss.backward()
    assert sum(a.down.weight.grad.abs().sum().item() for a in m.adapters)>0
