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

from collections import defaultdict
from dataclasses import dataclass
from pathlib import Path
import math,time
import joblib
import numpy as np
import pandas as pd
from scipy.spatial import cKDTree

POOL_NAMES=('same_student','same_course','structural','state')
P_STUDENT,P_COURSE,P_STRUCT,P_STATE=range(4)


def _norm_id(x):
    if pd.isna(x):return None
    s=str(x)
    try:
        f=float(s)
        if math.isfinite(f) and abs(f-round(f))<1e-9:return str(int(round(f)))
    except Exception:pass
    return s


def _safe_int(x,d=0):
    try:return int(float(x)) if x is not None and not pd.isna(x) else int(d)
    except Exception:return int(d)


def encode_relation(family,forward,kind):
    family=1 if _safe_int(family,2)==1 else 2;kind=max(1,min(3,_safe_int(kind,2)))
    if family==1:return kind if forward else 3+kind
    return 6+kind if forward else 9+kind


def relation_available(av,target):
    if av is None or pd.isna(av):return True
    try:return int(float(av))<int(float(target))
    except Exception:return False


class CourseRelationIndex:
    def __init__(self,raw_index_dir):
        p=Path(raw_index_dir)/'course_edges.joblib'
        if not p.exists():raise FileNotFoundError(f'Missing {p}')
        edges=joblib.load(p).copy();self.edge_map=defaultdict(list);self.edge_pair={}
        for r in edges.itertuples(index=False):
            a=_norm_id(getattr(r,'src'));b=_norm_id(getattr(r,'dst'));av=getattr(r,'available_nhhk',np.nan);fam=_safe_int(getattr(r,'family',0));kind=_safe_int(getattr(r,'kind',0));f=encode_relation(fam,True,kind);rv=encode_relation(fam,False,kind)
            self.edge_map[a].append((b,f,fam,kind,av));self.edge_map[b].append((a,rv,fam,kind,av));self.edge_pair[(a,b)]=(f,fam,kind,av);self.edge_pair[(b,a)]=(rv,fam,kind,av)
    def relation_code(self,a,b,target):
        a=_norm_id(a);b=_norm_id(b)
        if a==b:return 13
        z=self.edge_pair.get((a,b));return int(z[0]) if z and relation_available(z[3],target) else 0
    def neighbors(self,c,target,max_n=16):
        c=_norm_id(c);v=[]
        for nb,code,fam,kind,av in self.edge_map.get(c,[]):
            if relation_available(av,target):v.append((0 if fam==1 else 1,int(code),nb,fam,kind,av))
        return sorted(v,key=lambda x:(x[0],x[1],str(x[2])))[:int(max_n)]


@dataclass
class RetrievalStore:
    candidate_idx:np.ndarray       # [N,P] local bank positions, -1 padding
    pool_flags:np.ndarray          # [N,P,4]
    relation_code:np.ndarray       # [N,P]
    recency:np.ndarray             # [N,P] semester distance
    same_faculty:np.ndarray        # [N,P]
    coarse_distance:np.ndarray     # [N,P]
    support:np.ndarray             # [N,4] post-dedup counts per pool
    max_candidate_semester:np.ndarray
    chronology_violation:np.ndarray
    bank_size:int

    def __len__(self):return len(self.candidate_idx)


def _make_map(ids,semester):
    d=defaultdict(list)
    for i,k in enumerate(ids):d[_norm_id(k)].append(i)
    out={}
    sem=np.asarray(semester,float)
    for k,v in d.items():
        a=np.asarray(v,np.int32);a=a[np.argsort(sem[a],kind='stable')];out[k]=a
    return out


def _eligible_tail(arr,bank_sem,qsem,n):
    if arr is None or len(arr)==0:return np.zeros(0,np.int32)
    ss=bank_sem[arr];j=int(np.searchsorted(ss,qsem,side='left'))
    return arr[max(0,j-int(n)):j]


