# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
import json
import numpy as np
import pandas as pd

from suite2_common import v2_meta_features, support_matrix, safe_ap, safe_auc
import train_v3 as core

EPS=1e-12

@dataclass
class FeatureStandardizer:
    mean_: np.ndarray
    scale_: np.ndarray

    @classmethod
    def fit(cls, X: np.ndarray) -> 'FeatureStandardizer':
        X=np.asarray(X,float)
        X=np.nan_to_num(X,nan=0.0,posinf=0.0,neginf=0.0)
        mean=X.mean(axis=0)
        scale=X.std(axis=0)
        scale=np.where(scale<1e-6,1.0,scale)
        return cls(mean.astype(np.float32),scale.astype(np.float32))

    def transform(self, X: np.ndarray) -> np.ndarray:
        X=np.asarray(X,float)
        X=np.nan_to_num(X,nan=0.0,posinf=0.0,neginf=0.0)
        return ((X-self.mean_)/self.scale_).astype(np.float32)

    def save(self,path):
        np.savez(path,mean=self.mean_,scale=self.scale_)

    @classmethod
    def load(cls,path):
        z=np.load(path)
        return cls(z['mean'],z['scale'])


def discover_faculties(splits_dir,fold=1):
    d=Path(splits_dir)/f'fold_{int(fold)}'
    if not d.exists():
        raise FileNotFoundError(f'missing split directory: {d}')
    out=[]
    for p in sorted(d.glob('*_train.csv')):
        out.append(p.name[:-len('_train.csv')])
    if not out:
        raise RuntimeError(f'no *_train.csv files found in {d}')
    return out


def parse_faculties(value,available):
    if value is None or str(value).strip().lower() in {'','all','auto'}:
        return list(available)
    wanted=[x.strip() for x in str(value).split(',') if x.strip()]
    missing=[x for x in wanted if x not in available]
    if missing: raise ValueError(f'unknown faculties: {missing}')
    return wanted


def common_raw_features(caches,faculties):
    if not faculties: raise ValueError('no faculties')
    first=list(caches[faculties[0]]['feature_names'])
    common=set(first)
    for f in faculties[1:]:
        common &= set(caches[f]['feature_names'])
    out=[n for n in first if n in common]
    if not out: raise RuntimeError('no common raw features across faculties')
    return out


def align_raw_features(X,feature_names,common_names):
    idx={n:i for i,n in enumerate(feature_names)}
    missing=[n for n in common_names if n not in idx]
    if missing: raise KeyError(f'missing common features: {missing[:5]}')
    return np.asarray(X,float)[:,[idx[n] for n in common_names]]


def committee_mean(prob_matrix):
    p=np.asarray(prob_matrix,float)
    return np.clip(p.mean(axis=1),1e-7,1-1e-7)


def compose_features(X_raw,feature_names,common_names,base_prob,support):
    raw=align_raw_features(X_raw,feature_names,common_names)
    meta,mnames=v2_meta_features(base_prob)
    sup,snames=support_matrix(support)
    X=np.column_stack([raw,meta,sup])
    names=list(common_names)+mnames+snames
    return np.nan_to_num(X,nan=0.0,posinf=0.0,neginf=0.0).astype(np.float32),names


def faculty_class_sampling_weights(y,faculty_idx,faculty_names,beta=.9999):
    y=np.asarray(y,int); faculty_idx=np.asarray(faculty_idx,int)
    w=np.zeros(len(y),float); diag={}
    nfac=len(faculty_names)
    if nfac<1: raise ValueError('faculty_names empty')
    target_mass=len(y)/nfac
    for fi,name in enumerate(faculty_names):
        m=faculty_idx==fi
        if not np.any(m):
            diag[name]={'rows':0,'failures':0,'positive_weight':np.nan,'negative_weight':np.nan}
            continue
        yy=y[m]; counts={c:int((yy==c).sum()) for c in [0,1]}
        raw=np.ones(m.sum(),float)
        cls_w={}
        for c in [0,1]:
            n=counts[c]
            if n<=0:
                cls_w[c]=1.0
            elif beta<=0 or beta>=1:
                cls_w[c]=1.0/max(n,1)
            else:
                cls_w[c]=(1.0-beta)/(1.0-beta**n)
            raw[yy==c]=cls_w[c]
        s=raw.sum()
        raw*=target_mass/max(s,EPS)
        w[m]=raw
        diag[name]={
            'rows':int(m.sum()),'failures':counts[1],
            'positive_weight':float(raw[yy==1].mean()) if counts[1] else np.nan,
            'negative_weight':float(raw[yy==0].mean()) if counts[0] else np.nan,
            'total_mass':float(raw.sum()),
        }
    # keep average around one for intuitive sampler weights
    w*=len(w)/max(w.sum(),EPS)
    for name in diag:
        if diag[name]['rows']:
            fi=faculty_names.index(name);m=faculty_idx==fi
            diag[name]['total_mass']=float(w[m].sum())
            if np.any(m&(y==1)):diag[name]['positive_weight']=float(w[m&(y==1)].mean())
            if np.any(m&(y==0)):diag[name]['negative_weight']=float(w[m&(y==0)].mean())
    return w.astype(np.float64),diag


