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

import math
from pathlib import Path
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,
    router_diagnostics,
    adapter_diagnostics,
    adapter_parameter_rows,
    seed_everything,
    choose_device,
    logit_tensor,
)

EPS=1e-7


class CompetitiveResponsibilityResidualMoE(SharedPrivateResidualMoE):
    """Suite7 shared-private residual MoE with Suite8-style latent views.

    Unlike Suite8, specialization is driven primarily by row-level competitive
    training responsibilities. The model is designed to be initialized from an
    already fitted Suite7 checkpoint. `view_logits` is the only parameter absent
    from that checkpoint.
    """
    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.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_logit':cf_logit,
            '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 load_suite7_initialization(
    model:CompetitiveResponsibilityResidualMoE,
    checkpoint_path:str|Path,
    expected_faculties:Sequence[str]|None=None,
):
    checkpoint=torch.load(Path(checkpoint_path),map_location='cpu',weights_only=False)
    faculties=list(checkpoint.get('faculties',[]))
    if expected_faculties is not None and faculties and list(expected_faculties)!=faculties:
        raise ValueError(f'Suite7 checkpoint faculty ordering mismatch: expected={list(expected_faculties)} checkpoint={faculties}')
    result=model.load_state_dict(checkpoint['state_dict'],strict=False)
    missing=list(result.missing_keys);unexpected=list(result.unexpected_keys)
    allowed={'view_logits'}
    if set(missing)-allowed or unexpected:
        raise RuntimeError(f'incompatible Suite7 checkpoint: missing={missing} unexpected={unexpected}')
    return {
        'missing_keys':missing,
        'unexpected_keys':unexpected,
        'selected_epoch':checkpoint.get('selected_epoch'),
        'model_config':checkpoint.get('model_config',{}),
        'faculties':faculties,
    }


def counterfactual_losses_and_utility(y,q,counterfactual_prob):
    y=y.float();q=torch.clamp(q.float(),EPS,1-EPS);p=torch.clamp(counterfactual_prob.float(),EPS,1-EPS)
    lq=F.binary_cross_entropy(q,y,reduction='none')
    yy=y[:,None].expand_as(p)
    lk=F.binary_cross_entropy(p,yy,reduction='none')
    utility=lq[:,None]-lk
    return lq,lk,utility


def sparse_competitive_responsibilities(
    y,q,counterfactual_prob,
    temperature:float=0.10,
    top_k:int=2,
    min_expert_utility:float=0.0,
):
    """Create sparse detached responsibility targets over NULL + K experts.

    NULL has utility exactly zero. Experts with raw utility <=
    `min_expert_utility` are ineligible. If no expert is eligible, NULL receives
    all mass. Otherwise a softmax is applied only to the highest `top_k` eligible
    entries among NULL and experts.
    """
    if float(temperature)<=0:raise ValueError('temperature must be > 0')
    if int(top_k)<1:raise ValueError('top_k must be >= 1')
    lq,lk,utility=counterfactual_losses_and_utility(y,q,counterfactual_prob)
    n,k=utility.shape
    scores=torch.cat([torch.zeros((n,1),device=utility.device,dtype=utility.dtype),utility],dim=1)
    eligible=torch.cat([
        torch.ones((n,1),device=utility.device,dtype=torch.bool),
        utility>float(min_expert_utility)
    ],dim=1)
    masked=scores.masked_fill(~eligible,float('-inf'))
    kk=min(int(top_k),k+1)
    vals,idx=torch.topk(masked,k=kk,dim=1)
    valid=torch.isfinite(vals)
    # topk always includes NULL, so each row has >=1 finite value.
    safe_vals=vals.masked_fill(~valid,-1e9)/float(temperature)
    probs=torch.softmax(safe_vals,dim=1)*valid.to(vals.dtype)
    probs=probs/probs.sum(dim=1,keepdim=True).clamp_min(1e-12)
    resp=torch.zeros_like(scores)
    resp.scatter_(1,idx,probs)
    return resp.detach(),utility.detach(),{'committee_loss':lq.detach(),'expert_loss':lk.detach()}


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)/max(math.log(max(k,2)),1e-12)
    load=own.mean(dim=1);target=torch.full_like(load,1.0/k)
    return entropy.mean(),(load-target).pow(2).mean()


