# -*- coding: utf-8 -*-
from __future__ import annotations
from pathlib import Path
import numpy as np
import pandas as pd
import joblib
from suite14_data import Suite14Bundle
from suite7_common import common_raw_features,align_raw_features

E0_RAW_CONTEXT=['target_semester_registered_credits','target_semester_difficulty_weighted_workload','target_semester_average_course_difficulty','target_semester_unseen_course_rate','hist_warning_rate','prev_conduct_score','hist_conduct_mean','reg_span_days','reg_after_deadline_count','student_gpa_history_missing_flag','course_history_missing_flag']
E0_SUPPORT_CONTEXT=['history_semesters','history_rows','course_prior_rows','new_student','new_course']
FUSION_RAW_CONTEXT=[];FUSION_SUPPORT_CONTEXT=['history_semesters','history_rows','course_prior_rows','new_student','new_course']
E1_RAW_CONTEXT=['target_semester_registered_credits','target_semester_difficulty_weighted_workload','hist_warning_rate','prev_conduct_score','hist_conduct_mean','reg_span_days','reg_after_deadline_count','student_gpa_history_missing_flag'];E1_SUPPORT_CONTEXT=['history_semesters','history_rows','new_student']
E2_RAW_CONTEXT=['course_history_missing_flag'];E2_SUPPORT_CONTEXT=['course_prior_rows','new_course']
E3_RAW_CONTEXT=[];E3_SUPPORT_CONTEXT=['history_semesters','history_rows','course_prior_rows','new_student','new_course']
E4_RAW_CONTEXT=['student_gpa_history_missing_flag'];E4_SUPPORT_CONTEXT=['history_semesters','history_rows','new_student']
CONTEXT_SCHEMA={'e0':(E0_RAW_CONTEXT,E0_SUPPORT_CONTEXT),'fusion':(FUSION_RAW_CONTEXT,FUSION_SUPPORT_CONTEXT),'e1':(E1_RAW_CONTEXT,E1_SUPPORT_CONTEXT),'e2':(E2_RAW_CONTEXT,E2_SUPPORT_CONTEXT),'e3':(E3_RAW_CONTEXT,E3_SUPPORT_CONTEXT),'e4':(E4_RAW_CONTEXT,E4_SUPPORT_CONTEXT)}

def discover_faculties(cache_dir,fold=1):return [p.name[:-len(f'_fold_{int(fold)}.joblib')] for p in sorted(Path(cache_dir).glob(f'*_fold_{int(fold)}.joblib'))]
def parse_faculties(value,available):
    if not value or str(value).lower() in {'all','auto'}:return list(available)
    x=[s.strip() for s in str(value).split(',') if s.strip()];missing=[s for s in x if s not in available]
    if missing:raise ValueError(f'unknown faculties {missing}')
    return x

def _context_view(raw,names,support,raw_features,support_features):
    raw=np.asarray(raw,np.float32);idx={n:i for i,n in enumerate(names)};cols=[];aliases={'history_rows':['history_rows','student_prior_rows'],'student_prior_rows':['student_prior_rows','history_rows']}
    for n in raw_features:cols.append((raw[:,idx[n]] if n in idx else np.zeros(len(raw),np.float32))[:,None])
    for n in support_features:
        col=next((c for c in aliases.get(n,[n]) if c in support.columns),None);vals=pd.to_numeric(support[col],errors='coerce').fillna(0).to_numpy(np.float32) if col else np.zeros(len(raw),np.float32);cols.append(vals[:,None])
    return np.nan_to_num(np.column_stack(cols) if cols else np.zeros((len(raw),1),np.float32)).astype(np.float32)

def _semester_ordinal_array(values):
    out=[]
    for v in values:
        try:x=int(float(v));y=x//10;t=x%10;out.append(float(y*3+(t-1)) if t in (1,2,3) else 0.)
        except Exception:out.append(0.)
    return np.asarray(out,np.float32)

