"""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):
        self.bundle=bundle
        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))
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)
    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"])
        index[j,:n]=torch.from_numpy(r["index"])
    return dict(x=x,y=y,faculty=fac,semester_z=sz,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]))),
    )
