"""Group student-course registrations by (faculty, student, target semester)."""
from __future__ import annotations
import numpy as np
import torch
from torch.utils.data import Dataset

def build_groups(bundle,selected=None,max_courses=0):
    selected=np.arange(len(bundle.y)) if selected is None else np.asarray(selected,np.int64)
    groups={}
    for i in selected:
        key=(int(bundle.faculty_idx[i]),str(bundle.student_id[i]),float(bundle.target_semester[i]))
        groups.setdefault(key,[]).append(int(i))
    result=[]
    for key,rows in groups.items():
        # Never silently split a student's enrollment set.
        if max_courses and len(rows)>max_courses:
            raise ValueError(f"Group {key} has {len(rows)} registrations > max_courses={max_courses}")
        result.append(np.asarray(rows,dtype=np.int64))
    return result

class EnrollmentDataset(Dataset):
    def __init__(self,bundle,indices=None,max_courses=0,context_override=None):
        self.bundle=bundle
        self.context_override=context_override
        self.groups=build_groups(bundle,indices,max_courses)
    def __len__(self):return len(self.groups)
    def __getitem__(self,i):
        idx=self.groups[i];b=self.bundle
        return dict(index=idx, x=np.asarray(b.current[idx],np.float32),
            y=np.asarray(b.y[idx],np.float32),
            faculty=np.asarray(b.faculty_idx[idx],np.int64),
            semester_z=np.asarray(b.semester_z[idx],np.float32),
            semester_ordinal=np.asarray(b.semester_ordinal[idx],np.float32),
            context_course=np.asarray(
                b.current[idx,-17:] if self.context_override is None
                else self.context_override[idx],np.float32))
def collate_groups(batch):
    b=len(batch); m=max(len(x["index"]) for x in batch);d=batch[0]["x"].shape[1]
    x=torch.zeros(b,m,d);y=torch.zeros(b,m);fac=torch.zeros(b,m,dtype=torch.long)
    context=torch.zeros(b,m,17);ordinal=torch.zeros(b,m)
    sz=torch.zeros(b,m);mask=torch.zeros(b,m,dtype=torch.bool);index=torch.full((b,m),-1,dtype=torch.long)
    for j,r in enumerate(batch):
        n=len(r["index"]);mask[j,:n]=True
        x[j,:n]=torch.from_numpy(r["x"]);y[j,:n]=torch.from_numpy(r["y"])
        fac[j,:n]=torch.from_numpy(r["faculty"]);sz[j,:n]=torch.from_numpy(r["semester_z"])
        context[j,:n]=torch.from_numpy(r["context_course"])
        ordinal[j,:n]=torch.from_numpy(r["semester_ordinal"])
        index[j,:n]=torch.from_numpy(r["index"])
    return dict(x=x,y=y,faculty=fac,semester_z=sz,semester_ordinal=ordinal,context_course=context,valid=mask,index=index)

def group_summary(ds):
    lengths=np.asarray([len(g) for g in ds.groups],int)
    return dict(groups=len(lengths),singleton=int((lengths==1).sum()),
        singleton_fraction=float((lengths==1).mean()) if len(lengths) else 0.,
        mean_size=float(lengths.mean()) if len(lengths) else 0.,
        median_size=float(np.median(lengths)) if len(lengths) else 0.,
        maximum=int(lengths.max()) if len(lengths) else 0.)


def global_chronological_split(bundle, validation_semesters=3):
    """One calendar-time cutoff across *all* faculties.

    Per-faculty latest-block splitting is not a valid prospective simulation
    for a shared cross-faculty network: a newer semester in faculty B could
    train the encoder used to validate that same semester in faculty A.
    """
    ordinals = np.asarray(bundle.semester_ordinal, dtype=float)
    if not np.isfinite(ordinals).all():
        raise ValueError('Semester ordinals must all be finite')
    semesters = np.unique(ordinals)
    if len(semesters) < 2:
        raise ValueError('At least two historical calendar semesters are required')
    nv = min(int(validation_semesters), len(semesters)-1)
    if nv < 1:
        raise ValueError('validation_semesters must be >= 1')
    first_validation = semesters[-nv]
    tr = ordinals < first_validation
    va = ordinals >= first_validation
    assert tr.any() and va.any()
    assert np.max(ordinals[tr]) < np.min(ordinals[va])
    return tr, va, dict(
        train_semesters=semesters[:-nv].tolist(),
        validation_semesters=semesters[-nv:].tolist(),
        first_validation_semester=float(first_validation),
        train_rows=int(tr.sum()), validation_rows=int(va.sum()),
        train_faculties=int(len(np.unique(bundle.faculty_idx[tr]))),
        validation_faculties=int(len(np.unique(bundle.faculty_idx[va]))),
    )


def matched_peer_placebo(bundle, seed=30, course_dim=17, return_mask=False):
    """Return [N,course_dim] donor features matched on faculty, calendar semester,
    and EXACT enrollment-set size, excluding the original student-semester group.
    Never reads outcome labels. Unmatched groups are unchanged and reported.
    """
    groups=build_groups(bundle)
    buckets={}
    for gi,ids in enumerate(groups):
        k=(int(bundle.faculty_idx[ids[0]]),float(bundle.semester_ordinal[ids[0]]),len(ids))
        buckets.setdefault(k,[]).append(gi)
    rng=np.random.default_rng(seed)
    override=np.asarray(bundle.current[:,-course_dim:],np.float32).copy()
    matched=np.zeros(len(groups),bool)
    faculty_summary={}
    for gi,ids in enumerate(groups):
        f=int(bundle.faculty_idx[ids[0]])
        k=(f,float(bundle.semester_ordinal[ids[0]]),len(ids))
        donors=[other for other in buckets[k] if other!=gi and
                str(bundle.student_id[groups[other][0]])!=str(bundle.student_id[ids[0]])]
        if donors:
            chosen=groups[int(rng.choice(donors))]
            override[ids]=bundle.current[chosen,-course_dim:]
            matched[gi]=True
        cur=faculty_summary.setdefault(bundle.faculty_names[f],
          dict(groups=0,matched_groups=0,rows=0,matched_rows=0))
        cur["groups"]+=1;cur["rows"]+=len(ids)
        if matched[gi]:
            cur["matched_groups"]+=1;cur["matched_rows"]+=len(ids)
    result=dict(total_groups=len(groups),matched_groups=int(matched.sum()),
                total_rows=int(len(bundle.y)),matched_rows=int(sum(len(g) for j,g in enumerate(groups) if matched[j])),
                faculty=faculty_summary)
    if return_mask:
        row_match=np.zeros(len(bundle.y),dtype=bool)
        for gi,ids in enumerate(groups):
            if matched[gi]:row_match[ids]=True
        return override,result,row_match
    return override,result