def build_context_views(raw,names,support,target_semester):
    # Suite14 deliberately removes absolute semester from the learned gate.
    # Temporal adaptation is handled by chronology-safe authority calibration, not extrapolation.
    v={k:_context_view(raw,names,support,*spec) for k,spec in CONTEXT_SCHEMA.items()}
    v['gate']=v['fusion'].copy().astype(np.float32);return v

def context_feature_names():
    out={k:list(r)+list(s) for k,(r,s) in CONTEXT_SCHEMA.items()};out['gate']=list(FUSION_SUPPORT_CONTEXT);return out

def mastery_deficiency_target(component_events,component_mask):
    x=np.asarray(component_events,np.float32);m=np.asarray(component_mask,bool);out=np.zeros(len(x),np.float32)
    for i in range(len(x)):
        z=x[i][m[i]]
        if len(z)==0:continue
        grade=np.clip(z[:,0],0,10);passed=np.clip(z[:,2],0,1);rec=np.maximum(z[:,3],0);same=np.clip(z[:,4],0,1);related=np.clip(z[:,5],0,1);weight=np.clip(z[:,1],0,100)
        sev=.7*(1-passed)+.3*np.clip((5-grade)/5,0,1);w=(1/(1+rec))*(1+same+.5*related)*(1+.25*weight/100);out[i]=float(np.sum(w*sev)/(np.sum(w)+1e-8))
    return np.clip(out,0,1)

def student_history_risk_target(student_seq,student_mask):
    x=np.asarray(student_seq,np.float32);m=np.asarray(student_mask,bool);out=np.full(len(x),.5,np.float32)
    for i in range(len(x)):
        z=x[i][m[i]]
        if len(z)==0:continue
        gpa=np.clip(z[:,0],0,10);registered=np.maximum(z[:,2],1.);passed_credits=np.clip(z[:,3],0,None);debt=np.clip(z[:,4],0,None);rec=np.maximum(z[:,12],0)
        grade_def=np.clip((5-gpa)/5,0,1);debt_ratio=np.clip(debt/registered,0,1);unpassed=np.clip(1-passed_credits/registered,0,1);risk=.4*grade_def+.3*debt_ratio+.3*unpassed;w=1/(1+rec);out[i]=float(np.sum(w*risk)/(np.sum(w)+1e-8))
    return np.clip(out,0,1)

def course_history_risk_target(course_target):
    x=np.asarray(course_target,np.float32);count=np.clip(x[:,-5],0,None);fail=np.clip(x[:,-2],0,1);return np.where(count>0,fail,.5).astype(np.float32)

def build_mechanism_targets(y,student_seq,student_mask,course_target,component_events,component_mask):
    y=np.asarray(y,np.float32);e1=student_history_risk_target(student_seq,student_mask);e2=course_history_risk_target(course_target);e3=y;e4=mastery_deficiency_target(component_events,component_mask);return np.column_stack([e1,e2,e3,e4]).astype(np.float32)

def selected_oof_blocks(cache_obj,idx,n_train):
    idx=np.asarray(idx,int);key='cf_block_ids' if 'cf_block_ids' in cache_obj else 'train_groups';raw=np.asarray(cache_obj.get(key,np.full(int(n_train),np.nan)),dtype=object)
    if len(raw)!=int(n_train):raise ValueError(f'{key} length mismatch: {len(raw)} != {int(n_train)}')
    blocks=pd.to_numeric(pd.Series(raw[idx]),errors='coerce').to_numpy(float)
    if not np.isfinite(blocks).all():raise ValueError(f'Covered OOF rows contain non-numeric temporal block ids; key={key}')
    return blocks

