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

import json
from pathlib import Path
import numpy as np
import pandas as pd


def load_shared_feature_schema(shared_results_dir, fold: int) -> dict:
    path=Path(shared_results_dir)/f'fold_{int(fold)}'/'feature_schema.json'
    if not path.exists():
        raise FileNotFoundError(f'missing Suite5 shared feature schema: {path}')
    data=json.loads(path.read_text())
    if not data.get('common_raw_features'):
        raise ValueError(f'Suite5 shared feature schema has no common_raw_features: {path}')
    return data


def load_shared_fold_frame(shared_results_dir,fold:int,faculty:str,expected_y,expected_committee,atol:float=1e-6)->pd.DataFrame:
    path=Path(shared_results_dir)/f'fold_{int(fold)}'/f'{faculty}_scores.csv'
    if not path.exists():
        raise FileNotFoundError(f'missing Suite5 shared score file: {path}')
    df=pd.read_csv(path)
    required={'actual','committee','residual_moe_shared'}
    missing=sorted(required-set(df.columns))
    if missing:
        raise ValueError(f'Suite5 shared score file missing columns {missing}: {path}')
    y=np.asarray(expected_y,int);q=np.asarray(expected_committee,float)
    if len(df)!=len(y):
        raise ValueError(f'Suite5 shared score row alignment mismatch for {faculty} fold {fold}: {len(df)} != {len(y)}')
    if not np.array_equal(df.actual.to_numpy(int),y):
        raise ValueError(f'Suite5 shared score label alignment mismatch for {faculty} fold {fold}')
    qq=df.committee.to_numpy(float)
    if not np.allclose(qq,q,atol=float(atol),rtol=1e-5,equal_nan=False):
        max_abs=float(np.max(np.abs(qq-q))) if len(q) else 0.0
        raise ValueError(f'Suite5 shared score committee alignment mismatch for {faculty} fold {fold}; max_abs={max_abs:.3g}')
    return df


def _get(df,faculty,model,metric):
    d=df[(df.faculty==faculty)&(df.model==model)]
    if d.empty or metric not in d.columns:return np.nan
    return float(d.iloc[0][metric])


def _pref(private,shared,tol=1e-6):
    if not np.isfinite(private) or not np.isfinite(shared):return 'NA'
    d=private-shared
    if d>tol:return 'ADAPTER'
    if d<-tol:return 'SHARED'
    return 'TIE'


def build_shared_private_comparison(
    pooled:pd.DataFrame,
    operational:pd.DataFrame,
    private_model='residual_moe_shared_private',
    shared_model='residual_moe_shared',
    committee_model='committee',
)->pd.DataFrame:
    pooled_ops=operational[operational.fold.astype(str)=='POOLED'].copy()
    fixed=pooled_ops[pooled_ops.policy=='fixed'];drift=pooled_ops[pooled_ops.policy=='drift']
    rows=[]
    for faculty in sorted(pooled.faculty.unique()):
        c_ap=_get(pooled,faculty,committee_model,'ap');s_ap=_get(pooled,faculty,shared_model,'ap');p_ap=_get(pooled,faculty,private_model,'ap')
        c_auc=_get(pooled,faculty,committee_model,'auc');s_auc=_get(pooled,faculty,shared_model,'auc');p_auc=_get(pooled,faculty,private_model,'auc')
        c_f2=_get(pooled,faculty,committee_model,'f2_at_20');s_f2=_get(pooled,faculty,shared_model,'f2_at_20');p_f2=_get(pooled,faculty,private_model,'f2_at_20')
        def op(model,pdf,metric):return _get(pdf,faculty,model,metric)
        c_fix=op(committee_model,fixed,'fbeta');s_fix=op(shared_model,fixed,'fbeta');p_fix=op(private_model,fixed,'fbeta')
        c_dri=op(committee_model,drift,'fbeta');s_dri=op(shared_model,drift,'fbeta');p_dri=op(private_model,drift,'fbeta')
        prefs=[_pref(p_ap,s_ap),_pref(p_f2,s_f2),_pref(p_dri,s_dri)]
        av=sum(x=='ADAPTER' for x in prefs);sv=sum(x=='SHARED' for x in prefs)
        pattern='ADAPTER_STRONGER' if av>=2 else ('SHARED_STRONGER' if sv>=2 else 'MIXED')
        row={
            'faculty':faculty,
            'committee_ap':c_ap,'shared_ap':s_ap,'private_ap':p_ap,
            'shared_minus_committee_ap':s_ap-c_ap,'private_minus_committee_ap':p_ap-c_ap,'private_minus_shared_ap':p_ap-s_ap,
            'committee_auc':c_auc,'shared_auc':s_auc,'private_auc':p_auc,
            'private_minus_shared_auc':p_auc-s_auc,
            'committee_f2_20':c_f2,'shared_f2_20':s_f2,'private_f2_20':p_f2,
            'shared_minus_committee_f2_20':s_f2-c_f2,'private_minus_committee_f2_20':p_f2-c_f2,'private_minus_shared_f2_20':p_f2-s_f2,
            'committee_fixed_f2':c_fix,'shared_fixed_f2':s_fix,'private_fixed_f2':p_fix,'private_minus_shared_fixed_f2':p_fix-s_fix,
            'committee_drift_f2':c_dri,'shared_drift_f2':s_dri,'private_drift_f2':p_dri,'private_minus_shared_drift_f2':p_dri-s_dri,
            'ap_prefers':prefs[0],'f2_20_prefers':prefs[1],'drift_f2_prefers':prefs[2],'evidence_pattern':pattern,
        }
        for policy_name,pdf in [('fixed',fixed),('drift',drift)]:
            for model,short in [(committee_model,'committee'),(shared_model,'shared'),(private_model,'private')]:
                for metric in ['precision','recall','f1','flag_rate']:
                    row[f'{short}_{policy_name}_{metric}']=op(model,pdf,metric)
        rows.append(row)
    return pd.DataFrame(rows)


