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

from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List, Tuple

import joblib
import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset
from sklearn.decomposition import PCA

from suite25_common import semester_ordinal, latest_block_split

EPS=1e-6
COURSE_STATIC=['SoTinChi','SoTietMH','SoTietTuan','SiSoMax','SiSoMin','KhgTinhDTB','IsMHTN','IsMonKT','IsMHKN','IsMHDacThu','IsGDTiengAnh','IsMonNgoaiNgu']
COURSE_HIST=['hist_count','hist_mean','hist_std','hist_fail_rate','hist_pass_rate']
COURSE_FEATURES=COURSE_STATIC+COURSE_HIST


def discover_faculties(cache_dir:str|Path,fold:int=1)->List[str]:
    root=Path(cache_dir);suffix=f'_fold_{int(fold)}.joblib'
    out=[p.name[:-len(suffix)] for p in sorted(root.glob(f'*{suffix}'))]
    if not out:raise FileNotFoundError(f'No canonical cache files under {root}')
    return out


def parse_faculties(value:str|None,available:List[str])->List[str]:
    if value is None or str(value).strip().lower() in {'','all','auto'}:return list(available)
    wanted=[x.strip() for x in str(value).split(',') if x.strip()];missing=[x for x in wanted if x not in available]
    if missing:raise ValueError(f'Unknown faculties: {missing}')
    return wanted


def common_raw_features(caches:Dict[str,dict],faculties:List[str])->List[str]:
    first=list(caches[faculties[0]]['feature_names']);common=set(first)
    for f in faculties[1:]:common&=set(caches[f]['feature_names'])
    out=[n for n in first if n in common]
    if not out:raise RuntimeError('No common raw features across faculties')
    return out


def discover_common_feature_names(cache_dir,faculties,fold=1):
    caches={f:joblib.load(Path(cache_dir)/f'{f}_fold_{int(fold)}.joblib') for f in faculties}
    return common_raw_features(caches,faculties)


def align_raw_features(X,feature_names,common_names):
    idx={n:i for i,n in enumerate(feature_names)};missing=[n for n in common_names if n not in idx]
    if missing:raise KeyError(f'Missing common features: {missing[:10]}')
    return np.nan_to_num(np.asarray(X,np.float32)[:,[idx[n] for n in common_names]],nan=0.,posinf=0.,neginf=0.)


def selected_history_indices(d):
    covered=np.asarray(d['cf_covered_mask'],bool);p=np.asarray(d['cf_probabilities'],float)
    valid=covered&np.isfinite(p).all(1);return np.where(valid)[0]


def selected_blocks(d,idx):
    key='cf_block_ids' if 'cf_block_ids' in d else 'train_groups';raw=np.asarray(d.get(key,np.full(len(d['ytr']),np.nan)),dtype=object)
    z=pd.to_numeric(pd.Series(raw[idx]),errors='coerce').to_numpy(float)
    if not np.isfinite(z).all():raise ValueError(f'Non-finite temporal blocks source={key}')
    return z.astype(np.float32)


@dataclass
class RetrievalBundle:
    current:np.ndarray
    y:np.ndarray
    committee:np.ndarray
    faculty_idx:np.ndarray
    blocks:np.ndarray
    semester_ordinal:np.ndarray
    semester_z:np.ndarray
    target_semester:np.ndarray
    student_id:np.ndarray
    course_id:np.ndarray
    row_index:np.ndarray
    faculty_names:List[str]

    def __len__(self):return int(len(self.y))
    def subset(self,mask):
        m=np.asarray(mask,bool);kwargs={}
        for k,v in self.__dict__.items():
            kwargs[k]=v[m] if isinstance(v,np.ndarray) and len(v)==len(m) else v
        return RetrievalBundle(**kwargs)


