"""Fixed-shape, training-fitted numerical and optional coded-category preprocessing."""
from __future__ import annotations
import warnings
import numpy as np


class Preprocessor:
    def __init__(self, names, categorical=(), categorical_slots=32, clip=10.0):
        self.names = list(names)
        self.categorical = [n for n in categorical if n in self.names]
        self.categorical_slots = int(categorical_slots)
        self.clip = float(clip)
        if self.categorical_slots < 1 or self.clip <= 0:
            raise ValueError("Invalid preprocessing bounds")
        d = len(self.names)
        self.transformed_names = (["value::" + n for n in self.names] +
                                  ["missing::" + n for n in self.names])
        self.bundles = {n: [i, d+i] for i, n in enumerate(self.names)}
        for n in self.categorical:
            start = len(self.transformed_names)
            self.transformed_names += [f"category::{n}::{i}" for i in range(self.categorical_slots)]
            self.transformed_names += [f"category::{n}::unknown"]
            self.bundles[n] += list(range(start, len(self.transformed_names)))
        self.vocabularies = {}
        self.fitted = False

    @property
    def dimension(self):
        return len(self.transformed_names)

    def fit(self, X):
        X = self._check(X).astype(np.float64)
        X[~np.isfinite(X)] = np.nan
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", RuntimeWarning)
            self.median = np.nanmedian(X, axis=0)
        self.all_missing = ~np.isfinite(self.median)
        self.median[self.all_missing] = 0
        filled = np.where(np.isfinite(X), X, self.median)
        self.scale = filled.std(axis=0)
        self.scale[~np.isfinite(self.scale) | (self.scale < 1e-6)] = 1
        for n in self.categorical:
            values, counts = np.unique(X[np.isfinite(X[:, self.names.index(n)]), self.names.index(n)],
                                       return_counts=True)
            order = np.lexsort((values, -counts))[:self.categorical_slots]
            self.vocabularies[n] = values[order].tolist()
        self.fitted = True
        return self

    def _check(self, X):
        X = np.asarray(X)
        if X.ndim != 2 or X.shape[1] != len(self.names):
            raise ValueError("Preprocessor feature schema/dimension mismatch")
        return X

    def transform(self, X):
        if not self.fitted:
            raise ValueError("Preprocessor has not been fitted")
        X = self._check(X).astype(np.float64)
        missing = ~np.isfinite(X)
        filled = np.where(missing, self.median, X)
        scaled = np.clip((filled-self.median)/self.scale, -self.clip, self.clip)
        blocks = [scaled, missing.astype(np.float64)]
        for n in self.categorical:
            col = X[:, self.names.index(n)]
            encoded = np.zeros((len(X), self.categorical_slots+1), np.float32)
            encoded[:, -1] = 1
            for i, value in enumerate(self.vocabularies[n]):
                mask = np.isfinite(col) & (col == value)
                encoded[mask, -1] = 0
                encoded[mask, i] = 1
            blocks.append(encoded)
        output = np.concatenate(blocks, axis=1).astype(np.float32)
        if not np.isfinite(output).all():
            raise ValueError("Nonfinite preprocessed features")
        return output

    def audit(self):
        return dict(raw_dimension=len(self.names), transformed_dimension=self.dimension,
                    all_missing_features=[n for n, m in zip(self.names, self.all_missing) if m],
                    categorical=self.categorical, category_vocabularies=self.vocabularies,
                    missingness="CACHE_NONFINITE_ONLY; original source imputation/masks unrecoverable",
                    clip=self.clip)
