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

import json
from pathlib import Path
from typing import Mapping

import numpy as np
import pandas as pd


def load_shared_feature_schema(shared_results_dir, fold: int) -> dict:
    path = Path(shared_results_dir) / f"fold_{int(fold)}" / "feature_schema.json"
    if not path.exists():
        raise FileNotFoundError(f"missing shared feature schema: {path}")
    data = json.loads(path.read_text())
    if "common_raw_features" not in data or not data["common_raw_features"]:
        raise ValueError(f"shared feature schema has no common_raw_features: {path}")
    return data


def load_shared_fold_frame(
    shared_results_dir,
    fold: int,
    faculty: str,
    expected_y,
    expected_committee,
    atol: float = 1e-6,
) -> pd.DataFrame:
    path = Path(shared_results_dir) / f"fold_{int(fold)}" / f"{faculty}_scores.csv"
    if not path.exists():
        raise FileNotFoundError(f"missing shared score file: {path}")
    df = pd.read_csv(path)
    required = {"actual", "committee", "residual_moe_shared"}
    missing = sorted(required - set(df.columns))
    if missing:
        raise ValueError(f"shared score file missing columns {missing}: {path}")
    y = np.asarray(expected_y, int)
    q = np.asarray(expected_committee, float)
    if len(df) != len(y):
        raise ValueError(f"shared score row alignment mismatch for {faculty} fold {fold}: {len(df)} != {len(y)}")
    if not np.array_equal(df["actual"].to_numpy(int), y):
        raise ValueError(f"shared score label alignment mismatch for {faculty} fold {fold}")
    if not np.allclose(df["committee"].to_numpy(float), q, atol=float(atol), rtol=1e-5, equal_nan=False):
        max_abs = float(np.max(np.abs(df["committee"].to_numpy(float) - q))) if len(q) else 0.0
        raise ValueError(
            f"shared score committee alignment mismatch for {faculty} fold {fold}; max_abs={max_abs:.3g}"
        )
    return df


def load_shared_fold_scores(
    shared_results_dir,
    fold: int,
    faculty: str,
    expected_y,
    expected_committee,
    atol: float = 1e-6,
) -> np.ndarray:
    df = load_shared_fold_frame(
        shared_results_dir, fold, faculty, expected_y, expected_committee, atol=atol
    )
    return df["residual_moe_shared"].to_numpy(float)


def _get_metric(df: pd.DataFrame, faculty: str, model: str, metric: str) -> float:
    row = df[(df["faculty"] == faculty) & (df["model"] == model)]
    if row.empty or metric not in row.columns:
        return np.nan
    return float(row.iloc[0][metric])


def _prefer(local: float, shared: float, tol: float = 1e-6) -> str:
    if not np.isfinite(local) or not np.isfinite(shared):
        return "NA"
    d = local - shared
    if d > tol:
        return "LOCAL"
    if d < -tol:
        return "SHARED"
    return "TIE"


def build_transfer_diagnostic(
    pooled: pd.DataFrame,
    operational: pd.DataFrame,
    local_model: str = "residual_moe_target_only",
    shared_model: str = "residual_moe_shared",
    committee_model: str = "committee",
) -> pd.DataFrame:
    """Create a descriptive local-vs-shared transfer diagnostic.

    `evidence_pattern` is intentionally descriptive rather than causal. It counts
    which system is better on pooled AP, equal-budget F2@20, and drift-aware F2.
    Fixed/drift operational metrics are also emitted for fair comparison to V2/Council.
    """
    ops = operational.copy()
    pooled_ops = ops[ops["fold"].astype(str) == "POOLED"]
    fixed_ops = pooled_ops[pooled_ops["policy"] == "fixed"]
    drift_ops = pooled_ops[pooled_ops["policy"] == "drift"]
    faculties = sorted(set(pooled["faculty"]))
    rows = []

    def op(faculty, model, policy_df, metric):
        return _get_metric(policy_df, faculty, model, metric)

    for faculty in faculties:
        c_ap = _get_metric(pooled, faculty, committee_model, "ap")
        s_ap = _get_metric(pooled, faculty, shared_model, "ap")
        l_ap = _get_metric(pooled, faculty, local_model, "ap")
        c_auc = _get_metric(pooled, faculty, committee_model, "auc")
        s_auc = _get_metric(pooled, faculty, shared_model, "auc")
        l_auc = _get_metric(pooled, faculty, local_model, "auc")
        c_f2 = _get_metric(pooled, faculty, committee_model, "f2_at_20")
        s_f2 = _get_metric(pooled, faculty, shared_model, "f2_at_20")
        l_f2 = _get_metric(pooled, faculty, local_model, "f2_at_20")

        c_fixed = op(faculty, committee_model, fixed_ops, "fbeta")
        s_fixed = op(faculty, shared_model, fixed_ops, "fbeta")
        l_fixed = op(faculty, local_model, fixed_ops, "fbeta")
        c_drift = op(faculty, committee_model, drift_ops, "fbeta")
        s_drift = op(faculty, shared_model, drift_ops, "fbeta")
        l_drift = op(faculty, local_model, drift_ops, "fbeta")

        prefers = [_prefer(l_ap, s_ap), _prefer(l_f2, s_f2), _prefer(l_drift, s_drift)]
        local_votes = sum(x == "LOCAL" for x in prefers)
        shared_votes = sum(x == "SHARED" for x in prefers)
        if local_votes >= 2:
            pattern = "LOCAL_STRONGER"
        elif shared_votes >= 2:
            pattern = "SHARED_STRONGER"
        else:
            pattern = "MIXED"

        row = {
            "faculty": faculty,
            "committee_ap": c_ap, "shared_ap": s_ap, "local_ap": l_ap,
            "shared_minus_committee_ap": s_ap - c_ap,
            "local_minus_committee_ap": l_ap - c_ap,
            "local_minus_shared_ap": l_ap - s_ap,
            "committee_auc": c_auc, "shared_auc": s_auc, "local_auc": l_auc,
            "local_minus_shared_auc": l_auc - s_auc,
            "committee_f2_20": c_f2, "shared_f2_20": s_f2, "local_f2_20": l_f2,
            "shared_minus_committee_f2_20": s_f2 - c_f2,
            "local_minus_committee_f2_20": l_f2 - c_f2,
            "local_minus_shared_f2_20": l_f2 - s_f2,
            "committee_fixed_f2": c_fixed, "shared_fixed_f2": s_fixed, "local_fixed_f2": l_fixed,
            "local_minus_shared_fixed_f2": l_fixed - s_fixed,
            "committee_drift_f2": c_drift, "shared_drift_f2": s_drift, "local_drift_f2": l_drift,
            "local_minus_shared_drift_f2": l_drift - s_drift,
            "ap_prefers": prefers[0],
            "f2_20_prefers": prefers[1],
            "drift_f2_prefers": prefers[2],
            "evidence_pattern": pattern,
        }
        # Preserve the most decision-relevant operational details for each model.
        for policy_name, pdf in [("fixed", fixed_ops), ("drift", drift_ops)]:
            for model_name, short in [(committee_model, "committee"), (shared_model, "shared"), (local_model, "local")]:
                for metric in ["precision", "recall", "f1", "flag_rate"]:
                    row[f"{short}_{policy_name}_{metric}"] = op(faculty, model_name, pdf, metric)
        rows.append(row)
    return pd.DataFrame(rows)