def latest_block_split(faculty_idx,blocks,val_blocks=2):
    faculty_idx=np.asarray(faculty_idx,int);blocks=np.asarray(blocks,float)
    tr=np.zeros(len(blocks),bool);va=np.zeros(len(blocks),bool)
    for fi in np.unique(faculty_idx):
        m=(faculty_idx==fi)&np.isfinite(blocks)
        ub=sorted(pd.unique(blocks[m]))
        if not ub: continue
        nv=min(int(val_blocks),max(1,len(ub)-1)) if len(ub)>1 else 0
        if nv==0:
            tr[m]=True;continue
        vb=set(ub[-nv:])
        va[m&np.isin(blocks,list(vb))]=True
        tr[m&(~np.isin(blocks,list(vb)))]=True
    return tr,va


def fbeta_at_rate(y,score,rate=.20,beta=2.0):
    y=np.asarray(y,int);score=np.asarray(score,float)
    pred=core.warn_by_rate(score,float(rate))
    m=core.report(y,score,pred,float(beta))
    return m


def per_faculty_validation_rows(y,q,p,faculty_idx,faculty_names,beta=2.0,budget=.20):
    rows=[]
    for fi,name in enumerate(faculty_names):
        m=np.asarray(faculty_idx)==fi
        if not np.any(m):continue
        yy=np.asarray(y)[m];qq=np.asarray(q)[m];pp=np.asarray(p)[m]
        qc=fbeta_at_rate(yy,qq,budget,beta);mc=fbeta_at_rate(yy,pp,budget,beta)
        rows.append({
            'faculty':name,'rows':int(m.sum()),'failures':int(yy.sum()),
            'committee_ap':safe_ap(yy,qq),'model_ap':safe_ap(yy,pp),
            'committee_auc':safe_auc(yy,qq),'model_auc':safe_auc(yy,pp),
            'committee_f2_20':qc['fbeta'],'model_f2_20':mc['fbeta'],
        })
    return pd.DataFrame(rows)


def macro_delta_summary(rows):
    df=pd.DataFrame(rows).copy()
    if len(df)==0:
        return {'median_delta_ap':np.nan,'mean_delta_ap':np.nan,'worst_delta_ap':np.nan,'win_rate_ap':np.nan,
                'median_delta_f2_20':np.nan,'mean_delta_f2_20':np.nan,'worst_delta_f2_20':np.nan,'win_rate_f2_20':np.nan}
    dap=df['model_ap'].to_numpy(float)-df['committee_ap'].to_numpy(float)
    df2=df['model_f2_20'].to_numpy(float)-df['committee_f2_20'].to_numpy(float)
    return {
        'median_delta_ap':float(np.nanmedian(dap)),'mean_delta_ap':float(np.nanmean(dap)),
        'worst_delta_ap':float(np.nanmin(dap)),'win_rate_ap':float(np.nanmean(dap>0)),
        'median_delta_f2_20':float(np.nanmedian(df2)),'mean_delta_f2_20':float(np.nanmean(df2)),
        'worst_delta_f2_20':float(np.nanmin(df2)),'win_rate_f2_20':float(np.nanmean(df2>0)),
    }


def model_selection_score(rows,f2_weight=1.0):
    s=macro_delta_summary(rows)
    return float(s['median_delta_ap']+float(f2_weight)*s['median_delta_f2_20']),s


def save_json(obj,path):
    Path(path).write_text(json.dumps(obj,indent=2,default=lambda x: x.item() if hasattr(x,'item') else str(x)))

