from __future__ import annotations

import argparse
import copy
import json
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Mapping, Sequence

from reportlab.graphics import renderSVG
from reportlab.graphics.shapes import Circle, Drawing, Line, Rect, String
from reportlab.lib import colors


CONDITIONS = ("no_gate", "prompt_only", "stateless_hook", "beforedone")
CONDITION_LABELS = {
    "no_gate": "C0 No gate",
    "prompt_only": "C1 Prompt only",
    "stateless_hook": "C2 Stateless Hook",
    "beforedone": "C3 BeforeDone",
}
CONDITION_COLORS = {
    "no_gate": "#778396",
    "prompt_only": "#53769A",
    "stateless_hook": "#D18449",
    "beforedone": "#0A756A",
}
EXPECTED_CONFIRMATORY_RUNS = 144
FIGURE_WIDTH = 960
FIGURE_HEIGHT = 540


class FigureError(ValueError):
    """A figure cannot be derived without inventing or obscuring study data."""


@dataclass(frozen=True)
class FigureArtifact:
    key: str
    filename: str
    title: str
    caption: str
    drawing: Drawing


def _mapping(value: object, label: str) -> Mapping[str, Any]:
    if not isinstance(value, Mapping):
        raise FigureError(f"{label} must be an object")
    return value


def _number_or_none(value: object, label: str) -> float | None:
    if value is None:
        return None
    if isinstance(value, bool) or not isinstance(value, (int, float)):
        raise FigureError(f"{label} must be numeric or null")
    return float(value)


def _integer(value: object, label: str) -> int:
    if isinstance(value, bool) or not isinstance(value, int):
        raise FigureError(f"{label} must be an integer")
    return value


def load_results(root: Path) -> dict[str, Any]:
    path = root.resolve() / "data" / "analysis" / "results.json"
    try:
        payload = json.loads(path.read_text(encoding="utf-8"))
    except FileNotFoundError as exc:
        raise FigureError(f"missing analysis results: {path}") from exc
    except (OSError, json.JSONDecodeError) as exc:
        raise FigureError(f"cannot read analysis results: {exc}") from exc
    if not isinstance(payload, dict):
        raise FigureError("analysis results must be a JSON object")
    return payload


def confirmatory_completed_count(results: Mapping[str, Any]) -> int:
    input_data = _mapping(results.get("input"), "results.input")
    count = _integer(
        input_data.get("confirmatory_completed_count"),
        "results.input.confirmatory_completed_count",
    )
    if count < 0 or count > EXPECTED_CONFIRMATORY_RUNS:
        raise FigureError(
            "results.input.confirmatory_completed_count is outside the frozen schedule"
        )
    return count


def _validate_mode(results: Mapping[str, Any], mode: str) -> int:
    if mode not in {"draft", "final"}:
        raise FigureError("mode must be 'draft' or 'final'")
    completed = confirmatory_completed_count(results)
    if mode == "final" and completed != EXPECTED_CONFIRMATORY_RUNS:
        raise FigureError(
            "final figures require all 144 confirmatory runs; "
            f"found {completed}"
        )
    return completed


def _base_drawing(title: str, subtitle: str) -> Drawing:
    drawing = Drawing(FIGURE_WIDTH, FIGURE_HEIGHT)
    drawing.add(
        Rect(
            0,
            0,
            FIGURE_WIDTH,
            FIGURE_HEIGHT,
            fillColor=colors.white,
            strokeColor=colors.HexColor("#D8E0E7"),
            strokeWidth=2,
        )
    )
    drawing.add(
        Rect(
            0,
            FIGURE_HEIGHT - 10,
            FIGURE_WIDTH,
            10,
            fillColor=colors.HexColor("#0A756A"),
            strokeColor=None,
        )
    )
    drawing.add(
        String(
            54,
            FIGURE_HEIGHT - 58,
            title,
            fontName="Helvetica-Bold",
            fontSize=24,
            fillColor=colors.HexColor("#172534"),
        )
    )
    drawing.add(
        String(
            54,
            FIGURE_HEIGHT - 86,
            subtitle,
            fontName="Helvetica",
            fontSize=12,
            fillColor=colors.HexColor("#556575"),
        )
    )
    return drawing


