#!/usr/bin/env python3
"""Validate and merge the 18 formal E1 trained-feature audit shards."""

from __future__ import annotations

import argparse
import csv
import json
import math
import sys
from collections import defaultdict
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

PROJECT_ROOT = Path(__file__).resolve().parents[1]
if str(PROJECT_ROOT) not in sys.path:
    sys.path.insert(0, str(PROJECT_ROOT))

from run_e1_trained_features import LAYER_ORDER, _aggregate, _format, _write_csv


Row = dict[str, Any]
EXPECTED_GATES = (
    "relu6_self",
    "relu_self",
    "gelu_self",
    "smooth_clipped_self",
    "identity",
    "no_gate",
)
EXPECTED_PAIRS = {(gate, seed) for gate in EXPECTED_GATES for seed in range(3)}


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


def _convert(value: str) -> Any:
    if value == "":
        return None
    if value == "True":
        return True
    if value == "False":
        return False
    try:
        if value.lstrip("-").isdigit():
            return int(value)
        return float(value)
    except ValueError:
        return value


def _read_csv(path: Path) -> list[Row]:
    with path.open(newline="", encoding="utf-8") as handle:
        return [{key: _convert(value) for key, value in row.items()} for row in csv.DictReader(handle)]


def _weighted_gate_seed_rows(gate_rows: list[Row]) -> list[Row]:
    groups: dict[tuple[str, int, str], list[Row]] = defaultdict(list)
    for row in gate_rows:
        if float(row["cutoff"]) == 1.0:
            groups[(row["gate"], int(row["seed"]), row["stage"])].append(row)
    metrics = (
        "negative_fraction",
        "active_0_to_6_fraction",
        "above_reference_6_fraction",
        "actual_clip_crossing_fraction",
        "clip_value_mean",
    )
    result: list[Row] = []
    for (gate, seed, stage), rows in sorted(groups.items()):
        total = sum(int(row["element_count"]) for row in rows)
        output: Row = {
            "gate": gate,
            "seed": seed,
            "stage": stage,
            "element_count": total,
        }
        for metric in metrics:
            valid = [row for row in rows if row[metric] is not None]
            output[metric] = (
                sum(float(row[metric]) * int(row["element_count"]) for row in valid)
                / sum(int(row["element_count"]) for row in valid)
                if valid
                else None
            )
        result.append(output)
    return result


def _nonfinite_diagnostics(tables: dict[str, list[Row]]) -> tuple[list[Row], list[Row]]:
    """Return explicit nonfinite cells and an observation-level summary."""

    cells: list[Row] = []
    observations: dict[tuple[Any, ...], dict[str, Any]] = {}
    for table, rows in tables.items():
        for row_index, row in enumerate(rows, start=2):
            for metric, value in row.items():
                if not isinstance(value, float) or math.isfinite(value):
                    continue
                cell = {
                    "table": table,
                    "row": row_index,
                    "gate": row.get("gate"),
                    "seed": row.get("seed"),
                    "cutoff": row.get("cutoff"),
                    "layer": row.get("layer"),
                    "metric": metric,
                    "nonfinite_value": "nan" if math.isnan(value) else "inf" if value > 0 else "-inf",
                }
                cells.append(cell)
                key = (
                    table,
                    row.get("gate"),
                    row.get("seed"),
                    row.get("cutoff"),
                    row.get("layer"),
                )
                observation = observations.setdefault(
                    key,
                    {
                        "table": table,
                        "gate": row.get("gate"),
                        "seed": row.get("seed"),
                        "cutoff": row.get("cutoff"),
                        "layer": row.get("layer"),
                        "nonfinite_field_count": 0,
                        "nonfinite_metrics": set(),
                    },
                )
                observation["nonfinite_field_count"] += 1
                observation["nonfinite_metrics"].add(metric)
    summary: list[Row] = []
    for observation in observations.values():
        summary.append(
            {
                **observation,
                "nonfinite_metrics": ";".join(sorted(observation["nonfinite_metrics"])),
            }
        )
    summary.sort(
        key=lambda row: (
            str(row["table"]),
            str(row["gate"]),
            int(row["seed"]) if row["seed"] is not None else -1,
            float(row["cutoff"]) if row["cutoff"] is not None else -1.0,
            str(row["layer"]),
        )
    )
    return cells, summary