def load_fold_bundle(cache_dir,structured_dir,faculties,fold,common_names=None):
    cache_dir=Path(cache_dir);structured_dir=Path(structured_dir)
    caches={f:joblib.load(cache_dir/f'{f}_fold_{int(fold)}.joblib') for f in faculties}
    if common_names is None:common_names=common_raw_features(caches,faculties)
    hist=[];target=[]
    for fi,fac in enumerate(faculties):
        d=caches[fac];sp=structured_dir/f'{fac}_fold_{int(fold)}.joblib'
        if not sp.exists():raise FileNotFoundError(f'Missing structured cache: {sp}')
        sc=joblib.load(sp);idx=np.asarray(sc['train_row_index'],int);expected=selected_history_indices(d)
        if not np.array_equal(idx,expected):raise ValueError(f'Structured/canonical history mismatch for {fac} F{fold}')
        if np.asarray(sc['train']['course_target']).shape[-1]!=len(COURSE_FEATURES):raise ValueError('course_target schema mismatch')
        raw_h=align_raw_features(d['Xtr'][idx],d['feature_names'],common_names);raw_t=align_raw_features(d['Xte'],d['feature_names'],common_names)
        ct_h=np.asarray(sc['train']['course_target'],np.float32);ct_t=np.asarray(sc['target']['course_target'],np.float32)
        cur_h=np.concatenate([raw_h,np.nan_to_num(ct_h)],1).astype(np.float32);cur_t=np.concatenate([raw_t,np.nan_to_num(ct_t)],1).astype(np.float32)
        fr=d['train_frame'].iloc[idx].reset_index(drop=True);ft=d['test_frame'].reset_index(drop=True)
        sem_h=pd.to_numeric(fr['target_NHHK'],errors='coerce').to_numpy(float);sem_t=pd.to_numeric(ft['target_NHHK'],errors='coerce').to_numpy(float)
        if not np.isfinite(sem_h).all() or not np.isfinite(sem_t).all():raise ValueError(f'Non-finite target semester {fac} F{fold}')
        ord_h=np.asarray([semester_ordinal(v) for v in sem_h],np.float32);ord_t=np.asarray([semester_ordinal(v) for v in sem_t],np.float32)
        if not np.isfinite(ord_h).all() or not np.isfinite(ord_t).all():raise ValueError(f'Unparseable semester {fac} F{fold}')
        hist.append(dict(current=cur_h,y=np.asarray(d['ytr'],int)[idx].astype(np.int8),committee=np.asarray(d['cf_probabilities'],float)[idx].mean(1).astype(np.float32),faculty_idx=np.full(len(idx),fi,np.int16),blocks=selected_blocks(d,idx),semester_ordinal=ord_h,semester_z=np.zeros(len(idx),np.float32),target_semester=sem_h.astype(np.float32),student_id=fr['IDSV'].astype(str).to_numpy(),course_id=fr['IDMH'].astype(str).to_numpy(),row_index=idx.astype(np.int32)))
        try:
            import train_v3 as core;tb,_=core.extract_temporal_groups(d['test_frame']);tb=np.asarray(tb,np.float32)
        except Exception:tb=np.full(len(ft),float(fold),np.float32)
        
        if 'qte' in d and np.asarray(d['qte']).ndim==1:
            committee_t=np.asarray(d['qte'],float)
        else:
            committee_t=np.asarray(d['pte'],float).mean(1)
        target.append(dict(current=cur_t,y=np.asarray(d['yte'],int).astype(np.int8),committee=np.asarray(committee_t,np.float32),faculty_idx=np.full(len(ft),fi,np.int16),blocks=tb,semester_ordinal=ord_t,semester_z=np.zeros(len(ft),np.float32),target_semester=sem_t.astype(np.float32),student_id=ft['IDSV'].astype(str).to_numpy(),course_id=ft['IDMH'].astype(str).to_numpy(),row_index=np.arange(len(ft),dtype=np.int32)))
    def cat(parts):
        return RetrievalBundle(**{k:np.concatenate([p[k] for p in parts],0) for k in parts[0]},faculty_names=list(faculties))
    return cat(hist),cat(target),list(common_names)


