#!/usr/bin/env python3
"""Summarize the five-stock, three-seed hyperparameter sensitivity grid."""

from __future__ import annotations

import argparse
import csv
import json
import random
import statistics
from collections import defaultdict
from pathlib import Path


METHODS = ("timae", "lobgrid_timae", "simlob2026")
STOCKS = ("asset_001", "asset_002", "asset_017", "asset_005", "asset_033")
SEEDS = (2026, 2027, 2028)
AXES = {
    "latent_dim": ((64, "latent64"), (128, "baseline"), (256, "latent256")),
    "hidden_width": ((64, "width64"), (96, "baseline"), (128, "width128")),
    "attention_heads": ((2, "heads2"), (4, "baseline"), (8, "heads8")),
    "mask_ratio": ((0.2, "mask20"), (0.4, "baseline"), (0.6, "mask60")),
    "learning_rate": ((0.0001, "lr100"), (0.0003, "baseline"), (0.001, "lr1000")),
    "batch_size": ((64, "batch64"), (128, "baseline"), (256, "batch256")),
    "weight_decay": ((0.0, "wd0"), (0.00001, "baseline"), (0.0001, "wd1e4")),
}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--results-root", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    return parser.parse_args()


def percentile(values: list[float], probability: float) -> float:
    ordered = sorted(values)
    position = probability * (len(ordered) - 1)
    lower = int(position)
    upper = min(lower + 1, len(ordered) - 1)
    weight = position - lower
    return ordered[lower] * (1.0 - weight) + ordered[upper] * weight


def bootstrap_ci(values: list[float], seed: int) -> tuple[float, float]:
    rng = random.Random(seed)
    draws = sorted(
        statistics.fmean(values[rng.randrange(len(values))] for _ in values)
        for _ in range(20_000)
    )
    return percentile(draws, 0.025), percentile(draws, 0.975)


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def load_variant(directory: Path) -> dict[tuple[str, str, int, str], dict]:
    cases: dict[tuple[str, str, int, str], dict] = {}
    for path in sorted(directory.glob("*.json")):
        if path.name.endswith(".pretrain.json") or path.name == "resolved_config.json":
            continue
        payload = json.loads(path.read_text(encoding="utf-8"))
        if (
            payload.get("method") not in METHODS
            or payload.get("stock") not in STOCKS
            or int(payload.get("seed", -1)) not in SEEDS
            or abs(float(payload.get("label_budget", -1.0)) - 0.5) > 1e-12
            or payload.get("setting") not in {"from_scratch", "fine_tune"}
        ):
            continue
        key = (
            str(payload["method"]),
            str(payload["stock"]),
            int(payload["seed"]),
            str(payload["setting"]),
        )
        if key in cases:
            raise ValueError(f"Duplicate sensitivity case in {directory}: {key}")
        cases[key] = payload
    expected = {
        (method, stock, seed, setting)
        for method in METHODS
        for stock in STOCKS
        for seed in SEEDS
        for setting in ("from_scratch", "fine_tune")
    }
    if set(cases) != expected:
        missing = sorted(expected - set(cases))
        extra = sorted(set(cases) - expected)
        raise ValueError(
            f"{directory} is incomplete: missing={missing[:5]}, extra={extra[:5]}"
        )
    return cases


