# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
import json
import math
import re
from pathlib import Path

import numpy as np
from sklearn.cluster import MiniBatchKMeans

EPS = 1e-7


def base_probability_columns(feature_names):
    pairs=[]
    for i,n in enumerate(feature_names):
        m=re.fullmatch(r'probability__expert_(\d+)',str(n))
        if m:pairs.append((int(m.group(1)),i))
    if not pairs:
        raise ValueError('no probability__expert_* columns found in shared feature schema')
    return [i for _,i in sorted(pairs)]


def extract_base_probabilities(X, feature_names):
    cols=base_probability_columns(feature_names)
    p=np.asarray(X,float)[:,cols]
    return np.clip(p,EPS,1-EPS)


def _bce_prob(y,p):
    y=np.asarray(y,float)
    p=np.clip(np.asarray(p,float),EPS,1-EPS)
    return -(y*np.log(p)+(1-y)*np.log(1-p))


def _group_percentile(values, faculty_idx, blocks):
    values=np.asarray(values,float);faculty_idx=np.asarray(faculty_idx,int);blocks=np.asarray(blocks,float)
    out=np.full(len(values),.5,float)
    keys=np.column_stack([faculty_idx, np.nan_to_num(blocks,nan=-1e18)])
    for key in np.unique(keys,axis=0):
        m=(keys[:,0]==key[0])&(keys[:,1]==key[1]);idx=np.where(m)[0]
        if len(idx)==0:continue
        v=values[idx];order=np.argsort(v,kind='mergesort');ranks=np.empty(len(v),float);ranks[order]=(np.arange(len(v))+0.5)/len(v);out[idx]=ranks
    return out


@dataclass
class OpportunitySignature:
    features: np.ndarray
    feature_names: list[str]
    opportunity_score: np.ndarray
    committee_rank: np.ndarray


def build_opportunity_signature(y,q,base_probs,faculty_idx,blocks):
    y=np.asarray(y,int);q=np.clip(np.asarray(q,float),EPS,1-EPS);base=np.clip(np.asarray(base_probs,float),EPS,1-EPS)
    if base.ndim!=2 or len(base)!=len(y):raise ValueError('base_probs must be N x M and align with y')
    committee_loss=_bce_prob(y,q)
    expert_loss=np.column_stack([_bce_prob(y,base[:,k]) for k in range(base.shape[1])])
    utility=committee_loss[:,None]-expert_loss
    qrank=_group_percentile(q,faculty_idx,blocks)
    disagreement_std=base.std(axis=1);disagreement_spread=base.max(axis=1)-base.min(axis=1)
    best_utility=utility.max(axis=1);utility_std=utility.std(axis=1);utility_spread=utility.max(axis=1)-utility.min(axis=1)
    signed_error=y-q
    missed_failure=y*(1.0-q)
    false_alarm=(1-y)*q
    missed_rank=y*(1.0-qrank)
    false_alarm_rank=(1-y)*qrank
    entropy=-(q*np.log(q)+(1-q)*np.log(1-q))
    cols=[];names=[]
    for k in range(base.shape[1]):cols.append(utility[:,k]);names.append(f'base_utility_{k}')
    cols += [committee_loss,signed_error,missed_failure,false_alarm,missed_rank,false_alarm_rank,
             q,qrank,disagreement_std,disagreement_spread,best_utility,utility_std,utility_spread,entropy]
    names += ['committee_loss','signed_error','missed_failure_severity','false_alarm_severity',
              'missed_failure_rank_severity','false_alarm_rank_severity','committee_probability','committee_rank',
              'base_disagreement_std','base_disagreement_spread','best_base_utility','base_utility_std','base_utility_spread','committee_entropy']
    features=np.column_stack(cols)
    # Opportunity score deliberately emphasizes failures that the committee ranks/probabilities too low,
    # while still retaining false-alarm and expert-disagreement opportunities for precision.
    opportunity_score=(committee_loss + 0.75*missed_failure + 0.75*missed_rank + 0.20*false_alarm +
                       0.15*false_alarm_rank + 0.50*np.maximum(best_utility,0.0) + 0.20*disagreement_spread)
    return OpportunitySignature(np.nan_to_num(features,nan=0.0,posinf=0.0,neginf=0.0).astype(np.float32),names,
                                np.nan_to_num(opportunity_score,nan=0.0,posinf=0.0,neginf=0.0).astype(np.float32),qrank.astype(np.float32))


def _group_quantile_mask(score,faculty_idx,blocks,quantile):
    score=np.asarray(score,float);faculty_idx=np.asarray(faculty_idx,int);blocks=np.asarray(blocks,float)
    mask=np.zeros(len(score),bool);keys=np.column_stack([faculty_idx,np.nan_to_num(blocks,nan=-1e18)])
    q=float(np.clip(quantile,0.0,1.0))
    for key in np.unique(keys,axis=0):
        m=(keys[:,0]==key[0])&(keys[:,1]==key[1]);idx=np.where(m)[0]
        if len(idx)==0:continue
        thr=float(np.quantile(score[idx],q));mask[idx]=score[idx]>=thr
    return mask


