"""Chronological meta-episode generation plus upstream-compatible MetaBatch construction."""
from __future__ import annotations
from dataclasses import dataclass
import numpy as np
from .core import support_select, note

@dataclass(frozen=True)
class Episode:
    faculty:int
    origin:float
    support:np.ndarray
    query:np.ndarray
    def verify(self,h,release_gap=0):
        assert len(self.support)>0 and len(self.query)>0
        assert np.intersect1d(self.support,self.query).size==0
        assert np.all(h.semester_ordinal[self.support]<self.origin-release_gap)
        assert np.all(h.semester_ordinal[self.query]==self.origin)
        assert np.all(h.faculty_idx[self.support]==self.faculty)
        assert np.all(h.faculty_idx[self.query]==self.faculty)

def build_episodes(h,train_mask,support_budget,query_budget,seed,release_gap=0,min_positive_support=1):
    train=np.asarray(train_mask,bool)
    origins=np.unique(h.semester_ordinal[train]);episodes=[];skip=[]
    for f in np.unique(h.faculty_idx[train]):
        for origin in origins:
            cand=np.flatnonzero(train & (h.faculty_idx==f) & (h.semester_ordinal==origin))
            if len(cand)==0:continue
            sp,manifest=support_select(h,int(f),float(origin),support_budget,seed+int(f)*131+int(origin),release_gap)
            sp=sp[train[sp]]
            if len(sp)<2 or h.y[sp].sum()<min_positive_support or h.y[sp].sum()==len(sp):
                skip.append((int(f),float(origin),'insufficient_two_class_past_support'));continue
            # Repeat support across small query batches; never sample query with label-dependent probabilities.
            rng=np.random.default_rng(seed+int(f)*10007+int(origin));perm=rng.permutation(cand)
            for block in np.array_split(perm,max(1,int(np.ceil(len(perm)/query_budget)))):
                ep=Episode(int(f),float(origin),sp,block)
                ep.verify(h,release_gap);episodes.append(ep)
    return episodes,skip

def chronological_meta_batch(X,y,ep,n_estimators,seed,feature_shuffle='latin',outlier_threshold=4.):
    """Uses upstream TabICL's native EnsembleGenerator and MetaBatch, but explicit temporal split."""
    from tabicl._finetune.data import MetaBatch, _build_ensemble_generator
    import torch
    xs=np.asarray(X[ep.support],np.float32);ys=np.asarray(y[ep.support],int)
    xq=np.asarray(X[ep.query],np.float32);yq=np.asarray(y[ep.query],int)
    gen=_build_ensemble_generator(classification=True,n_estimators=n_estimators,norm_methods=None,feat_shuffle_method=feature_shuffle,class_shuffle_method='shift',outlier_threshold=outlier_threshold,random_state=seed)
    gen.fit(xs,ys);variants=gen.transform(xq,mode='both')
    xx=[];yt=[];yquery=[]
    for method,(xv,yv) in variants.items():
        xx.append(xv);yt.append(yv)
        for _feat,pattern in gen.ensemble_configs_[method]:
            yquery.append(np.asarray(pattern)[yq] if pattern is not None else yq)
    return MetaBatch(X=torch.from_numpy(np.concatenate(xx,axis=0)).float(),y_train=torch.from_numpy(np.concatenate(yt,axis=0)).float(),y_query=torch.from_numpy(np.stack(yquery,axis=0)).long(),train_size=len(ep.support))
