#!/usr/bin/env python3
"""Create a static SVG and Markdown summary of polytrope verification CSVs.

Uses only the Python standard library. Does not rerun the solver or alter input
CSVs; writes polytrope_profiles.svg and polytrope_summary.md in the input directory.
"""

import argparse
import csv
import html
import math
from pathlib import Path


FIELDS = (
    ("density_material", "theta_density", "density", "#2563eb"),
    ("enthalpy_material", "theta_enthalpy", "enthalpy", "#15803d"),
    ("potential", "theta_potential", "potential", "#c2410c"),
    ("gravity_radial", None, "radial gravity gradient", "#7e22ce"),
)


def read_rows(path):
    with path.open(newline="") as stream:
        return list(csv.DictReader(stream))


def number(value):
    try:
        return float(value)
    except (TypeError, ValueError):
        return math.nan


def read_metrics(directory):
    return {row["metric"]: number(row["value"])
            for row in read_rows(directory / "physical_metrics.csv")}


def metadata(directory):
    path = directory / "metadata.txt"
    if not path.exists():
        return {}
    return dict(line.split("=", 1) for line in path.read_text().splitlines() if "=" in line)


def finite_max(values):
    return max((value for value in values if math.isfinite(value)), default=math.nan)


def format_number(value):
    return f"{value:.5g}" if math.isfinite(value) else "not available"


def reference_scales(rows):
    origin = next((row for row in rows if number(row.get("xi")) == 0.0), None)
    if origin is None:
        raise ValueError("radial_profiles.csv must contain its analytic origin reference")
    density = number(origin["density_material_analytic"])
    enthalpy = number(origin["enthalpy_material_analytic"])
    nonzero = next(row for row in rows if number(row.get("xi")) > 0.0)
    radius = math.pi * number(nonzero["radius"]) / number(nonzero["xi"])
    if not all(math.isfinite(value) and value > 0.0 for value in (density, enthalpy, radius)):
        raise ValueError("Non-finite/non-positive fixed analytic reference scales")
    return {"density_material": density, "enthalpy_material": enthalpy,
            "potential": enthalpy, "gravity_radial": enthalpy / radius,
            "radius": radius}


def points(rows, column, scale=1.0, interior=False):
    result = []
    for row in rows:
        xi = number(row.get("xi"))
        if interior and xi > math.pi:
            continue
        result.append((xi, number(row.get(column)) / scale))
    return result


def path_segments(data, xmap, ymap, logarithmic=False):
    segments, current = [], []
    for x, y in data:
        if not math.isfinite(x) or not math.isfinite(y) or (logarithmic and y <= 0.0):
            if current:
                segments.append(current)
                current = []
            continue
        current.append((xmap(x), ymap(y)))
    if current:
        segments.append(current)
    return segments


