"""Reproduce component-frontier constructions and algebraic certificates.

All n=3..60, K=1..n+2, and 2n cyclic deletion offsets are checked. Complete
offset coverage follows an independently checked geometric rotation identity;
actual interval unions are checked at every sampled normal for the base offset.
The classical regular-polygon SMT theorem is an explicit proof dependency,
not a numerical conclusion of this script.
"""

from __future__ import annotations

import json
import math
from pathlib import Path

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np

from complexity_frontier import (
    PI, STEINER_DEPENDENCY, side_length, frontier_length, frontier_lower_bounds,
    regular_vertices, construction, graph_component_count,
    connected_repair_cost, repair_segments, penalized_optimum, joint_penalty_limit,
)
from finite_audit import alternating_polygon, missed_length_at_angle, maximal_required_gap

HERE = Path(__file__).resolve().parent


def verify():
    records = []
    offset_case_count = 0
    maxima = {"length_error": 0.0, "sampled_missed_length": 0.0,
              "sampled_required_gap": 0.0, "lower_bound_formula_error": 0.0,
              "rotation_equivariance_error": 0.0, "repair_length_error": 0.0,
              "repair_steiner_lower_bound_error": 0.0}
    for n in range(3, 61):
        vertices = regular_vertices(n)
        indices = np.arange(2 * n)
        d = side_length(n)
        rotations = []
        # Validate every vertex and hence every possible retained edge under
        # each cyclic offset. This is independent of the deletion subset.
        for offset in range(2 * n):
            phi = offset * PI / n
            rotation = np.array([[math.cos(phi), -math.sin(phi)],
                                  [math.sin(phi), math.cos(phi)]])
            error = float(np.max(np.abs(vertices @ rotation.T
                                         - vertices[(indices + offset) % (2 * n)])))
            assert error < 3e-14
            maxima["rotation_equivariance_error"] = max(maxima["rotation_equivariance_error"], error)
            # The entire normal grid is permuted by the same rotation.
            normals = np.mod(np.arange(n) * PI / n + phi, PI)
            expected = np.arange(n) * PI / n
            nearest_grid_error = np.min(np.abs(
                (normals[:, None] - expected[None, :] + PI / 2) % PI - PI / 2), axis=1)
            assert float(nearest_grid_error.max()) < 3e-14
            rotations.append(error)
        for budget in range(1, n + 3):
            q = min(budget, n)
            base = construction(n, budget, offset=1)
            length = float(np.linalg.norm(base["segments"][:, 1]
                                           - base["segments"][:, 0], axis=1).sum())
            expected = frontier_length(n, budget)
            length_error = abs(length - expected)
            lower = frontier_lower_bounds(n, budget)
            lower_error = abs(lower["combined_bound"] - expected)
            normals = np.arange(n) * PI / n
            missed = max(missed_length_at_angle(base["segments"], theta) for theta in normals)
            gap = max(maximal_required_gap(base["segments"], theta) for theta in normals)
            assert length_error < 2e-12 and lower_error < 2e-12
            assert missed < 2e-10 and gap < 2e-10
            # Check every offset combinatorially; the rotation identity above
            # transfers each full interval-union certificate to that offset.
            for offset in range(2 * n):
                shifted = construction(n, budget, offset)
                removed = shifted["deleted_edge_indices"]
                assert len(set(map(int, removed))) == q
                assert np.all(removed % 2 == offset % 2)
                retained = set(map(int, shifted["retained_edge_indices"]))
                opposite_parity = {j for j in range(2 * n) if j % 2 != offset % 2}
                assert opposite_parity.issubset(retained)
                assert graph_component_count(n, shifted["retained_edge_indices"]) == q
                # Exact integer edge accounting, separate from geometric float tests.
                assert len(retained) == 2 * n - q
                assert len(retained) + (q - 1) == 2 * n - 1
                offset_case_count += 1
            maxima["length_error"] = max(maxima["length_error"], length_error)
            maxima["sampled_missed_length"] = max(maxima["sampled_missed_length"], missed)
            maxima["sampled_required_gap"] = max(maxima["sampled_required_gap"], gap)
            maxima["lower_bound_formula_error"] = max(maxima["lower_bound_formula_error"], lower_error)
            records.append({"n": n, "K": budget, "realized_components": q,
                            "side_length": d, "formula_length": expected,
                            "measured_length": length,
                            "projection_lower_bound": lower["projection_bound"],
                            "component_steiner_lower_bound": lower["component_steiner_bound"],
                            "combined_lower_bound": lower["combined_bound"],
                            "max_base_sample_missed_length": missed,
                            "max_base_sample_gap": gap,
                            "verified_cyclic_offsets": 2 * n})
        alternating = alternating_polygon(n)
        added = repair_segments(n)
        repaired = np.concatenate((alternating, added), axis=0)
        added_length = float(np.linalg.norm(added[:, 1] - added[:, 0], axis=1).sum())
        total = float(np.linalg.norm(repaired[:, 1] - repaired[:, 0], axis=1).sum())
        steiner_minimum = (2 * n - 1) * d
        error = abs(added_length - connected_repair_cost(n))
        lower_error = abs(total - steiner_minimum)
        assert error < 2e-12 and lower_error < 2e-12
        assert graph_component_count(n, [j for j in range(2 * n) if j != 1]) == 1
        maxima["repair_length_error"] = max(maxima["repair_length_error"], error)
        maxima["repair_steiner_lower_bound_error"] = max(maxima["repair_steiner_lower_bound_error"], lower_error)
    return records, offset_case_count, maxima