def merge_external_references(base: pd.DataFrame, reference_metrics: str | Path | None) -> pd.DataFrame:
    if not reference_metrics:
        return base.copy()
    ref = pd.read_csv(reference_metrics)
    if "split" in ref.columns:
        ref = ref[ref["split"] == "holdout"]
    out = base.copy()
    for model in sorted(ref["model"].dropna().unique()):
        rr = ref[ref["model"] == model].copy()
        keep = [c for c in ["faculty", "ap", "auc", "fixed_f2", "drift_f2"] if c in rr.columns]
        rr = rr[keep].drop_duplicates("faculty")
        rr = rr.rename(columns={c: f"{model}_{c}" for c in keep if c != "faculty"})
        out = out.merge(rr, on="faculty", how="left")
    return out


def summarize_router_frame(df: pd.DataFrame) -> dict:
    weight_cols = [c for c in df.columns if c == "weight_null" or c.startswith("weight_expert_")]
    # Keep NULL first, then experts in numeric order if available.
    weight_cols = (["weight_null"] if "weight_null" in weight_cols else []) + sorted(
        [c for c in weight_cols if c != "weight_null"],
        key=lambda x: int(x.rsplit("_", 1)[-1]) if x.rsplit("_", 1)[-1].isdigit() else x,
    )
    if not weight_cols:
        return {
            "mean_null_weight": np.nan,
            "normalized_entropy": np.nan,
            "mean_max_weight": np.nan,
            "mean_abs_correction": np.nan,
            "mean_pairwise_residual_correlation": np.nan,
        }
    w = df[weight_cols].to_numpy(float)
    w = np.clip(w, 1e-12, 1.0)
    ent = -(w * np.log(w)).sum(axis=1)
    norm = ent / max(np.log(w.shape[1]), 1e-12)
    correction_col = "correction_logit" if "correction_logit" in df.columns else None
    residual_cols = sorted(
        [c for c in df.columns if c.startswith("residual_expert_")],
        key=lambda x: int(x.rsplit("_", 1)[-1]) if x.rsplit("_", 1)[-1].isdigit() else x,
    )
    pair_corr = np.nan
    if len(residual_cols) >= 2 and len(df) >= 2:
        r = df[residual_cols].to_numpy(float)
        c = np.corrcoef(r, rowvar=False)
        vals = c[np.triu_indices_from(c, k=1)]
        vals = vals[np.isfinite(vals)]
        if len(vals):
            pair_corr = float(np.mean(vals))
    return {
        "mean_null_weight": float(df["weight_null"].mean()) if "weight_null" in df.columns else np.nan,
        "normalized_entropy": float(np.mean(norm)),
        "mean_max_weight": float(np.mean(np.max(w, axis=1))),
        "mean_abs_correction": float(np.mean(np.abs(df[correction_col].to_numpy(float)))) if correction_col else np.nan,
        "mean_pairwise_residual_correlation": pair_corr,
    }
