autocad-mcp-pro/engineering/critique.py

"""Premium-quality critique checks for finished drawings.

Each focus runs an independent check; new focuses must be added to the
`CritiqueFocus` Literal in plan_spec.py *and* registered here. Closed enum
keeps drawing_critique scope from drifting.
"""

from __future__ import annotations

import math
from typing import TYPE_CHECKING

from .layers import ENGINEERING_LAYERS
from .plan_spec import (
    ALL_CRITIQUE_FOCUSES,
    ISO_128_LINEWEIGHTS_MM,
    CritiqueFocus,
    Issue,
)

if TYPE_CHECKING:
    from backends.base import AutoCADBackend


# Layer-name → expected ACI color, derived from ENGINEERING_LAYERS.
_EXPECTED_LAYER_COLOR: dict[str, int] = {
    name: color for name, color, _lt, _lw, _desc in ENGINEERING_LAYERS
}

# Dimension entity types that should sit on the DIM layer.
_DIM_TYPES = {
    "DIMENSION", "DIMLINEAR", "DIMALIGNED", "DIMANGULAR",
    "DIMRADIUS", "DIMDIAMETER", "DIMORDINATE",
}


async def _check_iso128(backend: AutoCADBackend) -> list[Issue]:
    """Layer lineweights must be in ISO_128_LINEWEIGHTS_MM (or -3=ByLayer
    sentinel meaning 'inherit')."""
    issues: list[Issue] = []
    try:
        layers = await backend.layer_list()
    except Exception as exc:
        return [Issue("warning", "iso128", f"layer_list failed: {exc}")]
    allowed = set(ISO_128_LINEWEIGHTS_MM)
    for lyr in layers:
        # CONSTRUCTION-class layers are intentionally sub-ISO (0.05mm scratch
        # weight) and must be cleared before finalize — never an ISO violation.
        if "CONST" in lyr.name.upper():
            continue
        lw = float(lyr.lineweight)
        # AutoCAD sentinels: -1 (Default), -2 (ByBlock), -3 (ByLayer);
        # 0.0 = ezdxf's "use default" — not an ISO 128 violation.
        if lw <= 0:
            continue
        # Layer lineweights come through as ezdxf/COM hundredths-of-a-mm
        # (e.g. 25 == 0.25mm) — they are NOT pre-normalised to mm, so accept
        # either the raw mm value or hundredths/100.
        if lw not in allowed and (lw / 100.0) not in allowed:
            issues.append(Issue(
                severity="warning",
                focus="iso128",
                message=(
                    f"Layer '{lyr.name}' lineweight {lw} mm is not in the "
                    f"ISO 128 set {sorted(allowed)}."
                ),
                detail={"layer": lyr.name, "lineweight": lw},
            ))
    return issues


async def _check_layer_color(backend: AutoCADBackend) -> list[Issue]:
    """Engineering-standard layers must keep their canonical ACI color."""
    issues: list[Issue] = []
    try:
        layers = await backend.layer_list()
    except Exception:
        return []
    for lyr in layers:
        expected = _EXPECTED_LAYER_COLOR.get(lyr.name)
        if expected is None:
            continue   # unknown layer — caller's responsibility
        if int(lyr.color) != int(expected):
            issues.append(Issue(
                severity="warning",
                focus="layer_color",
                message=(
                    f"Layer '{lyr.name}' has color {lyr.color}; "
                    f"engineering standard expects {expected}."
                ),
                detail={"layer": lyr.name, "got": int(lyr.color), "expected": expected},
            ))
    return issues


async def _check_construction_left(backend: AutoCADBackend) -> list[Issue]:
    """No construction/scratch geometry may remain before drawing_finalize.

    Matches any layer whose name contains 'CONST' (CONSTRUCTION, M-CONST-E-N, …)
    so the check is independent of the active layer set — a leftover iso13567
    scaffold on M-CONST-E-N is caught just like a mech one on CONSTRUCTION.
    """
    try:
        ents = await backend.entity_list(limit=5000)
    except Exception:
        return []
    leftover = [e for e in ents if "CONST" in (e.layer or "").upper()]
    if not leftover:
        return []
    return [Issue(
        severity="error",
        focus="construction_left",
        message=(
            f"{len(leftover)} entity/entities still on a construction layer. "
            "Call construction_clear() before drawing_finalize."
        ),
        handles=[e.handle for e in leftover[:50]],
        detail={"count": len(leftover),
                "layers": sorted({e.layer for e in leftover if e.layer})},
    )]


