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

import math
from typing import Sequence

import numpy as np
import torch
from torch import nn
import torch.nn.functional as F

from suite7_shared_private_moe import (
    SharedPrivateResidualMoE,
    capability_targets,
    specialization_mutual_information,
    router_diagnostics,
    adapter_diagnostics,
    adapter_parameter_rows,
    seed_everything,
    choose_device,
    logit_tensor,
)

EPS=1e-7


class TrueSpecialistSharedPrivateResidualMoE(SharedPrivateResidualMoE):
    """Suite7 plus learned expert-specific latent feature ownership.

    All Suite7-equivalent modules are constructed by `super().__init__` first.
    The only additional trainable object is `view_logits`, so same-seed Suite7
    parameters initialize identically. Each latent dimension is softly owned by
    experts via a softmax across experts. Uniform ownership produces unit scaling
    and therefore exactly the Suite7 expert input.
    """
    def __init__(
        self,
        *args,
        view_temperature:float=1.0,
        view_strength:float=0.5,
        view_init_std:float=0.01,
        **kwargs,
    ):
        super().__init__(*args,**kwargs)
        if not (0.0 <= float(view_strength) <= 1.0):
            raise ValueError('view_strength must be in [0,1]')
        if float(view_temperature) <= 0:
            raise ValueError('view_temperature must be > 0')
        self.view_temperature=float(view_temperature)
        self.view_strength=float(view_strength)
        self.view_init_std=float(view_init_std)
        dim=int(self.encoder[-1].normalized_shape[0]) if isinstance(self.encoder[-1],nn.LayerNorm) else int(self.adapters[0].up.out_features)
        self.representation_dim=dim
        self.view_logits=nn.Parameter(torch.zeros(self.n_experts,dim))
        if self.view_init_std>0:
            nn.init.normal_(self.view_logits,mean=0.0,std=self.view_init_std)

    def view_ownership(self):
        return torch.softmax(self.view_logits/max(self.view_temperature,1e-6),dim=0)

    def view_scales(self):
        own=self.view_ownership()
        return (1.0-self.view_strength)+self.view_strength*self.n_experts*own

    def apply_expert_views(self,h:torch.Tensor):
        scales=self.view_scales()
        return h[:,None,:]*scales[None,:,:]

    def forward(self,x,faculty_idx,q):
        e=self.faculty_embedding(faculty_idx)
        h=self.encoder(torch.cat([x,e],dim=1))
        h_adapted,adapter_out=self.apply_faculty_adapters(h,faculty_idx)
        views=self.apply_expert_views(h_adapted)
        residuals=torch.stack([self.experts[k](views[:,k,:]) for k in range(self.n_experts)],dim=1)
        logits=self.router(h_adapted)/max(self.router_temperature,1e-6)
        weights=torch.softmax(logits,dim=1)
        correction=(weights[:,1:]*residuals).sum(dim=1)
        zq=logit_tensor(q)
        final_logit=zq+correction
        cf_logit=zq[:,None]+residuals
        return {
            'final_logit':final_logit,
            'final_prob':torch.sigmoid(final_logit),
            'weights':weights,
            'residuals':residuals,
            'counterfactual_prob':torch.sigmoid(cf_logit),
            'shared_representation':h,
            'adapter_output':adapter_out,
            'adapted_representation':h_adapted,
            'representation':h_adapted,
            'correction':correction,
            'expert_views':views,
            'view_ownership':self.view_ownership(),
            'view_scales':self.view_scales(),
        }


def view_specialization_losses(ownership:torch.Tensor):
    own=ownership.clamp_min(1e-8)
    k=own.shape[0]
    entropy=-(own*torch.log(own)).sum(dim=0)
    norm_entropy=entropy/max(math.log(max(k,2)),1e-12)
    view_entropy=norm_entropy.mean()
    load=own.mean(dim=1)
    target=torch.full_like(load,1.0/k)
    view_balance=(load-target).pow(2).mean()
    return view_entropy,view_balance


def suite8_residual_moe_loss(
    output,y,q,
    router_lambda=0.5,
    specialization_lambda=0.01,
    magnitude_lambda=0.01,
    utility_temperature=0.25,
    view_entropy_lambda=0.02,
    view_balance_lambda=0.02,
):
    y=y.float();q=q.float()
    pred=F.binary_cross_entropy_with_logits(output['final_logit'],y)
    target,utility=capability_targets(y,q,output['counterfactual_prob'],utility_temperature)
    w=output['weights'].clamp_min(1e-8)
    router=F.kl_div(torch.log(w),target,reduction='batchmean')
    mi=specialization_mutual_information(w)
    mag=(w[:,1:].detach()*output['residuals'].pow(2)).sum(dim=1).mean()
    ve,vb=view_specialization_losses(output['view_ownership'])
    total=(pred+float(router_lambda)*router-float(specialization_lambda)*mi+
           float(magnitude_lambda)*mag+float(view_entropy_lambda)*ve+
           float(view_balance_lambda)*vb)
    return {'total':total,'prediction':pred,'router':router,'specialization_mi':mi,
            'magnitude':mag,'view_entropy':ve,'view_balance':vb,
            'utility':utility.detach(),'capability_target':target.detach()}