def _add_pending_panel(drawing: Drawing, completed: int) -> None:
    drawing.add(
        Rect(
            210,
            210,
            540,
            92,
            rx=10,
            ry=10,
            fillColor=colors.HexColor("#F5F8FA"),
            strokeColor=colors.HexColor("#8CA0B3"),
            strokeWidth=1.5,
            strokeDashArray=[8, 5],
        )
    )
    drawing.add(
        String(
            480,
            268,
            "NO CONFIRMATORY DATA",
            textAnchor="middle",
            fontName="Helvetica-Bold",
            fontSize=20,
            fillColor=colors.HexColor("#516273"),
        )
    )
    drawing.add(
        String(
            480,
            236,
            f"DRAFT - {completed}/{EXPECTED_CONFIRMATORY_RUNS} completed runs",
            textAnchor="middle",
            fontName="Helvetica",
            fontSize=14,
            fillColor=colors.HexColor("#66788A"),
        )
    )


def _outcome_rows(results: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]:
    outcomes = _mapping(results.get("outcomes"), "results.outcomes")
    metric = _mapping(
        outcomes.get("evidence_unsupported_completion"),
        "results.outcomes.evidence_unsupported_completion",
    )
    rows: dict[str, Mapping[str, Any]] = {}
    for condition in CONDITIONS:
        rows[condition] = _mapping(
            metric.get(condition),
            f"results.outcomes.evidence_unsupported_completion.{condition}",
        )
    return rows


def unsupported_completion_drawing(
    results: Mapping[str, Any],
    *,
    mode: str,
) -> Drawing:
    completed = _validate_mode(results, mode)
    rows = _outcome_rows(results)
    subtitle = (
        "Primary outcome: unsupported completed claims / eligible phase outputs"
    )
    drawing = _base_drawing("Unsupported completion by condition", subtitle)

    left, bottom, width, height = 104, 102, 790, 330
    for step in range(5):
        rate = step / 4
        y = bottom + height * rate
        drawing.add(
            Line(
                left,
                y,
                left + width,
                y,
                strokeColor=colors.HexColor("#E2E8ED"),
                strokeWidth=1,
            )
        )
        drawing.add(
            String(
                left - 18,
                y - 4,
                f"{int(rate * 100)}%",
                textAnchor="end",
                fontName="Helvetica",
                fontSize=10,
                fillColor=colors.HexColor("#607182"),
            )
        )

    bar_width = 112
    gap = (width - bar_width * len(CONDITIONS)) / (len(CONDITIONS) + 1)
    has_data = False
    for index, condition in enumerate(CONDITIONS):
        row = rows[condition]
        rate = _number_or_none(
            row.get("raw_rate"),
            f"unsupported completion rate for {condition}",
        )
        numerator = _integer(row.get("numerator"), f"{condition}.numerator")
        denominator = _integer(row.get("denominator"), f"{condition}.denominator")
        x = left + gap + index * (bar_width + gap)
        drawing.add(
            String(
                x + bar_width / 2,
                70,
                CONDITION_LABELS[condition],
                textAnchor="middle",
                fontName="Helvetica-Bold" if condition == "beforedone" else "Helvetica",
                fontSize=10,
                fillColor=colors.HexColor("#263747"),
            )
        )
        if rate is None:
            if denominator != 0:
                raise FigureError(
                    f"{condition} has a denominator but no unsupported-completion rate"
                )
            drawing.add(
                Rect(
                    x,
                    bottom,
                    bar_width,
                    height,
                    fillColor=colors.HexColor("#F4F6F8"),
                    strokeColor=colors.HexColor("#B5C0CA"),
                    strokeWidth=1,
                    strokeDashArray=[6, 5],
                )
            )
            drawing.add(
                String(
                    x + bar_width / 2,
                    bottom + 12,
                    "N/A",
                    textAnchor="middle",
                    fontName="Helvetica-Bold",
                    fontSize=11,
                    fillColor=colors.HexColor("#778797"),
                )
            )
            continue
        if not 0 <= rate <= 1 or denominator <= 0 or not 0 <= numerator <= denominator:
            raise FigureError(f"invalid unsupported-completion summary for {condition}")
        has_data = True
        bar_height = height * rate
        drawing.add(
            Rect(
                x,
                bottom,
                bar_width,
                bar_height,
                fillColor=colors.HexColor(CONDITION_COLORS[condition]),
                strokeColor=None,
            )
        )
        drawing.add(
            String(
                x + bar_width / 2,
                min(bottom + height - 14, bottom + bar_height + 10),
                f"{rate * 100:.1f}% ({numerator}/{denominator})",
                textAnchor="middle",
                fontName="Helvetica-Bold",
                fontSize=10,
                fillColor=colors.HexColor("#263747"),
            )
        )
    if mode == "draft" and not has_data:
        _add_pending_panel(drawing, completed)
    return drawing


