# -*- coding: utf-8 -*-
from __future__ import annotations
from collections import defaultdict
from dataclasses import dataclass
from pathlib import Path
import math
import numpy as np
import pandas as pd
import joblib
from suite23_common import semester_distance, semester_ordinal, stable_hash

# Fixed graph tensor schema -----------------------------------------------------
NODE_PAD=0; NODE_STUDENT=1; NODE_COURSE=2; NODE_FACULTY=3; NODE_GROUP=4
REL_PAD=0
REL_STUDENT_TOOK=1
REL_COURSE_TAKEN_BY=2
REL_COURSE_TO_RELATED=3
REL_RELATED_TO_COURSE=4
REL_COURSE_TO_GROUP=5
REL_GROUP_TO_COURSE=6
REL_ENTITY_TO_FACULTY=7
REL_FACULTY_TO_ENTITY=8

MAX_HISTORY_COURSES=8
MAX_COHORT_STUDENTS=12
MAX_STRUCT_COURSES=6
MAX_GROUPS=2
N_NODES=3+MAX_HISTORY_COURSES+MAX_COHORT_STUDENTS+MAX_STRUCT_COURSES+MAX_GROUPS
MAX_EDGES=2*(MAX_HISTORY_COURSES+MAX_COHORT_STUDENTS+MAX_STRUCT_COURSES+MAX_GROUPS)+MAX_HISTORY_COURSES+4
NODE_RAW_DIM=20
EDGE_RAW_DIM=8

SL_ROOT_STUDENT=0
SL_ROOT_COURSE=1
SL_FACULTY=2
SL_HISTORY=slice(3,3+MAX_HISTORY_COURSES)
SL_COHORT=slice(SL_HISTORY.stop,SL_HISTORY.stop+MAX_COHORT_STUDENTS)
SL_STRUCT=slice(SL_COHORT.stop,SL_COHORT.stop+MAX_STRUCT_COURSES)
SL_GROUP=slice(SL_STRUCT.stop,SL_STRUCT.stop+MAX_GROUPS)

STUDENT_PROFILE_NAMES=['hist_count','grade_mean','grade_std','fail_rate','pass_rate','recent3_mean','recent3_fail_rate','last_grade','grade_slope','credits_sum','unique_courses','semester_span','latest_recency','max_grade','min_grade','passed_credit_ratio']
COURSE_STATIC=['SoTinChi','SoTietMH','SoTietTuan','SiSoMax','SiSoMin','KhgTinhDTB','IsMHTN','IsMonKT','IsMHKN','IsMHDacThu','IsGDTiengAnh','IsMonNgoaiNgu']
COURSE_PROFILE_NAMES=COURSE_STATIC+['hist_count','hist_mean','hist_std','hist_fail_rate','hist_pass_rate']


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 _coalesce_grade(df):
    a=pd.to_numeric(df.get('DiemHP',pd.Series(np.nan,index=df.index)),errors='coerce')
    if 'DiemHPCalc' in df:
        b=pd.to_numeric(df['DiemHPCalc'],errors='coerce');a=a.where(a.notna(),b)
    return a




def _safe_int(x,default=0):
    try:
        if x is None or pd.isna(x):return int(default)
        return int(float(x))
    except Exception:return int(default)

def _date_to_nhhk(v):
    d=pd.to_datetime(v,errors='coerce')
    if pd.isna(d):return None
    y=int(d.year);m=int(d.month)
    if m>=8:return y*10+1
    if m<=5:return (y-1)*10+2
    return (y-1)*10+3


def encode_relation(family, forward, kind):
    """Match the chronology-safe Suite12/17 typed course-relation encoding.

    Codes 1..6 are family-1 forward/reverse relations; 7..12 are family-2.
    Code 13 is reserved for an exact same-course historical interaction.
    """
    family=1 if _safe_int(family,2)==1 else 2
    try: kind=max(1,min(3,_safe_int(kind,2)))
    except Exception: kind=2
    forward=bool(forward)
    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


