autorouter.py

"""
KiCAD Autorouter — A* maze routing with rip-up and reroute.

Key features
------------
- Reads track width, clearance and via constraints directly from the board's
  design settings and default net class (respects DRC rules).
- Per-net track widths are read from KiCAD net classes and applied when placing
  each connection.
- Copper zones are filled before routing; pad pairs already connected through a
  zone are skipped (no wire needed).
- Supports 45° diagonal routing (default) or strict 90° routing.
- Supports 2-layer and multi-layer (4, 6, … copper layer) boards.
- Two-phase routing: first attempts a single-layer (via-free) path; only
  inserts vias when no single-layer solution exists.
- Minimises trace length and via count.
- run_rur(): AI-guided rip-up and reroute, configurable attempt budget
  (default 100 total routing attempts across all connections).
- Router-cost settings (via cost, turn cost, layer costs) are persistent and
  saved to ~/.kicad_autorouter_settings.json.

Quick start (scripting console):
    import sys; sys.path.insert(0, '/path/to/kicad_autorouter')
    from autorouter import KiCADAutorouter
    routed, failed, total = KiCADAutorouter().run_rur()

With AI guidance:
    from ai_advisor import RouteAdvisor
    routed, failed, total = KiCADAutorouter().run_rur(advisor=RouteAdvisor())
"""

import heapq
import json
import math
import os
from collections import deque
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Set, Tuple

import pcbnew

# ── A* cost weight defaults (tunable via dialog) ───────────────────────────────

_DEFAULT_VIA_COST  = 40   # penalty per layer switch (>> 1 so vias are genuinely avoided)
_DEFAULT_TURN_COST = 1    # small: keeps wire count low without inflating total length

# ── Search limit ──────────────────────────────────────────────────────────────

MAX_ITER = 3_000_000   # A* iterations before declaring a connection unroutable

# ── Fallback constants (used only when board has no constraints set) ──────────

_FB_TRACK_MM      = 0.2
_FB_CLEARANCE_MM  = 0.2
_FB_VIA_SIZE_MM   = 0.6
_FB_VIA_DRILL_MM  = 0.3
_FB_GRID_MM       = 0.1

def _nm(mm: float) -> int:
    return int(pcbnew.FromMM(mm))


# ── Persistent user-settings file ────────────────────────────────────────────

_SETTINGS_FILE = os.path.expanduser("~/.kicad_autorouter_settings.json")

def _load_defaults() -> dict:
    try:
        with open(_SETTINGS_FILE) as f:
            return json.load(f)
    except Exception:
        return {}

def _save_defaults(settings: dict) -> None:
    try:
        with open(_SETTINGS_FILE, "w") as f:
            json.dump(settings, f, indent=2)
    except Exception as exc:
        print(f"[router] Could not save defaults: {exc}")


# Physical inner-layer constants in stackup order (KiCAD 10)
_INNER_CU_ATTRS = [f"In{i}_Cu" for i in range(1, 31)]

# Move direction sets: 4-directional (90°) and 8-directional (45°)
_DIRS_4 = ((1, 0), (-1, 0), (0, 1), (0, -1))
_DIRS_8 = (
    (1, 0), (-1, 0), (0, 1), (0, -1),
    (1, 1), (-1, 1), (1, -1), (-1, -1),
)


# ── Board constraints reader ──────────────────────────────────────────────────

@dataclass
class BoardConstraints:
    """
    Reads routing constraints from the board's design settings and default
    net class.  All dimensions are in KiCAD internal units (nanometres).
    """
    track_w:   int
    clearance: int
    via_size:  int
    via_drill: int
    cu_layers: List[int]   # copper layer IDs in physical stackup order

    @classmethod
    def from_board(cls, board) -> "BoardConstraints":
        ds = board.GetDesignSettings()

        # Default net class — may be None on a brand-new empty board
        nc = board.GetAllNetClasses().get("Default")

        def _nc(method: str) -> int:
            if nc is None:
                return 0
            try:
                return int(getattr(nc, method)())
            except Exception:
                return 0

        # Track width: strictest of board minimum and netclass value
        track_w = max(
            ds.m_TrackMinWidth or 0,
            _nc("GetTrackWidth"),
        ) or _nm(_FB_TRACK_MM)

        # Clearance
        clearance = max(
            ds.m_MinClearance or 0,
            _nc("GetClearance"),
        ) or _nm(_FB_CLEARANCE_MM)

        # Via outer diameter
        via_size = max(
            ds.m_ViasMinSize or 0,
            _nc("GetViaDiameter"),
        ) or _nm(_FB_VIA_SIZE_MM)

        # Via drill
        via_drill = max(
            ds.m_MinThroughDrill or 0,
            _nc("GetViaDrill"),
        ) or _nm(_FB_VIA_DRILL_MM)

        return cls(
            track_w   = track_w,
            clearance = clearance,
            via_size  = via_size,
            via_drill = via_drill,
            cu_layers = cls._enumerate_cu_layers(board),
        )

    @staticmethod
    def _enumerate_cu_layers(board) -> List[int]:
        """Return copper layer IDs in physical stackup order."""
        n = board.GetCopperLayerCount()
        layers = [pcbnew.F_Cu]
        n_inner = max(0, n - 2)
        for attr in _INNER_CU_ATTRS[:n_inner]:
            lid = getattr(pcbnew, attr, None)
            if lid is not None:
                layers.append(lid)
        layers.append(pcbnew.B_Cu)
        return layers

    @property
    def n_layers(self) -> int:
        return len(self.cu_layers)

    def kicad_layer(self, li: int) -> int:
        """Grid layer index → KiCAD layer ID."""
        return self.cu_layers[li]

    def grid_index(self, kicad_layer: int) -> Optional[int]:
        """KiCAD layer ID → grid layer index, or None if not a routed layer."""
        try:
            return self.cu_layers.index(kicad_layer)
        except ValueError:
            return None

    def summary(self) -> str:
        mm = pcbnew.ToMM
        return (
            f"track={mm(self.track_w):.3f}mm  "
            f"clearance={mm(self.clearance):.3f}mm  "
            f"via={mm(self.via_size):.3f}mm drill={mm(self.via_drill):.3f}mm  "
            f"layers={self.n_layers} {[self.kicad_layer(i) for i in range(self.n_layers)]}"
        )


# ── Routing grid ──────────────────────────────────────────────────────────────

