# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
from itertools import combinations
import numpy as np

VIEWS=('V1','V2','V3','V4')
CONTROL_NAMES=('history_semesters','history_rows','course_prior_rows','new_student','new_course')


def all_view_subsets():
    return [s for r in range(len(VIEWS)+1) for s in combinations(VIEWS,r)]


def subset_name(subset):
    s=tuple(subset)
    return 'CONTROL' if not s else '+'.join(s)


def _safe_stats(values,axis=0):
    x=np.asarray(values,np.float32)
    if x.size==0:
        shape=x.shape[1:] if x.ndim>1 else (1,)
        return np.zeros(shape,np.float32),np.ones(shape,np.float32)
    m=np.nanmean(x,axis=axis).astype(np.float32);sd=np.nanstd(x,axis=axis).astype(np.float32)
    sd=np.where(np.isfinite(sd)&(sd>1e-6),sd,1.).astype(np.float32)
    m=np.nan_to_num(m).astype(np.float32)
    return m,sd


def _masked_stats(x,mask):
    x=np.asarray(x,np.float32);mask=np.asarray(mask,bool)
    vals=x[mask]
    if vals.size==0:return np.zeros(x.shape[-1],np.float32),np.ones(x.shape[-1],np.float32)
    return _safe_stats(vals,0)


def _one_hot(values,nclasses):
    a=np.asarray(values,np.int64)
    out=np.zeros(a.shape+(int(nclasses),),np.float32)
    valid=(a>=0)&(a<int(nclasses))
    if valid.any():
        ii=np.nonzero(valid);out[ii+(a[valid],)]=1.
    return out

def _binary_code(values,nclasses):
    a=np.asarray(values,np.int64);bits=max(1,int(np.ceil(np.log2(max(int(nclasses),2)))));out=np.zeros(a.shape+(bits,),np.float32);valid=(a>=0)&(a<int(nclasses))
    z=np.where(valid,a,0)
    for j in range(bits):out[...,j]=((z>>j)&1).astype(np.float32)
    return out


def _names(prefix,shape):
    if len(shape)==1:return [f'{prefix}[{i}]' for i in range(shape[0])]
    if len(shape)==2:return [f'{prefix}[{i},{j}]' for i in range(shape[0]) for j in range(shape[1])]
    raise ValueError(shape)