def ensure_curriculum_groups(raw_index_dir,database_dir=None):
    """Create database-native structural group memberships.

    MMHTQ/ MMHTQCT encode course-relation groups in the available source schema.
    They are used as curriculum/structural-group nodes. This avoids inventing
    unsupervised course clusters while still supplying the curriculum-node role.
    """
    raw=Path(raw_index_dir);out=raw/'curriculum_groups.joblib'
    if out.exists():return out
    db=Path(database_dir) if database_dir else None
    if db is None or not db.exists():
        # deterministic fallback: connected components of family-2 structural edges
        ed=joblib.load(raw/'course_edges.joblib');fam_series=ed['family'] if 'family' in ed else pd.Series(0,index=ed.index);ed=ed[pd.to_numeric(fam_series,errors='coerce').fillna(0).astype(int)==2].copy()
        parent={}
        def find(x):
            parent.setdefault(x,x)
            while parent[x]!=x:
                parent[x]=parent[parent[x]];x=parent[x]
            return x
        def union(a,b):
            a=find(a);b=find(b)
            if a!=b:parent[b]=a
        for a,b in ed[['src','dst']].itertuples(index=False,name=None):union(_norm_id(a),_norm_id(b))
        rows=[]
        for c in list(parent):rows.append({'group_id':f'cc_{find(c)}','course_id':c,'kind':0,'available_nhhk':np.nan,'source':'family2_component'})
        joblib.dump(pd.DataFrame(rows),out,compress=3);return out
    def locate(name):
        p=next(iter(db.rglob(name)),None)
        return p
    p1=locate('MMHTQ.csv');p2=locate('MMHTQCT.csv')
    if p1 is None or p2 is None:
        return ensure_curriculum_groups(raw_index_dir,None)
    a=pd.read_csv(p1,usecols=lambda c:c in {'IDMHTQ','IDMH','LoaiTQ','NgayThem'},low_memory=False)
    b=pd.read_csv(p2,usecols=lambda c:c in {'IDMHTQ','IDMHDK','NgayThem'},low_memory=False)
    a['_group']=a['IDMHTQ'].map(_norm_id);a['_parent']=a['IDMH'].map(_norm_id);kind_series=a['LoaiTQ'] if 'LoaiTQ' in a else pd.Series(0,index=a.index);a['_kind']=pd.to_numeric(kind_series,errors='coerce').fillna(0).astype(int);a['_av1']=a.get('NgayThem',pd.Series(index=a.index,dtype=object)).map(_date_to_nhhk)
    b['_group']=b['IDMHTQ'].map(_norm_id);b['_child']=b['IDMHDK'].map(_norm_id);b['_av2']=b.get('NgayThem',pd.Series(index=b.index,dtype=object)).map(_date_to_nhhk)
    rows=[]
    for gid,parent,kind,av1 in a[['_group','_parent','_kind','_av1']].itertuples(index=False,name=None):
        if gid is not None and parent is not None:rows.append({'group_id':gid,'course_id':parent,'kind':int(kind),'available_nhhk':av1,'source':'MMHTQ'})
    j=b.merge(a[['_group','_kind','_av1']],on='_group',how='left')
    for gid,child,av2,kind,av1 in j[['_group','_child','_av2','_kind','_av1']].itertuples(index=False,name=None):
        if gid is None or child is None:continue
        av=max([x for x in [av1,av2] if x is not None and not pd.isna(x)],default=np.nan)
        rows.append({'group_id':gid,'course_id':child,'kind':int(kind) if not pd.isna(kind) else 0,'available_nhhk':av,'source':'MMHTQCT'})
    z=pd.DataFrame(rows).drop_duplicates(['group_id','course_id','kind']) if rows else pd.DataFrame(columns=['group_id','course_id','kind','available_nhhk','source'])
    joblib.dump(z,out,compress=3);return out