async def _check_untrimmed_corner(backend: AutoCADBackend) -> list[Issue]:
    """Two LINE endpoints within `tol` but not exactly equal usually means a
    corner where one line overshoots — TRIM/EXTEND/FILLET was forgotten."""
    tol = 0.5  # mm — generous; tighten via PlanSpec.notes later
    try:
        lines = await backend.entity_list(type_filter="LINE", limit=5000)
    except Exception:
        return []
    endpoints: list[tuple[str, tuple[float, float]]] = []
    for ln in lines:
        s = ln.properties.get("start")
        e = ln.properties.get("end")
        if s and e:
            endpoints.append((ln.handle, (float(s[0]), float(s[1]))))
            endpoints.append((ln.handle, (float(e[0]), float(e[1]))))
    issues: list[Issue] = []
    n = len(endpoints)
    seen: set[frozenset[str]] = set()
    for i in range(n):
        h1, p1 = endpoints[i]
        for j in range(i + 1, n):
            h2, p2 = endpoints[j]
            if h1 == h2:
                continue
            d = math.hypot(p1[0] - p2[0], p1[1] - p2[1])
            if 1e-9 < d <= tol:
                key = frozenset((h1, h2))
                if key in seen:
                    continue
                seen.add(key)
                issues.append(Issue(
                    severity="warning",
                    focus="untrimmed_corner",
                    message=(
                        f"Lines {h1} and {h2} have endpoints {d:.3f} mm apart — "
                        "likely an untrimmed corner (use entity_trim or entity_fillet)."
                    ),
                    handles=[h1, h2],
                    detail={"gap_mm": d, "p1": list(p1), "p2": list(p2)},
                ))
    return issues


async def _check_duplicate_entities(backend: AutoCADBackend) -> list[Issue]:
    """Two LINEs with identical endpoints (in either direction) are duplicates."""
    try:
        lines = await backend.entity_list(type_filter="LINE", limit=5000)
    except Exception:
        return []
    seen: dict[tuple, str] = {}
    issues: list[Issue] = []
    for ln in lines:
        s = ln.properties.get("start")
        e = ln.properties.get("end")
        if not (s and e):
            continue
        k1 = (round(s[0], 4), round(s[1], 4), round(e[0], 4), round(e[1], 4))
        k2 = (k1[2], k1[3], k1[0], k1[1])
        for key in (k1, k2):
            if key in seen:
                issues.append(Issue(
                    severity="warning",
                    focus="duplicate_entities",
                    message=f"Lines {seen[key]} and {ln.handle} are duplicates.",
                    handles=[seen[key], ln.handle],
                ))
                break
        else:
            seen[k1] = ln.handle
    return issues


def _dim_ref_point(e) -> tuple[float, float] | None:
    """Best-effort reference point for a dimension entity, tolerant of the
    per-backend property shape: explicit text/def points first, then the
    bounding-box centre (COM seeds `bounding_box` for every entity)."""
    for key in ("text_position", "defpoint", "insertion_point", "insertion"):
        ip = e.properties.get(key)
        if ip and len(ip) >= 2:
            return (float(ip[0]), float(ip[1]))
    bb = e.properties.get("bounding_box")
    try:
        if isinstance(bb, dict):
            mn, mx = bb.get("min"), bb.get("max")
            return ((mn[0] + mx[0]) / 2.0, (mn[1] + mx[1]) / 2.0)
        if bb and len(bb) == 2 and hasattr(bb[0], "__len__"):
            return ((bb[0][0] + bb[1][0]) / 2.0, (bb[0][1] + bb[1][1]) / 2.0)
        if bb and len(bb) >= 4:
            return ((bb[0] + bb[2]) / 2.0, (bb[1] + bb[3]) / 2.0)
    except (TypeError, IndexError, KeyError):
        return None
    return None


async def _check_dim_overlap(backend: AutoCADBackend) -> list[Issue]:
    """Two dimensions whose reference points are within `tol` likely overlap.

    Filters by entity TYPE (not layer) so dims land-anywhere — including the
    iso13567 M-DIMEN-T-N layer — are still considered.
    """
    tol = 5.0  # mm
    try:
        ents = await backend.entity_list(limit=5000)
    except Exception:
        return []
    dim_points: list[tuple[str, tuple[float, float]]] = []
    for e in ents:
        if e.type not in _DIM_TYPES and "DIM" not in e.type:
            continue
        ip = _dim_ref_point(e)
        if ip is not None:
            dim_points.append((e.handle, ip))
    issues: list[Issue] = []
    seen: set[frozenset[str]] = set()
    for i, (h1, p1) in enumerate(dim_points):
        for j in range(i + 1, len(dim_points)):
            h2, p2 = dim_points[j]
            d = math.hypot(p1[0] - p2[0], p1[1] - p2[1])
            if d <= tol:
                key = frozenset((h1, h2))
                if key in seen:
                    continue
                seen.add(key)
                issues.append(Issue(
                    severity="warning",
                    focus="dim_overlap",
                    message=f"Dimensions {h1} and {h2} are {d:.2f} mm apart — likely overlapping.",
                    handles=[h1, h2],
                ))
    return issues


_FOCUS_DISPATCH = {
    "iso128": _check_iso128,
    "layer_color": _check_layer_color,
    "dim_overlap": _check_dim_overlap,
    "untrimmed_corner": _check_untrimmed_corner,
    "duplicate_entities": _check_duplicate_entities,
    "construction_left": _check_construction_left,
}


async def run_critique(
    backend: AutoCADBackend,
    focus: list[CritiqueFocus] | None = None,
) -> list[Issue]:
    """Dispatch each requested focus check and return aggregated issues."""
    foci = list(focus) if focus is not None else list(ALL_CRITIQUE_FOCUSES)
    issues: list[Issue] = []
    for f in foci:
        check = _FOCUS_DISPATCH.get(f)
        if check is None:
            issues.append(Issue(
                severity="warning",
                focus=f,  # type: ignore[arg-type]
                message=f"Unknown critique focus '{f}' (closed enum).",
            ))
            continue
        issues.extend(await check(backend))
    return issues