def make_figure():
    plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 10,
                         "axes.titlesize": 12, "axes.labelsize": 10})
    fig, axes = plt.subplots(3, 2, figsize=(12.6, 12.8))
    fig.patch.set_facecolor("#f8fafc")
    for ax in axes.ravel():
        ax.set_facecolor("white")
        ax.spines[["top", "right"]].set_visible(False)
    ax = axes[0, 0]
    example = construction(12, 3, offset=1)
    theta = np.linspace(0, 2 * PI, 601)
    ax.plot(np.cos(theta), np.sin(theta), ls="--", lw=1, color="#94a3b8")
    palette = ["#2563eb", "#8b5cf6", "#0891b2"]
    # Colors identify the three connected polygonal paths after deleting edges1,3,5.
    for index, segment in zip(example["retained_edge_indices"], example["segments"]):
        group = 0 if index == 2 else (1 if index == 4 else 2)
        ax.plot(segment[:, 0], segment[:, 1], lw=4, color=palette[group],
                solid_capstyle="round")
    for index in example["deleted_edge_indices"]:
        points = example["vertices"][[index, (index + 1) % 24]]
        ax.plot(points[:, 0], points[:, 1], ls=":", color="#dc2626", lw=1.8)
    ax.set_aspect("equal"); ax.set_xlim(-1.12, 1.12); ax.set_ylim(-1.12, 1.12)
    ax.set_title("A. Exact construction: $n=12$, $K=3$", loc="left", fontweight="bold")
    ax.set_xlabel("$x$"); ax.set_ylabel("$y$")
    ax.text(0.04, 0.03, "Delete three edges of one parity.\nRetain every required contact vertex.",
            transform=ax.transAxes, fontsize=8, color="#475569",
            bbox={"facecolor": "white", "edgecolor": "none", "alpha": .9})

    ax = axes[0, 1]
    for n, color in zip([8, 16, 32, 64], ["#94a3b8", "#0891b2", "#8b5cf6", "#2563eb"]):
        budgets = np.arange(1, int(1.3 * n) + 1)
        values = [frontier_length(n, int(k)) / PI for k in budgets]
        ax.plot(budgets / n, values, color=color, lw=2, label=f"$n={n}$")
    ax.axhline(1, color="#64748b", ls="--", lw=1)
    ax.axvline(1, color="#cbd5e1", ls=":", lw=1)
    ax.set_xlim(0, 1.25); ax.set_ylim(.96, 2.04)
    ax.set_xlabel("Relative component budget $K/n$")
    ax.set_ylabel("Exact sampled optimum / $\\pi$")
    ax.set_title("B. The sharp complexity / length frontier", loc="left", fontweight="bold")
    ax.legend(frameon=False, fontsize=8)
    ax.grid(alpha=.15)

    ax = axes[1, 0]
    counts = np.arange(3, 257)
    for k, color in zip([1, 2, 4, 8], ["#2563eb", "#8b5cf6", "#0891b2", "#64748b"]):
        ax.plot(counts, [frontier_length(int(n), k) for n in counts], lw=2,
                color=color, label=f"Fixed $K={k}$")
    ax.axhline(2 * PI, ls="--", color="#dc2626", lw=1.5, label="Limit: $2\\pi$")
    ax.set_xscale("log", base=2); ax.set_xlim(3, 256); ax.set_ylim(2.9, 6.5)
    ax.set_xlabel("Audited normal count $n$")
    ax.set_ylabel("Total length")
    ax.set_title("C. Fixed component budgets restore the full limit", loc="left", fontweight="bold")
    ax.legend(frameon=False, fontsize=8, loc="lower right")
    ax.grid(alpha=.15)
    ax = axes[2, 0]
    n = 16
    d = side_length(n)
    scaled = np.linspace(0, 2.1, 501)
    connected = np.array([penalized_optimum(n, float(t * d))["connected_branch"]
                           / (n * d) for t in scaled])
    alternating = np.array([penalized_optimum(n, float(t * d))["alternating_branch"]
                             / (n * d) for t in scaled])
    ax.plot(scaled, alternating, color="#2563eb", lw=1.8,
            label="$n$-component branch")
    ax.plot(scaled, connected, color="#8b5cf6", lw=1.8,
            label="Connected branch")
    ax.plot(scaled, np.minimum(connected, alternating), color="#0f172a", lw=2.7,
            ls="--", label="Exact penalized optimum")
    ax.axvline(1, color="#dc2626", ls=":", lw=1.4)
    ax.scatter([1], [2], s=35, color="#dc2626", zorder=5)
    ax.set_xlim(0, 2.1); ax.set_ylim(.95, 2.2)
    ax.set_xlabel("Component penalty / side length $\\lambda/d$")
    ax.set_ylabel("$J_n(\\lambda)/(nd)$")
    ax.set_title("E. Exact penalty transition at $\\lambda=d$", loc="left", fontweight="bold")
    ax.legend(frameon=False, fontsize=8, loc="lower right")
    ax.grid(alpha=.15)

    ax = axes[2, 1]
    scaled_cost = np.linspace(0, 2 * PI, 501)
    for n, color in zip([8, 32, 128], ["#94a3b8", "#8b5cf6", "#2563eb"]):
        values = [penalized_optimum(n, float(c / n))["value"] for c in scaled_cost]
        ax.plot(scaled_cost / PI, values, lw=1.9, color=color, label=f"$n={n}$")
    ax.plot(scaled_cost / PI, [joint_penalty_limit(float(c)) for c in scaled_cost],
            color="#0f172a", lw=2.6, ls="--", label="$\\min(2\\pi,\\pi+c)$")
    ax.axvline(1, color="#dc2626", lw=1.2, ls=":")
    ax.set_xlim(0, 2); ax.set_ylim(2.95, 6.55)
    ax.set_xlabel("Scaled penalty $c/\\pi=n\\lambda/\\pi$")
    ax.set_ylabel("Penalized optimum $J_n(c/n)$")
    ax.set_title("F. Joint limit with $n\\lambda\\to c$", loc="left", fontweight="bold")
    ax.legend(frameon=False, fontsize=8, loc="lower right")
    ax.grid(alpha=.15)

    ax = axes[1, 1]
    selected = np.array([n * side_length(int(n)) for n in counts])
    repairs = np.array([connected_repair_cost(int(n)) for n in counts])
    ax.plot(counts, selected, color="#2563eb", lw=2.4, label="Alternating audit length")
    ax.plot(counts, repairs, color="#dc2626", lw=2.4, label="Exact minimum connection repair")
    ax.axhline(PI, color="#64748b", ls="--", lw=1.3, label="Each tends to $\\pi$")
    ax.set_xscale("log", base=2); ax.set_xlim(3, 256); ax.set_ylim(1.9, 3.3)
    ax.set_xlabel("Audited normal count $n$")
    ax.set_ylabel("Length")
    ax.set_title("D. Connecting the sampled optimum costs another $\\pi$", loc="left", fontweight="bold")
    ax.legend(frameon=False, fontsize=8, loc="lower right")
    ax.grid(alpha=.15)
    fig.suptitle("Component complexity controls the exact audit frontier",
                  x=.055, y=1.01, ha="left", fontsize=17, fontweight="bold", color="#0f172a")
    fig.tight_layout(h_pad=2.4, w_pad=2.5, rect=(0, .035, 1, .985))
    fig.text(.055, .005,
        "Interior finite-angle model: $L(n,K)=[2n-\\min(K,n)]\\,2\\sin(\\pi/(2n))$. "
        "The lower bound uses the classical regular-polygon Steiner theorem (Du-Hwang-Weng,1987).\n"
        "No unrestricted opaque-disk optimum or numerical proof of that Steiner theorem is claimed.",
        fontsize=9, color="#475569", linespacing=1.6)
    directory = HERE / "figures"
    directory.mkdir(exist_ok=True)
    fig.savefig(directory / "complexity_frontier.png", dpi=185,
                bbox_inches="tight", facecolor=fig.get_facecolor())
    fig.savefig(directory / "complexity_frontier.pdf", bbox_inches="tight",
                facecolor=fig.get_facecolor())
    plt.close(fig)


