import json
from typing import Dict, Any, List

import numpy as np
import pandas as pd
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix


LABEL_COL = "label_mof_cascade_boundary_stabilization"

POSITIVE_ALIGNMENT_THRESHOLD = 0.60
HIGH_UNCERTAINTY_THRESHOLD = 0.25
NARROW_WINDOW_THRESHOLD = 0.30
PATHWAY_SWITCH_THRESHOLD = 0.15


def _normalize_label_col(df: pd.DataFrame) -> str:
    candidates = [c for c in df.columns if c.startswith("label_")]

    if len(candidates) == 1:
        return candidates[0]

    if len(candidates) == 0 and LABEL_COL in df.columns:
        return LABEL_COL

    if len(candidates) == 0:
        raise ValueError("No label column found. Expected exactly one column starting with 'label_'.")

    raise ValueError(
        f"Could not uniquely identify label column. Found multiple label columns: {candidates}"
    )


def _safe_div(numerator: float, denominator: float) -> float:
    return float(numerator) / float(denominator) if denominator else 0.0


def _confusion_dict(y_true: pd.Series, y_pred: pd.Series) -> Dict[str, int]:
    tn, fp, fn, tp = confusion_matrix(y_true, y_pred, labels=[0, 1]).ravel()
    return {
        "tn": int(tn),
        "fp": int(fp),
        "fn": int(fn),
        "tp": int(tp),
    }


def _binary_metrics(y_true: pd.Series, y_pred: pd.Series) -> Dict[str, Any]:
    return {
        "accuracy": float(accuracy_score(y_true, y_pred)),
        "precision": float(precision_score(y_true, y_pred, zero_division=0)),
        "recall": float(recall_score(y_true, y_pred, zero_division=0)),
        "f1": float(f1_score(y_true, y_pred, zero_division=0)),
        "confusion_matrix": _confusion_dict(y_true, y_pred),
    }


def _path_accuracy(y_true_paths: pd.Series, y_pred_paths: pd.Series) -> float:
    mask = y_true_paths.notna() & y_pred_paths.notna()
    if mask.sum() == 0:
        return 0.0
    return float((y_true_paths[mask] == y_pred_paths[mask]).mean())


def _validate_prediction_ids(reference_df: pd.DataFrame, prediction_df: pd.DataFrame) -> None:
    if "scenario_id" not in reference_df.columns:
        raise ValueError("Reference file must include 'scenario_id'.")
    if "scenario_id" not in prediction_df.columns:
        raise ValueError("Prediction file must include 'scenario_id'.")

    ref_ids = set(reference_df["scenario_id"].astype(str))
    pred_ids = set(prediction_df["scenario_id"].astype(str))

    missing_in_pred = sorted(ref_ids - pred_ids)
    extra_in_pred = sorted(pred_ids - ref_ids)

    if missing_in_pred or extra_in_pred:
        parts: List[str] = []
        if missing_in_pred:
            parts.append(
                f"Missing prediction rows for scenario_id values: {missing_in_pred[:10]}"
                + (" ..." if len(missing_in_pred) > 10 else "")
            )
        if extra_in_pred:
            parts.append(
                f"Unexpected prediction rows for scenario_id values: {extra_in_pred[:10]}"
                + (" ..." if len(extra_in_pred) > 10 else "")
            )
        raise ValueError("Scenario ID mismatch between reference and prediction files. " + " | ".join(parts))

    if prediction_df["scenario_id"].duplicated().any():
        dupes = prediction_df.loc[prediction_df["scenario_id"].duplicated(), "scenario_id"].astype(str).tolist()
        raise ValueError(
            f"Prediction file contains duplicate scenario_id values: {dupes[:10]}"
            + (" ..." if len(dupes) > 10 else "")
        )

    if reference_df["scenario_id"].duplicated().any():
        dupes = reference_df.loc[reference_df["scenario_id"].duplicated(), "scenario_id"].astype(str).tolist()
        raise ValueError(
            f"Reference file contains duplicate scenario_id values: {dupes[:10]}"
            + (" ..." if len(dupes) > 10 else "")
        )