class RoutingGrid:
    """
    N-layer flat bytearray occupancy grid.
    All public methods that accept world coordinates expect KiCAD nm integers.
    """

    def __init__(self, bbox, n_layers: int = 2, grid_nm: int = 0):
        self.grid_nm = grid_nm or _nm(_FB_GRID_MM)
        self.ox      = bbox.GetX()
        self.oy      = bbox.GetY()
        self.cols    = max(1, bbox.GetWidth()  // self.grid_nm + 3)
        self.rows    = max(1, bbox.GetHeight() // self.grid_nm + 3)
        self.n_layers = n_layers
        self._obs = [bytearray(self.cols * self.rows) for _ in range(n_layers)]

    # ── coordinate conversion ─────────────────────────────────────────────

    def w2g(self, wx: int, wy: int) -> Tuple[int, int]:
        return (wx - self.ox) // self.grid_nm, (wy - self.oy) // self.grid_nm

    def g2w(self, c: int, r: int) -> Tuple[int, int]:
        g = self.grid_nm
        return self.ox + c * g + g // 2, self.oy + r * g + g // 2

    def in_bounds(self, c: int, r: int) -> bool:
        return 0 <= c < self.cols and 0 <= r < self.rows

    # ── obstacle primitives ───────────────────────────────────────────────

    def _idx(self, c: int, r: int) -> int:
        return r * self.cols + c

    def is_obs(self, c: int, r: int, li: int) -> bool:
        if not self.in_bounds(c, r) or li < 0 or li >= self.n_layers:
            return True
        return bool(self._obs[li][self._idx(c, r)])

    def set_obs(self, c: int, r: int, li: int) -> None:
        if self.in_bounds(c, r) and 0 <= li < self.n_layers:
            self._obs[li][self._idx(c, r)] = 1

    def clear_obs(self, c: int, r: int, li: int) -> None:
        if self.in_bounds(c, r) and 0 <= li < self.n_layers:
            self._obs[li][self._idx(c, r)] = 0

    def block_disk(self, c: int, r: int, li: int, radius: int) -> None:
        r2 = radius * radius + radius
        for dr in range(-radius, radius + 1):
            for dc in range(-radius, radius + 1):
                if dc * dc + dr * dr <= r2:
                    self.set_obs(c + dc, r + dr, li)

    def block_rect(
        self,
        wx0: int, wy0: int, wx1: int, wy1: int,
        li: int,
        margin_nm: int = 0,
    ) -> None:
        g = self.grid_nm
        c0, r0 = self.w2g(wx0 - margin_nm, wy0 - margin_nm)
        c1, r1 = self.w2g(wx1 + margin_nm, wy1 + margin_nm)
        for r in range(max(0, r0), min(self.rows, r1 + 2)):
            for c in range(max(0, c0), min(self.cols, c1 + 2)):
                self._obs[li][self._idx(c, r)] = 1

    def block_segment(
        self,
        wx0: int, wy0: int, wx1: int, wy1: int,
        li: int,
        margin_nm: int = 0,
    ) -> None:
        c0, r0 = self.w2g(wx0, wy0)
        c1, r1 = self.w2g(wx1, wy1)
        steps = max(abs(c1 - c0), abs(r1 - r0), 1)
        m = max(1, margin_nm // self.grid_nm)
        for i in range(steps + 1):
            t = i / steps
            c = round(c0 + t * (c1 - c0))
            r = round(r0 + t * (r1 - r0))
            self.block_disk(c, r, li, m)


# ── A* path search ─────────────────────────────────────────────────────────────

def _astar(
    grid:        RoutingGrid,
    sc: int, sr: int, sl: int,
    ec: int, er: int, el: int,
    start_clear: int = 0,
    end_clear:   int = 0,
    allow_vias:  bool = True,
    via_grid:    Optional[RoutingGrid] = None,
    via_cost:    int = _DEFAULT_VIA_COST,
    turn_cost:   int = _DEFAULT_TURN_COST,
    use_45:      bool = False,
    layer_costs: Optional[List[int]] = None,
) -> Optional[List[Tuple[int, int, int]]]:
    """
    A* from (sc, sr, sl) to (ec, er).  Preferred arrival layer is el.

    start_clear / end_clear: Manhattan radius around start / end that ignores
    obstacles — needed to exit / enter the pad's clearance zone.

    allow_vias: if False, layer transitions are forbidden (single-layer mode).

    use_45: if True, 8-directional movement (45° diagonals allowed);
            otherwise 4-directional (90° only).

    layer_costs: per-layer move cost multipliers; index matches grid layer index.
                 None means all layers cost 1.

    Returns list of (col, row, layer_idx) or None.
    """
    n    = grid.n_layers
    dirs = _DIRS_8 if use_45 else _DIRS_4

    def passable(nc: int, nr: int, li: int) -> bool:
        if not grid.in_bounds(nc, nr) or li < 0 or li >= n:
            return False
        if (nc, nr) == (ec, er):
            return True
        if start_clear and abs(nc - sc) + abs(nr - sr) <= start_clear:
            return True
        if end_clear and abs(nc - ec) + abs(nr - er) <= end_clear:
            return True
        return not grid.is_obs(nc, nr, li)

    def h(c: int, r: int, li: int) -> int:
        if use_45:
            # Chebyshev distance — admissible for 8-directional grid
            dist = max(abs(c - ec), abs(r - er))
        else:
            dist = abs(c - ec) + abs(r - er)
        layer_dist = abs(li - el) if allow_vias else 0
        return dist + layer_dist * via_cost

    INF = MAX_ITER * 10
    g_best: Dict[Tuple[int, int, int], int] = {(sc, sr, sl): 0}
    came_from: Dict[Tuple[int, int, int], Optional[Tuple[int, int, int]]] = {
        (sc, sr, sl): None
    }
    # heap: (f, g, col, row, layer, prev_dc, prev_dr, _)
    heap: list = [(h(sc, sr, sl), 0, sc, sr, sl, 0, 0, None)]

    iters = 0
    while heap and iters < MAX_ITER:
        iters += 1
        f, g, c, r, li, pdc, pdr, _ = heapq.heappop(heap)

        key = (c, r, li)
        if g > g_best.get(key, INF):
            continue

        if (c, r) == (ec, er):
            path: List[Tuple[int, int, int]] = []
            k: Optional[Tuple[int, int, int]] = key
            while k is not None:
                path.append(k)
                k = came_from[k]
            path.reverse()
            return path

        # Same-layer moves
        for dc, dr in dirs:
            nc, nr = c + dc, r + dr
            # Prevent diagonal corner-cutting: both orthogonal neighbours must be clear
            if dc != 0 and dr != 0:
                if grid.is_obs(c + dc, r, li) or grid.is_obs(c, r + dr, li):
                    continue
            if not passable(nc, nr, li):
                continue
            turn = turn_cost if (pdc, pdr) not in ((0, 0), (dc, dr)) else 0
            lc   = layer_costs[li] if layer_costs else 1
            ng   = g + lc + turn
            nkey = (nc, nr, li)
            if ng < g_best.get(nkey, INF):
                g_best[nkey] = ng
                came_from[nkey] = key
                heapq.heappush(heap, (ng + h(nc, nr, li), ng, nc, nr, li, dc, dr, key))

        # Via: transition to any other layer (through-hole via model).
        # Use via_grid for a strict all-layers check — no start/end bypass,
        # preventing vias from being placed inside pad clearance zones.
        if allow_vias and via_grid is not None:
            if not any(via_grid.is_obs(c, r, li2) for li2 in range(n)):
                for other in range(n):
                    if other == li:
                        continue
                    ng   = g + via_cost
                    nkey = (c, r, other)
                    if ng < g_best.get(nkey, INF):
                        g_best[nkey] = ng
                        came_from[nkey] = key
                        heapq.heappush(heap, (ng + h(c, r, other), ng, c, r, other, 0, 0, key))

    return None


# ── Main autorouter class ──────────────────────────────────────────────────────

class KiCADAutorouter:
    """
    Routes all unconnected pads on a KiCAD board.

    Constraints are read automatically from the board's design settings.
    Override any constraint by setting the corresponding attribute before
    calling run() / run_rur():
        router.track_mm      = 0.15   # override track width in mm
        router.clearance_mm  = 0.15
        router.via_size_mm   = 0.5
        router.via_drill_mm  = 0.25
        router.grid_mm       = 0.05   # finer grid for dense boards
        router.via_cost      = 40     # A* via penalty
        router.turn_cost     = 1      # A* turn penalty
        router.inner_layer_cost = None  # None → auto (prefer emptiest layer by density)
        router.use_45_degree = True   # allow 45° diagonal traces
        router.fill_zones    = True   # fill zones before routing
    """

    def __init__(self, board=None):
        self.board = board or pcbnew.GetBoard()

        # Physical constraint overrides — None means "read from board"
        self.track_mm     = None
        self.clearance_mm = None
        self.via_size_mm  = None
        self.via_drill_mm = None
        self.grid_mm      = None

        # Router cost overrides
        self.via_cost         = None   # None → _DEFAULT_VIA_COST
        self.turn_cost        = None   # None → _DEFAULT_TURN_COST
        self.inner_layer_cost = None   # None → 1 (equal preference for all layers)

        # Routing mode
        self.use_45_degree = True    # default: allow 45° diagonal traces
        self.fill_zones    = True    # default: fill zones before routing

        # Runtime state (set by _init_run)
        self._cst:               Optional[BoardConstraints]          = None
        self._grid:              Optional[RoutingGrid]               = None
        self._via_grid:          Optional[RoutingGrid]               = None
        self._bbox                                                   = None
        self._grid_nm:           int                                 = 0
        self._margin:            int                                 = 0
        self._margin_cells:      int                                 = 0
        self._via_margin:        int                                 = 0
        self._via_margin_cells:  int                                 = 0
        self._via_cost:          int                                 = _DEFAULT_VIA_COST
        self._turn_cost:         int                                 = _DEFAULT_TURN_COST
        self._layer_costs:       Optional[List[int]]                 = None
        self._use_45:            bool                                = True
        self._net_track_w:       Dict[int, int]                      = {}
        self._conn_tracks:       Dict[int, list]                     = {}
        self._conn_cells:        Dict[int, Set[Tuple[int,int,int]]]  = {}
        self._cell_to_conn:      Dict[Tuple[int,int,int], int]       = {}
        self._conn_via_cells:    Dict[int, Set[Tuple[int,int]]]      = {}
        self._conn_margin_cells: Dict[int, int]                      = {}

    # ── public entry points ───────────────────────────────────────────────

    def run(self, progress_cb=None) -> Tuple[int, int, int]:
        """Single-pass routing (no rip-up). Returns (routed, failed, total)."""
        self._init_run()
        connections = self._build_mst_connections()
        total = len(connections)
        routed = failed = 0
        for i, (net, pa, pb) in enumerate(connections):
            if progress_cb:
                progress_cb(i, total, net.GetNetname())
            if self._route_one(net, pa, pb, conn_id=i):
                routed += 1
            else:
                failed += 1
        pcbnew.Refresh()
        return routed, failed, total

    def run_rur(
        self,
        advisor=None,
        max_retries: int = 100,
        progress_cb=None,
    ) -> Tuple[int, int, int]:
        """
        Rip-up and reroute with optional AI guidance.

        max_retries: maximum number of rip-up retries *per connection* before
                     that connection is declared permanently failed.  Every
                     connection is always attempted at least once regardless of
                     this value.  Default 100.
        advisor:     RouteAdvisor instance for AI-assisted ordering and rip-up
                     decisions.  Falls back to built-in heuristics when None
                     or when the API is unavailable.

        Returns (routed, failed, total) where failed = total - routed, so the
        numbers always add up correctly.
        """
        self._init_run()
        connections = self._build_mst_connections()
        total = len(connections)
        if total == 0:
            return 0, 0, 0

        conn_meta = self._build_conn_meta(connections)

        # Per-connection retry counter (separate from "was it attempted" tracking)
        ripup_count: Dict[int, int] = {i: 0 for i in range(total)}

        # AI or heuristic initial ordering
        ordered = self._get_order(advisor, conn_meta, connections, pass_num=0)

        queue       = deque(ordered)
        routed_set: Set[int] = set()
        perm_failed: Set[int] = set()
        stuck_since: int      = 0

        while queue:
            conn_id = queue.popleft()
            if conn_id in routed_set or conn_id in perm_failed:
                continue

            net, pa, pb = connections[conn_id]
            retry_num   = ripup_count[conn_id]
            conn_meta[conn_id]["attempts"] = retry_num + 1

            if progress_cb:
                pending = len(queue)
                progress_cb(
                    len(routed_set),
                    total,
                    f"{net.GetNetname()}  "
                    f"[retry {retry_num}/{max_retries}, "
                    f"routed {len(routed_set)}/{total}, "
                    f"pending {pending}]",
                )

            if self._route_one(net, pa, pb, conn_id=conn_id):
                routed_set.add(conn_id)
                stuck_since = 0
                continue

            # Route failed — find what's blocking it
            blockers = [b for b in self._find_blockers(net, pa, pb) if b in routed_set]
            stuck_since += 1

            # Geometrically impossible regardless of other routes
            if not blockers:
                perm_failed.add(conn_id)
                continue

            # Retry budget for this connection exhausted
            if ripup_count[conn_id] >= max_retries:
                perm_failed.add(conn_id)
                continue

            # Decide what to rip up (AI or heuristic)
            re_query = stuck_since > 0 and stuck_since % 5 == 0
            to_ripup = self._decide_ripup(
                advisor, conn_id, blockers, conn_meta,
                ask_ai=re_query,
            )

            for rid in to_ripup:
                self._ripup_connection(rid)
                routed_set.discard(rid)
                perm_failed.discard(rid)
                queue.appendleft(rid)

            ripup_count[conn_id] += 1
            queue.appendleft(conn_id)

            # Periodically re-ask AI to reorder the pending work
            if re_query and advisor is not None and len(queue) > 1:
                remaining_ids = list(dict.fromkeys(queue))
                try:
                    reordered = self._get_order(
                        advisor, conn_meta, connections,
                        pass_num=sum(ripup_count.values()),
                        subset=remaining_ids,
                    )
                    queue = deque(reordered)
                except Exception:
                    pass

        pcbnew.Refresh()
        routed = len(routed_set)
        return routed, total - routed, total

    def unroute_all(self) -> None:
        for t in list(self.board.GetTracks()):
            self.board.Remove(t)
        pcbnew.Refresh()

    def constraints_summary(self) -> str:
        if self._cst is None:
            cst = BoardConstraints.from_board(self.board)
        else:
            cst = self._cst
        return cst.summary()

    # ── initialisation ────────────────────────────────────────────────────

    def _init_run(self) -> None:
        board = self.board
        cst   = BoardConstraints.from_board(board)
        self._cst = cst

        # Apply physical constraint overrides
        self._track_w = _nm(self.track_mm)     if self.track_mm     else cst.track_w
        self._clear   = _nm(self.clearance_mm) if self.clearance_mm else cst.clearance
        self._via_sz  = _nm(self.via_size_mm)  if self.via_size_mm  else cst.via_size
        self._via_dr  = _nm(self.via_drill_mm) if self.via_drill_mm else cst.via_drill
        self._grid_nm = _nm(self.grid_mm)      if self.grid_mm      else _nm(_FB_GRID_MM)

        # Per-net track widths from KiCAD net classes
        self._net_track_w = self._build_net_width_map()

        # Use maximum net track width for obstacle margins so the grid is
        # conservative enough regardless of which net is being routed.
        max_tw = max(self._net_track_w.values(), default=self._track_w)
        self._margin       = self._clear + max_tw // 2
        self._margin_cells = max(1, self._margin // self._grid_nm)

        # Via clearance: via_outer_radius + clearance
        self._via_margin       = self._via_sz // 2 + self._clear
        self._via_margin_cells = max(1, self._via_margin // self._grid_nm)

        # Router cost parameters
        self._via_cost  = self.via_cost  if self.via_cost  is not None else _DEFAULT_VIA_COST
        self._turn_cost = self.turn_cost if self.turn_cost is not None else _DEFAULT_TURN_COST
        self._use_45    = self.use_45_degree

        bbox = board.GetBoardEdgesBoundingBox()
        if bbox.GetWidth() == 0 or bbox.GetHeight() == 0:
            bbox = board.GetBoundingBox()
        self._bbox = bbox

        self._grid         = RoutingGrid(bbox, cst.n_layers, self._grid_nm)
        self._via_grid     = RoutingGrid(bbox, cst.n_layers, self._grid_nm)
        self._conn_tracks  = {}
        self._conn_cells   = {}
        self._cell_to_conn = {}
        self._conn_via_cells    = {}
        self._conn_margin_cells = {}

        # Fill zones before marking obstacles so that zone-connected pad pairs
        # can be detected and skipped during MST building.
        if self.fill_zones:
            self._fill_zones()

        self._mark_obstacles(self._grid)
        self._mark_via_obstacles(self._via_grid)

        # Per-layer move costs: if inner_layer_cost is set, use the old static
        # model (inner layers cost more to prefer surface layers).  Otherwise,
        # compute costs dynamically from obstacle density so that A* naturally
        # prefers routing on the emptiest layer (e.g. a free inner plane).
        n_layers = cst.n_layers
        if self.inner_layer_cost is not None:
            ilc = max(1, self.inner_layer_cost)
            self._layer_costs = [1] * n_layers
            for i in range(1, n_layers - 1):
                self._layer_costs[i] = ilc
        else:
            self._layer_costs = self._density_layer_costs(self._grid)

        print(f"[router] Constraints: {cst.summary()}")
        print(f"[router] Layer costs: {self._layer_costs}")

    # ── layer congestion costs ────────────────────────────────────────────

    @staticmethod
    def _density_layer_costs(grid: RoutingGrid) -> List[int]:
        """
        Compute per-layer A* move costs from obstacle density.

        The emptiest layer gets cost 1.  Other layers scale up proportionally,
        capped at 8×.  This lets A* discover free inner layers as natural
        highways without needing an explicit via-then-inner detour.
        """
        occupied = [sum(grid._obs[li]) for li in range(grid.n_layers)]
        min_occ  = max(1, min(occupied))
        costs    = [max(1, min(8, round(occ / min_occ))) for occ in occupied]
        return costs

    # ── per-net track width map ───────────────────────────────────────────

    def _build_net_width_map(self) -> Dict[int, int]:
        """Return a dict mapping net code → track width in nm."""
        all_classes = self.board.GetAllNetClasses()
        result: Dict[int, int] = {}
        for fp in self.board.GetFootprints():
            for pad in fp.Pads():
                nc_val = pad.GetNetCode()
                if nc_val in result or nc_val <= 0:
                    continue
                try:
                    nc_name = pad.GetNet().GetNetClassName()
                    nc = all_classes.get(nc_name)
                    if nc is not None:
                        w = int(nc.GetTrackWidth())
                        if w > 0:
                            result[nc_val] = w
                            continue
                except Exception:
                    pass
                result[nc_val] = self._track_w
        return result

    # ── zone fill and zone-connectivity helpers ───────────────────────────

    def _fill_zones(self) -> None:
        try:
            filler = pcbnew.ZONE_FILLER(self.board)
            filler.Fill(self.board.Zones())
            pcbnew.Refresh()
            print("[router] Copper zones filled.")
        except Exception as exc:
            print(f"[router] Zone fill skipped: {exc}")

    def _pad_in_zone(self, pad, zone) -> bool:
        """True if pad is electrically inside the given copper zone."""
        if not zone.IsOnCopperLayer():
            return False
        zone_layer = zone.GetLayer()
        try:
            pth = pad.GetAttribute() == pcbnew.PAD_ATTRIB_PTH
            if not pth and not pad.IsOnLayer(zone_layer):
                return False
            pt = pcbnew.VECTOR2I(pad.GetX(), pad.GetY())
            return zone.Outline().Contains(pt)
        except Exception:
            return False

    # ── obstacle marking ──────────────────────────────────────────────────

    def _pad_layer_indices(self, pad) -> List[int]:
        cst = self._cst
        indices = [i for i, lid in enumerate(cst.cu_layers) if pad.IsOnLayer(lid)]
        return indices or [0]

    def _mark_pads(self, grid: RoutingGrid, margin: int) -> None:
        cst = self._cst
        for fp in self.board.GetFootprints():
            for pad in fp.Pads():
                cx, cy = pad.GetX(), pad.GetY()
                sx, sy = pad.GetSizeX() // 2, pad.GetSizeY() // 2
                pli = self._pad_layer_indices(pad)
                if len(pli) == grid.n_layers or pad.GetAttribute() == pcbnew.PAD_ATTRIB_PTH:
                    pli = list(range(grid.n_layers))
                for li in pli:
                    grid.block_rect(cx - sx, cy - sy, cx + sx, cy + sy, li, margin)

    def _mark_obstacles(self, grid: RoutingGrid) -> None:
        cst    = self._cst
        margin = self._margin
        self._mark_pads(grid, margin)

        for track in self.board.GetTracks():
            cls = track.GetClass()
            if cls == "PCB_TRACK":
                li = cst.grid_index(track.GetLayer())
                if li is not None:
                    s, e = track.GetStart(), track.GetEnd()
                    grid.block_segment(s.x, s.y, e.x, e.y, li, margin)
            elif cls in ("PCB_VIA", "VIA"):
                cx, cy = track.GetX(), track.GetY()
                r = track.GetWidth() // 2
                for li in range(grid.n_layers):
                    grid.block_rect(cx - r, cy - r, cx + r, cy + r, li, margin)

    def _mark_via_obstacles(self, grid: RoutingGrid) -> None:
        """
        Build a separate grid for via-centre validity.

        Every cell (c, r) that is set means a new via centred there would
        violate DRC.  Three types of expansion:
          • pads / via holes  → via_sz/2 + clearance beyond pad edge
          • existing vias     → same margin beyond existing via edge
          • existing tracks   → via_sz/2 + track_w/2 + clearance from track centre
        """
        cst = self._cst
        r_v              = self._via_sz // 2
        via_pad_margin   = r_v + self._clear
        via_track_margin = r_v + self._track_w // 2 + self._clear

        # Pads
        for fp in self.board.GetFootprints():
            for pad in fp.Pads():
                cx, cy = pad.GetX(), pad.GetY()
                sx, sy = pad.GetSizeX() // 2, pad.GetSizeY() // 2
                pli = self._pad_layer_indices(pad)
                if len(pli) == grid.n_layers or pad.GetAttribute() == pcbnew.PAD_ATTRIB_PTH:
                    pli = list(range(grid.n_layers))
                for li in pli:
                    grid.block_rect(cx - sx, cy - sy, cx + sx, cy + sy, li, via_pad_margin)

        # Tracks and vias already on the board
        for track in self.board.GetTracks():
            cls = track.GetClass()
            if cls == "PCB_TRACK":
                li = cst.grid_index(track.GetLayer())
                if li is not None:
                    s, e = track.GetStart(), track.GetEnd()
                    grid.block_segment(s.x, s.y, e.x, e.y, li, via_track_margin)
            elif cls in ("PCB_VIA", "VIA"):
                cx, cy = track.GetX(), track.GetY()
                r = track.GetWidth() // 2
                for li in range(grid.n_layers):
                    grid.block_rect(cx - r, cy - r, cx + r, cy + r, li, via_pad_margin)

    # ── connection extraction ─────────────────────────────────────────────

    def _build_mst_connections(self) -> List[Tuple]:
        """
        Build minimum-spanning-tree connections for all nets.

        Pads that are already connected through a filled copper zone are
        pre-joined in a union-find structure so that no wire is routed
        between them.
        """
        net_pads: Dict[int, list] = {}
        for fp in self.board.GetFootprints():
            for pad in fp.Pads():
                nc = pad.GetNetCode()
                if nc > 0:
                    net_pads.setdefault(nc, []).append(pad)

        connections = []
        for pads in net_pads.values():
            if len(pads) < 2:
                continue

            n = len(pads)
            parent = list(range(n))

            def find(x: int) -> int:
                while parent[x] != x:
                    parent[x] = parent[parent[x]]
                    x = parent[x]
                return x

            def union(x: int, y: int) -> None:
                px, py = find(x), find(y)
                if px != py:
                    parent[px] = py

            # Pre-connect pads that share a filled copper zone of their net
            net_code = pads[0].GetNetCode()
            for zone in self.board.Zones():
                if zone.GetNetCode() != net_code or not zone.IsFilled():
                    continue
                zone_pad_indices = [
                    i for i, p in enumerate(pads) if self._pad_in_zone(p, zone)
                ]
                for k in range(1, len(zone_pad_indices)):
                    union(zone_pad_indices[0], zone_pad_indices[k])

            # Prim's MST over the resulting components
            in_tree: Set[int] = {find(0)}

            while True:
                best = None
                for i in range(n):
                    if find(i) not in in_tree:
                        continue
                    for j in range(n):
                        if find(j) in in_tree:
                            continue
                        d = self._dist2(pads[i], pads[j])
                        if best is None or d < best[0]:
                            best = (d, i, j)

                if best is None:
                    break

                _, a, b = best
                connections.append((pads[a].GetNet(), pads[a], pads[b]))
                comp_b = find(b)
                in_tree.add(comp_b)

        return connections

    def _dist2(self, pa, pb) -> int:
        return (pa.GetX() - pb.GetX()) ** 2 + (pa.GetY() - pb.GetY()) ** 2

    def _build_conn_meta(self, connections) -> Dict[int, dict]:
        meta = {}
        for i, (net, pa, pb) in enumerate(connections):
            length_mm = math.hypot(
                (pa.GetX() - pb.GetX()) / 1e6,
                (pa.GetY() - pb.GetY()) / 1e6,
            )
            meta[i] = {
                "id":        i,
                "net":       net.GetNetname(),
                "start_mm":  (pa.GetX() / 1e6, pa.GetY() / 1e6),
                "end_mm":    (pb.GetX() / 1e6, pb.GetY() / 1e6),
                "length_mm": length_mm,
                "attempts":  0,
            }
        return meta

    # ── routing one connection ────────────────────────────────────────────

    def _pad_clear_cells(self, pad) -> int:
        half = max(pad.GetSizeX(), pad.GetSizeY()) // 2
        return max(1, (half + self._margin) // self._grid_nm + 1)

    def _route_one(self, net, pad_a, pad_b, conn_id: int = -1) -> bool:
        """
        Two-phase routing:
          Phase 1 — via-free (single layer).  Minimises via count.
          Phase 2 — vias allowed.  Used only when Phase 1 fails.
        """
        grid     = self._grid
        via_grid = self._via_grid

        # Per-net track width and corresponding margin
        track_w = self._net_track_w.get(net.GetNetCode(), self._track_w)
        net_margin       = self._clear + track_w // 2
        net_margin_cells = max(1, net_margin // self._grid_nm)

        sc, sr = grid.w2g(pad_a.GetX(), pad_a.GetY())
        ec, er = grid.w2g(pad_b.GetX(), pad_b.GetY())
        sl = self._pad_layer_indices(pad_a)[0]
        el = self._pad_layer_indices(pad_b)[0]
        sc2 = self._pad_clear_cells(pad_a)
        ec2 = self._pad_clear_cells(pad_b)

        _astar_kw = dict(
            via_cost    = self._via_cost,
            turn_cost   = self._turn_cost,
            use_45      = self._use_45,
            layer_costs = self._layer_costs,
        )

        # Phase 1: no vias
        path = _astar(grid, sc, sr, sl, ec, er, el, sc2, ec2,
                      allow_vias=False, via_grid=via_grid, **_astar_kw)

        # Phase 2: allow vias only if needed
        if path is None:
            path = _astar(grid, sc, sr, sl, ec, er, el, sc2, ec2,
                          allow_vias=True, via_grid=via_grid, **_astar_kw)

        if path is None:
            return False

        # Identify via positions and pre-validate them
        via_positions: Set[Tuple[int, int]] = set()
        for i in range(len(path) - 1):
            c, r, li = path[i]
            _, _, nli = path[i + 1]
            if li != nli:
                via_positions.add((c, r))
                if not self._can_place_via(c, r):
                    mm = pcbnew.ToMM
                    wx, wy = grid.g2w(c, r)
                    print(
                        f"[router] WARN: via at "
                        f"({mm(wx):.2f}, {mm(wy):.2f}) mm "
                        f"failed safety check — connection skipped"
                    )
                    return False

        self._place_path(path, net, conn_id, track_w=track_w)

        if conn_id >= 0:
            self._conn_cells[conn_id]         = set(path)
            self._conn_via_cells[conn_id]     = via_positions
            self._conn_margin_cells[conn_id]  = net_margin_cells
            for cell in path:
                self._cell_to_conn[cell] = conn_id

        m  = net_margin_cells
        vm = self._via_margin_cells
        n  = grid.n_layers

        # Block track path (per-layer, track margin)
        for c, r, li in path:
            grid.block_disk(c, r, li, m)

        # Block via positions on ALL layers in both grids to prevent duplicates
        for vc, vr in via_positions:
            for li in range(n):
                grid.block_disk(vc, vr, li, m)
                via_grid.block_disk(vc, vr, li, vm)

        return True

    def _place_path(
        self,
        path: List[Tuple[int, int, int]],
        net,
        conn_id: int = -1,
        track_w: Optional[int] = None,
    ) -> None:
        board    = self.board
        grid     = self._grid
        cst      = self._cst
        tw       = track_w if track_w is not None else self._track_w

        i = 0
        while i < len(path) - 1:
            c,  r,  li  = path[i]
            nc, nr, nli = path[i + 1]

            if li != nli:
                # Layer change → through-hole via (spans all layers)
                wx, wy = grid.g2w(c, r)
                via = pcbnew.PCB_VIA(board)
                pt  = pcbnew.VECTOR2I(int(wx), int(wy))
                via.SetStart(pt)
                via.SetEnd(pt)
                via.SetWidth(self._via_sz)
                via.SetDrill(self._via_dr)
                via.SetNet(net)
                via.SetLayerPair(cst.cu_layers[0], cst.cu_layers[-1])
                board.Add(via)
                if conn_id >= 0:
                    self._conn_tracks.setdefault(conn_id, []).append(via)
                i += 1
                continue

            # Coalesce collinear same-layer steps into one PCB_TRACK
            dc, dr = nc - c, nr - r
            j = i + 1
            while j < len(path) - 1:
                c2, r2, li2 = path[j]
                c3, r3, li3 = path[j + 1]
                if li2 != li or (c3 - c2, r3 - r2) != (dc, dr):
                    break
                j += 1

            x0, y0 = grid.g2w(c,          r)
            x1, y1 = grid.g2w(path[j][0], path[j][1])

            track = pcbnew.PCB_TRACK(board)
            track.SetStart(pcbnew.VECTOR2I(int(x0), int(y0)))
            track.SetEnd(pcbnew.VECTOR2I(int(x1), int(y1)))
            track.SetWidth(tw)
            track.SetLayer(cst.kicad_layer(li))
            track.SetNet(net)
            board.Add(track)
            if conn_id >= 0:
                self._conn_tracks.setdefault(conn_id, []).append(track)

            i = j

    def _can_place_via(self, gc: int, gr: int) -> bool:
        """True if a via centred at grid cell (gc, gr) passes all-layers DRC."""
        return not any(
            self._via_grid.is_obs(gc, gr, li)
            for li in range(self._cst.n_layers)
        )

    # ── rip-up ────────────────────────────────────────────────────────────

    def _ripup_connection(self, conn_id: int) -> None:
        """Remove tracks/vias, clear ownership maps, rebuild both obstacle grids."""
        for t in self._conn_tracks.pop(conn_id, []):
            self.board.Remove(t)
        for cell in self._conn_cells.pop(conn_id, set()):
            self._cell_to_conn.pop(cell, None)
        self._conn_via_cells.pop(conn_id, None)
        self._conn_margin_cells.pop(conn_id, None)

        # Rebuild from current board state (board no longer contains ripped tracks)
        n  = self._cst.n_layers
        vm = self._via_margin_cells

        self._grid     = RoutingGrid(self._bbox, n, self._grid_nm)
        self._via_grid = RoutingGrid(self._bbox, n, self._grid_nm)
        self._mark_obstacles(self._grid)
        self._mark_via_obstacles(self._via_grid)

        if self.inner_layer_cost is None:
            self._layer_costs = self._density_layer_costs(self._grid)

        # Re-block cells occupied by still-routed connections, using each
        # connection's actual track margin.
        for cid, cells in self._conn_cells.items():
            m = self._conn_margin_cells.get(cid, self._margin_cells)
            for c, r, li in cells:
                self._grid.block_disk(c, r, li, m)
            for vc, vr in self._conn_via_cells.get(cid, set()):
                for li in range(n):
                    self._grid.block_disk(vc, vr, li, m)
                    self._via_grid.block_disk(vc, vr, li, vm)

    def _find_blockers(self, net, pad_a, pad_b) -> List[int]:
        """
        Route on a pad-only grid to find a geometric path, then return the
        conn_ids of any existing routes that overlap that path.
        """
        pad_grid = RoutingGrid(self._bbox, self._cst.n_layers, self._grid_nm)
        self._mark_pads(pad_grid, self._margin)

        sc, sr = pad_grid.w2g(pad_a.GetX(), pad_a.GetY())
        ec, er = pad_grid.w2g(pad_b.GetX(), pad_b.GetY())
        sl = self._pad_layer_indices(pad_a)[0]
        el = self._pad_layer_indices(pad_b)[0]

        path = _astar(
            pad_grid, sc, sr, sl, ec, er, el,
            self._pad_clear_cells(pad_a),
            self._pad_clear_cells(pad_b),
            allow_vias=True,
            via_grid=pad_grid,
            via_cost=self._via_cost,
            turn_cost=self._turn_cost,
            use_45=self._use_45,
            layer_costs=self._layer_costs,
        )
        if path is None:
            return []

        seen: Set[int] = set()
        for cell in path:
            cid = self._cell_to_conn.get(cell)
            if cid is not None:
                seen.add(cid)
        return list(seen)

    # ── ordering and rip-up decision ──────────────────────────────────────

    _POWER_KW = {"GND", "VCC", "VDD", "VSS", "PWR", "POWER"}

    def _net_priority(self, name: str) -> int:
        u = name.upper()
        return 0 if any(kw in u for kw in self._POWER_KW) else 1

    def _heuristic_order(
        self,
        conn_meta: Dict[int, dict],
        subset: Optional[List[int]] = None,
    ) -> List[int]:
        ids = subset if subset is not None else list(conn_meta.keys())
        return sorted(
            ids,
            key=lambda i: (
                self._net_priority(conn_meta[i]["net"]),
                conn_meta[i]["length_mm"],
            ),
        )

    def _heuristic_ripup(
        self,
        blockers: List[int],
        conn_meta: Dict[int, dict],
    ) -> List[int]:
        return sorted(
            blockers,
            key=lambda b: (
                self._net_priority(conn_meta[b]["net"]),
                -conn_meta[b]["length_mm"],
            ),
        )[:1]

    def _get_order(
        self,
        advisor,
        conn_meta: Dict[int, dict],
        connections,
        pass_num: int,
        subset: Optional[List[int]] = None,
    ) -> List[int]:
        if advisor is None:
            return self._heuristic_order(conn_meta, subset)
        board_info = {
            "width_mm":          self._bbox.GetWidth()  / 1e6,
            "height_mm":         self._bbox.GetHeight() / 1e6,
            "total_connections": len(connections),
            "total_nets":        len({m["net"] for m in conn_meta.values()}),
            "pass_num":          pass_num,
            "layers":            self._cst.n_layers,
        }
        ids_to_order = subset if subset is not None else list(conn_meta.keys())
        meta_list = [conn_meta[i] for i in ids_to_order]
        try:
            return advisor.rank_connections(meta_list, board_info)
        except Exception as exc:
            print(f"[AI] rank_connections failed ({exc}), using heuristic")
            return self._heuristic_order(conn_meta, ids_to_order)

    def _decide_ripup(
        self,
        advisor,
        conn_id: int,
        blockers: List[int],
        conn_meta: Dict[int, dict],
        ask_ai: bool = True,
    ) -> List[int]:
        if advisor is None or not ask_ai:
            return self._heuristic_ripup(blockers, conn_meta)
        try:
            return advisor.suggest_ripup(
                conn_meta[conn_id],
                [conn_meta[b] for b in blockers],
            )
        except Exception as exc:
            print(f"[AI] suggest_ripup failed ({exc}), using heuristic")
            return self._heuristic_ripup(blockers, conn_meta)


# ── Settings dialog ───────────────────────────────────────────────────────────

try:
    import wx

    class AutorouterSettingsDialog(wx.Dialog):
        """
        Two-tab settings dialog shown before routing starts.

        Step 1 — Constraints: physical DRC values (track, clearance, via, grid)
                               plus retries and AI guidance.
        Step 2 — Router costs: via cost, turn cost, inner-layer cost, track
                               angle mode, zone fill, and a 'Save as defaults'
                               button.

        Router-cost settings are persisted to ~/.kicad_autorouter_settings.json.
        Saved values are loaded and used to pre-fill all fields on next open.
        """

        def __init__(self, parent, cst: "BoardConstraints", board_info: dict):
            super().__init__(
                parent,
                title="KiCAD Autorouter — Settings",
                style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
            )
            self._cst      = cst
            self._saved    = _load_defaults()
            self._build_ui(board_info)
            self.Fit()
            self.SetMinSize(self.GetSize())
            self.Centre()

        # ── layout ────────────────────────────────────────────────────────

        def _build_ui(self, board_info: dict) -> None:
            mm   = pcbnew.ToMM
            sv   = self._saved
            root = wx.BoxSizer(wx.VERTICAL)

            # Board summary (read-only info line)
            n_layers = self._cst.n_layers
            summary = (
                f"Board: "
                f"{board_info.get('width_mm', 0):.0f} × "
                f"{board_info.get('height_mm', 0):.0f} mm,  "
                f"{n_layers} copper layer{'s' if n_layers != 1 else ''}"
            )
            root.Add(wx.StaticText(self, label=summary), 0, wx.ALL, 8)

            # ── Notebook (two tabs) ───────────────────────────────────────
            nb = wx.Notebook(self)

            # ── Tab 1: Constraints ────────────────────────────────────────
            page1 = wx.Panel(nb)
            self._build_constraints_page(page1, board_info)
            nb.AddPage(page1, "Step 1 — Constraints")

            # ── Tab 2: Router costs ───────────────────────────────────────
            page2 = wx.Panel(nb)
            self._build_router_page(page2)
            nb.AddPage(page2, "Step 2 — Router costs")

            root.Add(nb, 1, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 8)

            # ── Warning (always visible) ──────────────────────────────────
            warn = wx.StaticText(
                self,
                label="⚠  Save the board before routing — this cannot be undone.",
            )
            warn.SetForegroundColour(wx.Colour(160, 80, 0))
            root.Add(warn, 0, wx.LEFT | wx.BOTTOM, 8)

            # ── Buttons ───────────────────────────────────────────────────
            btns = wx.StdDialogButtonSizer()
            self._btn_ok = wx.Button(self, wx.ID_OK, label="Start routing")
            self._btn_ok.SetDefault()
            btns.AddButton(self._btn_ok)
            btns.AddButton(wx.Button(self, wx.ID_CANCEL))
            btns.Realize()
            root.Add(btns, 0, wx.EXPAND | wx.ALL, 8)

            self.SetSizer(root)
            self._btn_ok.Bind(wx.EVT_BUTTON, self._on_ok)

        def _build_constraints_page(self, page, board_info: dict) -> None:
            mm = pcbnew.ToMM
            sv = self._saved
            root = wx.BoxSizer(wx.VERTICAL)

            # ── Physical constraints ──────────────────────────────────────
            cst_box = wx.StaticBoxSizer(
                wx.StaticBox(page, label=" Routing constraints  (from board DRC) "),
                wx.VERTICAL,
            )
            fg = wx.FlexGridSizer(rows=0, cols=3, hgap=10, vgap=5)
            fg.AddGrowableCol(1)

            def add_mm(label, board_val_mm, key, attr, min_mm=0.001):
                val = sv.get(key, board_val_mm)
                fg.Add(
                    wx.StaticText(page, label=label + ":"),
                    0, wx.ALIGN_CENTER_VERTICAL,
                )
                ctrl = wx.TextCtrl(page, value=f"{val:.4f}", size=(100, -1))
                fg.Add(ctrl, 1, wx.EXPAND)
                fg.Add(
                    wx.StaticText(page, label="mm"),
                    0, wx.ALIGN_CENTER_VERTICAL,
                )
                setattr(self, attr, ctrl)
                setattr(self, f"{attr}_min", min_mm)

            add_mm("Track width",        mm(self._cst.track_w),   "track_mm",    "_t_track")
            add_mm("Clearance",          mm(self._cst.clearance), "clearance_mm","_t_clear")
            add_mm("Via outer diameter", mm(self._cst.via_size),  "via_size_mm", "_t_via_sz")
            add_mm("Via drill diameter", mm(self._cst.via_drill), "via_drill_mm","_t_via_dr")
            add_mm("Routing grid pitch", 0.1,                     "grid_mm",     "_t_grid",
                   min_mm=0.01)

            cst_box.Add(fg, 0, wx.EXPAND | wx.ALL, 6)
            root.Add(cst_box, 0, wx.EXPAND | wx.ALL, 8)

            # ── Routing settings ──────────────────────────────────────────
            set_box = wx.StaticBoxSizer(
                wx.StaticBox(page, label=" Routing settings "),
                wx.VERTICAL,
            )
            sf = wx.FlexGridSizer(rows=0, cols=3, hgap=10, vgap=5)
            sf.AddGrowableCol(1)

            sf.Add(
                wx.StaticText(page, label="Max retries per connection:"),
                0, wx.ALIGN_CENTER_VERTICAL,
            )
            self._t_retries = wx.SpinCtrl(
                page,
                value=str(sv.get("max_retries", 100)),
                min=1, max=100000, size=(100, -1),
            )
            sf.Add(self._t_retries, 0)
            sf.Add(wx.StaticText(page, label=""), 0)

            set_box.Add(sf, 0, wx.EXPAND | wx.ALL, 6)
            root.Add(set_box, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 8)

            # ── AI guidance ───────────────────────────────────────────────
            ai_box = wx.StaticBoxSizer(
                wx.StaticBox(page, label=" AI guidance  (Claude / Anthropic) "),
                wx.VERTICAL,
            )

            existing_key = os.environ.get("ANTHROPIC_API_KEY", "")

            self._cb_ai = wx.CheckBox(page, label="Enable AI-assisted routing and rip-up decisions")
            self._cb_ai.SetValue(bool(existing_key))
            ai_box.Add(self._cb_ai, 0, wx.ALL, 6)

            key_row = wx.FlexGridSizer(rows=1, cols=3, hgap=10, vgap=0)
            key_row.AddGrowableCol(1)
            key_row.Add(
                wx.StaticText(page, label="Anthropic API key:"),
                0, wx.ALIGN_CENTER_VERTICAL,
            )
            self._t_api_key = wx.TextCtrl(
                page,
                value=existing_key,
                style=wx.TE_PASSWORD,
                size=(280, -1),
            )
            if not existing_key:
                self._t_api_key.SetHint("sk-ant-api03-…")
            key_row.Add(self._t_api_key, 1, wx.EXPAND)

            self._btn_show_key = wx.ToggleButton(page, label="Show", size=(55, -1))
            self._btn_show_key.Bind(wx.EVT_TOGGLEBUTTON, self._on_show_key)
            key_row.Add(self._btn_show_key, 0, wx.ALIGN_CENTER_VERTICAL)

            ai_box.Add(key_row, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 6)

            if existing_key:
                note = wx.StaticText(
                    page,
                    label="Key pre-filled from ANTHROPIC_API_KEY environment variable.",
                )
                note.SetForegroundColour(wx.Colour(100, 100, 100))
                ai_box.Add(note, 0, wx.LEFT | wx.BOTTOM, 6)

            self._t_api_key.Enable(self._cb_ai.GetValue())
            self._btn_show_key.Enable(self._cb_ai.GetValue())
            self._cb_ai.Bind(wx.EVT_CHECKBOX, self._on_ai_toggle)

            root.Add(ai_box, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 8)

            page.SetSizer(root)

        def _build_router_page(self, page) -> None:
            sv   = self._saved
            root = wx.BoxSizer(wx.VERTICAL)

            # ── A* cost weights ───────────────────────────────────────────
            cost_box = wx.StaticBoxSizer(
                wx.StaticBox(page, label=" Router costs "),
                wx.VERTICAL,
            )
            cf = wx.FlexGridSizer(rows=0, cols=3, hgap=10, vgap=6)
            cf.AddGrowableCol(1)

            def add_spin(label, key, default, min_val, max_val, unit, attr):
                cf.Add(wx.StaticText(page, label=label + ":"), 0, wx.ALIGN_CENTER_VERTICAL)
                ctrl = wx.SpinCtrl(
                    page, value=str(sv.get(key, default)),
                    min=min_val, max=max_val, size=(100, -1),
                )
                cf.Add(ctrl, 0)
                cf.Add(wx.StaticText(page, label=unit), 0, wx.ALIGN_CENTER_VERTICAL)
                setattr(self, attr, ctrl)

            add_spin("Via cost",          "via_cost",          _DEFAULT_VIA_COST,  1,   9999,
                     "grid steps", "_t_via_cost")
            add_spin("Turn cost",         "turn_cost",         _DEFAULT_TURN_COST, 0,   100,
                     "grid steps", "_t_turn_cost")
            add_spin("Inner layer cost",  "inner_layer_cost",  1,                  1,   100,
                     "× outer",    "_t_inner_cost")

            hint = wx.StaticText(
                page,
                label="Higher via cost → fewer layer switches.  "
                      "Higher inner layer cost → prefer surface layers.",
            )
            hint.SetForegroundColour(wx.Colour(100, 100, 100))

            cost_box.Add(cf,   0, wx.EXPAND | wx.ALL, 6)
            cost_box.Add(hint, 0, wx.LEFT | wx.BOTTOM, 6)
            root.Add(cost_box, 0, wx.EXPAND | wx.ALL, 8)

            # ── Track angles ──────────────────────────────────────────────
            ang_box = wx.StaticBoxSizer(
                wx.StaticBox(page, label=" Track angles "),
                wx.VERTICAL,
            )
            use_45 = sv.get("use_45_degree", True)
            self._rb_45 = wx.RadioButton(
                page,
                label="45°  — diagonal traces allowed  (default)",
                style=wx.RB_GROUP,
            )
            self._rb_90 = wx.RadioButton(page, label="90°  — horizontal / vertical only")
            self._rb_45.SetValue(use_45)
            self._rb_90.SetValue(not use_45)
            ang_box.Add(self._rb_45, 0, wx.ALL, 5)
            ang_box.Add(self._rb_90, 0, wx.LEFT | wx.BOTTOM, 5)
            root.Add(ang_box, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 8)

            # ── Zone fill ─────────────────────────────────────────────────
            zone_box = wx.StaticBoxSizer(
                wx.StaticBox(page, label=" Copper zones "),
                wx.VERTICAL,
            )
            self._cb_fill_zones = wx.CheckBox(
                page, label="Fill copper zones before routing"
            )
            self._cb_fill_zones.SetValue(sv.get("fill_zones", True))
            zone_note = wx.StaticText(
                page,
                label="Pad pairs already connected through a filled zone\n"
                      "will not receive a routed wire.",
            )
            zone_note.SetForegroundColour(wx.Colour(100, 100, 100))
            zone_box.Add(self._cb_fill_zones, 0, wx.ALL, 5)
            zone_box.Add(zone_note, 0, wx.LEFT | wx.BOTTOM, 6)
            root.Add(zone_box, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, 8)

            # ── Save defaults button ──────────────────────────────────────
            btn_save = wx.Button(page, label="Save current settings as defaults")
            btn_save.Bind(wx.EVT_BUTTON, self._on_save_defaults)
            root.Add(btn_save, 0, wx.LEFT | wx.BOTTOM, 8)

            page.SetSizer(root)

        # ── event handlers ────────────────────────────────────────────────

        def _on_ai_toggle(self, _evt) -> None:
            enabled = self._cb_ai.GetValue()
            self._t_api_key.Enable(enabled)
            self._btn_show_key.Enable(enabled)

        def _on_show_key(self, _evt) -> None:
            # wx doesn't support changing TE_PASSWORD at runtime on all platforms,
            # so we swap the control's echo mode via a workaround.
            showing = self._btn_show_key.GetValue()
            self._btn_show_key.SetLabel("Hide" if showing else "Show")
            current = self._t_api_key.GetValue()
            style = 0 if showing else wx.TE_PASSWORD
            pos   = self._t_api_key.GetPosition()
            size  = self._t_api_key.GetSize()
            parent_sizer = self._t_api_key.GetContainingSizer()
            new_ctrl = wx.TextCtrl(self, value=current, pos=pos, size=size, style=style)
            if parent_sizer:
                parent_sizer.Replace(self._t_api_key, new_ctrl)
            self._t_api_key.Destroy()
            self._t_api_key = new_ctrl
            self.Layout()

        def _on_save_defaults(self, _evt) -> None:
            errors = self._validate()
            if errors:
                wx.MessageBox(
                    "Fix the following before saving:\n\n"
                    + "\n".join(f"  •  {e}" for e in errors),
                    "Cannot save",
                    wx.OK | wx.ICON_ERROR,
                    self,
                )
                return
            _save_defaults(self.get_settings())
            wx.MessageBox(
                f"Settings saved to:\n{_SETTINGS_FILE}",
                "Defaults saved",
                wx.OK | wx.ICON_INFORMATION,
                self,
            )

        def _on_ok(self, _evt) -> None:
            errors = self._validate()
            if errors:
                wx.MessageBox(
                    "Please correct the following:\n\n"
                    + "\n".join(f"  •  {e}" for e in errors),
                    "Invalid settings",
                    wx.OK | wx.ICON_ERROR,
                    self,
                )
                return
            self.EndModal(wx.ID_OK)

        # ── validation ────────────────────────────────────────────────────

        def _validate(self) -> list:
            errors = []

            def _float(ctrl, label, min_val=0.001):
                raw = ctrl.GetValue().replace(",", ".")
                try:
                    v = float(raw)
                except ValueError:
                    errors.append(f"{label}: '{raw}' is not a valid number")
                    return None
                if v < min_val:
                    errors.append(f"{label} must be ≥ {min_val} mm (got {v})")
                    return None
                return v

            t   = _float(self._t_track,   "Track width")
            c   = _float(self._t_clear,   "Clearance")
            vsz = _float(self._t_via_sz,  "Via outer diameter")
            vdr = _float(self._t_via_dr,  "Via drill diameter")
            _   = _float(self._t_grid,    "Routing grid pitch", min_val=0.01)

            if vsz is not None and vdr is not None and vdr >= vsz:
                errors.append(
                    f"Via drill ({vdr:.4f} mm) must be smaller than "
                    f"via outer diameter ({vsz:.4f} mm)"
                )

            if self._cb_ai.GetValue() and not self._t_api_key.GetValue().strip():
                errors.append(
                    "An Anthropic API key is required when AI guidance is enabled"
                )

            return errors

        # ── result accessor ───────────────────────────────────────────────

        def get_settings(self) -> dict:
            """Return the user's chosen settings.  Call after ShowModal() == wx.ID_OK."""
            def f(ctrl):
                return float(ctrl.GetValue().replace(",", "."))
            return {
                "track_mm":         f(self._t_track),
                "clearance_mm":     f(self._t_clear),
                "via_size_mm":      f(self._t_via_sz),
                "via_drill_mm":     f(self._t_via_dr),
                "grid_mm":          f(self._t_grid),
                "max_retries":      self._t_retries.GetValue(),
                "use_ai":           self._cb_ai.GetValue(),
                "api_key":          self._t_api_key.GetValue().strip(),
                # Router cost settings (step 2)
                "via_cost":         self._t_via_cost.GetValue(),
                "turn_cost":        self._t_turn_cost.GetValue(),
                "inner_layer_cost": self._t_inner_cost.GetValue(),
                "use_45_degree":    self._rb_45.GetValue(),
                "fill_zones":       self._cb_fill_zones.GetValue(),
            }


    # ── ActionPlugin ──────────────────────────────────────────────────────────

    class AutorouterPlugin(pcbnew.ActionPlugin):

        def defaults(self):
            self.name                = "Autorouter (RuR + AI)"
            self.category            = "Routing"
            self.description         = (
                "Auto-route all unconnected pads. Reads board constraints "
                "automatically. Uses A* with rip-up and reroute, minimises "
                "trace length and via count. Optionally uses Claude AI for "
                "intelligent connection ordering and rip-up decisions."
            )
            self.show_toolbar_button = True
            self.icon_file_name      = ""

        def Run(self):  # noqa: N802
            board = pcbnew.GetBoard()

            # Read constraints from board so the dialog can pre-fill them
            cst  = BoardConstraints.from_board(board)
            bbox = board.GetBoardEdgesBoundingBox()
            if bbox.GetWidth() == 0 or bbox.GetHeight() == 0:
                bbox = board.GetBoundingBox()
            board_info = {
                "n_layers":  cst.n_layers,
                "width_mm":  bbox.GetWidth()  / 1e6,
                "height_mm": bbox.GetHeight() / 1e6,
            }

            dlg = AutorouterSettingsDialog(None, cst, board_info)
            if dlg.ShowModal() != wx.ID_OK:
                dlg.Destroy()
                return
            s = dlg.get_settings()
            dlg.Destroy()

            # Apply user overrides to the router
            router = KiCADAutorouter(board)
            router.track_mm         = s["track_mm"]
            router.clearance_mm     = s["clearance_mm"]
            router.via_size_mm      = s["via_size_mm"]
            router.via_drill_mm     = s["via_drill_mm"]
            router.grid_mm          = s["grid_mm"]
            router.via_cost         = s["via_cost"]
            router.turn_cost        = s["turn_cost"]
            router.inner_layer_cost = s["inner_layer_cost"]
            router.use_45_degree    = s["use_45_degree"]
            router.fill_zones       = s["fill_zones"]

            # Build advisor if AI is enabled
            advisor = None
            if s["use_ai"] and s["api_key"]:
                try:
                    from .ai_advisor import RouteAdvisor
                    advisor = RouteAdvisor(api_key=s["api_key"])
                except Exception as exc:
                    wx.MessageBox(
                        f"Could not initialise AI advisor:\n{exc}\n\n"
                        "Routing will continue without AI guidance.",
                        "AI warning",
                        wx.OK | wx.ICON_WARNING,
                    )

            # Progress dialog
            progress = wx.ProgressDialog(
                "Autorouting…",
                "Initialising…",
                maximum=100,
                style=wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME | wx.PD_AUTO_HIDE,
            )

            def cb(done, total, label):
                pct = int(100 * done / total) if total else 0
                progress.Update(pct, label)

            try:
                routed, failed, total = router.run_rur(
                    advisor     = advisor,
                    max_retries = s["max_retries"],
                    progress_cb = cb,
                )
            finally:
                progress.Destroy()

            ai_note = " (with AI guidance)" if advisor else ""
            wx.MessageBox(
                f"Routing complete{ai_note}.\n\n"
                f"Total connections:  {total}\n"
                f"Routed:             {routed}\n"
                f"Failed / unrouted:  {failed}",
                "Autorouter — Done",
                wx.OK | wx.ICON_INFORMATION,
            )

    def register():
        AutorouterPlugin().register()

except ImportError:
    def register():
        print("wx not available; ActionPlugin registration skipped.")