"""Train a linear or small MLP probe on frozen paired features."""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

from milk10k_new_collapse_research.config import CLASS_NAMES, RESULTS_ROOT
from milk10k_new_collapse_research.features import make_feature_matrix
from milk10k_new_collapse_research.metrics_ext import write_standard_outputs


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--train-features", type=Path, required=True)
    parser.add_argument("--val-features", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, default=RESULTS_ROOT / "linear_probe")
    parser.add_argument("--feature-mode", choices=["pair", "clinical", "dermoscopic"], default="pair")
    parser.add_argument("--probe", choices=["logistic", "mlp"], default="logistic")
    parser.add_argument("--max-iter", type=int, default=1000)
    parser.add_argument("--seed", type=int, default=42)
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    train = dict(np.load(args.train_features, allow_pickle=True))
    val = dict(np.load(args.val_features, allow_pickle=True))
    class_names = infer_class_names(train, val)
    label_to_idx = {label: idx for idx, label in enumerate(class_names)}
    x_train = make_feature_matrix(train, args.feature_mode)
    x_val = make_feature_matrix(val, args.feature_mode)
    y_train = np.asarray([label_to_idx[str(label)] for label in train["label"]], dtype=np.int64)
    y_val = np.asarray([label_to_idx[str(label)] for label in val["label"]], dtype=np.int64)

    if args.probe == "logistic":
        clf = LogisticRegression(
            max_iter=args.max_iter,
            class_weight="balanced",
            solver="lbfgs",
            random_state=args.seed,
        )
    else:
        clf = MLPClassifier(
            hidden_layer_sizes=(512,),
            alpha=1e-4,
            batch_size=64,
            max_iter=args.max_iter,
            early_stopping=True,
            random_state=args.seed,
        )
    model = make_pipeline(StandardScaler(), clf)
    model.fit(x_train, y_train)
    y_prob = model.predict_proba(x_val)
    y_prob = align_probabilities(y_prob, model.classes_, len(class_names))
    val_df = prediction_frame(val)
    metrics = write_standard_outputs(
        args.output_dir,
        val_df,
        y_val,
        y_prob,
        class_names,
        extra={
            "experiment": "linear_probe",
            "feature_mode": args.feature_mode,
            "probe": args.probe,
            "train_features": str(args.train_features),
            "val_features": str(args.val_features),
        },
    )
    (args.output_dir / "probe_config.json").write_text(json.dumps({"metrics_f1_macro": metrics["f1_macro"]}, indent=2))


def infer_class_names(*arrays: dict[str, np.ndarray]) -> list[str]:
    observed = sorted({str(label) for data in arrays for label in data["label"].tolist()})
    preferred = [label for label in CLASS_NAMES if label in observed]
    extras = [label for label in observed if label not in preferred]
    return preferred + extras


def align_probabilities(y_prob: np.ndarray, classes: np.ndarray, n_classes: int) -> np.ndarray:
    aligned = np.zeros((y_prob.shape[0], n_classes), dtype=np.float64)
    for src_idx, class_idx in enumerate(classes):
        aligned[:, int(class_idx)] = y_prob[:, src_idx]
    row_sum = aligned.sum(axis=1, keepdims=True)
    return aligned / np.clip(row_sum, 1e-12, None)


def prediction_frame(data: dict[str, np.ndarray]) -> pd.DataFrame:
    return pd.DataFrame(
        {
            "lesion_id": [str(item) for item in data["lesion_id"]],
            "clinical_path": [""] * len(data["label"]),
            "dermoscopic_path": [""] * len(data["label"]),
        }
    )


if __name__ == "__main__":
    main()