# -*- coding: utf-8 -*-
from __future__ import annotations

from dataclasses import dataclass
from typing import Iterable, Sequence
import json
import numpy as np

DOMAIN_NAMES=(
    'student_sparse',
    'course_sparse',
    'temporal_deterioration',
    'history_relational',
)
EPS=1e-12


def _clip01(x):
    return np.clip(np.nan_to_num(np.asarray(x,float),nan=0.0,posinf=1.0,neginf=0.0),0.0,1.0)


def _safe_col(X, index, name, default=0.0):
    j=index.get(name)
    if j is None:
        return np.full(len(X),float(default),float)
    return np.nan_to_num(np.asarray(X[:,j],float),nan=float(default),posinf=float(default),neginf=float(default))


def _unlog_count(z):
    return np.maximum(np.expm1(np.maximum(np.asarray(z,float),0.0)),0.0)


@dataclass
class DomainScores:
    scores: np.ndarray
    uncertainty: np.ndarray
    names: tuple[str,...]=DOMAIN_NAMES
    components: dict[str,np.ndarray]|None=None


class _EmpiricalReference:
    def __init__(self, values:Sequence[float]):
        v=np.asarray(values,float)
        v=v[np.isfinite(v)]
        self.values=np.sort(v) if len(v) else np.array([0.0],float)

    def cdf(self,x):
        x=np.asarray(x,float)
        return np.searchsorted(self.values,x,side='right')/max(len(self.values),1)

    def upper_percentile(self,x):
        return _clip01(self.cdf(x))

    def lower_percentile(self,x):
        return _clip01(1.0-self.cdf(x)+1.0/max(len(self.values),1))

    def to_dict(self):
        if len(self.values)<=64:
            vals=self.values.tolist()
        else:
            qs=np.linspace(0,1,33)
            vals=np.quantile(self.values,qs).tolist()
            return {'quantile_grid':qs.tolist(),'quantile_values':vals,'n':int(len(self.values))}
        return {'values':vals,'n':int(len(self.values))}


