#!/usr/bin/env python3
# Source: q4-ml-coding.html
from typing import Callable

import numpy as np


def kfold_indices(y: np.ndarray, k: int = 5, stratified: bool = False,
                  seed: int = 0) -> list[np.ndarray]:
    """Split row ids 0..n-1 into k disjoint test folds. Shuffled."""
    rng = np.random.default_rng(seed)
    n = len(y)
    if k < 2 or k > n:
        raise ValueError("need 2 <= k <= n")
    if not stratified:
        return np.array_split(rng.permutation(n), k)
    folds: list[list[int]] = [[] for _ in range(k)]
    offset = 0
    for c in np.unique(y):
        ids = rng.permutation(np.flatnonzero(y == c))
        for j, i in enumerate(ids):
            folds[(j + offset) % k].append(int(i))   # deal like cards
        offset += len(ids)                           # next class starts where this one stopped
    return [np.array(sorted(f)) for f in folds]


def cross_validate(X: np.ndarray, y: np.ndarray,
                   fit_predict: Callable[[np.ndarray, np.ndarray, np.ndarray], np.ndarray],
                   metric: Callable[[np.ndarray, np.ndarray], float],
                   k: int = 5, stratified: bool = False, seed: int = 0) -> tuple[float, float]:
    """fit_predict(X_tr, y_tr, X_te) -> predictions. Returns (mean, std) of metric."""
    scores = []
    all_ids = np.arange(len(y))
    for test in kfold_indices(y, k, stratified, seed):
        train = np.setdiff1d(all_ids, test, assume_unique=True)
        # Fit every preprocessing step on train only, inside fit_predict.
        pred = fit_predict(X[train], y[train], X[test])
        scores.append(metric(y[test], pred))
    s = np.array(scores)
    return float(s.mean()), float(s.std(ddof=1))


if __name__ == "__main__":
    rng = np.random.default_rng(7)
    y = np.array([0] * 90 + [1] * 10)
    folds = kfold_indices(y, 5, stratified=True)
    assert sorted(np.concatenate(folds).tolist()) == list(range(100))
    assert all(y[f].sum() == 2 for f in folds)        # 10 positives over 5 folds

    X = rng.normal(size=(100, 2)) + y[:, None] * 3.0

    def nearest_mean(Xtr: np.ndarray, ytr: np.ndarray, Xte: np.ndarray) -> np.ndarray:
        mu = np.stack([Xtr[ytr == c].mean(0) for c in (0, 1)])
        return ((Xte[:, None, :] - mu[None]) ** 2).sum(-1).argmin(1)

    acc = lambda t, p: float((t == p).mean())
    m, s = cross_validate(X, y, nearest_mean, acc, k=5, stratified=True)
    assert m > 0.9
    print("ok", round(m, 3), round(s, 3))
