"""Suite29: permutation-equivariant masked set attention (one logit per course)."""
from __future__ import annotations
import math
import torch
from torch import nn
from torch.nn import functional as F

class EnrollmentSetNet(nn.Module):
    def __init__(self, n_features, n_faculties, width=128, heads=4, dropout=.1):
        super().__init__()
        if width % heads: raise ValueError("width must divide heads")
        self.width, self.heads, self.dk = width, heads, width // heads
        self.faculty = nn.Embedding(n_faculties, 12)
        self.encoder = nn.Sequential(nn.Linear(n_features+13,width),nn.LayerNorm(width),
             nn.GELU(),nn.Linear(width,width),nn.LayerNorm(width),nn.GELU())
        self.qkv = nn.Linear(width,3*width)
        self.null_k = nn.Parameter(torch.randn(1,heads,1,self.dk)*.02)
        self.null_v = nn.Parameter(torch.randn(1,heads,1,self.dk)*.02)
        self.attn_out = nn.Linear(width,width)
        self.norm = nn.LayerNorm(width)
        self.ff = nn.Sequential(nn.Linear(width,2*width),nn.GELU(),nn.Dropout(dropout),nn.Linear(2*width,width))
        self.head = nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width//2),
                                  nn.GELU(),nn.Dropout(dropout),nn.Linear(width//2,1))
        self.dropout=nn.Dropout(dropout)

    def forward(self,x,valid,faculty,semester_z,mode="set",diagnostics=False):
        """x [B,M,D], valid [B,M], faculty [B,M], semester_z [B,M]."""
        if mode not in ("set","self_only"): raise ValueError(mode)
        valid=valid.bool()
        if (~valid.any(1)).any(): raise ValueError("Empty enrollment set")
        b,m,_=x.shape; h=self.encoder(torch.cat([x,self.faculty(faculty),semester_z.unsqueeze(-1)],-1))
        q,k,v=self.qkv(h).chunk(3,-1)
        reshape=lambda t:t.view(b,m,self.heads,self.dk).transpose(1,2)
        q,k,v=map(reshape,(q,k,v))
        k=torch.cat([k,self.null_k.expand(b,-1,-1,-1)],2)
        v=torch.cat([v,self.null_v.expand(b,-1,-1,-1)],2)
        score=q@k.transpose(-1,-2)/math.sqrt(self.dk)
        keys=torch.cat([valid,valid.new_ones((b,1))],1)
        allow=keys[:,None,None,:]
        if mode=="self_only":
            diag=torch.eye(m,device=x.device,dtype=torch.bool)
            self_null=torch.cat([diag,torch.ones(m,1,device=x.device,dtype=torch.bool)],1)
            allow=allow & self_null[None,None,:,:]
        score=score.masked_fill(~allow,torch.finfo(score.dtype).min)
        a=F.softmax(score,dim=-1)*valid[:,None,:,None].to(score.dtype)
        c=(a@v).transpose(1,2).contiguous().view(b,m,self.width)
        h=h+self.dropout(self.attn_out(c))
        h=h+self.ff(self.norm(h))
        logits=self.head(h).squeeze(-1).masked_fill(~valid,0.)
        if not diagnostics:return logits
        diag=torch.eye(m,device=x.device,dtype=a.dtype)[None,None,:,:]
        real=a[...,:m]; denom=valid.sum().clamp_min(1)*self.heads
        diag_self=(real*diag).sum()/denom
        peer=(real*(1-diag)).sum()/denom
        null=a[...,-1].sum()/denom
        return logits,{"self_mass":diag_self,"peer_mass":peer,"null_mass":null,
            # Per-real-registration attention allocation for later stratification.
            # Already averaged across heads, so each valid query sums to one.
            "row_self_mass":(real*diag).sum(-1).mean(1),
            "row_peer_mass":(real*(1-diag)).sum(-1).mean(1),
            "row_null_mass":a[...,-1].mean(1)}

def masked_bce(logits,y,valid):
    return F.binary_cross_entropy_with_logits(logits[valid],y[valid].float())
