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

import numpy as np
from suite2_common import safe_ap,safe_auc,equal_budget_metrics
from suite10_semantic_domains import DOMAIN_NAMES
from suite10_semantic_moe import shrink_reliability


def _metric(y,p,beta=2.0):
    y=np.asarray(y,int);p=np.asarray(p,float)
    if len(y)==0:return {'ap':np.nan,'auc':np.nan,'f2_20':np.nan}
    return {'ap':safe_ap(y,p),'auc':safe_auc(y,p),'f2_20':equal_budget_metrics(y,p,.20,beta).get('fbeta',np.nan)}


def _valid(y,min_rows,min_failures):
    y=np.asarray(y,int)
    return len(y)>=int(min_rows) and int(y.sum())>=int(min_failures) and np.unique(y).size>=2


def domain_viability_rows(y,q,domain_scores,faculty_idx,faculty_names,fold,split,core_threshold=.60,min_rows=50,min_failures=5,beta=2.0):
    y=np.asarray(y,int);q=np.asarray(q,float);m=np.asarray(domain_scores,float);f=np.asarray(faculty_idx,int);rows=[]
    for fi,name in enumerate(faculty_names):
        base=f==fi
        for k,dn in enumerate(DOMAIN_NAMES):
            core=base&(m[:,k]>=float(core_threshold)); yy=y[core]
            met=_metric(yy,q[core],beta) if _valid(yy,min_rows,min_failures) else {'ap':np.nan,'auc':np.nan,'f2_20':np.nan}
            rows.append({'fold':fold,'split':split,'faculty':name,'domain':dn,'domain_index':k+1,'faculty_rows':int(base.sum()),'core_rows':int(core.sum()),'core_rate':float(core.sum()/max(base.sum(),1)),'core_failures':int(yy.sum()),'core_prevalence':float(yy.mean()) if len(yy) else np.nan,'mean_domain_score':float(np.mean(m[base,k])) if np.any(base) else np.nan,'committee_ap_core':met['ap'],'committee_auc_core':met['auc'],'committee_f2_20_core':met['f2_20'],'valid_core_metric':bool(_valid(yy,min_rows,min_failures))})
    # pooled cross-faculty row per domain
    for k,dn in enumerate(DOMAIN_NAMES):
        core=m[:,k]>=float(core_threshold);yy=y[core];met=_metric(yy,q[core],beta) if _valid(yy,min_rows,min_failures) else {'ap':np.nan,'auc':np.nan,'f2_20':np.nan}
        rows.append({'fold':fold,'split':split,'faculty':'__ALL__','domain':dn,'domain_index':k+1,'faculty_rows':len(y),'core_rows':int(core.sum()),'core_rate':float(core.mean()),'core_failures':int(yy.sum()),'core_prevalence':float(yy.mean()) if len(yy) else np.nan,'mean_domain_score':float(np.mean(m[:,k])),'committee_ap_core':met['ap'],'committee_auc_core':met['auc'],'committee_f2_20_core':met['f2_20'],'valid_core_metric':bool(_valid(yy,min_rows,min_failures))})
    return rows


def domain_overlap_rows(domain_scores,faculty_idx,faculty_names,fold,split,core_threshold=.60):
    m=np.asarray(domain_scores,float);f=np.asarray(faculty_idx,int);core=m>=float(core_threshold);rows=[]
    scopes=[('__ALL__',np.ones(len(m),bool))]+[(name,f==fi) for fi,name in enumerate(faculty_names)]
    for faculty,base in scopes:
        denom=max(int(base.sum()),1)
        for i,di in enumerate(DOMAIN_NAMES):
            for j,dj in enumerate(DOMAIN_NAMES):
                if j<i:continue
                a=base&core[:,i];b=base&core[:,j];inter=a&b;union=a|b
                rows.append({'fold':fold,'split':split,'faculty':faculty,'domain_i':di,'domain_j':dj,'intersection_rows':int(inter.sum()),'intersection_rate':float(inter.sum()/denom),'jaccard':float(inter.sum()/max(union.sum(),1)),'domain_i_rate':float(a.sum()/denom),'domain_j_rate':float(b.sum()/denom)})
    return rows