def main() -> None:
    args = parse_args()
    variants = {
        variant
        for values in AXES.values()
        for _, variant in values
    }
    cases = {
        variant: load_variant(args.results_root / variant)
        for variant in sorted(variants)
    }

    stock_rows: list[dict[str, object]] = []
    summary_rows: list[dict[str, object]] = []
    for axis_index, (axis, values) in enumerate(AXES.items()):
        for value_index, (value, variant) in enumerate(values):
            for method_index, method in enumerate(METHODS):
                stock_deltas = []
                stock_scratch = []
                stock_pooled = []
                for stock in STOCKS:
                    scratch = [
                        float(cases[variant][(method, stock, seed, "from_scratch")]["test"]["macro_f1"])
                        for seed in SEEDS
                    ]
                    pooled = [
                        float(cases[variant][(method, stock, seed, "fine_tune")]["test"]["macro_f1"])
                        for seed in SEEDS
                    ]
                    scratch_mean = statistics.fmean(scratch)
                    pooled_mean = statistics.fmean(pooled)
                    delta_mean = statistics.fmean(
                        candidate - baseline
                        for candidate, baseline in zip(pooled, scratch)
                    )
                    stock_scratch.append(scratch_mean)
                    stock_pooled.append(pooled_mean)
                    stock_deltas.append(delta_mean)
                    stock_rows.append(
                        {
                            "axis": axis,
                            "value": value,
                            "variant": variant,
                            "method": method,
                            "stock": stock,
                            "n_seeds": len(SEEDS),
                            "scratch_macro_f1_mean": scratch_mean,
                            "pooled_macro_f1_mean": pooled_mean,
                            "paired_delta_mean": delta_mean,
                            "paired_delta_seed_sd": statistics.stdev(
                                candidate - baseline
                                for candidate, baseline in zip(pooled, scratch)
                            ),
                        }
                    )
                ci_low, ci_high = bootstrap_ci(
                    stock_deltas,
                    20260801 + 100 * axis_index + 10 * value_index + method_index,
                )
                summary_rows.append(
                    {
                        "axis": axis,
                        "value": value,
                        "variant": variant,
                        "method": method,
                        "n_stocks": len(STOCKS),
                        "seeds_per_stock": len(SEEDS),
                        "scratch_macro_f1_mean": statistics.fmean(stock_scratch),
                        "pooled_macro_f1_mean": statistics.fmean(stock_pooled),
                        "paired_delta_mean": statistics.fmean(stock_deltas),
                        "paired_delta_median": statistics.median(stock_deltas),
                        "ci95_low": ci_low,
                        "ci95_high": ci_high,
                        "wins": sum(value_ > 0 for value_ in stock_deltas),
                    }
                )

    range_rows: list[dict[str, object]] = []
    for axis in AXES:
        for method in METHODS:
            cells = [
                row
                for row in summary_rows
                if row["axis"] == axis and row["method"] == method
            ]
            if len(cells) != 3:
                raise ValueError(f"Expected three values for {axis}/{method}")
            best = max(cells, key=lambda row: float(row["paired_delta_mean"]))
            worst = min(cells, key=lambda row: float(row["paired_delta_mean"]))
            retained = next(row for row in cells if row["variant"] == "baseline")
            range_rows.append(
                {
                    "axis": axis,
                    "method": method,
                    "retained_value": retained["value"],
                    "retained_delta": retained["paired_delta_mean"],
                    "minimum_delta": worst["paired_delta_mean"],
                    "minimum_value": worst["value"],
                    "maximum_delta": best["paired_delta_mean"],
                    "maximum_value": best["value"],
                    "delta_span": float(best["paired_delta_mean"])
                    - float(worst["paired_delta_mean"]),
                    "positive_values": sum(
                        float(row["paired_delta_mean"]) > 0 for row in cells
                    ),
                }
            )

    overall_rows: list[dict[str, object]] = []
    for method in METHODS:
        unique_by_variant: dict[str, dict[str, object]] = {}
        for row in summary_rows:
            if row["method"] != method:
                continue
            variant = str(row["variant"])
            previous = unique_by_variant.get(variant)
            if previous is not None and abs(
                float(previous["paired_delta_mean"])
                - float(row["paired_delta_mean"])
            ) > 1e-12:
                raise ValueError(f"Inconsistent repeated baseline for {method}")
            unique_by_variant[variant] = row
        if len(unique_by_variant) != 15:
            raise ValueError(
                f"Expected 15 unique configurations for {method}; "
                f"found {len(unique_by_variant)}"
            )
        cells = list(unique_by_variant.values())
        best = max(cells, key=lambda row: float(row["paired_delta_mean"]))
        worst = min(cells, key=lambda row: float(row["paired_delta_mean"]))
        deltas = [float(row["paired_delta_mean"]) for row in cells]
        retained = unique_by_variant["baseline"]
        overall_rows.append(
            {
                "method": method,
                "n_unique_configurations": len(cells),
                "retained_delta": retained["paired_delta_mean"],
                "minimum_delta": worst["paired_delta_mean"],
                "minimum_variant": worst["variant"],
                "maximum_delta": best["paired_delta_mean"],
                "maximum_variant": best["variant"],
                "median_delta": statistics.median(deltas),
                "positive_configurations": sum(value > 0 for value in deltas),
                "within_practical_range": sum(abs(value) <= 0.01 for value in deltas),
            }
        )

    args.output_dir.mkdir(parents=True, exist_ok=True)
    write_csv(args.output_dir / "hyperparameter_stock_summary.csv", stock_rows)
    write_csv(args.output_dir / "hyperparameter_sensitivity.csv", summary_rows)
    write_csv(args.output_dir / "hyperparameter_axis_ranges.csv", range_rows)
    write_csv(args.output_dir / "hyperparameter_overall_ranges.csv", overall_rows)
    payload = {
        "design": {
            "stocks": list(STOCKS),
            "methods": list(METHODS),
            "seeds": list(SEEDS),
            "label_budget": 0.5,
            "axes": {
                axis: [value for value, _ in values]
                for axis, values in AXES.items()
            },
            "aggregation": "seeds paired and averaged within stock; five stock means form the reporting units",
            "retained_configuration": {
                "latent_dim": 128,
                "hidden_width": 96,
                "attention_heads": 4,
                "mask_ratio": 0.4,
                "learning_rate": 0.0003,
                "batch_size": 128,
                "weight_decay": 0.00001,
            },
        },
        "rows": summary_rows,
        "axis_ranges": range_rows,
        "overall_ranges": overall_rows,
    }
    (args.output_dir / "hyperparameter_sensitivity.json").write_text(
        json.dumps(payload, indent=2) + "\n",
        encoding="utf-8",
    )

    lines = [
        "# Hyperparameter sensitivity",
        "",
        "Each row changes one setting from the retained configuration. Seeds are paired within stock before the five-stock summary.",
        "",
        "| axis | value | method | scratch F1 | pooled F1 | paired delta [95% stock interval] | wins/5 |",
        "|---|---:|---|---:|---:|---:|---:|",
    ]
    for row in summary_rows:
        lines.append(
            f"| {row['axis']} | {row['value']} | {row['method']} | "
            f"{row['scratch_macro_f1_mean']:.4f} | "
            f"{row['pooled_macro_f1_mean']:.4f} | "
            f"{row['paired_delta_mean']:+.4f} "
            f"[{row['ci95_low']:+.4f}, {row['ci95_high']:+.4f}] | "
            f"{row['wins']}/5 |"
        )
    lines.extend(
        [
            "",
            "## Across-value ranges",
            "",
            "| axis | method | retained delta | minimum | maximum | span | positive values |",
            "|---|---|---:|---:|---:|---:|---:|",
        ]
    )
    for row in range_rows:
        lines.append(
            f"| {row['axis']} | {row['method']} | "
            f"{row['retained_delta']:+.4f} | "
            f"{row['minimum_delta']:+.4f} ({row['minimum_value']}) | "
            f"{row['maximum_delta']:+.4f} ({row['maximum_value']}) | "
            f"{row['delta_span']:.4f} | {row['positive_values']}/3 |"
        )
    lines.extend(
        [
            "",
            "## Across the 15 unique configurations",
            "",
            "| method | retained | minimum | maximum | median | positive | within ±0.01 |",
            "|---|---:|---:|---:|---:|---:|---:|",
        ]
    )
    for row in overall_rows:
        lines.append(
            f"| {row['method']} | {row['retained_delta']:+.4f} | "
            f"{row['minimum_delta']:+.4f} ({row['minimum_variant']}) | "
            f"{row['maximum_delta']:+.4f} ({row['maximum_variant']}) | "
            f"{row['median_delta']:+.4f} | "
            f"{row['positive_configurations']}/15 | "
            f"{row['within_practical_range']}/15 |"
        )
    (args.output_dir / "hyperparameter_sensitivity.md").write_text(
        "\n".join(lines) + "\n",
        encoding="utf-8",
    )
    print(
        f"wrote {len(summary_rows)} hyperparameter summaries from "
        f"{len(stock_rows)} stock-level cells"
    )


if __name__ == "__main__":
    main()