@dataclass
class RetrievalPreprocessor:
    mean_:np.ndarray
    scale_:np.ndarray
    semester_mean:float
    semester_scale:float
    pca:PCA

    @classmethod
    def fit(cls,bundle:RetrievalBundle,mask,seed=42,pca_dim=24,pca_rows=100000):
        m=np.asarray(mask,bool);x=np.nan_to_num(bundle.current[m].astype(np.float32));mean=x.mean(0);scale=x.std(0);scale=np.where(scale<1e-6,1.,scale);z=(x-mean)/scale
        sem=bundle.semester_ordinal[m].astype(np.float32);sm=float(np.mean(sem));ss=float(np.std(sem));ss=1. if ss<1e-6 else ss
        if len(z)>pca_rows:
            rng=np.random.default_rng(seed);idx=np.sort(rng.choice(len(z),size=int(pca_rows),replace=False));zp=z[idx]
        else:zp=z
        ncomp=int(max(1,min(pca_dim,zp.shape[1],len(zp))));solver='randomized' if ncomp<min(zp.shape) else 'full';pca=PCA(n_components=ncomp,svd_solver=solver,random_state=seed);pca.fit(zp)
        return cls(mean.astype(np.float32),scale.astype(np.float32),sm,ss,pca)

    def transform(self,b:RetrievalBundle)->RetrievalBundle:
        x=((np.nan_to_num(b.current.astype(np.float32))-self.mean_)/self.scale_).astype(np.float32);sz=((b.semester_ordinal-self.semester_mean)/self.semester_scale).astype(np.float32)
        return RetrievalBundle(x,b.y,b.committee,b.faculty_idx,b.blocks,b.semester_ordinal,sz,b.target_semester,b.student_id,b.course_id,b.row_index,b.faculty_names)

    def coarse(self,b:RetrievalBundle)->np.ndarray:
        z=self.pca.transform(np.asarray(b.current,np.float32)).astype(np.float32)
        n=np.linalg.norm(z,axis=1,keepdims=True);return z/np.maximum(n,1e-6)


def current_feature_names(common_names):return list(common_names)+[f'course::{x}' for x in COURSE_FEATURES]


class RetrievalDataset(Dataset):
    def __init__(self,query:RetrievalBundle,bank:RetrievalBundle,store=None,indices=None,bank_y_override=None):
        self.query=query;self.bank=bank;self.store=store;self.indices=np.arange(len(query),dtype=np.int64) if indices is None else np.asarray(indices,np.int64);self.bank_y=np.asarray(bank.y if bank_y_override is None else bank_y_override,np.int8)
    def __len__(self):return len(self.indices)
    def __getitem__(self,j):
        i=int(self.indices[j]);out={'current':torch.from_numpy(self.query.current[i]),'faculty_idx':torch.tensor(int(self.query.faculty_idx[i]),dtype=torch.long),'semester_z':torch.tensor(float(self.query.semester_z[i]),dtype=torch.float32),'y':torch.tensor(float(self.query.y[i]),dtype=torch.float32),'committee':torch.tensor(float(self.query.committee[i]),dtype=torch.float32),'bundle_index':torch.tensor(i,dtype=torch.long)}
        if self.store is None:
            out.update({'candidate_x':torch.zeros((1,self.query.current.shape[1]),dtype=torch.float32),'candidate_y':torch.zeros(1,dtype=torch.long),'candidate_faculty':torch.zeros(1,dtype=torch.long),'candidate_semester_z':torch.zeros(1),'candidate_mask':torch.zeros(1,dtype=torch.bool),'pool_flags':torch.zeros((1,4),dtype=torch.float32),'relation_code':torch.zeros(1,dtype=torch.long),'recency':torch.zeros(1),'same_faculty':torch.zeros(1),'coarse_distance':torch.zeros(1)})
            return out
        idx=np.asarray(self.store.candidate_idx[i],np.int64);mask=idx>=0;safe=np.where(mask,idx,0)
        out['candidate_x']=torch.from_numpy(np.asarray(self.bank.current[safe],np.float32));out['candidate_y']=torch.from_numpy(self.bank_y[safe].astype(np.int64));out['candidate_faculty']=torch.from_numpy(np.asarray(self.bank.faculty_idx[safe],np.int64));out['candidate_semester_z']=torch.from_numpy(np.asarray(self.bank.semester_z[safe],np.float32));out['candidate_mask']=torch.from_numpy(mask);out['pool_flags']=torch.from_numpy(np.asarray(self.store.pool_flags[i],np.float32));out['relation_code']=torch.from_numpy(np.asarray(self.store.relation_code[i],np.int64));out['recency']=torch.from_numpy(np.asarray(self.store.recency[i],np.float32));out['same_faculty']=torch.from_numpy(np.asarray(self.store.same_faculty[i],np.float32));out['coarse_distance']=torch.from_numpy(np.asarray(self.store.coarse_distance[i],np.float32));return out