def _cost_rows(
    results: Mapping[str, Any],
    metric: str,
) -> dict[str, Mapping[str, Any]]:
    costs = _mapping(results.get("costs"), "results.costs")
    descriptive = _mapping(costs.get("descriptive"), "results.costs.descriptive")
    summary = _mapping(descriptive.get(metric), f"results.costs.descriptive.{metric}")
    rows: dict[str, Mapping[str, Any]] = {}
    for condition in CONDITIONS:
        rows[condition] = _mapping(
            summary.get(condition),
            f"results.costs.descriptive.{metric}.{condition}",
        )
    return rows


def cost_tradeoff_drawing(
    results: Mapping[str, Any],
    *,
    mode: str,
) -> Drawing:
    completed = _validate_mode(results, mode)
    verifier_rows = _cost_rows(results, "verifier_executions")
    wall_rows = _cost_rows(results, "wall_seconds")
    drawing = _base_drawing(
        "Verification cost and elapsed-time trade-off",
        "Condition medians; whiskers show the interquartile range",
    )

    points: list[tuple[str, float, float, float, float, float, float]] = []
    for condition in CONDITIONS:
        verifier = verifier_rows[condition]
        wall = wall_rows[condition]
        x = _number_or_none(verifier.get("median"), f"{condition}.verifier median")
        y = _number_or_none(wall.get("median"), f"{condition}.wall median")
        x1 = _number_or_none(verifier.get("q1"), f"{condition}.verifier q1")
        x3 = _number_or_none(verifier.get("q3"), f"{condition}.verifier q3")
        y1 = _number_or_none(wall.get("q1"), f"{condition}.wall q1")
        y3 = _number_or_none(wall.get("q3"), f"{condition}.wall q3")
        n_x = _integer(verifier.get("n"), f"{condition}.verifier n")
        n_y = _integer(wall.get("n"), f"{condition}.wall n")
        values = (x, y, x1, x3, y1, y3)
        if all(value is None for value in values):
            if n_x != 0 or n_y != 0:
                raise FigureError(f"{condition} has cost counts without summaries")
            continue
        if any(value is None for value in values) or n_x <= 0 or n_x != n_y:
            raise FigureError(f"incomplete cost summary for {condition}")
        assert x is not None and y is not None
        assert x1 is not None and x3 is not None and y1 is not None and y3 is not None
        if min(x, y, x1, x3, y1, y3) < 0 or not (x1 <= x <= x3 and y1 <= y <= y3):
            raise FigureError(f"invalid cost quartiles for {condition}")
        points.append((condition, x, y, x1, x3, y1, y3))

    left, bottom, width, height = 116, 104, 730, 320
    max_x = max((point[4] for point in points), default=4.0)
    max_y = max((point[6] for point in points), default=120.0)
    max_x = max(1.0, max_x * 1.2)
    max_y = max(1.0, max_y * 1.2)
    for step in range(5):
        fraction = step / 4
        x = left + width * fraction
        y = bottom + height * fraction
        drawing.add(
            Line(
                x,
                bottom,
                x,
                bottom + height,
                strokeColor=colors.HexColor("#E2E8ED"),
                strokeWidth=1,
            )
        )
        drawing.add(
            Line(
                left,
                y,
                left + width,
                y,
                strokeColor=colors.HexColor("#E2E8ED"),
                strokeWidth=1,
            )
        )
        drawing.add(
            String(
                x,
                bottom - 18,
                f"{max_x * fraction:.1f}",
                textAnchor="middle",
                fontName="Helvetica",
                fontSize=9,
                fillColor=colors.HexColor("#607182"),
            )
        )
        drawing.add(
            String(
                left - 14,
                y - 3,
                f"{max_y * fraction:.0f}",
                textAnchor="end",
                fontName="Helvetica",
                fontSize=9,
                fillColor=colors.HexColor("#607182"),
            )
        )
    drawing.add(
        String(
            left + width / 2,
            56,
            "Visible-verifier executions per run",
            textAnchor="middle",
            fontName="Helvetica-Bold",
            fontSize=11,
            fillColor=colors.HexColor("#405263"),
        )
    )
    drawing.add(
        String(
            26,
            bottom + height / 2,
            "Wall seconds",
            textAnchor="middle",
            fontName="Helvetica-Bold",
            fontSize=11,
            fillColor=colors.HexColor("#405263"),
            angle=90,
        )
    )

    for condition, x, y, x1, x3, y1, y3 in points:
        px = left + width * x / max_x
        py = bottom + height * y / max_y
        px1 = left + width * x1 / max_x
        px3 = left + width * x3 / max_x
        py1 = bottom + height * y1 / max_y
        py3 = bottom + height * y3 / max_y
        color = colors.HexColor(CONDITION_COLORS[condition])
        drawing.add(Line(px1, py, px3, py, strokeColor=color, strokeWidth=2))
        drawing.add(Line(px, py1, px, py3, strokeColor=color, strokeWidth=2))
        drawing.add(Circle(px, py, 8, fillColor=color, strokeColor=colors.white))
        drawing.add(
            String(
                px + 12,
                py + 8,
                CONDITION_LABELS[condition],
                fontName="Helvetica-Bold",
                fontSize=10,
                fillColor=color,
            )
        )
    if mode == "draft" and not points:
        _add_pending_panel(drawing, completed)
    return drawing