class SemanticDomainCalibrator:
    """Pre-outcome semantic domain calibrator.

    All normalization references are fitted without labels.  Faculty-specific
    empirical references are used where possible; a global fallback is always
    stored for unseen/small faculties.
    """
    def __init__(self,feature_names,faculty_values,refs,global_refs):
        self.feature_names=list(feature_names)
        self.index={n:i for i,n in enumerate(self.feature_names)}
        self.faculty_values=list(faculty_values)
        self.refs=refs
        self.global_refs=global_refs

    @classmethod
    def fit(cls,X,feature_names,faculty_idx,faculty_values:Iterable[int]|None=None):
        X=np.asarray(X,float); f=np.asarray(faculty_idx,int)
        vals=sorted(np.unique(f).tolist()) if faculty_values is None else list(faculty_values)
        idx={n:i for i,n in enumerate(feature_names)}
        def col(name,default=0.): return _safe_col(X,idx,name,default)
        hist_rows=_unlog_count(col('log1p_history_rows'))
        course_rows=_unlog_count(col('log1p_course_prior_rows'))
        target_count=np.maximum(col('hist_target_course_count'),0)
        same_attempt=np.maximum(col('hist_same_course_attempts'),0)
        same_comp=np.maximum(col('hist_same_course_component_count'),0)
        # Positive deterioration magnitudes only. Availability is handled later.
        d={
            'student_rows':hist_rows,
            'student_prior_courses':np.maximum(col('student_prior_course_count_log'),0),
            'course_rows':course_rows,
            'target_course_count':target_count,
            'same_course_attempts':same_attempt,
            'same_course_components':same_comp,
            'det_semester':np.maximum(col('hist_semester_gpa10_mean')-col('recent3_semester_gpa10_mean'),0),
            'det_latest':np.maximum(col('prev_cumulative_gpa10')-col('prev_semester_gpa10'),0),
            'det_course':np.maximum(col('hist_course_grade10_mean')-col('recent3_course_grade10_mean'),0),
            'det_component':np.maximum(col('hist_component_grade_mean')-col('recent3_component_grade_mean'),0),
            'det_conduct':np.maximum((col('hist_conduct_mean')-col('prev_conduct_score'))/10.0,0),
            'det_warning':np.maximum(col('recent3_warning_count')/np.maximum(col('recent3_semester_count'),1.0)-col('hist_warning_rate'),0),
            'unc_spread':np.maximum(col('probability_spread'),0),
            'unc_entropy':np.maximum(col('ensemble_entropy'),0),
        }
        global_refs={k:_EmpiricalReference(v) for k,v in d.items()}
        refs={}
        for fv in vals:
            m=f==int(fv)
            refs[int(fv)]={}
            for k,v in d.items():
                vv=v[m]
                # Very small faculty references are unstable; fall back globally.
                refs[int(fv)][k]=_EmpiricalReference(vv) if len(vv)>=32 else global_refs[k]
        return cls(feature_names,vals,refs,global_refs)

    def _ref(self,faculty,key):
        return self.refs.get(int(faculty),{}).get(key,self.global_refs[key])

    def _percentile_by_faculty(self,values,faculty_idx,key,upper=True):
        values=np.asarray(values,float); f=np.asarray(faculty_idx,int); out=np.zeros(len(values),float)
        for fv in np.unique(f):
            m=f==fv; ref=self._ref(fv,key)
            out[m]=ref.upper_percentile(values[m]) if upper else ref.lower_percentile(values[m])
        return _clip01(out)

    def transform(self,X,faculty_idx):
        X=np.asarray(X,float); f=np.asarray(faculty_idx,int); idx=self.index
        c=lambda n,d=0.:_safe_col(X,idx,n,d)
        hist_sem=_unlog_count(c('log1p_history_semesters'))
        hist_rows=_unlog_count(c('log1p_history_rows'))
        course_rows=_unlog_count(c('log1p_course_prior_rows'))
        new_student=_clip01(c('new_student'))
        new_course=_clip01(c('new_course'))
        student_missing=_clip01(c('student_gpa_history_missing_flag'))
        course_missing=_clip01(c('course_history_missing_flag'))

        # Student-sparse: exact cold-start dominates; 1-2 semester histories form fringe.
        sem_sparse=np.where(hist_sem<=0,1.0,np.where(hist_sem<=1,0.75,np.where(hist_sem<=2,0.45,np.where(hist_sem<=3,0.20,0.05))))
        row_sparse=self._percentile_by_faculty(hist_rows,f,'student_rows',upper=False)
        prior_sparse=self._percentile_by_faculty(np.maximum(c('student_prior_course_count_log'),0),f,'student_prior_courses',upper=False)
        student_sparse=np.maximum.reduce([new_student,student_missing,0.60*sem_sparse+0.25*row_sparse+0.15*prior_sparse])

        # Course-sparse: exact new/missing course history dominates; otherwise use support percentile.
        course_sparse_pct=self._percentile_by_faculty(course_rows,f,'course_rows',upper=False)
        course_sparse=np.maximum.reduce([new_course,course_missing,course_sparse_pct])

        # Temporal deterioration: combine strongest two positive, available signals.
        recent_sem_count=c('recent3_semester_count')
        hist_sem_count=np.maximum(c('hist_semester_count'),hist_sem)
        sem_av=(hist_sem_count>=2)&(recent_sem_count>=1)
        course_av=(c('hist_course_grade10_count')>=2)&(c('recent3_course_grade10_count')>=1)
        comp_av=(c('hist_component_grade_count')>=2)&(c('recent3_component_grade_count')>=1)
        conduct_av=(c('hist_conduct_mean')>0)&(c('prev_conduct_score')>0)&(hist_sem>=1)
        warn_av=hist_sem>=2
        raw_det={
            'det_semester':np.maximum(c('hist_semester_gpa10_mean')-c('recent3_semester_gpa10_mean'),0),
            'det_latest':np.maximum(c('prev_cumulative_gpa10')-c('prev_semester_gpa10'),0),
            'det_course':np.maximum(c('hist_course_grade10_mean')-c('recent3_course_grade10_mean'),0),
            'det_component':np.maximum(c('hist_component_grade_mean')-c('recent3_component_grade_mean'),0),
            'det_conduct':np.maximum((c('hist_conduct_mean')-c('prev_conduct_score'))/10.0,0),
            'det_warning':np.maximum(c('recent3_warning_count')/np.maximum(recent_sem_count,1.0)-c('hist_warning_rate'),0),
        }
        avail=[sem_av,sem_av,course_av,comp_av,conduct_av,warn_av]
        det_cols=[]
        for (key,val),av in zip(raw_det.items(),avail):
            p=self._percentile_by_faculty(val,f,key,upper=True)
            # zero deterioration should be zero domain evidence even if zero has high CDF mass.
            p=np.where((val>1e-8)&av,p,0.0)
            det_cols.append(p)
        det=np.column_stack(det_cols)
        top=np.sort(det,axis=1)[:,-2:]
        temporal=_clip01(0.60*top[:,1]+0.40*top[:,0])
        temporal*=np.clip(hist_sem/3.0,0.0,1.0)

        # History-rich relational: require student history, then increase with course and same-course evidence.
        hist_rich=np.clip((hist_sem-1.5)/2.5,0.0,1.0)
        course_rich=self._percentile_by_faculty(course_rows,f,'course_rows',upper=True)
        target_count=np.maximum(c('hist_target_course_count'),0)
        target_rich=self._percentile_by_faculty(target_count,f,'target_course_count',upper=True)
        same_attempt=np.maximum(c('hist_same_course_attempts'),0)
        same_comp=np.maximum(c('hist_same_course_component_count'),0)
        same_attempt_p=np.where(same_attempt>0,self._percentile_by_faculty(same_attempt,f,'same_course_attempts',upper=True),0.0)
        same_comp_p=np.where(same_comp>0,self._percentile_by_faculty(same_comp,f,'same_course_components',upper=True),0.0)
        rel_evidence=np.maximum.reduce([same_attempt_p,same_comp_p,0.60*target_rich])
        relational=_clip01(hist_rich*(0.35+0.65*rel_evidence)*(0.45+0.55*course_rich))

        scores=np.column_stack([student_sparse,course_sparse,temporal,relational])

        # Uncertainty is deliberately separate from semantic domain identity.
        spread=np.maximum(c('probability_spread'),0); entropy=np.maximum(c('ensemble_entropy'),0)
        usp=self._percentile_by_faculty(spread,f,'unc_spread',upper=True)
        uen=self._percentile_by_faculty(entropy,f,'unc_entropy',upper=True)
        uncertainty=_clip01(0.5*usp+0.5*uen)
        components={
            'history_semesters':hist_sem,'history_rows':hist_rows,'course_prior_rows':course_rows,
            'student_sparse_semester_component':sem_sparse,'student_sparse_support_component':row_sparse,'student_sparse_prior_course_component':prior_sparse,
            'course_sparse_support_component':course_sparse_pct,'temporal_raw_max':det.max(axis=1),
            'history_rich_component':hist_rich,'relational_evidence_component':rel_evidence,
            'uncertainty_spread_percentile':usp,'uncertainty_entropy_percentile':uen,
        }
        return DomainScores(_clip01(scores),uncertainty,DOMAIN_NAMES,components)

    def to_dict(self):
        return {
            'feature_names':self.feature_names,
            'faculty_values':self.faculty_values,
            'domain_names':list(DOMAIN_NAMES),
            'faculty_reference_sizes':{str(f):{k:int(len(v.values)) for k,v in d.items()} for f,d in self.refs.items()},
            'global_reference_sizes':{k:int(len(v.values)) for k,v in self.global_refs.items()},
            'notes':{
                'student_sparse':'observable history support; exact new_student/missing history dominates',
                'course_sparse':'observable course support; exact new_course/missing course history dominates',
                'temporal_deterioration':'positive recent-vs-long-term deterioration percentiles only',
                'history_relational':'history richness x course support x relational evidence',
                'uncertainty':'separate authority signal; never changes semantic membership',
            },
        }