class Figure:
    def __init__(self, title):
        self.parts = [
            '<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="910" viewBox="0 0 1200 910" role="img">',
            f"<title>{html.escape(title)}</title>",
            '<desc>Fixed-reference n=1 physical-radius profiles, absolute mean errors, angular scatter, and sampling coverage.</desc>',
            '<rect width="1200" height="910" fill="#ffffff"/>',
            '<style>text{font-family:Arial,Helvetica,sans-serif;fill:#1f2937;font-size:12px}.title{font-size:22px;font-weight:bold}.panel{font-size:15px;font-weight:bold}.small{font-size:11px}</style>',
            f'<text class="title" x="65" y="35">{html.escape(title)}</text>',
            '<text x="65" y="58">Physical spheres; ξ = πr/R. Reference R and central scales are prescribed, never fitted.</text>',
        ]

    def panel(self, ident, box, title, xlabel, ylabel, xlim, ylim, series, log=False):
        left, top, width, height = box
        xmap = lambda value: left + width * (value - xlim[0]) / (xlim[1] - xlim[0])
        if log:
            lower, upper = math.log10(ylim[0]), math.log10(ylim[1])
            ymap = lambda value: top + height * (upper - math.log10(value)) / (upper - lower)
            ticks = [(10.0 ** exponent, f"1e{exponent}")
                     for exponent in range(math.ceil(lower), math.floor(upper) + 1)]
            if len(ticks) > 7:
                ticks = ticks[::math.ceil(len(ticks) / 7)]
        else:
            ymap = lambda value: top + height * (ylim[1] - value) / (ylim[1] - ylim[0])
            ticks = [(ylim[0] + i * (ylim[1] - ylim[0]) / 4.0,
                      f"{ylim[0] + i * (ylim[1] - ylim[0]) / 4.0:.2g}") for i in range(5)]
        self.parts.append(f'<text class="panel" x="{left}" y="{top - 58}">{html.escape(title)}</text>')
        self.parts.append(f'<defs><clipPath id="{ident}"><rect x="{left}" y="{top}" width="{width}" height="{height}"/></clipPath></defs>')
        for value, label in ticks:
            y = ymap(value)
            self.parts.append(f'<line x1="{left}" x2="{left + width}" y1="{y:.3f}" y2="{y:.3f}" stroke="#e5e7eb"/>')
            self.parts.append(f'<text x="{left - 9}" y="{y + 4:.3f}" text-anchor="end">{label}</text>')
        for i in range(5):
            value = xlim[0] + i * (xlim[1] - xlim[0]) / 4.0
            x = xmap(value)
            self.parts.append(f'<line x1="{x:.3f}" x2="{x:.3f}" y1="{top}" y2="{top + height}" stroke="#f1f5f9"/>')
            self.parts.append(f'<text x="{x:.3f}" y="{top + height + 20}" text-anchor="middle">{value:.3g}</text>')
        self.parts.append(f'<rect x="{left}" y="{top}" width="{width}" height="{height}" fill="none" stroke="#64748b"/>')
        self.parts.append(f'<text x="{left + width / 2}" y="{top + height + 42}" text-anchor="middle">{html.escape(xlabel)}</text>')
        self.parts.append(f'<text transform="translate({left - 57},{top + height / 2}) rotate(-90)" text-anchor="middle">{html.escape(ylabel)}</text>')
        legend_index = 0
        for item in series:
            dash = ' stroke-dasharray="6 4"' if item.get("dash") else ""
            for segment in path_segments(item["data"], xmap, ymap, log):
                if len(segment) == 1:
                    x, y = segment[0]
                    self.parts.append(f'<circle clip-path="url(#{ident})" cx="{x:.3f}" cy="{y:.3f}" r="2" fill="{item["color"]}"/>')
                else:
                    coordinates = " ".join(f"{x:.3f},{y:.3f}" for x, y in segment)
                    self.parts.append(f'<polyline clip-path="url(#{ident})" points="{coordinates}" fill="none" stroke="{item["color"]}" stroke-width="1.8"{dash}/>')
            if item.get("label"):
                x = left + (legend_index % 2) * width / 2
                y = top - 35 + (legend_index // 2) * 17
                self.parts.append(f'<line x1="{x}" x2="{x + 20}" y1="{y}" y2="{y}" stroke="{item["color"]}" stroke-width="2"{dash}/>')
                self.parts.append(f'<text class="small" x="{x + 26}" y="{y + 4}">{html.escape(item["label"])}</text>')
                legend_index += 1

    def write(self, path, control):
        note = "Solid: measured state. Dashed same-color: analytic-mesh control." if control else "Mean errors and scatter are separately scaled by fixed central/reference values."
        self.parts.append(f'<text class="small" x="65" y="864">{html.escape(note)}</text>')
        self.parts.append('<text class="small" x="65" y="884">Missing/nonfinite samples are not connected; zero errors are omitted on logarithmic axes. Material means are conditional.</text>')
        self.parts.append("</svg>")
        path.write_text("\n".join(self.parts) + "\n")


def logarithmic_limits(series):
    values = [y for item in series for _, y in item["data"] if math.isfinite(y) and y > 0.0]
    if not values:
        return 1e-16, 1.0
    lower = max(-300, math.floor(math.log10(min(values))))
    upper = max(lower + 2, math.ceil(math.log10(max(values))))
    return 10.0 ** lower, 10.0 ** upper


def make_figure(directory, rows, control_rows):
    scales = reference_scales(rows)
    control_scales = reference_scales(control_rows) if control_rows else {}
    if control_rows:
        for key in scales:
            if not math.isclose(scales[key], control_scales[key], rel_tol=1e-12):
                raise ValueError(f"Control and measured fixed-reference scales differ: {key}")
    figure = Figure("n = 1 polytrope: physical profile verification")
    analytic = [(math.pi * i / 300, math.sin(math.pi * i / 300) / (math.pi * i / 300) if i else 1.0)
                for i in range(301)]
    profile_series = [{"data": analytic, "color": "#111827", "label": "analytic sin(ξ)/ξ", "dash": True}]
    for _, column, label, color in FIELDS[:3]:
        profile_series.append({"data": points(rows, column, interior=True), "color": color, "label": label})
    profile_values = [y for item in profile_series for _, y in item["data"] if math.isfinite(y)]
    lo, hi = min(profile_values), max(profile_values)
    padding = max(0.05, 0.05 * (hi - lo))
    figure.panel("profiles", (85, 150, 470, 255), "Interior dimensionless profiles", "ξ = πr/R", "θ from each field",
                 (0.0, math.pi), (lo - padding, hi + padding), profile_series)
    maximum_xi = finite_max(number(row["xi"]) for row in rows)
    mean_series, scatter_series = [], []
    for field, _, label, color in FIELDS:
        mean_series.append({"data": [(x, abs(y)) for x, y in points(rows, field + "_mean_error_scaled")], "color": color, "label": label})
        scatter_series.append({"data": points(rows, field + "_angular_rms", scales[field]), "color": color, "label": label})
        if control_rows:
            mean_series.append({"data": [(x, abs(y)) for x, y in points(control_rows, field + "_mean_error_scaled")], "color": color, "dash": True})
            scatter_series.append({"data": points(control_rows, field + "_angular_rms", control_scales[field]), "color": color, "dash": True})
    figure.panel("mean_errors", (690, 150, 440, 255), "Absolute spherical-mean error", "ξ = πr/R", "absolute error / fixed scale",
                 (0.0, maximum_xi), logarithmic_limits(mean_series), mean_series, log=True)
    figure.panel("scatter", (85, 565, 470, 230), "Angular RMS about the spherical mean", "ξ = πr/R", "angular RMS / fixed scale",
                 (0.0, maximum_xi), logarithmic_limits(scatter_series), scatter_series, log=True)
    coverage = [
        {"data": points(rows, "located_weight_fraction"), "color": "#111827", "label": "point location"},
        {"data": points(rows, "material_weight_fraction"), "color": "#64748b", "label": "stellar material"},
        {"data": points(rows, "density_material_valid_weight_fraction"), "color": "#2563eb", "label": "finite density", "dash": True},
        {"data": points(rows, "enthalpy_material_valid_weight_fraction"), "color": "#15803d", "label": "finite enthalpy", "dash": True},
    ]
    figure.panel("coverage", (690, 565, 440, 230), "Sampling coverage (inspect before means)", "ξ = πr/R", "fraction of requested angular weight",
                 (0.0, maximum_xi), (-0.03, 1.03), coverage)
    figure.write(directory / "polytrope_profiles.svg", bool(control_rows))


def make_report(directory, rows, metrics, checks, control_directory, control_metrics):
    info = metadata(directory)
    failed = [row for row in checks if row.get("passed", "").lower() not in ("1", "true")]
    lines = ["# Polytrope physical verification", "", f"Source: `{directory.resolve()}`.", "",
             f"Declared screening checks: **{len(checks) - len(failed)}/{len(checks)} passed**. "
             "These budgets are not a mesh-convergence certificate.", ""]
    if info:
        lines.append(f"Mode: `{info.get('mode', 'unknown')}`. Solver convergence: `{info.get('solver_converged', 'not applicable/reported')}`.")
        if "solver_failure" in info:
            lines.extend(["", "Solver failure: " + info["solver_failure"]])
        lines.append("")
    lines.extend(["![Fixed-reference physical profiles, errors, angular scatter, and coverage](polytrope_profiles.svg)", "",
                  "## Main diagnostics", ""])
    if control_directory:
        lines.extend([f"Analytic-mesh control: `{control_directory.resolve()}`. Control errors are shown directly, not subtracted from numerical errors.", ""])
    lines.append("| Metric | Measured |" + (" Analytic-mesh control |" if control_directory else ""))
    lines.append("|---|---:|" + ("---:|" if control_directory else ""))
    selected = ("mass", "mass_relative_error", "volume_radius_relative_error", "surface_radius_relative_rms_error",
                "density_relative_l2_error", "enthalpy_relative_l2_error", "potential_relative_l2_error",
                "gravity_gradient_relative_l2_error", "binding_energy", "pressure_integral", "virial_error",
                "force_virial_error", "enthalpy_virial_error", "enthalpy_force_virial_error",
                "gravity_energy_consistency", "eos_enthalpy_scaled_rms", "closure_projection_pressure_gap",
                "closure_projection_pressure_gap_relative_defect",
                "normalized_bordered_residual", "normalized_unbordered_residual", "normalized_central_border_action",
                "invalid_stellar_corner_samples", "maximum_stellar_corner_element_condition",
                "profile_missing_points", "profile_maximum_location_error", "profile_maximum_scaled_error",
                "profile_maximum_angular_rms_scaled")
    for key in selected:
        if key not in metrics:
            continue
        row = f"| `{key}` | {format_number(metrics[key])} |"
        if control_directory:
            row += f" {format_number(control_metrics.get(key, math.nan))} |"
        lines.append(row)
    lines.extend(["", "## Radial-profile diagnostics", "",
                  "| Field | Max absolute mean error / fixed scale | Max angular RMS / fixed scale |", "|---|---:|---:|"])
    scales = reference_scales(rows)
    for field, _, label, _ in FIELDS:
        mean_error = finite_max(abs(number(row.get(field + "_mean_error_scaled"))) for row in rows)
        scatter = finite_max(number(row.get(field + "_angular_rms")) / scales[field] for row in rows)
        lines.append(f"| {label} | {format_number(mean_error)} | {format_number(scatter)} |")
    incomplete = [row for row in rows if number(row.get("located_weight_fraction")) < 1.0 - 1e-10]
    partial_material = [row for row in rows if 1e-10 < number(row.get("material_weight_fraction")) < 1.0 - 1e-10]
    lines.extend(["", f"Shells with incomplete point-location coverage: **{len(incomplete)}**. "
                  f"Shells crossing the numerical material boundary: **{len(partial_material)}**.", "",
                  "Density/enthalpy means are conditional on located stellar material and finite values. "
                  "Missing samples and undefined exterior material fields are never zero-filled. "
                  "Angular RMS exposes nonspherical variation that a spherical mean can hide. "
                  "Origin data are single traces; radial gravity is undefined there. "
                  "Gravity is outward-positive ∇Φ, not inward acceleration.", ""])
    if failed:
        lines.extend(["## Failed declared screens", "", "| Metric | Observed | Maximum allowed |", "|---|---:|---:|"])
        for row in failed:
            lines.append(f"| `{row['metric']}` | {format_number(number(row['observed']))} | {format_number(number(row['maximum_allowed']))} |")
        lines.append("")
    lines.append("All plotted normalizations use the prescribed analytic reference. No radius, central density, or potential offset is fitted.")
    (directory / "polytrope_summary.md").write_text("\n".join(lines) + "\n")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("directory", type=Path)
    parser.add_argument("--control-directory", type=Path)
    args = parser.parse_args()
    rows = read_rows(args.directory / "radial_profiles.csv")
    if not rows:
        parser.error("radial_profiles.csv contains no rows")
    metrics = read_metrics(args.directory)
    checks = read_rows(args.directory / "verification_checks.csv")
    control_rows = read_rows(args.control_directory / "radial_profiles.csv") if args.control_directory else []
    control_metrics = read_metrics(args.control_directory) if args.control_directory else {}
    make_figure(args.directory, rows, control_rows)
    make_report(args.directory, rows, metrics, checks, args.control_directory, control_metrics)
    print(args.directory / "polytrope_profiles.svg")
    print(args.directory / "polytrope_summary.md")


if __name__ == "__main__":
    main()