def _report(
    sample_hash: str,
    accuracy_summary: list[Row],
    auc_summary: list[Row],
    feature_summary: list[Row],
    transfer_summary: list[Row],
    gate_summary: list[Row],
    nonfinite_cells: list[Row],
    nonfinite_summary: list[Row],
) -> str:
    lines = [
        "# E1 Trained CIFAR-100 Feature Audit",
        "",
        "Status: complete formal 6-gate x 3-seed matrix.",
        "",
        "## Frozen Protocol",
        "",
        "- Exactly 18 `checkpoint_last.pt` files at fixed epoch 100.",
        "- `checkpoint_best.pt` is excluded to avoid CIFAR-100 test-selection leakage.",
        f"- Every run uses the same 10,000 ordered test samples; index hash `{sample_hash}`.",
        "- Butterworth order 4, cutoffs 0, 0.125, 0.25, 0.5, 0.75, and identity endpoint 1.",
        "",
        "## Frequency-Accuracy AUC",
        "",
        "| Gate | Seeds | Identity Top-1 | Top-1 AUC |",
        "|---|---:|---:|---:|",
    ]
    for row in auc_summary:
        lines.append(
            f"| {row['gate']} | {row['count']} | {_format(row['identity_top1_mean'])} +/- {_format(row['identity_top1_std'])} | "
            f"{_format(row['frequency_accuracy_auc_top1_mean'])} +/- {_format(row['frequency_accuracy_auc_top1_std'])} |"
        )
    lines.extend(
        [
            "",
            "## Accuracy Curve",
            "",
            "| Gate | Cutoff | Top-1 | Top-5 |",
            "|---|---:|---:|---:|",
        ]
    )
    for row in accuracy_summary:
        lines.append(
            f"| {row['gate']} | {row['cutoff']} | {_format(row['top1_mean'])} +/- {_format(row['top1_std'])} | "
            f"{_format(row['top5_mean'])} +/- {_format(row['top5_std'])} |"
        )
    lines.extend(
        [
            "",
            "## Identity-Input Feature PSD",
            "",
            "| Gate | Layer | Size | Centroid | High/low | Entropy |",
            "|---|---|---|---:|---:|---:|",
        ]
    )
    for row in feature_summary:
        lines.append(
            f"| {row['gate']} | {row['layer']} | {row['height']}x{row['width']} | "
            f"{_format(row['spectral_centroid_mean'])} | {_format(row['high_low_ratio_mean'])} | "
            f"{_format(row['spectral_entropy_mean'])} |"
        )
    lines.extend(
        [
            "",
            "## Cutoff 0.25 Feature Transfer",
            "",
            "| Gate | Layer | Centroid delta | Entropy delta |",
            "|---|---|---:|---:|",
        ]
    )
    for row in transfer_summary:
        lines.append(
            f"| {row['gate']} | {row['layer']} | {_format(row['centroid_delta_vs_identity_mean'])} | "
            f"{_format(row['entropy_delta_vs_identity_mean'])} |"
        )
    lines.extend(
        [
            "",
            "## Identity-Input Gate Regions",
            "",
            "| Gate | Stage | Negative | Active [0,6) | Above 6 | Clip mean | Actual clip crossing |",
            "|---|---|---:|---:|---:|---:|---:|",
        ]
    )
    for row in gate_summary:
        lines.append(
            f"| {row['gate']} | {row['stage']} | {_format(row['negative_fraction_mean'])} | "
            f"{_format(row['active_0_to_6_fraction_mean'])} | {_format(row['above_reference_6_fraction_mean'])} | "
            f"{_format(row['clip_value_mean_mean'])} | {_format(row['actual_clip_crossing_fraction_mean'])} |"
        )
    lines.extend(
        [
            "",
            "## Nonfinite Diagnostics",
            "",
            f"- Nonfinite numeric cells: {len(nonfinite_cells)}.",
            f"- Affected table observations: {len(nonfinite_summary)}.",
            "- Aggregates exclude nonfinite values. If no finite observation remains, the statistic is JSON null and report NA; values are never replaced by zero.",
            "",
            "| Table | Gate | Seed | Cutoff | Layer | Nonfinite fields |",
            "|---|---|---:|---:|---|---|",
        ]
    )
    for row in nonfinite_summary:
        lines.append(
            f"| {row['table']} | {row['gate']} | {row['seed']} | {row['cutoff']} | "
            f"{row['layer']} | {row['nonfinite_metrics']} |"
        )
    lines.extend(
        [
            "",
            "## Interpretation Limits",
            "",
            "- Stage3 is 2x2 and has no non-DC FFT cell below normalized radius 0.5; its high/low ratio is NA.",
            "- Stage4 and pre_classifier are 1x1, so their spatial PSD values are NA.",
            "- Frequency-Accuracy AUC measures causal sensitivity to this input filter protocol, not model function frequency.",
            "",
        ]
    )
    return "\n".join(lines)