def _state_candidates(bank_coarse,bank_sem,query_coarse,query_sem,k=32,progress=True):
    n=len(query_sem);out=np.full((n,int(k)),-1,np.int32);dist=np.full((n,int(k)),np.inf,np.float32)
    uniq=np.unique(np.asarray(query_sem,float));t0=time.time()
    for gi,qsem in enumerate(uniq):
        qm=np.where(np.asarray(query_sem)==qsem)[0];eligible=np.where(np.asarray(bank_sem)<qsem)[0]
        if len(eligible)==0:continue
        kk=min(int(k),len(eligible));tree=cKDTree(np.asarray(bank_coarse[eligible],np.float32),leafsize=64,compact_nodes=True,balanced_tree=True);dd,ii=tree.query(np.asarray(query_coarse[qm],np.float32),k=kk,workers=-1)
        if kk==1:dd=np.asarray(dd)[:,None];ii=np.asarray(ii)[:,None]
        out[np.ix_(qm,np.arange(kk))]=eligible[np.asarray(ii,np.int64)];dist[np.ix_(qm,np.arange(kk))]=np.asarray(dd,np.float32)
        if progress:print(f'[STATE RETRIEVAL] semester={qsem:g} queries={len(qm):,} eligible_bank={len(eligible):,} k={kk}')
    if progress:print(f'[STATE RETRIEVAL] complete N={n:,} in {(time.time()-t0)/60:.2f} min')
    return out,dist


def materialize_retrieval_store(
    relation_index:CourseRelationIndex,
    bank,query,bank_coarse,query_coarse,
    student_pool=16,course_pool=24,struct_pool=24,state_pool=32,
    struct_courses=10,struct_per_course=4,max_candidates=96,progress_every=25000,
):
    """Build chronology-safe candidate pools without target labels.

    `bank` contains the only rows allowed to contribute candidate labels. All
    candidate rows must have semester_ordinal strictly lower than the query.
    Candidate generation uses identity/course structure plus an unsupervised
    PCA-space nearest-neighbour pool. Learned TabR-style re-ranking happens in
    the neural model, not here.
    """
    n=len(query);P=int(max_candidates);bank_sem=np.asarray(bank.semester_ordinal,float);qsem=np.asarray(query.semester_ordinal,float)
    student_map=_make_map(bank.student_id,bank_sem);course_map=_make_map(bank.course_id,bank_sem)
    state_idx,state_dist=_state_candidates(bank_coarse,bank_sem,query_coarse,qsem,state_pool,progress=True)
    cand=np.full((n,P),-1,np.int32);flags=np.zeros((n,P,4),np.uint8);rel=np.zeros((n,P),np.uint8);rec=np.zeros((n,P),np.float16);samefac=np.zeros((n,P),np.uint8);support=np.zeros((n,4),np.int16);maxsem=np.full(n,-np.inf,np.float32);viol=np.zeros(n,bool)
    bank_course=np.asarray([_norm_id(x) for x in bank.course_id],object);bank_student=np.asarray([_norm_id(x) for x in bank.student_id],object);bank_fac=np.asarray(bank.faculty_idx,int);qcourse=np.asarray([_norm_id(x) for x in query.course_id],object);qstudent=np.asarray([_norm_id(x) for x in query.student_id],object)
    t0=time.time()
    for i in range(n):
        qc=qcourse[i];qs=qstudent[i];qt=float(query.target_semester[i]);qo=float(qsem[i]);slots={};rels={}
        def add(j,pool,rcode=0):
            j=int(j)
            if j<0 or float(bank_sem[j])>=qo:return
            s=slots.get(j)
            if s is None:
                if len(slots)>=P:return
                s=len(slots);slots[j]=s;cand[i,s]=j
            flags[i,s,pool]=1
            if rcode:rels[s]=int(rcode)
        # Same student: inspect a larger recent tail, prioritize same/related target course.
        arr=_eligible_tail(student_map.get(qs),bank_sem,qo,max(int(student_pool)*4,32));rank=[]
        for j in arr:
            bc=bank_course[int(j)];rcode=relation_index.relation_code(bc,qc,qt);pri=0 if bc==qc else 1 if rcode else 2;rank.append((pri,-float(bank_sem[int(j)]),int(j),rcode))
        for _,__,j,rcode in sorted(rank)[:int(student_pool)]:add(j,P_STUDENT,rcode)
        # Exact target-course analogues: recent cases first.
        for j in _eligible_tail(course_map.get(qc),bank_sem,qo,course_pool):add(j,P_COURSE,13)
        # Structurally related target-course analogues.
        sr=[]
        for _pri,rcode,nb,_fam,_kind,_av in relation_index.neighbors(qc,qt,struct_courses):
            for j in _eligible_tail(course_map.get(_norm_id(nb)),bank_sem,qo,struct_per_course):sr.append((-float(bank_sem[int(j)]),int(j),int(rcode)))
        for _,j,rcode in sorted(sr)[:int(struct_pool)]:add(j,P_STRUCT,rcode)
        # Global/current-state analogues from unsupervised chronological KD-tree.
        for j in state_idx[i]:
            if j>=0:add(int(j),P_STATE,relation_index.relation_code(bank_course[int(j)],qc,qt))
        # Final metadata. A candidate may belong to multiple pools.
        for j,s in slots.items():
            bc=bank_course[j];rcode=rels.get(s,relation_index.relation_code(bc,qc,qt));rel[i,s]=np.uint8(max(0,min(13,rcode)));r=max(qo-float(bank_sem[j]),0.);rec[i,s]=np.float16(min(r,100.));samefac[i,s]=np.uint8(bank_fac[j]==int(query.faculty_idx[i]));maxsem[i]=max(maxsem[i],float(bank_sem[j]))
        if slots:support[i]=flags[i,:len(slots)].sum(0).astype(np.int16)
        viol[i]=bool(slots and maxsem[i]>=qo)
        if progress_every and (i+1)%int(progress_every)==0:print(f'[RETRIEVAL CACHE] {i+1:,}/{n:,}')
    if viol.any():raise RuntimeError(f'RETRIEVAL CHRONOLOGY VIOLATION rows={np.where(viol)[0][:10].tolist()}')
    # Coarse distances for all unioned candidates (not just state pool), chunked.
    cd=np.zeros((n,P),np.float16);chunk=10000
    for a in range(0,n,chunk):
        b=min(n,a+chunk);idx=cand[a:b];m=idx>=0;safe=np.where(m,idx,0);q=np.asarray(query_coarse[a:b],np.float32)[:,None,:];z=np.asarray(bank_coarse[safe],np.float32);d=np.sqrt(np.maximum(np.sum((q-z)**2,axis=-1),0.));d[~m]=0.;cd[a:b]=d.astype(np.float16)
    maxsem=np.where(np.isfinite(maxsem),maxsem,-1).astype(np.float32)
    print(f'[RETRIEVAL CACHE] complete N={n:,} bank={len(bank):,} maxP={P} in {(time.time()-t0)/60:.2f} min')
    return RetrievalStore(cand,flags,rel,rec,samefac,cd,support,maxsem,viol,len(bank))