def expert_contract_rows(y,q,expert_prob,domain_scores,faculty_idx,faculty_names,fold,split,core_threshold=.60,min_rows=50,min_failures=5,beta=2.0):
    y=np.asarray(y,int);q=np.asarray(q,float);p=np.asarray(expert_prob,float);m=np.asarray(domain_scores,float);f=np.asarray(faculty_idx,int);rows=[]
    scopes=[('__ALL__',np.ones(len(y),bool))]+[(name,f==fi) for fi,name in enumerate(faculty_names)]
    for faculty,base in scopes:
        for k,dn in enumerate(DOMAIN_NAMES):
            inside=base&(m[:,k]>=float(core_threshold));outside=base&~(m[:,k]>=float(core_threshold))
            rec={'fold':fold,'split':split,'faculty':faculty,'expert':k+1,'domain':dn,'in_rows':int(inside.sum()),'in_failures':int(y[inside].sum()),'out_rows':int(outside.sum()),'out_failures':int(y[outside].sum())}
            for tag,mask in [('in_domain',inside),('out_domain',outside)]:
                if _valid(y[mask],min_rows,min_failures):
                    b=_metric(y[mask],q[mask],beta);e=_metric(y[mask],p[mask,k],beta)
                    rec.update({f'{tag}_committee_ap':b['ap'],f'{tag}_expert_ap':e['ap'],f'{tag}_delta_ap':e['ap']-b['ap'],f'{tag}_committee_auc':b['auc'],f'{tag}_expert_auc':e['auc'],f'{tag}_delta_auc':e['auc']-b['auc'],f'{tag}_committee_f2_20':b['f2_20'],f'{tag}_expert_f2_20':e['f2_20'],f'{tag}_delta_f2_20':e['f2_20']-b['f2_20']})
                else:
                    for key in ['committee_ap','expert_ap','delta_ap','committee_auc','expert_auc','delta_auc','committee_f2_20','expert_f2_20','delta_f2_20']:rec[f'{tag}_{key}']=np.nan
            rec['specialization_contrast_ap']=rec['in_domain_delta_ap']-rec['out_domain_delta_ap'] if np.isfinite(rec['in_domain_delta_ap']) and np.isfinite(rec['out_domain_delta_ap']) else np.nan
            rec['specialization_contrast_f2_20']=rec['in_domain_delta_f2_20']-rec['out_domain_delta_f2_20'] if np.isfinite(rec['in_domain_delta_f2_20']) and np.isfinite(rec['out_domain_delta_f2_20']) else np.nan
            rows.append(rec)
    return rows


def _reliability_signal(y,q,p,beta=2.0):
    b=_metric(y,q,beta);e=_metric(y,p,beta)
    if not np.isfinite(b['ap']) or not np.isfinite(e['ap']) or not np.isfinite(b['f2_20']) or not np.isfinite(e['f2_20']):return np.nan
    return float((e['ap']-b['ap'])+(e['f2_20']-b['f2_20']))