@dataclass
class ViewMatrixBuilder:
    faculty_count:int
    student_mean:np.ndarray;student_scale:np.ndarray
    course_mean:np.ndarray;course_scale:np.ndarray
    relation_mean:np.ndarray;relation_scale:np.ndarray
    component_mean:np.ndarray;component_scale:np.ndarray
    control_mean:np.ndarray;control_scale:np.ndarray
    context_stats:dict
    course_relation_classes:int
    relation_classes:int
    component_classes:int

    @classmethod
    def fit(cls,bundle,mask):
        m=np.asarray(mask,bool)
        sm,ss=_masked_stats(bundle.student_seq[m],bundle.student_mask[m])
        ct=np.asarray(bundle.course_target[m],np.float32)[:,None,:]
        cn=np.asarray(bundle.course_neighbors[m],np.float32);cm=np.asarray(bundle.course_neighbor_mask[m],bool)
        allc=np.concatenate([ct,cn],1);allcm=np.concatenate([np.ones((len(ct),1),bool),cm],1);cmn,cs=_masked_stats(allc,allcm)
        rm,rs=_masked_stats(bundle.relation_events[m],bundle.relation_mask[m]);xm,xs=_masked_stats(bundle.component_events[m],bundle.component_mask[m])
        ctrl=np.asarray(bundle.fusion_context[m],np.float32);ctrlm,ctrls=_safe_stats(ctrl,0)
        ctx={}
        for k in ('e1_context','e2_context','e3_context','e4_context'):
            x=np.asarray(getattr(bundle,k)[m],np.float32);ctx[k]=_safe_stats(x,0)
        def ncls(a,default):
            z=np.asarray(a[m] if len(np.asarray(a))==len(m) else a,np.int64)
            return max(default,int(z.max())+1 if z.size else default)
        return cls(len(bundle.faculty_names),sm,ss,cmn,cs,rm,rs,xm,xs,ctrlm,ctrls,ctx,
                   ncls(bundle.course_relation_type,13),ncls(bundle.relation_type,14),ncls(bundle.component_type,12))

    def _student(self,b):
        mask=np.asarray(b.student_mask,bool);x=(np.nan_to_num(np.asarray(b.student_seq,np.float32))-self.student_mean)/self.student_scale;x[~mask]=0.
        names=_names('student_seq',x.shape[1:])+[f'student_mask[{i}]' for i in range(mask.shape[1])]
        return np.concatenate([x.reshape(len(x),-1),mask.astype(np.float32)],1),names

    def _course(self,b):
        target=(np.nan_to_num(np.asarray(b.course_target,np.float32))-self.course_mean)/self.course_scale
        mask=np.asarray(b.course_neighbor_mask,bool);neigh=(np.nan_to_num(np.asarray(b.course_neighbors,np.float32))-self.course_mean)/self.course_scale;neigh[~mask]=0.
        oh=_binary_code(b.course_relation_type,self.course_relation_classes);oh[~mask]=0.
        names=[f'course_target[{i}]' for i in range(target.shape[1])]+_names('course_neighbors',neigh.shape[1:])+[f'course_neighbor_mask[{i}]' for i in range(mask.shape[1])]+_names('course_relation_type',oh.shape[1:])
        return np.concatenate([target,neigh.reshape(len(target),-1),mask.astype(np.float32),oh.reshape(len(target),-1)],1),names

    def _relation(self,b):
        mask=np.asarray(b.relation_mask,bool);x=(np.nan_to_num(np.asarray(b.relation_events,np.float32))-self.relation_mean)/self.relation_scale;x[~mask]=0.;oh=_binary_code(b.relation_type,self.relation_classes);oh[~mask]=0.
        target=(np.nan_to_num(np.asarray(b.course_target,np.float32))-self.course_mean)/self.course_scale
        names=[f'course_target[{i}]' for i in range(target.shape[1])]+_names('relation_events',x.shape[1:])+[f'relation_mask[{i}]' for i in range(mask.shape[1])]+_names('relation_type',oh.shape[1:])
        return np.concatenate([target,x.reshape(len(x),-1),mask.astype(np.float32),oh.reshape(len(x),-1)],1),names

    def _component(self,b):
        mask=np.asarray(b.component_mask,bool);x=(np.nan_to_num(np.asarray(b.component_events,np.float32))-self.component_mean)/self.component_scale;x[~mask]=0.;oh=_binary_code(b.component_type,self.component_classes);oh[~mask]=0.
        names=_names('component_events',x.shape[1:])+[f'component_mask[{i}]' for i in range(mask.shape[1])]+_names('component_type',oh.shape[1:])
        return np.concatenate([x.reshape(len(x),-1),mask.astype(np.float32),oh.reshape(len(x),-1)],1),names

    def controls(self,b,return_feature_names=False):
        raw=np.asarray(b.fusion_context,np.float32);x=(np.nan_to_num(raw)-self.control_mean)/self.control_scale
        fac=_one_hot(np.asarray(b.faculty_idx,np.int64),self.faculty_count)
        mat=np.concatenate([x,fac],1).astype(np.float32)
        names=[f'control_{CONTROL_NAMES[i] if i<len(CONTROL_NAMES) else i}' for i in range(x.shape[1])]+[f'faculty[{i}]' for i in range(self.faculty_count)]
        return (mat,names) if return_feature_names else mat

    def _full_context(self,b,v):
        key={'V1':'e1_context','V2':'e2_context','V3':'e3_context','V4':'e4_context'}[v];x=np.asarray(getattr(b,key),np.float32);m,s=self.context_stats[key];x=(np.nan_to_num(x)-m)/s
        return x.astype(np.float32),[f'{key}[{i}]' for i in range(x.shape[1])]

    def transform(self,b,subset,include_full_context=False,return_feature_names=False):
        subset=tuple(subset);bad=[v for v in subset if v not in VIEWS]
        if bad:raise ValueError(f'unknown views: {bad}')
        parts=[];names=[]
        for v in subset:
            x,n={'V1':self._student,'V2':self._course,'V3':self._relation,'V4':self._component}[v](b);parts.append(x);names.extend(n)
            if include_full_context:
                c,cn=self._full_context(b,v);parts.append(c);names.extend(cn)
        mat=np.concatenate(parts,1).astype(np.float32) if parts else np.zeros((len(b.y),0),np.float32)
        return (mat,names) if return_feature_names else mat