def load_fold_bundle(cache_dir,structured_dir,faculties,fold,common_names=None):
    caches={f:joblib.load(Path(cache_dir)/f'{f}_fold_{fold}.joblib') for f in faculties}
    if common_names is None:common_names=common_raw_features(caches,faculties)
    hp=[];tp=[]
    for fi,f in enumerate(faculties):
        d=caches[f];sp=Path(structured_dir)/f'{f}_fold_{fold}.joblib'
        if not sp.exists():raise FileNotFoundError(f'missing Suite12/Suite14 structured cache: {sp}')
        sc=joblib.load(sp);idx=np.asarray(sc['train_row_index'],int);m=np.asarray(d['cf_covered_mask'],bool)&np.isfinite(np.asarray(d['cf_probabilities'],float)).all(1);expected=np.where(m)[0]
        if not np.array_equal(idx,expected):raise ValueError(f'structured/canonical OOF row mismatch {f} F{fold}')
        rawh=align_raw_features(d['Xtr'][idx],d['feature_names'],common_names).astype(np.float32);rawt=align_raw_features(d['Xte'],d['feature_names'],common_names).astype(np.float32);suph=d['support_hist'].iloc[idx].reset_index(drop=True);supt=d['support_target'].reset_index(drop=True)
        teacher=np.asarray(d['cf_probabilities'],float)[idx].astype(np.float32);tt=np.asarray(d['pte'],float).astype(np.float32);blocks=selected_oof_blocks(d,idx,len(d['ytr']));frh=d['train_frame'].iloc[idx].reset_index(drop=True);frt=d['test_frame'].reset_index(drop=True)
        try:
            import train_v3 as core;tb,_=core.extract_temporal_groups(d['test_frame']);tb=np.asarray(tb,float)
        except Exception:tb=pd.to_numeric(frt.get('target_NHHK',pd.Series(np.nan,index=frt.index)),errors='coerce').to_numpy(float)
        def mk(raw,support,frame,y,teach,blocks,row_index,sobj):
            sem=pd.to_numeric(frame['target_NHHK'],errors='coerce').fillna(0).to_numpy(np.float32);ctx=build_context_views(raw,common_names,support,sem);a=sobj
            return dict(flat=raw,e0_context=ctx['e0'],fusion_context=ctx['fusion'],gate_context=ctx['gate'],e1_context=ctx['e1'],e2_context=ctx['e2'],e3_context=ctx['e3'],e4_context=ctx['e4'],y=np.asarray(y,np.int8),teacher=teach,mechanism_targets=np.zeros((len(y),4),np.float32),faculty_idx=np.full(len(y),fi,np.int16),blocks=np.asarray(blocks,float),row_index=np.asarray(row_index,np.int32),
                student_id=frame['IDSV'].astype(str).to_numpy(),course_id=frame['IDMH'].astype(str).to_numpy(),target_semester=sem,
                student_seq=np.asarray(a['student_seq'],np.float32),student_mask=np.asarray(a['student_mask'],bool),course_target=np.asarray(a['course_target'],np.float32),course_neighbors=np.asarray(a['course_neighbors'],np.float32),course_neighbor_mask=np.asarray(a['course_neighbor_mask'],bool),course_relation_type=np.asarray(a['course_relation_type'],np.int64),relation_events=np.asarray(a['relation_events'],np.float32),relation_mask=np.asarray(a['relation_mask'],bool),relation_type=np.asarray(a['relation_type'],np.int64),component_events=np.asarray(a['component_events'],np.float32),component_mask=np.asarray(a['component_mask'],bool),component_type=np.asarray(a['component_type'],np.int64))
        hp.append(mk(rawh,suph,frh,np.asarray(d['ytr'],int)[idx],teacher,blocks,idx,sc['train']));tp.append(mk(rawt,supt,frt,np.asarray(d['yte'],int),tt,tb,np.arange(len(d['yte'])),sc['target']))
    def cat(parts):
        kw={k:np.concatenate([p[k] for p in parts],axis=0) for k in parts[0]};b=Suite14Bundle(faculty_names=list(faculties),**kw);b.mechanism_targets=build_mechanism_targets(b.y,b.student_seq,b.student_mask,b.course_target,b.component_events,b.component_mask);return b
    return cat(hp),cat(tp),list(common_names)