def verify_penalties():
    cases = []
    maximum_error = 0.0
    for n in range(3, 61):
        d = side_length(n)
        penalties = [factor * d for factor in [0, .25, .75, 1, 1.25, 2, 5]]
        penalties += [.02, .1, .5]
        for penalty in penalties:
            exact = penalized_optimum(n, penalty)
            objectives = np.array([frontier_length(n, k) + penalty * k
                                     for k in range(1, n + 1)])
            error = abs(float(objectives.min()) - exact["value"])
            assert error < 2e-12
            maximum_error = max(maximum_error, error)
            for k in exact["minimizing_component_counts"]:
                assert abs(objectives[k - 1] - exact["value"]) < 2e-12
            if penalty == d:
                assert len(exact["minimizing_component_counts"]) == n
                assert float(np.ptp(objectives)) < 2e-12
            cases.append({"n": n, "penalty": penalty,
                          "threshold": d, "value": exact["value"],
                          "phase": exact["phase"], "enumeration_error": error})
    limits = []
    for c in [0, .5 * PI, PI, 1.5 * PI, 2 * PI]:
        sequence = [{"n": 2**power,
                     "value": penalized_optimum(2**power, c / 2**power)["value"]}
                    for power in range(2, 15)]
        target = joint_penalty_limit(c)
        assert abs(sequence[-1]["value"] - target) < 3e-4
        limits.append({"scaled_penalty_c": c, "limit": target, "sequence": sequence})
    fixed = []
    for penalty in [.01, .1, 1.0]:
        n = 32768
        value = penalized_optimum(n, penalty)["value"]
        target = 2 * PI + penalty
        assert abs(value - target) < 2e-4
        fixed.append({"fixed_penalty": penalty, "n": n,
                      "value": value, "limit": target})
    return {"case_count": len(cases), "maximum_enumeration_error": maximum_error,
            "cases": cases, "joint_limit_sequences": limits,
            "fixed_positive_penalty_checks": fixed}