def main() -> None:
    args = parse_args()
    shard_root = args.shard_root.resolve()
    output_dir = args.output_dir.resolve()
    allowed = Path("/tmp/gmnet_runs/e1_trained_features/full").resolve()
    if output_dir != allowed:
        raise ValueError(f"formal merged output must be {allowed}")
    result_paths = sorted(shard_root.glob("*/results.json"))
    if len(result_paths) != 18:
        raise ValueError(f"expected 18 shard results, found {len(result_paths)}")

    manifests: list[Row] = []
    accuracy_rows: list[Row] = []
    auc_rows: list[Row] = []
    feature_rows: list[Row] = []
    gate_rows: list[Row] = []
    sample_hashes: set[str] = set()
    pairs: set[tuple[str, int]] = set()
    for result_path in result_paths:
        result = json.loads(result_path.read_text(encoding="utf-8"))
        protocol = result["protocol"]
        if result["status"] != "full":
            raise ValueError(f"non-full shard: {result_path}")
        if protocol["checkpoint_name"] != "checkpoint_last.pt":
            raise ValueError(f"wrong checkpoint policy: {result_path}")
        if protocol["require_epochs_completed"] != 100 or protocol["sample_count"] != 10_000:
            raise ValueError(f"wrong frozen protocol: {result_path}")
        if protocol["cutoffs"] != [0.0, 0.125, 0.25, 0.5, 0.75, 1.0]:
            raise ValueError(f"wrong cutoffs: {result_path}")
        sample_hashes.add(protocol["sample_indices_sha256"])
        shard = result_path.parent
        shard_manifest = _read_csv(shard / "checkpoint_manifest.csv")
        if len(shard_manifest) != 1:
            raise ValueError(f"expected one checkpoint per shard: {shard}")
        manifest = shard_manifest[0]
        if manifest["checkpoint_name"] != "checkpoint_last.pt" or manifest["checkpoint_epochs_completed"] != 100:
            raise ValueError(f"checkpoint is not fixed epoch100 last: {shard}")
        pair = (manifest["gate"], int(manifest["seed"]))
        if pair in pairs:
            raise ValueError(f"duplicate shard {pair}")
        pairs.add(pair)
        manifests.append(manifest)
        accuracy_rows.extend(_read_csv(shard / "accuracy_curve.csv"))
        auc_rows.extend(_read_csv(shard / "accuracy_auc.csv"))
        feature_rows.extend(_read_csv(shard / "feature_metrics.csv"))
        gate_rows.extend(_read_csv(shard / "gate_regions.csv"))
    if pairs != EXPECTED_PAIRS:
        raise ValueError(f"checkpoint matrix mismatch; missing={sorted(EXPECTED_PAIRS - pairs)}")
    if len(sample_hashes) != 1:
        raise ValueError(f"sample subsets differ across shards: {sample_hashes}")
    sample_hash = next(iter(sample_hashes))

    nonfinite_cells, nonfinite_summary = _nonfinite_diagnostics(
        {
            "checkpoint_manifest": manifests,
            "accuracy_curve": accuracy_rows,
            "accuracy_auc": auc_rows,
            "feature_metrics": feature_rows,
            "gate_regions": gate_rows,
        }
    )

    accuracy_summary = _aggregate(
        accuracy_rows, ("gate", "cutoff"), ("top1", "top5")
    )
    auc_summary = _aggregate(
        auc_rows,
        ("gate",),
        ("identity_top1", "identity_top5", "frequency_accuracy_auc_top1", "frequency_accuracy_auc_top5"),
    )
    identity_features = [row for row in feature_rows if row["cutoff"] == 1.0]
    feature_summary = _aggregate(
        identity_features,
        ("gate", "layer", "height", "width"),
        ("spectral_centroid", "high_low_ratio", "spectral_entropy"),
    )
    feature_summary.sort(key=lambda row: (row["gate"], LAYER_ORDER.index(row["layer"])))
    transfer_rows = [row for row in feature_rows if row["cutoff"] == 0.25]
    transfer_summary = _aggregate(
        transfer_rows,
        ("gate", "layer"),
        ("centroid_delta_vs_identity", "entropy_delta_vs_identity"),
    )
    transfer_summary.sort(key=lambda row: (row["gate"], LAYER_ORDER.index(row["layer"])))
    gate_seed_rows = _weighted_gate_seed_rows(gate_rows)
    gate_summary = _aggregate(
        gate_seed_rows,
        ("gate", "stage"),
        (
            "negative_fraction",
            "active_0_to_6_fraction",
            "above_reference_6_fraction",
            "clip_value_mean",
            "actual_clip_crossing_fraction",
        ),
    )

    output_dir.mkdir(parents=True, exist_ok=True)
    _write_csv(output_dir / "checkpoint_manifest.csv", manifests)
    _write_csv(output_dir / "accuracy_curve.csv", accuracy_rows)
    _write_csv(output_dir / "accuracy_auc.csv", auc_rows)
    _write_csv(output_dir / "feature_metrics.csv", feature_rows)
    _write_csv(output_dir / "gate_regions.csv", gate_rows)
    _write_csv(output_dir / "accuracy_summary.csv", accuracy_summary)
    _write_csv(output_dir / "accuracy_auc_summary.csv", auc_summary)
    _write_csv(output_dir / "feature_summary.csv", feature_summary)
    _write_csv(output_dir / "feature_transfer_summary.csv", transfer_summary)
    _write_csv(output_dir / "gate_seed_summary.csv", gate_seed_rows)
    _write_csv(output_dir / "gate_summary.csv", gate_summary)
    if nonfinite_cells:
        _write_csv(output_dir / "nonfinite_cells.csv", nonfinite_cells)
        _write_csv(output_dir / "nonfinite_summary.csv", nonfinite_summary)
    merged = {
        "schema_version": 1,
        "experiment_id": "E1-trained-cifar100-feature-audit-formal",
        "timestamp_utc": datetime.now(UTC).isoformat(),
        "status": "complete",
        "checkpoint_policy": "checkpoint_last.pt at fixed epoch 100",
        "checkpoint_count": len(manifests),
        "sample_count_per_run": 10_000,
        "sample_indices_sha256": sample_hash,
        "accuracy_auc_summary": auc_summary,
        "feature_identity_summary": feature_summary,
        "feature_transfer_cutoff_0_25_summary": transfer_summary,
        "gate_identity_summary": gate_summary,
        "nonfinite_diagnostics": {
            "numeric_cell_count": len(nonfinite_cells),
            "affected_observation_count": len(nonfinite_summary),
            "handling": "Excluded from aggregate statistics; all-nonfinite aggregates are null, never zero.",
            "observations": nonfinite_summary,
        },
    }
    (output_dir / "results.json").write_text(
        json.dumps(merged, indent=2, allow_nan=False) + "\n", encoding="utf-8"
    )
    (output_dir / "REPORT.md").write_text(
        _report(
            sample_hash,
            accuracy_summary,
            auc_summary,
            feature_summary,
            transfer_summary,
            gate_summary,
            nonfinite_cells,
            nonfinite_summary,
        ),
        encoding="utf-8",
    )
    print(f"Merged 18 formal shards: {output_dir}")


if __name__ == "__main__":
    main()