def estimate_reliability(y,q,expert_prob,domain_scores,faculty_idx,blocks,faculty_names,core_threshold=.60,min_rows=50,min_failures=5,reliability_gain=.03,shrink_rows=200.0,beta=2.0,failure_equiv_rows=20.0):
    y=np.asarray(y,int);q=np.asarray(q,float);p=np.asarray(expert_prob,float);m=np.asarray(domain_scores,float);f=np.asarray(faculty_idx,int);blocks=np.asarray(blocks,float)
    F=len(faculty_names);K=len(DOMAIN_NAMES);local=np.zeros((F,K));support=np.zeros((F,K));global_r=np.zeros(K);detail=[]
    for k,dn in enumerate(DOMAIN_NAMES):
        core=m[:,k]>=float(core_threshold);valid=core&_finite_blocks(blocks)
        yy=y[core]
        sig=_reliability_signal(yy,q[core],p[core,k],beta) if _valid(yy,min_rows,min_failures) else np.nan
        block_s=[]
        for b in np.unique(blocks[valid]):
            bm=core&(blocks==b)
            if _valid(y[bm],max(10,min_rows//3),max(1,min_failures//2)):
                s=_reliability_signal(y[bm],q[bm],p[bm,k],beta)
                if np.isfinite(s):block_s.append(s)
        pos=float(np.mean(np.asarray(block_s)>0)) if block_s else 0.0
        strength=np.clip(max(sig if np.isfinite(sig) else 0.0,0.0)/max(float(reliability_gain),1e-8),0,1)
        global_r[k]=strength*(0.5+0.5*pos) if strength>0 else 0.0
        for fi,name in enumerate(faculty_names):
            fm=(f==fi)&core; yy=y[fm];support[fi,k]=min(float(fm.sum()),float(yy.sum())*float(failure_equiv_rows))
            lsig=_reliability_signal(yy,q[fm],p[fm,k],beta) if _valid(yy,min_rows,min_failures) else np.nan
            bsignals=[]
            for b in np.unique(blocks[fm&_finite_blocks(blocks)]):
                bm=fm&(blocks==b)
                if _valid(y[bm],max(10,min_rows//3),max(1,min_failures//2)):
                    s=_reliability_signal(y[bm],q[bm],p[bm,k],beta)
                    if np.isfinite(s):bsignals.append(s)
            pfrac=float(np.mean(np.asarray(bsignals)>0)) if bsignals else 0.0
            sstrength=np.clip(max(lsig if np.isfinite(lsig) else 0.0,0.0)/max(float(reliability_gain),1e-8),0,1)
            local[fi,k]=sstrength*(0.5+0.5*pfrac) if sstrength>0 else 0.0
            detail.append({'faculty':name,'expert':k+1,'domain':dn,'core_rows':int(fm.sum()),'core_failures':int(yy.sum()),'effective_reliability_support':float(support[fi,k]),'combined_signal':lsig,'positive_block_fraction':pfrac,'local_reliability_raw':local[fi,k]})
    shrunk=shrink_reliability(local,support,global_r,shrink_rows)
    for r in detail:
        fi=faculty_names.index(r['faculty']);k=r['expert']-1;r['global_reliability']=global_r[k];r['shrunk_reliability']=shrunk[fi,k]
    return {'local_reliability':local,'local_support':support,'global_reliability':global_r,'reliability':shrunk,'detail_rows':detail}


def _finite_blocks(b):
    return np.isfinite(np.asarray(b,float))


def authority_summary(weights,uncertainty,domain_scores):
    w=np.asarray(weights,float);u=np.asarray(uncertainty,float);m=np.asarray(domain_scores,float);authority=w[:,1:].sum(1)
    return {'rows':len(w),'mean_null_weight':float(np.mean(w[:,0])),'mean_authority':float(np.mean(authority)),'median_authority':float(np.median(authority)),'p90_authority':float(np.quantile(authority,.9)),'mean_uncertainty':float(np.mean(u)),'mean_max_domain_score':float(np.mean(np.max(m,axis=1))),'multi_domain_core_rate':float(np.mean((m>=.6).sum(axis=1)>=2))}


def mean_pairwise_residual_correlation(residuals):
    r=np.asarray(residuals,float)
    if r.ndim!=2 or r.shape[1]<2 or len(r)<3:return np.nan
    c=np.corrcoef(r,rowvar=False);vals=[]
    for i in range(c.shape[0]):
        for j in range(i+1,c.shape[1]):
            if np.isfinite(c[i,j]):vals.append(c[i,j])
    return float(np.mean(vals)) if vals else np.nan


def domain_drift_rows(train_scores,val_scores,target_scores,faculty_idx_train,faculty_idx_val,faculty_idx_target,faculty_names,fold,core_threshold=.60):
    rows=[]
    for fi,name in enumerate(faculty_names):
        for k,dn in enumerate(DOMAIN_NAMES):
            rec={'fold':fold,'faculty':name,'domain':dn}
            vals={}
            for split,s,f in [('train',train_scores,faculty_idx_train),('validation',val_scores,faculty_idx_val),('target',target_scores,faculty_idx_target)]:
                z=np.asarray(s)[np.asarray(f)==fi,k]
                vals[split]=z
                rec[f'{split}_mean_score']=float(np.mean(z)) if len(z) else np.nan
                rec[f'{split}_core_rate']=float(np.mean(z>=float(core_threshold))) if len(z) else np.nan
            rec['target_minus_train_core_rate']=rec['target_core_rate']-rec['train_core_rate'] if np.isfinite(rec['target_core_rate']) and np.isfinite(rec['train_core_rate']) else np.nan
            rec['target_to_train_core_ratio']=rec['target_core_rate']/max(rec['train_core_rate'],1e-6) if np.isfinite(rec['target_core_rate']) and np.isfinite(rec['train_core_rate']) else np.nan
            rows.append(rec)
    return rows
