"""Differentiable prequential Gaussian readiness filter with coherent ordinal likelihood."""
from __future__ import annotations
import math
import torch
from torch import nn
from torch.nn import functional as F

GRADE_BOUNDS=[5.,6.,7.,8.,9.]

def grade_bins(grade):
    return torch.bucketize(torch.nan_to_num(grade,nan=0.),torch.tensor(GRADE_BOUNDS,device=grade.device,dtype=grade.dtype),right=True)

def ordinal_probabilities(utility,kappa):
    """utility [...], kappa [...,5], returns [...,6]. Failure is exactly bin 0."""
    c=torch.sigmoid(kappa-utility.unsqueeze(-1))
    return torch.cat([c[...,:1],c[...,1:]-c[...,:-1],1-c[...,-1:]],dim=-1).clamp_min(1.e-7)

def ordinal_score_fisher(utility,kappa,grade,label):
    """Analytic score ∂log L/∂utility and expected scalar Fisher I_u."""
    c=torch.sigmoid(kappa-utility.unsqueeze(-1)); dc=-c*(1.-c)
    p=torch.cat([c[...,:1],c[...,1:]-c[...,:-1],1.-c[...,-1:]],dim=-1).clamp_min(1.e-7)
    dp=torch.cat([dc[...,:1],dc[...,1:]-dc[...,:-1],-dc[...,-1:]],dim=-1)
    gb=grade_bins(grade).unsqueeze(-1)
    score_ord=torch.gather(dp/p,-1,gb).squeeze(-1)
    fish_ord=(dp.square()/p).sum(-1)
    fail=c[...,0];score_bin=fail-label;fish_bin=fail*(1.-fail)
    present=torch.isfinite(grade)
    return torch.where(present,score_ord,score_bin),torch.where(present,fish_ord,fish_bin)

class CourseEncoder(nn.Module):
    def __init__(self,faculty_count,course_dim,id_vocab,k=4,kind='bottleneck',width=48):
        super().__init__();self.k=k;self.kind=kind
        self.meta=nn.Sequential(nn.Linear(course_dim,width),nn.GELU(),nn.Linear(width,k if kind=='bottleneck' else k+1))
        self.faculty=nn.Embedding(faculty_count,k if kind=='bottleneck' else k+1)
        self.id=nn.Embedding(id_vocab,k if kind=='bottleneck' else k+1,padding_idx=0)
        nn.init.normal_(self.faculty.weight,std=.015);nn.init.zeros_(self.id.weight)
        nn.init.zeros_(self.meta[-1].weight);nn.init.zeros_(self.meta[-1].bias)
        with torch.no_grad():
            if kind=='bottleneck':self.meta[-1].bias.fill_(-3.2)
            else:self.meta[-1].bias[-1]=-3.2
    def forward(self,meta,faculty,course_id,count,shrink=12.):
        d=self.meta(meta)+self.faculty(faculty).unsqueeze(-2)
        r=self.id(course_id)*(count/(count+shrink)).unsqueeze(-1)
        if self.kind=='bottleneck':return d+r
        return d+r

