"""Cross-case-study temporal feature summary."""

import warnings

import plotly.graph_objects as go
import polars as pl
from IPython.display import display

warnings.filterwarnings("ignore")

from utils.paths import get_case_study_dir

# Scale parameters (Papermill overrides for testing; readers see production values)
START_DATE = None  # use full dataset

CASE_STUDIES = [
    "etfs",
    "crypto_perps_funding",
    "nasdaq100_microstructure",
    "sp500_equity_option_analytics",
    "us_firm_characteristics",
    "fx_pairs",
    "cme_futures",
    "sp500_options",
    "us_equities_panel",
]

DISPLAY_NAMES = {
    "etfs": "ETFs",
    "crypto_perps_funding": "Crypto Perps",
    "nasdaq100_microstructure": "NASDAQ-100",
    "sp500_equity_option_analytics": "S&P 500 Eq+Opt",
    "us_firm_characteristics": "US Firm Chars",
    "fx_pairs": "FX Pairs",
    "cme_futures": "CME Futures",
    "sp500_options": "S&P 500 Options",
    "us_equities_panel": "US Equities",
}

# Columns that are identifiers, not features
_ID_COLS = {"timestamp", "symbol", "product", "stock_id", "instrument_id", "date", "asset"}

# Known temporal model prefixes
_TEMPORAL_MODELS = {
    "hmm": "hmm",
    "garch": "garch",
    "kalman": "kalman",
    "arima": "arima",
    "ffd": "ffd",
    "spectral": "spectral",
    "bayesian": "bayesian_sv",
    "regime": "hmm",
    "vol": "garch",
}


def load_temporal_info(case_study_id: str) -> dict | None:
    """Load temporal feature summary by introspecting model_based.parquet schema."""
    case_dir = get_case_study_dir(case_study_id)
    mb_path = case_dir / "features" / "model_based.parquet"
    if not mb_path.exists():
        return None

    schema = pl.scan_parquet(mb_path).collect_schema()
    feature_names = [c for c in schema.names() if c not in _ID_COLS]
    n_features = len(feature_names)

    # Detect which temporal models are represented
    models_used: dict[str, bool] = {}
    for model_key in ["hmm", "garch", "kalman", "arima", "ffd", "spectral", "bayesian_sv"]:
        models_used[model_key] = any(model_key in f.lower() for f in feature_names)

    # Group by prefix
    family_counts: dict[str, int] = {}
    for name in feature_names:
        parts = name.split("_")
        family = parts[0] if len(parts) > 1 else "other"
        family_counts[family] = family_counts.get(family, 0) + 1

    return {
        "n_temporal_features": n_features,
        "feature_names": feature_names,
        "models_used": models_used,
        "family_counts": family_counts,
    }

# Load all temporal feature info
all_temporal: dict[str, dict] = {}
has_incremental: dict[str, dict] = {}
no_temporal: list[str] = []

for cs in CASE_STUDIES:
    result = load_temporal_info(cs)
    if result is None:
        no_temporal.append(cs)
        continue
    all_temporal[cs] = result
    has_incremental[cs] = result

print(f"Case studies with temporal features: {len(all_temporal)}/{len(CASE_STUDIES)}")
if no_temporal:
    print(f"  No temporal data: {', '.join(DISPLAY_NAMES.get(cs, cs) for cs in no_temporal)}")

# Extract model inventory from feature name patterns in model_based.parquet
model_inventory = []
known_models = ["hmm", "garch", "kalman", "arima", "ffd", "spectral", "bayesian_sv"]

for cs, result in all_temporal.items():
    row = {"case_study": DISPLAY_NAMES[cs]}
    for model in known_models:
        row[model] = "Y" if result["models_used"].get(model, False) else ""
    row["n_features"] = result["n_temporal_features"]
    model_inventory.append(row)

inv_df = pl.DataFrame(model_inventory)
inv_df

if all_temporal:
    feat_counts = []
    for cs, result in all_temporal.items():
        feat_counts.append(
            {
                "case_study": DISPLAY_NAMES[cs],
                "n_temporal_features": result["n_temporal_features"],
            }
        )

    feat_df = pl.DataFrame(feat_counts).sort("n_temporal_features", descending=True)

    fig = go.Figure(
        go.Bar(
            x=[r["case_study"] for r in feat_counts],
            y=[r["n_temporal_features"] for r in feat_counts],
            marker_color="#3498db",
            text=[str(r["n_temporal_features"]) for r in feat_counts],
            textposition="outside",
        )
    )
    fig.update_layout(
        title="Temporal Features per Case Study",
        yaxis_title="Number of Temporal Features",
        template="plotly_white",
        height=400,
    )
    fig.show()

if has_incremental:
    # Show temporal feature names per case study
    incr_rows = []
    for cs, result in has_incremental.items():
        for feat_name in result["feature_names"][:10]:
            incr_rows.append(
                {
                    "case_study": DISPLAY_NAMES[cs],
                    "feature": feat_name,
                }
            )

    if incr_rows:
        incr_df = pl.DataFrame(incr_rows)
        display(incr_df)

        # Bar chart: feature count by family per case study
        fig = go.Figure()
        for cs in has_incremental:
            result = has_incremental[cs]
            families = sorted(result["family_counts"].keys())
            fig.add_trace(
                go.Bar(
                    name=DISPLAY_NAMES[cs],
                    x=families,
                    y=[result["family_counts"][f] for f in families],
                )
            )

        fig.update_layout(
            title="Temporal Feature Families by Case Study",
            yaxis_title="Feature Count",
            template="plotly_white",
            height=500,
            xaxis_tickangle=-45,
            barmode="group",
        )
        fig.show()
    else:
        print("No temporal feature data available.")
else:
    print("No model_based.parquet found. Run case study temporal notebooks first.")

# Extract regime information from temporal feature names
regime_info = []
for cs, result in all_temporal.items():
    has_hmm = result["models_used"].get("hmm", False)
    # Check for regime-related features
    regime_features = [
        f for f in result["feature_names"] if "regime" in f.lower() or "hmm" in f.lower()
    ]

    regime_info.append(
        {
            "case_study": DISPLAY_NAMES[cs],
            "has_hmm": "Y" if has_hmm else "",
            "n_regime_features": len(regime_features),
        }
    )

regime_df = pl.DataFrame(regime_info)
regime_df

# Temporal models are all fitted walk-forward within the CV framework (per the pipeline design).
# We note which models are present per case study as a discipline check.
discipline_rows = []
for cs, result in all_temporal.items():
    models = result["models_used"]
    active_models = [m for m, used in models.items() if used]
    discipline_rows.append(
        {
            "case_study": DISPLAY_NAMES[cs],
            "n_temporal_features": result["n_temporal_features"],
            "active_models": ", ".join(active_models) if active_models else "none detected",
        }
    )

disc_df = pl.DataFrame(discipline_rows)
disc_df