def main():
    records, offsets, maxima = verify()
    penalties = verify_penalties()
    make_figure()
    report = {"status": "PASS", "n_range": [3, 60],
        "component_budget_range": "K=1,...,n+2 for each n",
        "base_family_count": len(records), "all_cyclic_offset_case_count": offsets,
        "offset_validation": "All edge subsets and graph components checked explicitly; geometric rotation equivariance transfers complete base sampled-interval-union certificates to every cyclic offset.",
        "scope": "Exact component-budget frontier for interior uniform-normal audits.",
        "arithmetic": "Exact integer edge counts plus geometric analytic formulas evaluated in float64.",
        "proof_dependency": STEINER_DEPENDENCY,
        "not_claimed": ["Independent proof or numerical verification of the Steiner minimum tree theorem",
                        "The unrestricted fully opaque disk optimum",
                        "Interval-arithmetic certification"],
        "max_observed_errors": maxima,
        "fixed_budget_limit": "2*pi for each fixed positive integer K",
        "repair_cost_formula": "(n-1)*2*sin(pi/(2*n))",
        "repair_cost_limit": "pi",
        "penalty_formula": "J_n(lambda)=min((2*n-1)*d+lambda,n*d+n*lambda)",
        "penalty_threshold": "lambda=d=2*sin(pi/(2*n))",
        "joint_penalty_limit": "If lambda_n->0 and n*lambda_n->c, J_n(lambda_n)->min(2*pi,pi+c)",
        "fixed_positive_penalty_limit": "2*pi+lambda",
        "penalty_verification": penalties,
        "versions": {"numpy": np.__version__, "matplotlib": matplotlib.__version__},
        "cases": records}
    (HERE / "COMPLEXITY_VERIFICATION.json").write_text(json.dumps(report, indent=2) + "\n")
    summary = {key: report[key] for key in ["status", "base_family_count",
          "all_cyclic_offset_case_count", "max_observed_errors"]}
    summary["penalty_case_count"] = penalties["case_count"]
    summary["max_penalty_enumeration_error"] = penalties["maximum_enumeration_error"]
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()