class ReadinessModel(nn.Module):
    def __init__(self,context_dim,course_dim,faculty_count,id_vocab,k=4,kind='bottleneck',context_only=False,binary_only=False,
                 tau=.65,discount=.7,damping=.65,draws_train=8,draws_eval=32,seed=71):
        super().__init__();self.k=k;self.kind=kind;self.context_only=context_only;self.binary_only=binary_only
        self.tau=tau;self.discount=discount;self.damping=damping;self.n_draws_train=draws_train;self.n_draws_eval=draws_eval
        self.context=nn.Sequential(nn.Linear(context_dim,48),nn.GELU(),nn.Linear(48,k+k+2*k))
        # Context variance is diagonal plus low-rank; zero-initialized factor starts with valid SPD diagonal.
        nn.init.normal_(self.context[-1].weight,std=.004);nn.init.zeros_(self.context[-1].bias)
        with torch.no_grad():self.context[-1].bias[k:2*k]=-1.
        self.course=CourseEncoder(faculty_count,course_dim,id_vocab,k,kind)
        self.ord_raw=nn.Parameter(torch.full((faculty_count,4),math.log(math.exp(.8)-1)))
        self.process_log=nn.Parameter(torch.full((k,),-4.))
        self.rho_logit=nn.Parameter(torch.tensor(1.5))
        # Gain fixed in pilot to protect scale; no free intercept behind utility.
        self.register_buffer('base_eps',self._sobol(draws_eval,k,seed))
        self.register_buffer('eye',torch.eye(k))
    @staticmethod
    def _sobol(n,k,seed):
        if n%2:raise ValueError('Antithetic draw count must be even')
        u=torch.quasirandom.SobolEngine(k,scramble=True,seed=seed).draw(n//2).clamp(1e-5,1-1e-5)
        z=(2**.5)*torch.erfinv(2*u-1)
        return torch.cat([z,-z],dim=0)
    def ctx(self,x):
        z=self.context(x);k=self.k;mean=z[:,:k];diag=F.softplus(z[:,k:2*k])+.08
        factors=z[:,2*k:].reshape(-1,k,2)*.16
        cov=torch.diag_embed(diag)+factors@factors.transpose(-1,-2)
        return mean,cov
    def forecast(self,x,old_mu,old_cov,gap,has_old):
        mean,cov=self.ctx(x)
        rho=(torch.sigmoid(self.rho_logit)*torch.exp(-F.softplus(self.process_log.mean())*torch.clamp(gap-1,min=0))).clamp(.01,.99)
        rho=torch.where(has_old,rho,torch.zeros_like(rho));r=rho.unsqueeze(-1);R=r.unsqueeze(-1)
        mu=r*old_mu+(1-r)*mean
        out=R.square()*old_cov+(1-R.square())*cov+torch.clamp(gap,min=1).view(-1,1,1)*torch.diag_embed(F.softplus(self.process_log)).unsqueeze(0)
        return mu,out,rho
    def thresholds(self,faculty):
        inc=F.softplus(self.ord_raw[faculty]).clamp(.12,3.)
        return torch.cat([torch.zeros((*faculty.shape,1),device=faculty.device,dtype=inc.dtype),torch.cumsum(inc,-1)],-1)
    def score(self,theta,cp):
        if self.kind=='bottleneck':
            d=torch.logsumexp((cp-theta)/self.tau,dim=-1)-math.log(self.k)
            return -self.tau*d  # success utility; θ↑ => utility↑
        raw_a=F.softplus(cp[...,:self.k])+.05
        a=raw_a / math.sqrt(self.k)
        return (a*theta).sum(-1)-cp[...,-1]
    def slope(self,mu,cp):
        if self.kind=='bottleneck':return torch.softmax((cp-mu.unsqueeze(1))/self.tau,dim=-1)
        return (F.softplus(cp[...,:self.k])+.05)/math.sqrt(self.k)
    def predict_bins(self,mu,cov,cp,kappa,draws):
        B=mu.shape[0];n=cp.shape[1];S=int(draws)
        L=torch.linalg.cholesky(cov+self.eye.unsqueeze(0)*1e-5)
        theta=mu[:,None,:]+torch.einsum('bij,sj->bsi',L,self.base_eps[:S])
        u=self.score(theta[:,:,None,:],cp[:,None,:,:])
        probs=ordinal_probabilities(u,kappa[:,None,:,:]);return probs.mean(dim=1)
    def assimilate(self,mu,cov,cp,kappa,grade,y,eligible):
        # A single order-invariant Fisher update for all released courses of one semester.
        util=self.score(mu[:,None,:],cp)
        grad_scalar,fisher_scalar=ordinal_score_fisher(util,kappa,grade,y)
        slope=self.slope(mu,cp)
        mm=eligible.float()
        g=(grad_scalar*mm).unsqueeze(-1)*slope
        g=g.sum(1)*self.discount
        f=(fisher_scalar*mm).unsqueeze(-1).unsqueeze(-1)*slope.unsqueeze(-1)*slope.unsqueeze(-2)
        f=f.sum(1)*self.discount
        prec=torch.cholesky_inverse(torch.linalg.cholesky(cov+self.eye[None]*1e-5))
        post_prec=prec+f+self.eye[None]*1e-5
        LL=torch.linalg.cholesky(post_prec)
        post_cov=torch.cholesky_inverse(LL)
        displacement=torch.cholesky_solve(g.unsqueeze(-1),LL).squeeze(-1)*self.damping
        post_mu=mu+displacement
        active=eligible.any(dim=-1)
        return torch.where(active.unsqueeze(-1),post_mu,mu),torch.where(active[:,None,None],post_cov,cov),displacement,f
    def forward(self,batch,eval_draws=False,intervention=None,return_debug=False):
        B,T,M=batch['mask'].shape;device=batch['mask'].device
        old_mu=torch.zeros(B,self.k,device=device);old_cov=self.eye[None].expand(B,-1,-1).clone()
        old_sem=torch.zeros(B,device=device);had=torch.zeros(B,device=device,dtype=torch.bool);history_count=torch.zeros(B,device=device)
        outputs=[];loss_sum=torch.zeros((),device=device);loss_rows=torch.zeros((),device=device)
        anchor=torch.zeros((),device=device);anchor_terms=0
        diag={'updates':[],'rho':[],'mu':[],'cov_eigs':[],'support':[],'prior_var':[],'grad_dir':[],'fisher_trace':[]}
        for t in range(T):
            mask=batch['mask'][:,t];valid=batch['term_valid'][:,t]
            if not valid.any():continue
            sem=batch['semester'][:,t];gap=torch.where(had,(sem-old_sem).clamp(min=1),torch.ones_like(sem))
            mu,cov,rho=self.forecast(batch['context'][:,t],old_mu,old_cov,gap,had)
            if self.training:
                anchor=anchor+(mu[valid].mean(0).square().mean())
                anchor_terms+=1
            fac=batch['faculty'][:,t];cp=self.course(batch['course_meta'][:,t],fac,batch['course_id'][:,t],batch['course_count'][:,t]);kappa=self.thresholds(fac).unsqueeze(1).expand(-1,M,-1)
            p=self.predict_bins(mu,cov,cp,kappa,self.n_draws_eval if eval_draws else self.n_draws_train)
            if intervention=='mean_only':
                u=self.score(mu[:,None,:],cp);p=ordinal_probabilities(u,kappa)
            pred=p[...,0]
            gradtheta=self.slope(mu,cp)
            projected=torch.einsum('bmk,bkl,bml->bm',gradtheta,cov,gradtheta).clamp_min(0)
            target_extra={'projected_variance':projected,'history_count':history_count[:,None].expand(-1,M),
                          'mu_norm':torch.linalg.vector_norm(mu,dim=-1)[:,None].expand(-1,M),
                          'cov_trace':torch.diagonal(cov,dim1=-2,dim2=-1).sum(-1)[:,None].expand(-1,M),
                          'retention':rho[:,None].expand(-1,M)}
            for bin_id in range(6):target_extra[f'gradebin_{bin_id}']=p[...,bin_id]
            outputs.append((t,pred,batch['result_index'][:,t].clone(),mask.clone(),target_extra))
            update=mask&batch['update'][:,t]
            if self.training and intervention!='score_only':
                if self.binary_only:
                    obs=torch.where(batch['label'][:,t]>0.5,p[...,0],1-p[...,0]).clamp_min(1e-7)
                else:
                    b=grade_bins(batch['grade'][:,t]);prob_grade=torch.gather(p,-1,b.unsqueeze(-1)).squeeze(-1)
                    obs=torch.where(torch.isfinite(batch['grade'][:,t]),prob_grade,torch.where(batch['label'][:,t]>0.5,p[...,0],1-p[...,0])).clamp_min(1e-7)
                loss_sum=loss_sum-(torch.log(obs)*update).sum();loss_rows=loss_rows+update.float().sum()
            if self.context_only or intervention in ('no_history','score_only'):
                nxt_mu,nxt_cov=mu,cov;shift=torch.zeros_like(mu);fish=torch.zeros(B,self.k,self.k,device=device)
            else:
                ugrade=batch['grade'][:,t]
                if self.binary_only:ugrade=torch.full_like(ugrade,float('nan'))
                if intervention=='no_grade':ugrade=torch.full_like(ugrade,float('nan'))
                uy=batch['label'][:,t]
                if intervention=='shuffle_outcomes':uy=torch.roll(uy,1,1);ugrade=torch.roll(ugrade,1,1)
                nxt_mu,nxt_cov,shift,fish=self.assimilate(mu,cov,cp,kappa,ugrade,uy,update)
            # Preserve previous state on padded terms. Earlier outcomes are assimilated after prediction.
            old_mu=torch.where(valid[:,None],nxt_mu,old_mu)
            old_cov=torch.where(valid[:,None,None],nxt_cov,old_cov)
            had=had | (valid&update.any(1));old_sem=torch.where(valid,sem,old_sem)
            history_count=history_count+update.float().sum(1)
            if return_debug:
                diag['updates'].append(shift.detach());diag['rho'].append(rho.detach());diag['mu'].append(mu.detach())
                diag['cov_eigs'].append(torch.linalg.eigvalsh(cov.detach()));diag['support'].append(update.sum(1).detach())
                diag['prior_var'].append(torch.diagonal(cov,dim1=-2,dim2=-1).detach())
                diag['grad_dir'].append(shift.detach());diag['fisher_trace'].append(torch.diagonal(fish,dim1=-2,dim2=-1).sum(-1).detach())
        return loss_sum/loss_rows.clamp_min(1)+.0005*anchor/max(anchor_terms,1),outputs,diag
