"""Historical directed donor screening, nested prequential policy replay, and conservative admission."""
from __future__ import annotations
import numpy as np
import pandas as pd
from s32_model import fit_weighted,predict
from s32_metrics import score
from s32_data import stable_seed,note

def language_group(f):
    # Explicit lexical PRESPECIFIED CONTROL, not a discovered cluster.
    return f.startswith('khoa_tieng_')

def language_donors(target,faculties):
    return [f for f in faculties if f!=target and language_group(target) and language_group(f)]

def trial_origins(data,target,max_origins=4,min_history=100,min_failures=5,min_validation=30,min_validation_failures=2,gap=0):
    h=data.history[target]
    out=[]
    # Candidate valid origins are selected from target history alone, independent of outcomes in the OUTER target period.
    for origin in sorted(np.unique(h.semester)):
        tr=(h.semester<origin-gap);va=(h.semester==origin)
        if tr.sum()>=min_history and h.y[tr].sum()>=min_failures and va.sum()>=min_validation and h.y[va].sum()>=min_validation_failures and (~h.y[va].astype(bool)).sum()>0:
            out.append(int(origin))
    return out[-max_origins:]

def donor_grid(data,target,config):
    """Historical source screening; reports every source/origin, incl negative transfer."""
    params=dict(max_donor_rows=config.donor_budget,seed=config.seed,
                max_iter=config.max_iter,min_samples_leaf=config.min_samples_leaf,
                release_gap=config.release_gap)
    origins=trial_origins(data,target,config.selection_origins,config.min_history,config.min_history_failures,
                          config.min_validation,config.min_validation_failures,config.release_gap)
    note('SELECTION_ORIGINS',target=target,fold=data.fold,origins=origins,availability='semester_proxy')
    rows=[]
    for origin in origins:
        val=data.history[target];val=val.sub(val.semester==origin)
        base,mat,diag=fit_weighted(data,target,origin,representation='common',**params)
        ref=score(val.y,predict(base,mat,val))
        note('SCREEN_BASE',target=target,fold=data.fold,origin=origin,ap=ref['ap'],rows=len(val),failures=int(val.y.sum()))
        for donor in data.faculties():
            if donor==target:continue
            try:
                model,matrix,details=fit_weighted(data,target,origin,[(donor,1.)],config.rho,
                    representation='common',**params)
                result=score(val.y,predict(model,matrix,val))
                row={'fold':data.fold,'target':target,'source':donor,'origin':origin,
                     'target_val_rows':len(val),'target_val_failures':int(val.y.sum()),
                     'base_ap':ref['ap'],'donor_ap':result['ap'],'delta_ap':result['ap']-ref['ap'],
                     'base_auc':ref['auc'],'donor_auc':result['auc'],
                     'donor_rows':details['n_donor'],'donor_failures':details['source_failures'].get(donor,0),
                     'rho':config.rho,'source_age':details['source_mean_age'].get(donor,float('nan')),
                     'source_mass':details['source_mass'].get(donor,0),'seconds':details['seconds']}
                rows.append(row)
                note('TRANSFER_EDGE',fold=data.fold,target=target,source=donor,origin=origin,
                     delta_ap=row['delta_ap'],ap=result['ap'],base_ap=ref['ap'],
                     donor_failures=row['donor_failures'])
            except ValueError as e:
                note('TRANSFER_SKIP',fold=data.fold,target=target,source=donor,origin=origin,reason=str(e).replace(' ','_'))
    return pd.DataFrame(rows),origins

def candidate_policy(rows,target,origins,min_delta=.001,min_win_rate=.50,min_count=2,max_donors=3):
    if rows.empty or len(origins)<min_count:return []
    tab=rows[(rows.target==target)&rows.origin.isin(origins)].copy()
    if tab.empty:return []
    g=tab.groupby('source').agg(mean_delta=('delta_ap','mean'),
         win_rate=('delta_ap',lambda x:float((x>0).mean())),
         count=('delta_ap','count'),worst_delta=('delta_ap','min')).reset_index()
    g=g[(g['count']>=min_count)&(g.mean_delta>min_delta)&(g.win_rate>=min_win_rate)]
    g=g.sort_values(['mean_delta','win_rate','source'],ascending=[False,False,True]).head(max_donors)
    return [(x.source,float(x.mean_delta)) for x in g.itertuples()]

def replay_policy(data,target,edges,origins,config):
    """At origin j select donors strictly from earlier origin observations, then test j.
    Never use the origin being predicted to select its donors.
    """
    out=[]
    for i in range(2,len(origins)):
        origin=origins[i]
        selected=candidate_policy(edges,target,origins[:i],config.min_delta,config.min_win_rate,2,config.max_selected)
        val=data.history[target].sub(data.history[target].semester==origin)
        common=dict(seed=config.seed,max_iter=config.max_iter,min_samples_leaf=config.min_samples_leaf,
                    release_gap=config.release_gap)
        local,fun,_=fit_weighted(data,target,origin,representation='common',**common)
        base=score(val.y,predict(local,fun,val))
        if selected:
            cap=max(1,config.donor_budget//len(selected))
            model,mat,diag=fit_weighted(data,target,origin,selected,config.rho,
                representation='common',max_donor_rows=cap,**common)
            risk=score(val.y,predict(model,mat,val))
        else:risk=base;diag={'n_donor':0}
        row={'fold':data.fold,'faculty':target,'origin':origin,'policy_sources':','.join(s for s,w in selected),
             'policy_donor_count':len(selected),'base_ap':base['ap'],'policy_ap':risk['ap'],
             'delta_ap':risk['ap']-base['ap'],'policy_donor_rows':diag['n_donor'],
             'selected_using_origins':','.join(map(str,origins[:i]))}
        out.append(row);note('POLICY_REPLAY',**row)
    return pd.DataFrame(out)

def select_final(data,target,edges,origins,replay,config):
    if len(origins)<config.min_origins:return [],'insufficient historical origins'
    picked=candidate_policy(edges,target,origins,config.min_delta,config.min_win_rate,
                             max(2,config.min_origins-1),config.max_selected)
    if not picked:return [],'no stable positive directed edge'
    if replay.empty:return [],'no prequential replay'
    if len(replay)<config.min_replays:return [],'insufficient independent replay origins'
    if not np.isfinite(replay.delta_ap).all():return [],'non-finite replay evidence'
    if replay.delta_ap.mean()<=config.min_replay_delta:
        return [],f'prequential policy delta {replay.delta_ap.mean():+.6f} below threshold'
    if (replay.delta_ap < -config.max_replay_harm).any():
        return [],'prequential policy exceeds harm tolerance'
    return picked,'admitted by older-origin prequential replay'

def random_sources(data,target,k,seed):
    candidates=[x for x in data.faculties() if x!=target]
    if k<=0 or not candidates:return []
    rng=np.random.default_rng(stable_seed(seed,target,data.fold,'random'))
    return [(x,1.) for x in rng.choice(candidates,size=min(k,len(candidates)),replace=False)]
