# -*- coding: utf-8 -*-
from __future__ import annotations
import torch
from torch import nn


def _logit(p):
    p=p.clamp(1e-5,1-1e-5);return torch.log(p)-torch.log1p(-p)

def _mlp(inp,hid,out,drop=.1):
    return nn.Sequential(nn.Linear(inp,hid),nn.LayerNorm(hid),nn.GELU(),nn.Dropout(drop),nn.Linear(hid,out))

class CommitteePreservingGlobalExpert(nn.Module):
    """Suite14 E0 architecture, isolated for Suite15 anchor generation."""
    def __init__(self,flat_dim,context_dim,n_faculties,d_model=64,faculty_dim=8,residual_bound=2.5,dropout=.1):
        super().__init__();self.fac=nn.Embedding(n_faculties,faculty_dim);self.residual_bound=float(residual_bound)
        self.backbone=nn.Sequential(nn.Linear(flat_dim+context_dim+faculty_dim,2*d_model),nn.LayerNorm(2*d_model),nn.GELU(),nn.Dropout(dropout),nn.Linear(2*d_model,d_model),nn.LayerNorm(d_model),nn.GELU())
        self.teacher_branch=_mlp(10,d_model,d_model,dropout);self.fuse=nn.Sequential(nn.Linear(2*d_model,d_model),nn.LayerNorm(d_model),nn.GELU());self.residual=nn.Linear(d_model,1);self.teacher_recon=nn.Linear(d_model,3);self.skip_norm=nn.LayerNorm(d_model)
        skip=torch.zeros(10,d_model);n=min(10,d_model);skip[:n,:n]=torch.eye(n);self.register_buffer('teacher_skip_matrix',skip);nn.init.zeros_(self.residual.weight);nn.init.zeros_(self.residual.bias)
    def teacher_features(self,p):
        p=p.clamp(1e-5,1-1e-5);q=p.mean(1,keepdim=True);lg=_logit(p);std=p.std(1,keepdim=True,unbiased=False);spread=p.max(1,keepdim=True).values-p.min(1,keepdim=True).values;ent=-(q*torch.log(q)+(1-q)*torch.log(1-q));return torch.cat([p,lg,q,std,spread,ent],1)
    def forward(self,flat,context,faculty,committee_probs):
        features=self.teacher_features(committee_probs);neural=self.backbone(torch.cat([flat,context,self.fac(faculty)],1));te=self.teacher_branch(features);learned=self.fuse(torch.cat([neural,te],1));skip=features@self.teacher_skip_matrix;h=self.skip_norm(learned+skip);raw=self.residual(h).squeeze(1);delta=self.residual_bound*torch.tanh(raw/max(self.residual_bound,1e-6));q=committee_probs.mean(1).clamp(1e-5,1-1e-5);return {'logit':_logit(q)+delta,'teacher_logits':self.teacher_recon(h),'delta':delta,'representation':h}

class ConditionalResidualProbe(nn.Module):
    def __init__(self,input_dim,hidden=(256,128),residual_bound=2.0,dropout=.1):
        super().__init__();dims=[int(input_dim),*map(int,hidden)];layers=[]
        for a,b in zip(dims[:-1],dims[1:]):layers.extend([nn.Linear(a,b),nn.LayerNorm(b),nn.GELU(),nn.Dropout(dropout)])
        self.backbone=nn.Sequential(*layers) if layers else nn.Identity();self.out=nn.Linear(dims[-1],1);self.residual_bound=float(residual_bound);nn.init.zeros_(self.out.weight);nn.init.zeros_(self.out.bias)
    def forward(self,x):
        raw=self.out(self.backbone(x)).squeeze(1)
        return self.residual_bound*torch.tanh(raw/max(self.residual_bound,1e-6)) if self.residual_bound>0 else raw

def apply_residual(anchor_logit,delta):return anchor_logit+delta