class GraphEvidenceIndex:
    def __init__(self,raw_index_dir,database_dir=None):
        root=Path(raw_index_dir);self.root=root
        needed=['course_history.joblib','course_static.joblib','course_edges.joblib']
        missing=[x for x in needed if not (root/x).exists()]
        if missing:raise FileNotFoundError(f'Missing Suite12 raw-index files: {missing} under {root}')
        self.hp=joblib.load(root/'course_history.joblib').copy();self.static_df=joblib.load(root/'course_static.joblib').copy();self.edges=joblib.load(root/'course_edges.joblib').copy()
        self.hp['IDSV']=self.hp.IDSV.map(_norm_id);self.hp['IDMH']=self.hp.IDMH.map(_norm_id);self.hp['NHHK']=pd.to_numeric(self.hp.NHHK,errors='coerce');self.hp['grade_value']=_coalesce_grade(self.hp);credit_series=self.hp['SoTinChi'] if 'SoTinChi' in self.hp else pd.Series(0,index=self.hp.index);pass_series=self.hp['DatHP'] if 'DatHP' in self.hp else pd.Series(np.nan,index=self.hp.index);self.hp['credits_value']=pd.to_numeric(credit_series,errors='coerce').fillna(0);self.hp['passed_value']=pd.to_numeric(pass_series,errors='coerce');self.hp['passed_value']=self.hp['passed_value'].where(self.hp['passed_value'].notna(),(self.hp['grade_value']>=5).astype(float))
        self.hp=self.hp[self.hp.IDSV.notna()&self.hp.IDMH.notna()&self.hp.NHHK.notna()&self.hp.grade_value.notna()].copy()
        self.by_student={k:g.sort_values('NHHK') for k,g in self.hp.groupby('IDSV',sort=False)};self.by_course={k:g.sort_values('NHHK') for k,g in self.hp.groupby('IDMH',sort=False)}
        self.static_df['IDMH']=self.static_df.IDMH.map(_norm_id);self.static={}
        for r in self.static_df.itertuples(index=False):self.static[_norm_id(getattr(r,'IDMH'))]=np.nan_to_num(np.array([pd.to_numeric(getattr(r,c,np.nan),errors='coerce') for c in COURSE_STATIC],np.float32))
        self.edge_map=defaultdict(list);self.edge_pair={}
        for r in self.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),0);kind=_safe_int(getattr(r,'kind',0),0)
            fwd=encode_relation(fam,True,kind);rev=encode_relation(fam,False,kind)
            self.edge_map[a].append((b,fwd,fam,kind,av));self.edge_map[b].append((a,rev,fam,kind,av));self.edge_pair[(a,b)]=(fwd,fam,kind,av);self.edge_pair[(b,a)]=(rev,fam,kind,av)
        gp=ensure_curriculum_groups(root,database_dir);self.groups=joblib.load(gp).copy();self.group_by_course=defaultdict(list);self.group_members=defaultdict(set)
        if len(self.groups):
            for r in self.groups.itertuples(index=False):
                c=_norm_id(getattr(r,'course_id'));g=str(getattr(r,'group_id'));kind=_safe_int(getattr(r,'kind',0),0);av=getattr(r,'available_nhhk',np.nan);self.group_by_course[c].append((g,kind,av));self.group_members[g].add(c)
        students=sorted(set(self.hp.IDSV.astype(str)));courses=sorted(set(self.hp.IDMH.astype(str))|set(self.static.keys())|set(self.edge_map.keys()));groups=sorted(self.group_members)
        self.student_to_idx={x:i for i,x in enumerate(students)};self.course_to_idx={x:i for i,x in enumerate(courses)};self.group_to_idx={x:i for i,x in enumerate(groups)};self.idx_to_student=students;self.idx_to_course=courses;self.idx_to_group=groups
        self._student_cache={};self._course_cache={};self._cohort_cache={};self._history_cache={};self._struct_cache={};self._group_cache={};self._group_profile_cache={}

    def student_profile(self,s,target):
        s=_norm_id(s);key=(s,int(float(target)))
        if key in self._student_cache:return self._student_cache[key]
        g=self.by_student.get(s);z=g[g.NHHK<float(target)] if g is not None else None
        out=np.zeros(len(STUDENT_PROFILE_NAMES),np.float32)
        if z is not None and len(z):
            grades=z.grade_value.to_numpy(float);credits=z.credits_value.to_numpy(float);passed=z.passed_value.to_numpy(float);sem=z.NHHK.to_numpy(float);recent=grades[-3:]
            x=np.arange(len(grades),dtype=float);slope=float(np.polyfit(x,grades,1)[0]) if len(grades)>1 else 0.;ords=[semester_ordinal(v) for v in sem];ords=[o for o in ords if o is not None];span=float(max(ords)-min(ords)) if len(ords)>1 else 0.;rec=semester_distance(target,sem[-1]);den=max(float(np.sum(credits)),1e-6)
            out=np.array([len(grades),grades.mean(),grades.std() if len(grades)>1 else 0.,np.mean(grades<5),np.mean(grades>=5),recent.mean(),np.mean(recent<5),grades[-1],slope,np.sum(credits),z.IDMH.nunique(),span,0. if not np.isfinite(rec) else rec,np.max(grades),np.min(grades),float(np.sum(credits*passed)/den)],np.float32)
        self._student_cache[key]=out;return out

    def course_profile(self,c,target):
        c=_norm_id(c);key=(c,int(float(target)))
        if key in self._course_cache:return self._course_cache[key]
        st=self.static.get(c,np.zeros(len(COURSE_STATIC),np.float32));g=self.by_course.get(c);hist=np.zeros(5,np.float32)
        if g is not None:
            z=g[g.NHHK<float(target)];grades=z.grade_value.to_numpy(float)
            if len(grades):hist=np.array([len(grades),grades.mean(),grades.std() if len(grades)>1 else 0.,np.mean(grades<5),np.mean(grades>=5)],np.float32)
        out=np.nan_to_num(np.concatenate([st,hist])).astype(np.float32);self._course_cache[key]=out;return out

    def history_courses(self,s,target_course,target,max_n=MAX_HISTORY_COURSES):
        s=_norm_id(s);target_course=_norm_id(target_course);key=(s,target_course,int(float(target)),int(max_n))
        if key in self._history_cache:return self._history_cache[key]
        g=self.by_student.get(s);z=g[g.NHHK<float(target)].copy() if g is not None else pd.DataFrame()
        rows=[]
        if len(z):
            # one latest edge per course, prioritize structural relation to target then recency
            z=z.sort_values('NHHK').drop_duplicates('IDMH',keep='last')
            for r in z.itertuples(index=False):
                c=_norm_id(getattr(r,'IDMH'));pair=self.edge_pair.get((c,target_course));rel=1 if pair and relation_available(pair[3],target) else 0;rows.append((0 if c==target_course else 1 if rel else 2,-float(getattr(r,'NHHK')),r,pair))
            rows.sort(key=lambda x:(x[0],x[1]));rows=rows[:max_n]
        self._history_cache[key]=rows;return rows

    def cohort_students(self,c,target,max_n=MAX_COHORT_STUDENTS):
        c=_norm_id(c);key=(c,int(float(target)),int(max_n))
        if key in self._cohort_cache:return self._cohort_cache[key]
        g=self.by_course.get(c);z=g[g.NHHK<float(target)].copy() if g is not None else pd.DataFrame();rows=[]
        if len(z):
            z=z.sort_values('NHHK').drop_duplicates('IDSV',keep='last');recent=z.tail(max_n//2);remaining=z.iloc[:-len(recent)] if len(recent) else z
            need=max_n-len(recent)
            if need>0 and len(remaining)>0:
                rng=np.random.default_rng(stable_hash(c,target,max_n)%2**32);sel=np.sort(rng.choice(len(remaining),size=min(need,len(remaining)),replace=False));picked=remaining.iloc[sel]
                zz=pd.concat([recent,picked],ignore_index=True)
            else:zz=recent
            rows=list(zz.sort_values('NHHK',ascending=False).itertuples(index=False))[:max_n]
        self._cohort_cache[key]=rows;return rows

    def structural_courses(self,c,target,max_n=MAX_STRUCT_COURSES):
        c=_norm_id(c);key=(c,int(float(target)),int(max_n))
        if key in self._struct_cache:return self._struct_cache[key]
        vals=[]
        for nb,code,fam,kind,av in self.edge_map.get(c,[]):
            if relation_available(av,target): vals.append((0 if fam==1 else 1,code,nb,fam,kind,av))
        vals=sorted(vals,key=lambda x:(x[0],x[1],x[2]))[:max_n];self._struct_cache[key]=vals;return vals

    def curriculum_groups(self,c,target,max_n=MAX_GROUPS):
        c=_norm_id(c);key=(c,int(float(target)),int(max_n));out=[]
        if key in self._group_cache:return self._group_cache[key]
        for gid,kind,av in self.group_by_course.get(c,[]):
            if relation_available(av,target):out.append((gid,kind,av,len(self.group_members.get(gid,()))))
        out=sorted(out,key=lambda x:(x[1],-x[3],x[0]))[:max_n];self._group_cache[key]=out;return out


    def group_profile(self,gid,target,kind=0):
        key=(str(gid),int(float(target)),int(kind))
        if key in self._group_profile_cache:return self._group_profile_cache[key]
        members=sorted(self.group_members.get(str(gid),()))
        # Keep the node inductive: aggregate course attributes/history, never course IDs.
        # Deterministic cap bounds construction cost for very large structural groups.
        if len(members)>64:
            order=np.argsort([stable_hash(gid,target,c) for c in members])[:64]
            members=[members[i] for i in order]
        prof=np.stack([self.course_profile(c,target) for c in members],axis=0) if members else np.zeros((0,len(COURSE_PROFILE_NAMES)),np.float32)
        out=np.zeros(NODE_RAW_DIM,np.float32)
        if len(prof):
            out[:len(COURSE_PROFILE_NAMES)]=np.nan_to_num(prof.mean(0)).astype(np.float32)
            out[19]=float(np.nanstd(prof[:,15])) if prof.shape[1]>15 else 0.0
        out[17]=math.log1p(len(self.group_members.get(str(gid),())))
        out[18]=float(kind)
        self._group_profile_cache[key]=out;return out

    def id_code(self,node_type,value):
        v=_norm_id(value)
        if node_type==NODE_STUDENT:return self.student_to_idx.get(v,-1)
        if node_type==NODE_COURSE:return self.course_to_idx.get(v,-1)
        if node_type==NODE_GROUP:return self.group_to_idx.get(str(value),-1)
        return -1


def _edge_attr(grade=0,credits=0,passed=0,recency=0,rel_code=0,direct=0,structural=0,support=1):
    rec=max(float(recency),0.) if np.isfinite(recency) else 0.
    return np.array([float(grade)/10.,float(credits)/10.,float(passed),math.log1p(rec)/3.,math.exp(-rec/3.),float(rel_code)/13.,float(direct),float(structural)*float(support)],np.float32)


def build_query_graph(index:GraphEvidenceIndex,student,course,target,faculty_idx):
    student=_norm_id(student);course=_norm_id(course);target=float(target)
    node_x=np.zeros((N_NODES,NODE_RAW_DIM),np.float16);node_type=np.zeros(N_NODES,np.uint8);node_mask=np.zeros(N_NODES,bool);node_entity=np.full(N_NODES,-1,np.int32)
    edge_src=np.zeros(MAX_EDGES,np.uint8);edge_dst=np.zeros(MAX_EDGES,np.uint8);edge_type=np.zeros(MAX_EDGES,np.uint8);edge_attr=np.zeros((MAX_EDGES,EDGE_RAW_DIM),np.float16);edge_mask=np.zeros(MAX_EDGES,bool)
    # root nodes
    sp=index.student_profile(student,target);cp=index.course_profile(course,target);node_x[0,:len(sp)]=sp;node_type[0]=NODE_STUDENT;node_mask[0]=1;node_entity[0]=index.id_code(NODE_STUDENT,student)
    node_x[1,:len(cp)]=cp;node_type[1]=NODE_COURSE;node_mask[1]=1;node_entity[1]=index.id_code(NODE_COURSE,course)
    node_type[2]=NODE_FACULTY;node_mask[2]=1;node_entity[2]=int(faculty_idx)
    ep=0;max_edge_sem=-np.inf
    def add_edge(a,b,r,attr=None):
        nonlocal ep
        if ep>=MAX_EDGES:raise RuntimeError('graph edge capacity exceeded')
        edge_src[ep]=a;edge_dst[ep]=b;edge_type[ep]=r;edge_mask[ep]=1
        if attr is not None:edge_attr[ep]=np.asarray(attr,np.float16)
        ep+=1
    # faculty edges are hetero context, no target information
    add_edge(0,2,REL_ENTITY_TO_FACULTY);add_edge(2,0,REL_FACULTY_TO_ENTITY);add_edge(1,2,REL_ENTITY_TO_FACULTY);add_edge(2,1,REL_FACULTY_TO_ENTITY)
    # student's past course edges
    hist=index.history_courses(student,course,target)
    for j,item in enumerate(hist):
        _pri,_neg,r,pair=item;slot=SL_HISTORY.start+j;c=_norm_id(getattr(r,'IDMH'));prof=index.course_profile(c,target);node_x[slot,:len(prof)]=prof;node_type[slot]=NODE_COURSE;node_mask[slot]=1;node_entity[slot]=index.id_code(NODE_COURSE,c)
        grade=float(getattr(r,'grade_value'));credits=float(getattr(r,'credits_value'));passed=float(getattr(r,'passed_value'));sem=float(getattr(r,'NHHK'));rec=semester_distance(target,sem);max_edge_sem=max(max_edge_sem,sem);same=(c==course);rel_code=13 if same else (pair[0] if pair and relation_available(pair[3],target) else 0);direct=1 if pair and int(pair[1])==1 else 0;ea=_edge_attr(grade,credits,passed,rec,rel_code,direct,0)
        add_edge(0,slot,REL_STUDENT_TOOK,ea);add_edge(slot,0,REL_COURSE_TAKEN_BY,ea)
        # explicit relation from historical course into the target when available
        if rel_code:
            ra=_edge_attr(0,0,0,0,rel_code,direct,1)
            add_edge(slot,1,REL_COURSE_TO_RELATED,ra)
    # target-course historical cohort students
    cohort=index.cohort_students(course,target)
    for j,r in enumerate(cohort):
        slot=SL_COHORT.start+j;s=_norm_id(getattr(r,'IDSV'));prof=index.student_profile(s,target);node_x[slot,:len(prof)]=prof;node_type[slot]=NODE_STUDENT;node_mask[slot]=1;node_entity[slot]=index.id_code(NODE_STUDENT,s)
        grade=float(getattr(r,'grade_value'));credits=float(getattr(r,'credits_value'));passed=float(getattr(r,'passed_value'));sem=float(getattr(r,'NHHK'));rec=semester_distance(target,sem);max_edge_sem=max(max_edge_sem,sem);ea=_edge_attr(grade,credits,passed,rec,0,0,0)
        add_edge(slot,1,REL_STUDENT_TOOK,ea);add_edge(1,slot,REL_COURSE_TAKEN_BY,ea)
    # structural neighbors
    struct=index.structural_courses(course,target)
    for j,(_pri,code,nb,fam,kind,av) in enumerate(struct):
        slot=SL_STRUCT.start+j;prof=index.course_profile(nb,target);node_x[slot,:len(prof)]=prof;node_type[slot]=NODE_COURSE;node_mask[slot]=1;node_entity[slot]=index.id_code(NODE_COURSE,nb);ea=_edge_attr(0,0,0,0,code,1 if fam==1 else 0,1)
        add_edge(slot,1,REL_COURSE_TO_RELATED,ea);add_edge(1,slot,REL_RELATED_TO_COURSE,ea)
    groups=index.curriculum_groups(course,target)
    for j,(gid,kind,av,count) in enumerate(groups):
        slot=SL_GROUP.start+j;node_x[slot]=index.group_profile(gid,target,kind);node_type[slot]=NODE_GROUP;node_mask[slot]=1;node_entity[slot]=index.id_code(NODE_GROUP,gid);ea=_edge_attr(0,0,0,0,kind,0,1)
        add_edge(1,slot,REL_COURSE_TO_GROUP,ea);add_edge(slot,1,REL_GROUP_TO_COURSE,ea)
    violation=bool(np.isfinite(max_edge_sem) and max_edge_sem>=target)
    support=np.array([len(hist),len(cohort),len(struct),len(groups)],np.int16)
    return {'node_x':node_x,'node_type':node_type,'node_mask':node_mask,'node_entity':node_entity,'edge_src':edge_src,'edge_dst':edge_dst,'edge_type':edge_type,'edge_attr':edge_attr,'edge_mask':edge_mask,'support':support,'max_edge_semester':np.float32(max_edge_sem if np.isfinite(max_edge_sem) else -1),'chronology_violation':violation}


class GraphTensorStore:
    KEYS=('node_x','node_type','node_mask','node_entity','edge_src','edge_dst','edge_type','edge_attr','edge_mask','support','max_edge_semester','chronology_violation')
    def __init__(self,data):
        self.data=data;self.n=len(data['node_x'])
    def __len__(self):return self.n
    def __getitem__(self,i):return {k:self.data[k][i] for k in self.KEYS}


def materialize_graphs(index,bundle,progress_every=25000):
    n=len(bundle.y);data={
        'node_x':np.zeros((n,N_NODES,NODE_RAW_DIM),np.float16),'node_type':np.zeros((n,N_NODES),np.uint8),'node_mask':np.zeros((n,N_NODES),bool),'node_entity':np.full((n,N_NODES),-1,np.int32),
        'edge_src':np.zeros((n,MAX_EDGES),np.uint8),'edge_dst':np.zeros((n,MAX_EDGES),np.uint8),'edge_type':np.zeros((n,MAX_EDGES),np.uint8),'edge_attr':np.zeros((n,MAX_EDGES,EDGE_RAW_DIM),np.float16),'edge_mask':np.zeros((n,MAX_EDGES),bool),
        'support':np.zeros((n,4),np.int16),'max_edge_semester':np.full(n,-1,np.float32),'chronology_violation':np.zeros(n,bool)}
    for i,(s,c,t,f) in enumerate(zip(bundle.student_id,bundle.course_id,bundle.target_semester,bundle.faculty_idx)):
        g=build_query_graph(index,s,c,t,int(f))
        for k in data:data[k][i]=g[k]
        if progress_every and (i+1)%progress_every==0:print(f'[GRAPH CACHE] {i+1:,}/{n:,}')
    if data['chronology_violation'].any():
        bad=np.where(data['chronology_violation'])[0][:10];raise RuntimeError(f'CHRONOLOGY VIOLATION in graph cache rows {bad.tolist()}')
    return GraphTensorStore(data)
