"""Table of the two exploratory extensions: real-time forecast shrinkage and U.S. state variables.

Panel A compares each learned model with its "_rs" version (forecast deviation scaled by a
slope estimated inside each training window) on capped value-weighted and equal-weighted
factors. Panel B compares models with and without the U.S. state variables on the sample
where all of them exist (feature months from 1990-01, so out of sample 2001-2025).

    python scripts/extensions.py
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import numpy as np
import pandas as pd

MODELS = [("ols", "OLS"), ("enet", "Elastic net"), ("gbrt", "GBRT")]
SCOPES = ("own", "dm_only")


def _load(run: Path) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    if json.loads((run / "run_manifest.json").read_text()).get("provenance") != "JKP":
        raise SystemExit(f"{run} is not a real-data run")
    r2 = pd.read_csv(run / "r2_oos.csv").set_index(["model", "scope"])
    port = pd.read_csv(run / "portfolios.csv").set_index("strategy")
    preds = pd.read_parquet(run / "predictions.parquet", columns=["model", "scope", "target_month", "scale"])
    return r2, port, preds


def _cells(r2: pd.DataFrame, port: pd.DataFrame, model: str) -> dict:
    row = {}
    for s in SCOPES:
        row[f"r2_{s}"] = r2.loc[(model, s), "r2_vs_shrink_pct"]
        row[f"t_{s}"] = r2.loc[(model, s), "cw_t_shrink"]
        row[f"sr_{s}"] = port.loc[f"{model}:{s}", "sharpe_net"]
    return row


def _mean_scale(preds: pd.DataFrame, model: str, scope: str) -> float:
    g = preds[(preds["model"] == model) & (preds["scope"] == scope)]
    return float(g.groupby(g["target_month"].dt.year)["scale"].first().mean())


def _f(x: float, d: int = 2) -> str:
    return "--" if pd.isna(x) else f"{x:.{d}f}".replace("-", "$-$")


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--rs", default="reports/jkp_em_rs")
    ap.add_argument("--rs-ew", default="reports/jkp_em_ew_rs")
    ap.add_argument("--no-macro", default="reports/jkp_em_from1990")
    ap.add_argument("--macro", default="reports/jkp_em_macro")
    ap.add_argument("--out", default="reports/robustness/extensions.csv")
    ap.add_argument("--tex", default="paper/tables/extensions.tex")
    a = ap.parse_args()

    rows = []
    for panel, label, run in (("A", "Capped value-weighted factors", a.rs), ("A", "Equal-weighted factors", a.rs_ew)):
        r2, port, preds = _load(Path(run))
        for m, name in MODELS:
            rows.append({"panel": panel, "block": label, "model": name, "variant": "As estimated", **_cells(r2, port, m)})
            rows.append({"panel": panel, "block": label, "model": name, "variant": "Real-time shrinkage",
                         **_cells(r2, port, f"{m}_rs"), "scale_own": _mean_scale(preds, f"{m}_rs", "own"),
                         "scale_dm_only": _mean_scale(preds, f"{m}_rs", "dm_only")})
        rows.append({"panel": panel, "block": label, "model": "Static portfolio", "variant": "",
                     "sr_own": port.loc["static_ew", "sharpe_net"]})
        rows.append({"panel": panel, "block": label, "model": "Shrinkage-mean portfolio", "variant": "",
                     "sr_own": port.loc["shrink_mean:rule", "sharpe_net"]})
    base, with_macro = _load(Path(a.no_macro)), _load(Path(a.macro))
    for m, name in MODELS:
        rows.append({"panel": "B", "block": "From 1990", "model": name, "variant": "Without state variables",
                     **_cells(base[0], base[1], m)})
        rows.append({"panel": "B", "block": "From 1990", "model": name, "variant": "With state variables",
                     **_cells(with_macro[0], with_macro[1], m)})
    rows.append({"panel": "B", "block": "From 1990", "model": "Static portfolio", "variant": "",
                 "sr_own": base[1].loc["static_ew", "sharpe_net"]})
    rows.append({"panel": "B", "block": "From 1990", "model": "Shrinkage-mean portfolio", "variant": "",
                 "sr_own": base[1].loc["shrink_mean:rule", "sharpe_net"]})
    df = pd.DataFrame(rows)
    Path(a.out).parent.mkdir(parents=True, exist_ok=True)
    df.to_csv(a.out, index=False)

    lines = [r"\begin{table}[!ht]", r"\centering\footnotesize\setlength{\tabcolsep}{4pt}",
             r"\caption{Exploratory extensions}", r"\label{tab:extensions}",
             r"\begin{tabular}{llrrrrrr}", r"\toprule",
             r" & & \multicolumn{3}{c}{EM-trained} & \multicolumn{3}{c}{DM-trained} \\",
             r"\cmidrule(lr){3-5}\cmidrule(lr){6-8}",
             r"Model & Forecast & $R^2_{OS}$ (\%) & CW $t$ & SR net & $R^2_{OS}$ (\%) & CW $t$ & SR net \\"]
    titles = {"A": "Panel A: real-time forecast shrinkage, out of sample 2000--2025",
              "B": "Panel B: U.S. state variables, feature months from 1990, out of sample 2001--2025"}
    for panel in ("A", "B"):
        lines += [r"\midrule", rf"\multicolumn{{8}}{{l}}{{\textit{{{titles[panel]}}}}} \\"]
        for block, g in df[df["panel"] == panel].groupby("block", sort=False):
            if panel == "A":
                lines.append(rf"\multicolumn{{8}}{{l}}{{{block}}} \\")
            prev = None
            for _, r in g.iterrows():
                if r["variant"] == "":
                    lines.append(f"{r['model']} & & & & {_f(r['sr_own'])} & & & \\\\")
                    continue
                name = "" if r["model"] == prev else r["model"]
                prev = r["model"]
                lines.append(f"{name} & {r['variant']} & " + " & ".join(
                    [_f(r[f'r2_{s}'], 3) + " & " + _f(r[f't_{s}']) + " & " + _f(r[f'sr_{s}']) for s in SCOPES]) + r" \\")
            lines.append(r"\addlinespace")
    sc = df[df["variant"] == "Real-time shrinkage"][["scale_own", "scale_dm_only"]].to_numpy()
    lines += [r"\bottomrule", r"\end{tabular}", "", r"\vspace{4pt}",
              r"\begin{minipage}{0.97\linewidth}\footnotesize",
              r"\textit{Notes:} $R^2_{OS}$ and Clark--West $t$ against the shrinkage mean; SR net is the net Sharpe "
              r"ratio of the timing portfolio at 20 basis points per unit of turnover (for the static and "
              r"shrinkage-mean rows, of those portfolios). Real-time shrinkage multiplies each forecast's "
              r"deviation from the shrinkage mean by a slope in $[0,1]$ estimated inside the training window: "
              r"the model is fitted on labels before the window's last 36 months and the slope of realized on "
              r"forecast deviations over those months is the scale; the model is then refitted on the whole "
              rf"window. Average yearly scales range from {np.nanmin(sc):.2f} to {np.nanmax(sc):.2f}. "
              r"State variables: log VIX, the U.S. 10-year minus 3-month Treasury spread and the 12-month log "
              r"change of the broad trade-weighted dollar (FRED), dated at the end of the feature month; both "
              r"rows of Panel B use the same sample. Both extensions were chosen after seeing the baseline "
              r"results and are exploratory.",
              r"\end{minipage}", r"\end{table}"]
    Path(a.tex).write_text("\n".join(lines) + "\n")
    with pd.option_context("display.width", 250, "display.max_columns", 20):
        print(df.drop(columns=["panel"]).round(3).to_string(index=False))


if __name__ == "__main__":
    main()