@dataclass
class CrossFacultyBundle:
    X: np.ndarray
    y: np.ndarray
    q: np.ndarray
    faculty_idx: np.ndarray
    blocks: np.ndarray
    row_index: np.ndarray
    faculty_names: list[str]
    feature_names: list[str]
    support_history_semesters: np.ndarray


def load_fold_caches(cache_dir,faculties,fold):
    import joblib
    out={}
    for f in faculties:
        p=Path(cache_dir)/f'{f}_fold_{int(fold)}.joblib'
        if not p.exists(): raise FileNotFoundError(f'missing canonical cache: {p}')
        out[f]=joblib.load(p)
    return out


def build_historical_bundle(caches,faculties,common_names):
    Xs=[];ys=[];qs=[];fis=[];bs=[];ris=[];hs=[];fn=None
    for fi,f in enumerate(faculties):
        d=caches[f];m=np.asarray(d['cf_covered_mask'],bool)
        probs=np.asarray(d['cf_probabilities'],float)
        m &= np.isfinite(probs).all(axis=1)
        if 'cf_block_ids' in d:
            block=np.asarray(pd.to_numeric(pd.Series(d['cf_block_ids']),errors='coerce'),float)
        else:
            block=np.asarray(d.get('train_groups',np.full(len(m),np.nan)),float)
        m &= np.isfinite(block)
        idx=np.where(m)[0]
        if len(idx)==0:continue
        X,names=compose_features(d['Xtr'][idx],d['feature_names'],common_names,probs[idx],d['support_hist'].iloc[idx].reset_index(drop=True))
        if fn is None:fn=names
        elif fn!=names:raise RuntimeError('shared feature-name mismatch')
        Xs.append(X);ys.append(np.asarray(d['ytr'],int)[idx]);qs.append(committee_mean(probs[idx]));fis.append(np.full(len(idx),fi,int));bs.append(block[idx]);ris.append(idx.astype(int));
        hs.append(d['support_hist'].iloc[idx]['history_semesters'].to_numpy(int) if 'history_semesters' in d['support_hist'] else np.zeros(len(idx),int))
    if not Xs:raise RuntimeError('no chronology-safe historical OOF rows found')
    return CrossFacultyBundle(np.concatenate(Xs),np.concatenate(ys),np.concatenate(qs),np.concatenate(fis),np.concatenate(bs),np.concatenate(ris),list(faculties),fn,np.concatenate(hs))


def build_target_bundle(caches,faculties,common_names):
    Xs=[];ys=[];qs=[];fis=[];bs=[];ris=[];hs=[];fn=None
    for fi,f in enumerate(faculties):
        d=caches[f];probs=np.asarray(d['pte'],float)
        X,names=compose_features(d['Xte'],d['feature_names'],common_names,probs,d['support_target'])
        if fn is None:fn=names
        elif fn!=names:raise RuntimeError('shared feature-name mismatch')
        Xs.append(X);ys.append(np.asarray(d['yte'],int));qs.append(np.asarray(d['qte'],float));fis.append(np.full(len(X),fi,int));
        # target block is diagnostic only; never used for fitting
        try:
            g,_=core.extract_temporal_groups(d['test_frame']);g=np.asarray(pd.to_numeric(pd.Series(g),errors='coerce'),float)
        except Exception:g=np.full(len(X),np.nan)
        bs.append(g);ris.append(np.arange(len(X),dtype=int));hs.append(d['support_target']['history_semesters'].to_numpy(int) if 'history_semesters' in d['support_target'] else np.zeros(len(X),int))
    return CrossFacultyBundle(np.concatenate(Xs),np.concatenate(ys),np.concatenate(qs),np.concatenate(fis),np.concatenate(bs),np.concatenate(ris),list(faculties),fn,np.concatenate(hs))


def subset_bundle(bundle,mask,faculty_names=None,remap_faculty=False):
    mask=np.asarray(mask,bool);fi=bundle.faculty_idx[mask].copy();names=list(bundle.faculty_names if faculty_names is None else faculty_names)
    if remap_faculty:
        old=sorted(np.unique(fi));mp={v:i for i,v in enumerate(old)};fi=np.asarray([mp[v] for v in fi],int);names=[bundle.faculty_names[v] for v in old]
    return CrossFacultyBundle(bundle.X[mask],bundle.y[mask],bundle.q[mask],fi,bundle.blocks[mask],bundle.row_index[mask],names,list(bundle.feature_names),bundle.support_history_semesters[mask])