def retrieval_support_frame(store:RetrievalStore,query,bank):
    rows=[];mask=store.candidate_idx>=0;safe=np.where(mask,store.candidate_idx,0);cy=np.asarray(bank.y,int)[safe]
    for fi,fac in enumerate(query.faculty_names):
        m=np.asarray(query.faculty_idx)==fi
        if not m.any():continue
        r={'faculty':fac,'rows':int(m.sum()),'prevalence':float(np.mean(query.y[m])),'any_candidate_zero_rate':float(np.mean(mask[m].sum(1)==0))}
        for p,name in enumerate(POOL_NAMES):
            cnt=store.pool_flags[m,:,p].sum(1);r[f'{name}_mean']=float(cnt.mean());r[f'{name}_zero_rate']=float(np.mean(cnt==0));pm=(store.pool_flags[m,:,p].astype(bool)&mask[m]);r[f'{name}_candidate_fail_rate']=float(cy[m][pm].mean()) if pm.any() else np.nan
        valid=mask[m];r['candidate_mean']=float(valid.sum(1).mean());r['cross_faculty_candidate_rate']=float(np.mean((1-store.same_faculty[m])[valid])) if valid.any() else np.nan;r['candidate_recency_mean']=float(store.recency[m][valid].mean()) if valid.any() else np.nan
        rows.append(r)
    return pd.DataFrame(rows)


def shuffled_bank_labels(bank,seed=42):
    rng=np.random.default_rng(seed);y=np.asarray(bank.y,np.int8).copy()
    for fi in np.unique(bank.faculty_idx):
        idx=np.where(np.asarray(bank.faculty_idx)==fi)[0];vals=y[idx].copy();rng.shuffle(vals);y[idx]=vals
    return y
