KiCAD-MCP-Server

"""
Design rules command implementations for KiCAD interface
"""

import logging
import math
import os
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

import pcbnew
from commands.routing import persist_net_assignment_to_project
from utils.kicad_cli import kicad_cli_not_found_message, resolve_kicad_cli
from utils.kicad_dru import (
    build_layer_constraint_rule,
    persist_layer_constraint_rule,
    resolve_dru_path,
    rule_name_for_layer,
)

logger = logging.getLogger("kicad_interface")


class DesignRuleCommands:
    """Handles design rule checking and configuration"""

    def __init__(self, board: Optional[pcbnew.BOARD] = None):
        """Initialize with optional board instance"""
        self.board = board

    def set_design_rules(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """Set design rules for the PCB"""
        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            design_settings = self.board.GetDesignSettings()

            # Convert mm to nanometers for KiCAD internal units
            scale = 1000000  # mm to nm

            # Set clearance
            if "clearance" in params:
                design_settings.m_MinClearance = int(params["clearance"] * scale)

            # KiCAD 9.0: Use SetCustom* methods instead of SetCurrent* (which were removed)
            # Track if we set any custom track/via values
            custom_values_set = False

            if "trackWidth" in params:
                design_settings.SetCustomTrackWidth(int(params["trackWidth"] * scale))
                custom_values_set = True

            # Via settings
            if "viaDiameter" in params:
                design_settings.SetCustomViaSize(int(params["viaDiameter"] * scale))
                custom_values_set = True
            if "viaDrill" in params:
                design_settings.SetCustomViaDrill(int(params["viaDrill"] * scale))
                custom_values_set = True

            # KiCAD 9.0: Activate custom track/via values so they become the current values
            if custom_values_set:
                design_settings.UseCustomTrackViaSize(True)

            # Set micro via settings (use properties - methods removed in KiCAD 9.0)
            if "microViaDiameter" in params:
                design_settings.m_MicroViasMinSize = int(params["microViaDiameter"] * scale)
            if "microViaDrill" in params:
                design_settings.m_MicroViasMinDrill = int(params["microViaDrill"] * scale)

            # Set minimum values
            if "minTrackWidth" in params:
                design_settings.m_TrackMinWidth = int(params["minTrackWidth"] * scale)
            if "minViaDiameter" in params:
                design_settings.m_ViasMinSize = int(params["minViaDiameter"] * scale)

            # KiCAD 9.0: m_ViasMinDrill removed - use m_MinThroughDrill instead
            if "minViaDrill" in params:
                design_settings.m_MinThroughDrill = int(params["minViaDrill"] * scale)

            if "minMicroViaDiameter" in params:
                design_settings.m_MicroViasMinSize = int(params["minMicroViaDiameter"] * scale)
            if "minMicroViaDrill" in params:
                design_settings.m_MicroViasMinDrill = int(params["minMicroViaDrill"] * scale)

            # KiCAD 9.0: m_MinHoleDiameter removed - use m_MinThroughDrill
            if "minHoleDiameter" in params:
                design_settings.m_MinThroughDrill = int(params["minHoleDiameter"] * scale)

            # KiCAD 9.0: Added hole clearance settings
            if "holeClearance" in params:
                design_settings.m_HoleClearance = int(params["holeClearance"] * scale)
            if "holeToHoleMin" in params:
                design_settings.m_HoleToHoleMin = int(params["holeToHoleMin"] * scale)

            # Build response with KiCAD 9.0 compatible properties
            # After UseCustomTrackViaSize(True), GetCurrent* returns the custom values
            response_rules = {
                "clearance": design_settings.m_MinClearance / scale,
                "trackWidth": design_settings.GetCurrentTrackWidth() / scale,
                "viaDiameter": design_settings.GetCurrentViaSize() / scale,
                "viaDrill": design_settings.GetCurrentViaDrill() / scale,
                "microViaDiameter": design_settings.m_MicroViasMinSize / scale,
                "microViaDrill": design_settings.m_MicroViasMinDrill / scale,
                "minTrackWidth": design_settings.m_TrackMinWidth / scale,
                "minViaDiameter": design_settings.m_ViasMinSize / scale,
                "minThroughDrill": design_settings.m_MinThroughDrill / scale,
                "minMicroViaDiameter": design_settings.m_MicroViasMinSize / scale,
                "minMicroViaDrill": design_settings.m_MicroViasMinDrill / scale,
                "holeClearance": design_settings.m_HoleClearance / scale,
                "holeToHoleMin": design_settings.m_HoleToHoleMin / scale,
                "viasMinAnnularWidth": design_settings.m_ViasMinAnnularWidth / scale,
            }

            return {
                "success": True,
                "message": "Updated design rules",
                "rules": response_rules,
            }

        except Exception as e:
            logger.error(f"Error setting design rules: {str(e)}")
            return {
                "success": False,
                "message": "Failed to set design rules",
                "errorDetails": str(e),
            }

    def get_design_rules(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """Get current design rules - KiCAD 9.0 compatible"""
        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            design_settings = self.board.GetDesignSettings()
            scale = 1000000  # nm to mm

            # Build rules dict with KiCAD 9.0 compatible properties
            rules = {
                # Core clearance and track settings
                "clearance": design_settings.m_MinClearance / scale,
                "trackWidth": design_settings.GetCurrentTrackWidth() / scale,
                "minTrackWidth": design_settings.m_TrackMinWidth / scale,
                # Via settings (current values from methods)
                "viaDiameter": design_settings.GetCurrentViaSize() / scale,
                "viaDrill": design_settings.GetCurrentViaDrill() / scale,
                # Via minimum values
                "minViaDiameter": design_settings.m_ViasMinSize / scale,
                "viasMinAnnularWidth": design_settings.m_ViasMinAnnularWidth / scale,
                # Micro via settings
                "microViaDiameter": design_settings.m_MicroViasMinSize / scale,
                "microViaDrill": design_settings.m_MicroViasMinDrill / scale,
                "minMicroViaDiameter": design_settings.m_MicroViasMinSize / scale,
                "minMicroViaDrill": design_settings.m_MicroViasMinDrill / scale,
                # KiCAD 9.0: Hole and drill settings (replaces removed m_ViasMinDrill and m_MinHoleDiameter)
                "minThroughDrill": design_settings.m_MinThroughDrill / scale,
                "holeClearance": design_settings.m_HoleClearance / scale,
                "holeToHoleMin": design_settings.m_HoleToHoleMin / scale,
                # Other constraints
                "copperEdgeClearance": design_settings.m_CopperEdgeClearance / scale,
                "silkClearance": design_settings.m_SilkClearance / scale,
            }

            return {"success": True, "rules": rules}

        except Exception as e:
            logger.error(f"Error getting design rules: {str(e)}")
            return {
                "success": False,
                "message": "Failed to get design rules",
                "errorDetails": str(e),
            }

    def set_layer_constraints(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """Set per-layer minimum track width / clearance / via dimensions.

        Unlike ``set_design_rules`` (global board settings, mutated on the
        live ``pcbnew.BOARD``), per-layer constraints are not exposed by any
        pcbnew API — real KiCad 9+ per-layer rules are expressed in a
        project-scoped ``.kicad_dru`` custom-rules text file, sibling to the
        ``.kicad_pcb``, which ``kicad-cli pcb drc`` (and the GUI) picks up
        automatically. This writes a ``(rule "mcp_layer_constraint_<layer>"
        ...)`` block to that file — pure text, no live board mutation — so
        the constraint takes effect on the *next* DRC run (``run_drc`` /
        ``get_drc_violations``), not retroactively on data already computed.
        """
        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            layer = params.get("layer")
            if not layer:
                return {
                    "success": False,
                    "message": "Missing parameter",
                    "errorDetails": "layer is required",
                }

            # The layer name is interpolated into two quoted S-expression
            # tokens — (rule "mcp_layer_constraint_<layer>") and
            # (layer "<layer>") — so a quote, backslash or paren would both
            # corrupt the .kicad_dru and break the by-name lookup that a later
            # update relies on to find and replace this rule. Reject those
            # rather than write a file KiCad cannot parse. Deliberately not an
            # allowlist of known layer names: KiCad 10 reports "F.Silkscreen"
            # while ".kicad_dru" and kicad-cli also accept "F.SilkS", and user
            # layers can be renamed, so a strict check would reject valid input.
            if any(c in str(layer) for c in '"\\()\n\r'):
                return {
                    "success": False,
                    "message": "Invalid layer name",
                    "errorDetails": (
                        f"Layer name {layer!r} contains a character that cannot appear "
                        'in a .kicad_dru quoted token (one of: " \\ ( ) newline)'
                    ),
                }

            min_track_width = params.get("minTrackWidth")
            min_clearance = params.get("minClearance")
            min_via_diameter = params.get("minViaDiameter")
            min_via_drill = params.get("minViaDrill")

            if not any(
                v is not None
                for v in (min_track_width, min_clearance, min_via_diameter, min_via_drill)
            ):
                return {
                    "success": False,
                    "message": "No constraints provided",
                    "errorDetails": (
                        "Provide at least one of minTrackWidth, minClearance, "
                        "minViaDiameter, minViaDrill"
                    ),
                }

            try:
                board_path = self.board.GetFileName()
            except Exception:
                board_path = None
            dru_path = resolve_dru_path(board_path)

            rule_name = rule_name_for_layer(layer)
            rule_text = build_layer_constraint_rule(
                layer,
                min_track_width=min_track_width,
                min_clearance=min_clearance,
                min_via_diameter=min_via_diameter,
                min_via_drill=min_via_drill,
            )
            persist = persist_layer_constraint_rule(dru_path, rule_name, rule_text)

            if not persist.get("persisted"):
                return {
                    "success": False,
                    "message": "Failed to set layer constraints",
                    "errorDetails": persist.get("warning"),
                }

            return {
                "success": True,
                "message": f"Set layer constraints for {layer}",
                "layer": layer,
                "ruleName": rule_name,
                "druFile": persist["druFile"],
            }

        except Exception as e:
            logger.error(f"Error setting layer constraints: {str(e)}")
            return {
                "success": False,
                "message": "Failed to set layer constraints",
                "errorDetails": str(e),
            }

    def assign_net_to_class(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """Assign an existing net to an existing net class.

        Mirrors ``RoutingCommands.create_netclass``'s dual-write shape: a
        best-effort in-memory ``NETINFO_ITEM.SetClass`` for the live SWIG
        session, plus a durable write to the project's
        ``net_settings.netclass_assignments`` (KiCad 7+ net-class membership
        lives in ``.kicad_pro``, not the ``.kicad_pcb`` the SWIG board save
        writes — same reasoning as issue #302).
        """
        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            net_name = params.get("net")
            class_name = params.get("netClass")

            if not net_name or not class_name:
                return {
                    "success": False,
                    "message": "Missing parameters",
                    "errorDetails": "net and netClass are both required",
                }

            netinfo = self.board.GetNetInfo()
            nets_map = netinfo.NetsByName()
            if not nets_map.has_key(net_name):
                return {
                    "success": False,
                    "message": f"Net not found: {net_name}",
                    "errorDetails": f"'{net_name}' does not exist on the board",
                }
            net = nets_map[net_name]

            # KiCad 6/7 returns NETCLASSES with .Find; KiCad 9/10 returns a
            # dict-like netclasses_map. Same defensive lookup as create_netclass.
            net_classes = self.board.GetNetClasses()
            resolved = None
            if hasattr(net_classes, "Find"):
                resolved = net_classes.Find(class_name)
            else:
                try:
                    if class_name in net_classes:
                        resolved = net_classes[class_name]
                except Exception:
                    resolved = None

            if resolved is None:
                return {
                    "success": False,
                    "message": f"Net class not found: {class_name}",
                    "errorDetails": f"Create it first with create_netclass (got '{class_name}')",
                }

            in_memory_warning = None
            try:
                net.SetClass(resolved)
            except Exception as exc:
                in_memory_warning = f"in-memory net class assignment failed: {exc}"
                logger.warning("assign_net_to_class: %s", in_memory_warning)

            pro_path = None
            try:
                board_path = self.board.GetFileName()
                if board_path and board_path.endswith(".kicad_pcb"):
                    pro_path = str(Path(board_path).with_suffix(".kicad_pro"))
            except Exception:
                pro_path = None

            persist = persist_net_assignment_to_project(pro_path, net_name, class_name)

            warnings = [w for w in (in_memory_warning, persist.get("warning")) if w]
            if in_memory_warning and not persist.get("persisted"):
                # Neither the live board nor the project file received the assignment.
                return {
                    "success": False,
                    "message": "Failed to assign net to class",
                    "errorDetails": "; ".join(warnings),
                }

            result = {
                "success": True,
                "message": f"Assigned net {net_name} to class {class_name}",
                "net": net_name,
                "netClass": class_name,
                "persisted": persist.get("persisted", False),
            }
            if persist.get("projectFile"):
                result["projectFile"] = persist["projectFile"]
            if warnings:
                result["warning"] = "; ".join(warnings)
            return result

        except Exception as e:
            logger.error(f"Error assigning net to class: {str(e)}")
            return {
                "success": False,
                "message": "Failed to assign net to class",
                "errorDetails": str(e),
            }

    def check_clearance(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """Check the measured clearance between two PCB items against the board's
        minimum clearance design rule.

        Items resolve to an axis-aligned bounding box (``GetBoundingBox()``) —
        the same AABB approximation ``check_courtyard_overlaps`` already uses
        for footprint-to-footprint checks. This is approximate for
        non-rectangular/angled items (e.g. a circular pad's bbox is its
        bounding square, an angled track's bbox is larger than the track
        itself), so it can read closer than the true clearance never further.
        It is a fast ad-hoc check, not a substitute for a full DRC run
        (``run_drc`` / ``get_drc_violations``), which uses KiCad's exact
        polygon-based clearance resolver.

        Item resolution supports ``id`` (item UUID) for any type, and
        ``reference`` for ``type: "component"``. Position-based lookup is not
        supported in this version — callers should query the item's UUID
        first (e.g. via ``query_traces`` / ``get_component_pads``).
        """
        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            item1_spec = params.get("item1")
            item2_spec = params.get("item2")
            if not item1_spec or not item2_spec:
                return {
                    "success": False,
                    "message": "Missing parameters",
                    "errorDetails": "item1 and item2 are both required",
                }

            item1, err1 = self._resolve_clearance_item(item1_spec)
            if err1:
                return {
                    "success": False,
                    "message": "Could not resolve item1",
                    "errorDetails": err1,
                }
            item2, err2 = self._resolve_clearance_item(item2_spec)
            if err2:
                return {
                    "success": False,
                    "message": "Could not resolve item2",
                    "errorDetails": err2,
                }

            scale = 1000000  # nm to mm
            distance_mm = self._bbox_gap_nm(item1.GetBoundingBox(), item2.GetBoundingBox()) / scale

            required_mm = self.board.GetDesignSettings().m_MinClearance / scale

            return {
                "success": True,
                "actualClearance": round(distance_mm, 6),
                "requiredClearance": round(required_mm, 6),
                "meetsRequirement": distance_mm >= required_mm,
                "unit": "mm",
            }

        except Exception as e:
            logger.error(f"Error checking clearance: {str(e)}")
            return {
                "success": False,
                "message": "Failed to check clearance",
                "errorDetails": str(e),
            }

    def _resolve_clearance_item(self, spec: Dict[str, Any]) -> Tuple[Optional[Any], Optional[str]]:
        """Resolve a ``check_clearance`` item spec to a board item.

        Returns ``(item, None)`` on success or ``(None, error_message)`` on
        failure. Supports ``id`` (UUID, any type) and ``reference``
        (``type: "component"`` only).
        """
        item_type = spec.get("type")
        item_id = spec.get("id")
        reference = spec.get("reference")

        if item_type == "component":
            if reference:
                fp = self.board.FindFootprintByReference(reference)
                if fp:
                    return fp, None
                return None, f"component '{reference}' not found"
            if item_id:
                for fp in self.board.GetFootprints():
                    if fp.m_Uuid.AsString() == item_id:
                        return fp, None
                return None, f"component with id '{item_id}' not found"
            return None, "component requires 'reference' or 'id'"

        if item_type in ("track", "via"):
            if not item_id:
                return None, f"{item_type} requires 'id' (position lookup is not supported)"
            for track in self.board.GetTracks():
                if track.m_Uuid.AsString() == item_id:
                    return track, None
            return None, f"{item_type} with id '{item_id}' not found"

        if item_type == "pad":
            if not item_id:
                return None, "pad requires 'id' (position lookup is not supported)"
            for fp in self.board.GetFootprints():
                for pad in fp.Pads():
                    if pad.m_Uuid.AsString() == item_id:
                        return pad, None
            return None, f"pad with id '{item_id}' not found"

        if item_type == "zone":
            if not item_id:
                return None, "zone requires 'id' (position lookup is not supported)"
            for zone in self.board.Zones():
                if zone.m_Uuid.AsString() == item_id:
                    return zone, None
            return None, f"zone with id '{item_id}' not found"

        return None, f"unknown item type: {item_type!r}"

    @staticmethod
    def _bbox_gap_nm(box1: Any, box2: Any) -> float:
        """Edge-to-edge gap (nm) between two pcbnew ``BOX2I`` bounding boxes.

        Returns 0 when the boxes overlap or touch.
        """
        dx = max(0, max(box1.GetLeft() - box2.GetRight(), box2.GetLeft() - box1.GetRight()))
        dy = max(0, max(box1.GetTop() - box2.GetBottom(), box2.GetTop() - box1.GetBottom()))
        return math.hypot(dx, dy)

    def run_drc(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """Run Design Rule Check using kicad-cli"""
        import json
        import platform
        import shutil
        import subprocess
        import tempfile

        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            report_path = params.get("reportPath")
            # Caller-overridable timeout (seconds). Defaults to 600s for big boards
            # but smaller MCP transport budgets (e.g. 120s) can lower it explicitly.
            try:
                timeout_sec = int(params.get("timeoutSec", 600))
            except (TypeError, ValueError):
                timeout_sec = 600
            timeout_sec = max(10, min(timeout_sec, 1800))  # clamp to [10, 1800]

            # Get the board file path
            board_file = self.board.GetFileName()
            if not board_file or not os.path.exists(board_file):
                return {
                    "success": False,
                    "message": "Board file not found",
                    "errorDetails": "Cannot run DRC without a saved board file",
                }

            # Find kicad-cli executable
            kicad_cli = self._find_kicad_cli()
            if not kicad_cli:
                return {
                    "success": False,
                    "message": kicad_cli_not_found_message(),
                }

            # Create temporary JSON output file
            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmp:
                json_output = tmp.name

            try:
                # Build command
                cmd = [
                    kicad_cli,
                    "pcb",
                    "drc",
                    "--format",
                    "json",
                    "--output",
                    json_output,
                    "--units",
                    "mm",
                    board_file,
                ]

                logger.info(f"Running DRC command (timeout={timeout_sec}s): {' '.join(cmd)}")

                # Run DRC. subprocess.run kills the child on TimeoutExpired.
                result = subprocess.run(
                    cmd,
                    capture_output=True,
                    text=True,
                    timeout=timeout_sec,
                )

                if result.returncode != 0:
                    logger.error(f"DRC command failed: {result.stderr}")
                    return {
                        "success": False,
                        "message": "DRC command failed",
                        "errorDetails": result.stderr,
                    }

                # Read JSON output
                with open(json_output, "r", encoding="utf-8") as f:
                    drc_data = json.load(f)

                # Parse violations from kicad-cli output
                violations = []
                violation_counts: dict[str, int] = {}
                severity_counts = {"error": 0, "warning": 0, "info": 0}

                for violation in drc_data.get("violations", []):
                    vtype = violation.get("type", "unknown")
                    vseverity = violation.get("severity", "error")

                    # Extract location from first item's pos (kicad-cli JSON format)
                    items = violation.get("items", [])
                    loc_x, loc_y = 0, 0
                    if items and "pos" in items[0]:
                        loc_x = items[0]["pos"].get("x", 0)
                        loc_y = items[0]["pos"].get("y", 0)

                    violations.append(
                        {
                            "type": vtype,
                            "severity": vseverity,
                            "message": violation.get("description", ""),
                            "location": {
                                "x": loc_x,
                                "y": loc_y,
                                "unit": "mm",
                            },
                        }
                    )

                    # Count violations by type
                    violation_counts[vtype] = violation_counts.get(vtype, 0) + 1

                    # Count by severity
                    if vseverity in severity_counts:
                        severity_counts[vseverity] += 1

                # Determine where to save the violations file
                board_dir = os.path.dirname(board_file)
                board_name = os.path.splitext(os.path.basename(board_file))[0]
                violations_file = os.path.join(board_dir, f"{board_name}_drc_violations.json")

                # Always save violations to JSON file (for large result sets)
                with open(violations_file, "w", encoding="utf-8") as f:
                    json.dump(
                        {
                            "board": board_file,
                            "timestamp": drc_data.get("date", "unknown"),
                            "total_violations": len(violations),
                            "violation_counts": violation_counts,
                            "severity_counts": severity_counts,
                            "violations": violations,
                        },
                        f,
                        indent=2,
                    )

                # Save text report if requested
                if report_path:
                    report_path = os.path.abspath(os.path.expanduser(report_path))
                    cmd_report = [
                        kicad_cli,
                        "pcb",
                        "drc",
                        "--format",
                        "report",
                        "--output",
                        report_path,
                        "--units",
                        "mm",
                        board_file,
                    ]
                    subprocess.run(cmd_report, capture_output=True, timeout=timeout_sec)

                # Return summary only (not full violations list)
                return {
                    "success": True,
                    "message": f"Found {len(violations)} DRC violations",
                    "summary": {
                        "total": len(violations),
                        "by_severity": severity_counts,
                        "by_type": violation_counts,
                    },
                    "violationsFile": violations_file,
                    "reportPath": report_path if report_path else None,
                }

            finally:
                # Clean up temp JSON file
                if os.path.exists(json_output):
                    os.unlink(json_output)

        except subprocess.TimeoutExpired:
            logger.error(f"DRC command timed out after {timeout_sec}s")
            return {
                "success": False,
                "message": "DRC command timed out",
                "errorDetails": (
                    f"Command took longer than {timeout_sec} seconds; "
                    "raise timeoutSec param for very large boards"
                ),
            }
        except Exception as e:
            logger.error(f"Error running DRC: {str(e)}")
            return {
                "success": False,
                "message": "Failed to run DRC",
                "errorDetails": str(e),
            }

    def _find_kicad_cli(self) -> Optional[str]:
        """Find kicad-cli executable via the centralized resolver.

        Resolution order: $KICAD_CLI override -> next to the running interpreter
        (KiCad's bundled python bin/) -> PATH -> known per-OS install locations.
        """
        return resolve_kicad_cli()

    def get_drc_violations(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """
        Get list of DRC violations

        Note: This command internally uses run_drc() which calls kicad-cli.
        The old BOARD.GetDRCMarkers() API was removed in KiCAD 9.0.
        This implementation provides backward compatibility by parsing kicad-cli output.
        """
        import json

        try:
            if not self.board:
                return {
                    "success": False,
                    "message": "No board is loaded",
                    "errorDetails": "Load or create a board first",
                }

            severity = params.get("severity", "all")

            # Run DRC using kicad-cli (this saves violations to JSON file)
            drc_result = self.run_drc({})

            if not drc_result.get("success"):
                return drc_result  # Return the error from run_drc

            # Read violations from the saved JSON file
            violations_file = drc_result.get("violationsFile")
            if not violations_file or not os.path.exists(violations_file):
                return {
                    "success": False,
                    "message": "Violations file not found",
                    "errorDetails": "run_drc did not create violations file",
                }

            # Load violations from file
            with open(violations_file, "r", encoding="utf-8") as f:
                data = json.load(f)

            all_violations = data.get("violations", [])

            # Filter by severity if specified
            if severity != "all":
                filtered_violations = [v for v in all_violations if v.get("severity") == severity]
            else:
                filtered_violations = all_violations

            return {
                "success": True,
                "violations": filtered_violations,
                "violationsFile": violations_file,  # Include file path for reference
            }

        except Exception as e:
            logger.error(f"Error getting DRC violations: {str(e)}")
            return {
                "success": False,
                "message": "Failed to get DRC violations",
                "errorDetails": str(e),
            }