def _softmax_rows(z):
    z=np.asarray(z,float);z=z-z.max(axis=1,keepdims=True);e=np.exp(np.clip(z,-60,60));return e/np.maximum(e.sum(axis=1,keepdims=True),EPS)


class OpportunityDomainDiscoverer:
    """Discover NULL + K latent domains from chronology-safe OOF opportunity signatures.

    Domain discovery can use historical labels because it is fit only on historical OOF rows.
    Deployment never calls this object with target labels; a separate prospective router predicts
    the discovered domain from observable model inputs.
    """
    def __init__(self,n_domains=4,opportunity_quantile=.65,temperature=.75,seed=42,max_cluster_rows=150000,batch_size=4096):
        self.n_domains=int(n_domains);self.opportunity_quantile=float(opportunity_quantile);self.temperature=float(temperature)
        self.seed=int(seed);self.max_cluster_rows=int(max_cluster_rows);self.batch_size=int(batch_size)
        self.mean_=None;self.scale_=None;self.clusterer=None;self.feature_names=None;self.cluster_order_=None

    def _standardize_fit(self,X):
        self.mean_=np.asarray(X,float).mean(axis=0);self.scale_=np.asarray(X,float).std(axis=0);self.scale_=np.where(self.scale_<1e-6,1.0,self.scale_)
        return (X-self.mean_)/self.scale_

    def _standardize(self,X):
        return (np.asarray(X,float)-self.mean_)/self.scale_

    def opportunity_mask(self,signature,faculty_idx,blocks):
        return _group_quantile_mask(signature.opportunity_score,faculty_idx,blocks,self.opportunity_quantile)

    def fit(self,signature,faculty_idx,blocks):
        X=np.asarray(signature.features,float);self.feature_names=list(signature.feature_names);opp=self.opportunity_mask(signature,faculty_idx,blocks)
        idx=np.where(opp)[0]
        if len(idx)<max(self.n_domains*20,100):raise ValueError(f'not enough opportunity rows for {self.n_domains} domains: {len(idx)}')
        Z=self._standardize_fit(X[idx])
        if len(idx)>self.max_cluster_rows:
            rng=np.random.default_rng(self.seed);take=rng.choice(len(idx),self.max_cluster_rows,replace=False);Zfit=Z[take]
        else:Zfit=Z
        km=MiniBatchKMeans(n_clusters=self.n_domains,random_state=self.seed,batch_size=min(self.batch_size,max(len(Zfit),256)),n_init=10,reassignment_ratio=.01)
        km.fit(Zfit);self.clusterer=km
        # Deterministic order: missed-failure severity, signed error, then best utility.
        name_to_i={n:i for i,n in enumerate(self.feature_names)}
        raw_centers=km.cluster_centers_*self.scale_[None,:]+self.mean_[None,:]
        keys=[]
        for k,c in enumerate(raw_centers):
            keys.append((-
                float(c[name_to_i.get('missed_failure_severity',0)]),
                -float(c[name_to_i.get('signed_error',0)]),
                -float(c[name_to_i.get('best_base_utility',0)]),k))
        self.cluster_order_=np.array([x[-1] for x in sorted(keys)],int)
        return self

    def _cluster_probs(self,features):
        Z=self._standardize(features);dist=self.clusterer.transform(Z)
        p=_softmax_rows(-(dist**2)/max(self.temperature,1e-6))
        # reorder raw KMeans labels into stable domain order
        return p[:,self.cluster_order_]

    def transform(self,signature,faculty_idx,blocks):
        if self.clusterer is None:raise RuntimeError('discoverer is not fit')
        opp=self.opportunity_mask(signature,faculty_idx,blocks);out=np.zeros((len(signature.features),self.n_domains+1),float)
        out[~opp,0]=1.0
        if np.any(opp):out[opp,1:]=self._cluster_probs(signature.features[opp])
        return out.astype(np.float32)

    def fit_transform(self,signature,faculty_idx,blocks):
        return self.fit(signature,faculty_idx,blocks).transform(signature,faculty_idx,blocks)

    def hard_labels(self,signature,faculty_idx,blocks):
        return np.argmax(self.transform(signature,faculty_idx,blocks),axis=1).astype(np.int64)

    def center_frame(self):
        import pandas as pd
        if self.clusterer is None:return pd.DataFrame()
        raw=self.clusterer.cluster_centers_*self.scale_[None,:]+self.mean_[None,:];raw=raw[self.cluster_order_]
        df=pd.DataFrame(raw,columns=self.feature_names);df.insert(0,'domain',np.arange(1,self.n_domains+1));return df

    def to_dict(self):
        if self.clusterer is None:raise RuntimeError('discoverer is not fit')
        return {'n_domains':self.n_domains,'opportunity_quantile':self.opportunity_quantile,'temperature':self.temperature,'seed':self.seed,
                'feature_names':self.feature_names,'mean':self.mean_.tolist(),'scale':self.scale_.tolist(),'cluster_order':self.cluster_order_.tolist(),
                'cluster_centers':self.clusterer.cluster_centers_.tolist()}

    def save(self,path):
        Path(path).write_text(json.dumps(self.to_dict(),indent=2))
