# -*- coding: utf-8 -*-
from __future__ import annotations
from pathlib import Path
import numpy as np
import pandas as pd
import joblib
from suite12_data import Suite12Bundle
from suite7_common import common_raw_features,align_raw_features
from suite2_common import support_matrix

# Context is deliberately split by evidence contract.  These vectors are
# *not* interchangeable: private experts only see the context appropriate to
# their mechanism.  The broad global context is reserved for E0 and final
# evidence fusion/gating.
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 must remain course-centric.  In particular, do not broadcast the target
# student's warning/conduct/workload/history features or student-faculty id.
E2_RAW_CONTEXT=['course_history_missing_flag']
E2_SUPPORT_CONTEXT=['course_prior_rows','new_course']

# E3 is pair-centric.  Only evidence-support context is provided; the actual
# student/course relationship is represented by the historical relation tokens.
E3_RAW_CONTEXT=[]
E3_SUPPORT_CONTEXT=['history_semesters','history_rows','course_prior_rows','new_student','new_course']

# E4 is mastery-centric.  It receives student-history availability context but
# not course/global workload signals; assessment tokens carry course relation.
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):
    out=[]
    for p in sorted(Path(cache_dir).glob(f'*_fold_{int(fold)}.joblib')):out.append(p.name[:-len(f'_fold_{int(fold)}.joblib')])
    return out

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=[]
    for n in raw_features:
        if n in idx:cols.append(np.asarray(raw[:,idx[n]],np.float32)[:,None])
        else:cols.append(np.zeros((len(raw),1),np.float32))
    # Use the canonical support dataframe directly so the evidence contract is
    # explicit.  Accept the historical alias student_prior_rows in synthetic
    # or older caches, but prefer history_rows used by Suite5+.
    aliases={'history_rows':['history_rows','student_prior_rows'],'student_prior_rows':['student_prior_rows','history_rows']}
    for n in support_features:
        candidates=aliases.get(n,[n]);col=next((c for c in candidates if c in support.columns),None)
        if col is not None:cols.append(pd.to_numeric(support[col],errors='coerce').fillna(0).to_numpy(np.float32)[:,None])
        else:cols.append(np.zeros((len(raw),1),np.float32))
    if not cols:return np.zeros((len(raw),1),np.float32)
    return np.nan_to_num(np.column_stack(cols)).astype(np.float32)

def build_context_views(raw,names,support):
    return {k:_context_view(raw,names,support,*spec) for k,spec in CONTEXT_SCHEMA.items()}

def context_feature_names():
    return {k:list(raws)+list(sups) for k,(raws,sups) in CONTEXT_SCHEMA.items()}


def selected_oof_blocks(cache_obj, idx, n_train):
    """Return numeric temporal block ids for already-selected OOF rows.

    `cf_block_ids` intentionally contains empty strings on chronology-ineligible
    training rows that never received OOF predictions.  Therefore selection
    must happen before numeric coercion.  This mirrors the chronology-safe
    Suite7+ loading logic without letting expected blanks outside `idx` crash
    Suite12.
    """
    idx=np.asarray(idx,int)
    if 'cf_block_ids' in cache_obj:
        raw=np.asarray(cache_obj['cf_block_ids'],dtype=object)
        if len(raw)!=int(n_train):
            raise ValueError(f"cf_block_ids length mismatch: {len(raw)} != {int(n_train)}")
        selected=raw[idx]
        blocks=pd.to_numeric(pd.Series(selected),errors='coerce').to_numpy(float)
        if not np.isfinite(blocks).all():
            bad=np.asarray(selected,dtype=object)[~np.isfinite(blocks)]
            sample=[str(x) for x in bad[:5]]
            raise ValueError(
                "Covered OOF rows contain non-numeric temporal block ids "
                f"(cf_mode={cache_obj.get('cf_mode','unknown')}, sample={sample}). "
                "Suite12 requires chronology-safe temporal OOF blocks."
            )
        return blocks
    raw=np.asarray(cache_obj.get('train_groups',np.full(int(n_train),np.nan)),dtype=object)
    if len(raw)!=int(n_train):
        raise ValueError(f"train_groups 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("Selected OOF rows contain unavailable temporal groups.")
    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)
    hist_parts=[];tgt_parts=[]
    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 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']))
        def mk(raw,contexts,y,teach,blocks,row_index,sobj):
            a=sobj
            return dict(flat=raw,e0_context=contexts['e0'],fusion_context=contexts['fusion'],e1_context=contexts['e1'],e2_context=contexts['e2'],e3_context=contexts['e3'],e4_context=contexts['e4'],
                        y=np.asarray(y,np.int8),teacher=teach,faculty_idx=np.full(len(y),fi,np.int16),blocks=np.asarray(blocks,float),row_index=np.asarray(row_index,np.int32),
                        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))
        hist_parts.append(mk(rawh,build_context_views(rawh,common_names,suph),np.asarray(d['ytr'],int)[idx],teacher,blocks,idx,sc['train']))
        try:
            import train_v3 as core;tb,_=core.extract_temporal_groups(d['test_frame']);tb=np.asarray(tb,float)
        except Exception:tb=np.full(len(d['yte']),np.nan)
        tgt_parts.append(mk(rawt,build_context_views(rawt,common_names,supt),np.asarray(d['yte'],int),tt,tb,np.arange(len(d['yte'])),sc['target']))
    def cat(parts):
        kw={};keys=parts[0].keys()
        for k in keys:kw[k]=np.concatenate([p[k] for p in parts],axis=0)
        return Suite12Bundle(faculty_names=list(faculties),**kw)
    return cat(hist_parts),cat(tgt_parts),list(common_names)