def score(reference_csv: str, prediction_csv: str) -> Dict[str, Any]:
    ref = pd.read_csv(reference_csv)
    pred = pd.read_csv(prediction_csv)

    label_col = _normalize_label_col(ref)

    if label_col not in pred.columns:
        raise ValueError(f"Predictions must include '{label_col}'.")

    _validate_prediction_ids(ref, pred)

    merged = ref.merge(
        pred,
        on="scenario_id",
        suffixes=("_true", "_pred"),
        how="inner",
        validate="one_to_one",
    )

    y_true = merged[f"{label_col}_true"].astype(int)
    y_pred = merged[f"{label_col}_pred"].astype(int)

    metrics = _binary_metrics(y_true, y_pred)

    # A correct rescue in v0.9 requires all three conditions:
    # 1. the system stabilized
    # 2. the trajectory improved meaningfully
    # 3. the intervention was aligned with the true regime
    correct_rescue_exists = (
        (merged["stabilization_success"] == 1) &
        (merged["trajectory_shift"] < -0.10) &
        (merged["intervention_alignment_score"] >= POSITIVE_ALIGNMENT_THRESHOLD)
    )

    recall_correct_intervention_selection = _safe_div(
        ((y_pred == 1) & correct_rescue_exists).sum(),
        correct_rescue_exists.sum()
    )

    predicted_effective = (y_pred == 1)

    # OR logic is intentional.
    # A predicted effective intervention is false-effective if it fails
    # on any one of the core rescue-validity dimensions.
    structurally_misaligned = (
        (merged["intervention_alignment_score"] < POSITIVE_ALIGNMENT_THRESHOLD) |
        (merged["stabilization_success"] == 0) |
        (merged["trajectory_shift"] >= -0.10)
    )

    false_effective_intervention_rate = _safe_div(
        (predicted_effective & structurally_misaligned).sum(),
        predicted_effective.sum()
    )

    high_uncertainty_mask = merged["intervention_uncertainty"] >= HIGH_UNCERTAINTY_THRESHOLD
    missed_rescue_mask = correct_rescue_exists & (y_pred == 0)
    narrow_window_mask = merged["rescue_window_width"] <= NARROW_WINDOW_THRESHOLD

    primary_path_acc = 0.0
    secondary_path_acc = 0.0
    alignment_acc = 0.0
    competition_error = 0.0
    pathway_switch_misread_rate = 0.0

    if "primary_intervention_path_pred" in merged.columns:
        primary_path_acc = _path_accuracy(
            merged["primary_intervention_path_true"],
            merged["primary_intervention_path_pred"]
        )

    if "secondary_intervention_path_pred" in merged.columns:
        secondary_path_acc = _path_accuracy(
            merged["secondary_intervention_path_true"],
            merged["secondary_intervention_path_pred"]
        )

    if "predicted_intervention_alignment_score" in pred.columns:
        tmp = ref[["scenario_id", "intervention_alignment_score"]].merge(
            pred[["scenario_id", "predicted_intervention_alignment_score"]],
            on="scenario_id",
            how="inner",
            validate="one_to_one",
        )
        true_align = (tmp["intervention_alignment_score"] >= POSITIVE_ALIGNMENT_THRESHOLD).astype(int)
        pred_align = (tmp["predicted_intervention_alignment_score"] >= POSITIVE_ALIGNMENT_THRESHOLD).astype(int)
        alignment_acc = float((true_align == pred_align).mean())

    if "predicted_intervention_competition_ratio" in pred.columns:
        tmp = ref[["scenario_id", "intervention_competition_ratio"]].merge(
            pred[["scenario_id", "predicted_intervention_competition_ratio"]],
            on="scenario_id",
            how="inner",
            validate="one_to_one",
        )
        competition_error = float(
            np.mean(
                np.abs(
                    tmp["intervention_competition_ratio"] -
                    tmp["predicted_intervention_competition_ratio"]
                )
            )
        )

    if "predicted_pathway_switch_velocity" in pred.columns:
        tmp = ref[["scenario_id", "pathway_switch_velocity"]].merge(
            pred[["scenario_id", "predicted_pathway_switch_velocity"]],
            on="scenario_id",
            how="inner",
            validate="one_to_one",
        )
        true_switch = (tmp["pathway_switch_velocity"].abs() >= PATHWAY_SWITCH_THRESHOLD).astype(int)
        pred_switch = (tmp["predicted_pathway_switch_velocity"].abs() >= PATHWAY_SWITCH_THRESHOLD).astype(int)
        pathway_switch_misread_rate = float((true_switch != pred_switch).mean())

    support = {
        "num_rows": int(len(merged)),
        "correct_rescue_count": int(correct_rescue_exists.sum()),
        "predicted_effective_count": int(predicted_effective.sum()),
        "missed_rescue_count": int(missed_rescue_mask.sum()),
        "narrow_window_count": int(narrow_window_mask.sum()),
        "high_uncertainty_count": int(high_uncertainty_mask.sum()),
        "positive_class_count": int((y_true == 1).sum()),
        "negative_class_count": int((y_true == 0).sum()),
    }

    class_balance = {
        "positive_rate": float((y_true == 1).mean()),
        "negative_rate": float((y_true == 0).mean()),
    }

    thresholds = {
        "positive_alignment_threshold": float(POSITIVE_ALIGNMENT_THRESHOLD),
        "high_uncertainty_threshold": float(HIGH_UNCERTAINTY_THRESHOLD),
        "narrow_window_threshold": float(NARROW_WINDOW_THRESHOLD),
        "pathway_switch_threshold": float(PATHWAY_SWITCH_THRESHOLD),
    }

    diagnostics = {
        "recall_correct_intervention_selection": float(recall_correct_intervention_selection),
        "false_effective_intervention_rate": float(false_effective_intervention_rate),
        "primary_intervention_path_accuracy": float(primary_path_acc),
        "secondary_intervention_path_accuracy": float(secondary_path_acc),
        "intervention_alignment_accuracy": float(alignment_acc),

        # These rates are conditioned on missed rescues.
        # If there are no missed rescues, both resolve to 0.0 by design.
        # That indicates zero miss-attributable burden, not missing data.

        # Of missed rescues, what fraction occurred under high intervention uncertainty
        "high_uncertainty_intervention_miss_rate": float(
            _safe_div(
                (missed_rescue_mask & high_uncertainty_mask).sum(),
                missed_rescue_mask.sum()
            )
        ),

        # Of missed rescues, what fraction occurred in narrow rescue windows
        "rescue_window_miss_rate": float(
            _safe_div(
                (missed_rescue_mask & narrow_window_mask).sum(),
                missed_rescue_mask.sum()
            )
        ),

        "intervention_competition_error": float(competition_error),
        "pathway_switch_misread_rate": float(pathway_switch_misread_rate),
    }

    return {
        "label_column": label_col,
        "primary_metric": "recall_correct_intervention_selection",
        "secondary_metric": "false_effective_intervention_rate",
        "thresholds": thresholds,
        "support": support,
        "class_balance": class_balance,
        "binary_metrics": metrics,
        "diagnostics": diagnostics,
    }


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser()
    parser.add_argument("--reference", required=True, help="Path to reference CSV")
    parser.add_argument("--prediction", required=True, help="Path to prediction CSV")
    args = parser.parse_args()

    results = score(args.reference, args.prediction)
    print(json.dumps(results, indent=2))