def build_figure_artifacts(
    results: Mapping[str, Any],
    *,
    mode: str,
) -> list[FigureArtifact]:
    _validate_mode(results, mode)
    return [
        FigureArtifact(
            key="unsupported_completion",
            filename="unsupported-completion-by-condition.svg",
            title="Unsupported completion by condition",
            caption=(
                "Figure 1. Unsupported completed claims as a fraction of eligible "
                "phase outputs. In draft mode, N/A bars explicitly indicate that no "
                "confirmatory estimate exists."
            ),
            drawing=unsupported_completion_drawing(results, mode=mode),
        ),
        FigureArtifact(
            key="cost_tradeoff",
            filename="cost-verification-tradeoff.svg",
            title="Verification cost and elapsed-time trade-off",
            caption=(
                "Figure 2. Median visible-verifier executions and wall-clock time by "
                "condition, with interquartile-range whiskers. An empty draft panel "
                "contains no simulated points."
            ),
            drawing=cost_tradeoff_drawing(results, mode=mode),
        ),
    ]


def scaled_drawing(drawing: Drawing, width: float) -> Drawing:
    scaled = copy.deepcopy(drawing)
    factor = width / float(drawing.width)
    scaled.scale(factor, factor)
    scaled.width = float(drawing.width) * factor
    scaled.height = float(drawing.height) * factor
    return scaled


def generate_figures(root: Path, *, mode: str) -> list[Path]:
    root = root.resolve()
    results = load_results(root)
    artifacts = build_figure_artifacts(results, mode=mode)
    output = root / "paper" / "generated" / "figures"
    output.mkdir(parents=True, exist_ok=True)
    written: list[Path] = []
    for artifact in artifacts:
        svg = renderSVG.drawToString(artifact.drawing)
        if not svg.endswith("\n"):
            svg += "\n"
        path = output / artifact.filename
        path.write_bytes(svg.encode("utf-8"))
        written.append(path)
    return written


def _parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Generate deterministic figures from canonical BeforeDone analysis."
    )
    parser.add_argument("--root", type=Path, default=Path.cwd())
    parser.add_argument("--mode", choices=("draft", "final"), default="draft")
    return parser


def main(argv: Sequence[str] | None = None) -> int:
    args = _parser().parse_args(argv)
    try:
        paths = generate_figures(args.root, mode=args.mode)
    except (FigureError, OSError) as exc:
        print(f"figure generation failed: {exc}", file=sys.stderr)
        return 2
    for path in paths:
        print(path)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())