def merge_external_references(base:pd.DataFrame,reference_metrics:str|Path|None)->pd.DataFrame:
    if not reference_metrics:return base.copy()
    ref=pd.read_csv(reference_metrics)
    if 'split' in ref.columns:ref=ref[ref.split=='holdout']
    out=base.copy()
    for model in sorted(ref.model.dropna().unique()):
        rr=ref[ref.model==model].copy()
        keep=[c for c in ['faculty','ap','auc','fixed_f2','drift_f2'] if c in rr.columns]
        rr=rr[keep].drop_duplicates('faculty')
        rr=rr.rename(columns={c:f'{model}_{c}' for c in keep if c!='faculty'})
        out=out.merge(rr,on='faculty',how='left')
    return out


def summarize_shared_router_frame(df:pd.DataFrame)->dict:
    weight_cols=(['weight_null'] if 'weight_null' in df.columns else [])+sorted(
        [c for c in df.columns if c.startswith('weight_expert_')],
        key=lambda x:int(x.rsplit('_',1)[-1]) if x.rsplit('_',1)[-1].isdigit() else x,
    )
    if not weight_cols:
        return {'mean_null_weight':np.nan,'normalized_entropy':np.nan,'mean_max_weight':np.nan,'mean_abs_correction':np.nan,'mean_pairwise_residual_correlation':np.nan}
    w=np.clip(df[weight_cols].to_numpy(float),1e-12,1.0)
    ent=-(w*np.log(w)).sum(axis=1)/max(np.log(w.shape[1]),1e-12)
    rcols=sorted([c for c in df.columns if c.startswith('residual_expert_')],key=lambda x:int(x.rsplit('_',1)[-1]))
    pc=np.nan
    if len(rcols)>=2 and len(df)>=2:
        c=np.corrcoef(df[rcols].to_numpy(float),rowvar=False);vals=c[np.triu_indices_from(c,k=1)];vals=vals[np.isfinite(vals)]
        if len(vals):pc=float(vals.mean())
    return {
        'mean_null_weight':float(df.weight_null.mean()) if 'weight_null' in df.columns else np.nan,
        'normalized_entropy':float(ent.mean()),
        'mean_max_weight':float(w.max(axis=1).mean()),
        'mean_abs_correction':float(np.abs(df.correction_logit.to_numpy(float)).mean()) if 'correction_logit' in df.columns else np.nan,
        'mean_pairwise_residual_correlation':pc,
    }