def ownership_diagnostics(ownership):
    own=np.asarray(ownership,float)
    if own.ndim!=2:raise ValueError('ownership must be K x D')
    k,d=own.shape
    own=np.clip(own,1e-12,None);own=own/np.maximum(own.sum(axis=0,keepdims=True),1e-12)
    ent=-(own*np.log(own)).sum(axis=0)/max(math.log(max(k,2)),1e-12)
    load=own.mean(axis=1)
    imbalance=float(np.mean((load-1.0/k)**2))
    cos=[]
    for i in range(k):
        for j in range(i+1,k):
            den=np.linalg.norm(own[i])*np.linalg.norm(own[j])
            if den>0:cos.append(float(np.dot(own[i],own[j])/den))
    out={'normalized_ownership_entropy':float(np.mean(ent)),
         'ownership_load_imbalance':imbalance,
         'mean_pairwise_ownership_cosine':float(np.mean(cos)) if cos else np.nan}
    for i,v in enumerate(load,1):out[f'ownership_load_expert_{i}']=float(v)
    return out


def expert_view_cosine_diagnostics(views):
    v=np.asarray(views,float)
    if v.ndim!=3:raise ValueError('views must be N x K x D')
    vals=[]
    k=v.shape[1]
    for i in range(k):
        for j in range(i+1,k):
            a=v[:,i,:];b=v[:,j,:]
            den=np.linalg.norm(a,axis=1)*np.linalg.norm(b,axis=1)
            m=den>1e-12
            if np.any(m):vals.extend((np.sum(a[m]*b[m],axis=1)/den[m]).tolist())
    return {'mean_pairwise_view_cosine':float(np.mean(vals)) if vals else np.nan,
            'std_pairwise_view_cosine':float(np.std(vals)) if vals else np.nan}


def counterfactual_utility_diagnostics(y,q,counterfactual_prob):
    y=np.asarray(y,float);q=np.clip(np.asarray(q,float),EPS,1-EPS);p=np.clip(np.asarray(counterfactual_prob,float),EPS,1-EPS)
    if p.ndim!=2 or len(p)!=len(y):raise ValueError('counterfactual_prob must be N x K aligned to y')
    lq=-(y*np.log(q)+(1-y)*np.log(1-q))
    lk=-(y[:,None]*np.log(p)+(1-y)[:,None]*np.log(1-p))
    util=lq[:,None]-lk
    allu=np.concatenate([np.zeros((len(y),1)),util],axis=1)
    winner=np.argmax(allu,axis=1)
    out={'win_rate_null':float(np.mean(winner==0))}
    for k in range(p.shape[1]):
        out[f'win_rate_expert_{k+1}']=float(np.mean(winner==k+1))
        out[f'mean_utility_expert_{k+1}']=float(np.mean(util[:,k]))
        if np.any(y==1):out[f'mean_failure_utility_expert_{k+1}']=float(np.mean(util[y==1,k]))
        if np.any(y==0):out[f'mean_normal_utility_expert_{k+1}']=float(np.mean(util[y==0,k]))
    out['mean_best_nonnull_utility']=float(np.mean(np.max(util,axis=1)))
    out['fraction_any_expert_beats_null']=float(np.mean(np.max(util,axis=1)>0))
    return out


def ownership_rows(model:TrueSpecialistSharedPrivateResidualMoE,fold:int):
    own=model.view_ownership().detach().cpu().numpy();sc=model.view_scales().detach().cpu().numpy()
    rows=[]
    for k in range(own.shape[0]):
        order=np.argsort(-own[k])
        rank=np.empty_like(order);rank[order]=np.arange(1,len(order)+1)
        for d in range(own.shape[1]):
            rows.append({'fold':fold,'expert':k+1,'latent_dim':d,'ownership':float(own[k,d]),'scale':float(sc[k,d]),'rank_within_expert':int(rank[d])})
    return rows


def top_ownership_summary(model:TrueSpecialistSharedPrivateResidualMoE,top_n:int=8):
    own=model.view_ownership().detach().cpu().numpy();parts=[]
    for k in range(own.shape[0]):
        idx=np.argsort(-own[k])[:int(top_n)]
        s=','.join(f'{int(d)}:{own[k,d]:.3f}' for d in idx)
        parts.append(f'E{k+1}[{s}]')
    return ' '.join(parts)


__all__=[
    'TrueSpecialistSharedPrivateResidualMoE','suite8_residual_moe_loss','ownership_diagnostics',
    'expert_view_cosine_diagnostics','counterfactual_utility_diagnostics','ownership_rows',
    'top_ownership_summary','router_diagnostics','adapter_diagnostics','adapter_parameter_rows',
    'seed_everything','choose_device',
]
