"""Exact component/length frontier for interior uniform-angle audits.

For n>=3 sampled normals k*pi/n, candidates are compact rectifiable subsets
of the closed unit disk with at most K connected components. The optimum is
    (2*n - min(K,n)) * 2*sin(pi/(2*n)).

Proof dependency: the classical Steiner minimum tree theorem for regular
N-gons, N>=6, due to Jarnik--Koessler and Du--Hwang--Weng (1987), DOI
10.1007/BF02187871. Its minimum network length is (N-1) times the side length.
The numerical verification accompanying this module does NOT prove that
classical theorem or search all Steiner topologies.

Every sampled tangent forces its unit-circle contact vertex into an interior
candidate. Connecting its terminal-meeting components by at most K-1 polygon
sides gives the Steiner lower bound (2n-K)*d. The projection lower bound n*d
also applies. Deleting min(K,n) edges of one parity attains their maximum.

This is the sampled-angle INTERIOR problem, not unrestricted full opacity.
"""

from __future__ import annotations

import math
import numpy as np

PI = math.pi
STEINER_DEPENDENCY = {
    "authors": ["D. Z. Du", "F. K. Hwang", "J. F. Weng"],
    "title": "Steiner minimal trees for regular polygons",
    "journal": "Discrete & Computational Geometry",
    "year": 1987, "volume": 2, "pages": "65-84",
    "doi": "10.1007/BF02187871",
    "primary_url": "https://doi.org/10.1007/BF02187871",
    "used_statement": "For a regular N-gon with N>=6, a Steiner minimum tree is the polygon with one edge removed.",
    "numerically_proved_here": False,
}


def _validate(n, components=1):
    if isinstance(n, bool) or int(n) != n or n < 3:
        raise ValueError("n must be an integer at least three")
    if isinstance(components, bool) or int(components) != components or components < 1:
        raise ValueError("Component budget must be a positive integer")
    return int(n), int(components)


def side_length(n):
    n, _ = _validate(n)
    return 2 * math.sin(PI / (2 * n))


def frontier_length(n, components):
    n, components = _validate(n, components)
    return (2 * n - min(components, n)) * side_length(n)


def frontier_lower_bounds(n, components):
    n, components = _validate(n, components)
    d = side_length(n)
    return {"projection_bound": n * d,
            "component_steiner_bound": (2 * n - components) * d,
            "combined_bound": max(n * d, (2 * n - components) * d),
            "steiner_connected_terminal_bound": (2 * n - 1) * d}


def regular_vertices(n):
    n, _ = _validate(n)
    theta = np.arange(2 * n) * PI / n
    return np.column_stack((np.cos(theta), np.sin(theta)))


def construction(n, components, offset=1):
    """Delete q=min(K,n) same-parity edges, starting at a cyclic offset."""
    n, components = _validate(n, components)
    offset = int(offset) % (2 * n)
    q = min(components, n)
    vertices = regular_vertices(n)
    deleted = (offset + 2 * np.arange(q)) % (2 * n)
    keep = np.ones(2 * n, dtype=bool)
    keep[deleted] = False
    indices = np.flatnonzero(keep)
    segments = np.stack((vertices[indices], vertices[(indices + 1) % (2 * n)]), axis=1)
    return {"segments": segments, "vertices": vertices,
            "retained_edge_indices": indices, "deleted_edge_indices": deleted,
            "realized_components": q, "component_budget": components,
            "length_formula": frontier_length(n, components), "offset": offset}


def graph_component_count(n, retained_edge_indices):
    n, _ = _validate(n)
    parent = list(range(2 * n))

    def root(v):
        while parent[v] != v:
            parent[v] = parent[parent[v]]
            v = parent[v]
        return v

    for edge in retained_edge_indices:
        a, b = int(edge), (int(edge) + 1) % (2 * n)
        ra, rb = root(a), root(b)
        parent[rb] = ra
    return len({root(v) for v in range(2 * n)})


def connected_repair_cost(n):
    """Minimum extra length needed to connect the alternating selected edges.

    Steiner branching cannot improve this cost by the cited regular-polygon
    theorem. Adding every unselected odd edge except one attains it.
    """
    n, _ = _validate(n)
    return (n - 1) * side_length(n)


def penalized_optimum(n, component_penalty):
    """Exact minimum of length + lambda*(actual component count).

    On the frontier the objective is affine in K. The optimizer is the
    alternating construction for lambda<d, a connected path for lambda>d,
    and every K=1,...,n at lambda=d. No continuum/full-opacity assertion is
    made by this finite-audit penalization formula.
    """
    n, _ = _validate(n)
    penalty = float(component_penalty)
    if not math.isfinite(penalty) or penalty < 0:
        raise ValueError("Component penalty must be finite and nonnegative")
    d = side_length(n)
    connected = (2 * n - 1) * d + penalty
    alternating = n * d + n * penalty
    if penalty < d:
        minimizers = [n]
        phase = "n components"
    elif penalty > d:
        minimizers = [1]
        phase = "one component"
    else:
        minimizers = list(range(1, n + 1))
        phase = "all component counts tie"
    return {"value": min(connected, alternating),
            "connected_branch": connected, "alternating_branch": alternating,
            "threshold": d, "penalty": penalty,
            "minimizing_component_counts": minimizers, "phase": phase}


def joint_penalty_limit(c):
    """Limit when lambda_n->0 and n*lambda_n->c>=0: min(2*pi,pi+c)."""
    c = float(c)
    if not math.isfinite(c) or c < 0:
        raise ValueError("The scaled limiting penalty must be finite and nonnegative")
    return min(2 * PI, PI + c)


def repair_segments(n, omitted_odd_edge=1):
    n, _ = _validate(n)
    omitted_odd_edge = int(omitted_odd_edge) % (2 * n)
    if omitted_odd_edge % 2 != 1:
        raise ValueError("The omitted edge must be unselected (odd indexed)")
    vertices = regular_vertices(n)
    indices = np.array([j for j in range(1, 2 * n, 2) if j != omitted_odd_edge])
    return np.stack((vertices[indices], vertices[(indices + 1) % (2 * n)]), axis=1)