def competitive_specialist_loss(
    output,y,q,
    responsibilities:torch.Tensor|None=None,
    responsibility_temperature:float=.10,
    responsibility_top_k:int=2,
    min_expert_utility:float=0.0,
    magnitude_lambda:float=.01,
    view_entropy_lambda:float=.002,
    view_balance_lambda:float=.01,
):
    if responsibilities is None:
        responsibilities,utility,losses=sparse_competitive_responsibilities(
            y,q,output['counterfactual_prob'],responsibility_temperature,
            responsibility_top_k,min_expert_utility,
        )
    else:
        responsibilities=responsibilities.detach()
        _,lk,utility0=counterfactual_losses_and_utility(y,q,output['counterfactual_prob'])
        utility=utility0.detach();losses={'expert_loss':lk.detach()}
    expert_mass=responsibilities[:,1:]
    # Counterfactual expert BCE is recomputed from logits so gradients are stable.
    yy=y.float()[:,None].expand_as(output['counterfactual_logit'])
    lk=F.binary_cross_entropy_with_logits(output['counterfactual_logit'],yy,reduction='none')
    denom=expert_mass.sum().clamp_min(1.0)
    expert=(expert_mass*lk).sum()/denom
    mag=(expert_mass*output['residuals'].pow(2)).sum()/denom
    ve,vb=view_specialization_losses(output['view_ownership'])
    total=expert+float(magnitude_lambda)*mag+float(view_entropy_lambda)*ve+float(view_balance_lambda)*vb
    return {
        'total':total,'expert_prediction':expert,'magnitude':mag,
        'view_entropy':ve,'view_balance':vb,'responsibilities':responsibilities,
        'utility':utility,'expert_mass':expert_mass.detach(),
    }


def router_distillation_loss(
    output,y,q,
    responsibility_temperature:float=.10,
    responsibility_top_k:int=2,
    min_expert_utility:float=0.0,
):
    target,utility,_=sparse_competitive_responsibilities(
        y,q,output['counterfactual_prob'],responsibility_temperature,
        responsibility_top_k,min_expert_utility,
    )
    w=output['weights'].clamp_min(1e-8)
    kl=F.kl_div(torch.log(w),target,reduction='batchmean')
    return {'total':kl,'router_kl':kl,'responsibilities':target,'utility':utility}


def set_trainable_phase(model:CompetitiveResponsibilityResidualMoE,phase:str):
    """Freeze/unfreeze parameters for discovery/router/joint phases."""
    phase=str(phase).lower()
    for p in model.parameters():p.requires_grad=False
    if phase=='discovery':
        for p in model.experts.parameters():p.requires_grad=True
        model.view_logits.requires_grad=True
    elif phase=='router':
        for p in model.router.parameters():p.requires_grad=True
    elif phase=='joint':
        for p in model.experts.parameters():p.requires_grad=True
        for p in model.router.parameters():p.requires_grad=True
        model.view_logits.requires_grad=True
    else:
        raise ValueError(f'unknown phase: {phase}')
    return [p for p in model.parameters() if p.requires_grad]


def ownership_diagnostics(ownership):
    own=np.asarray(ownership,float)
    if own.ndim!=2:raise ValueError('ownership must be K x D')
    k=own.shape[0];own=np.clip(own,1e-12,None);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);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':float(np.mean((load-1.0/k)**2)),
         '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 top_ownership_summary(model:CompetitiveResponsibilityResidualMoE,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)]
        parts.append(f'E{k+1}['+','.join(f'{int(d)}:{own[k,d]:.3f}' for d in idx)+']')
    return ' '.join(parts)


__all__=[
    'CompetitiveResponsibilityResidualMoE','load_suite7_initialization',
    'counterfactual_losses_and_utility','sparse_competitive_responsibilities',
    'competitive_specialist_loss','router_distillation_loss','set_trainable_phase',
    'ownership_diagnostics','expert_view_cosine_diagnostics','top_ownership_summary',
    'router_diagnostics','adapter_diagnostics','adapter_parameter_rows','seed_everything','choose_device',
]
