from __future__ import annotations

import math
import os
import re
from dataclasses import dataclass
from pathlib import Path


TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop"))
NC_NAME = "task-20.nc"
WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))")

CONTRACT = {
    "program": 2040,
    "part_half": (60.0, 40.0),
    "tools": {
        1: {"diameter": 16.0, "spindle": 6500.0, "feed": 700.0},
        2: {"diameter": 10.0, "spindle": 8000.0, "feed": 500.0},
        3: {"diameter": 5.0, "spindle": 5000.0, "feed": 180.0},
        4: {"diameter": 8.0, "spindle": 5500.0, "feed": 220.0},
    },
    "pockets": (
        (-48.0, -22.0, -10.0, 10.0),
        (-13.0, 13.0, -10.0, 10.0),
        (22.0, 48.0, -10.0, 10.0),
    ),
    "holes": tuple(
        (x, y)
        for x in (-45.0, -15.0, 15.0, 45.0)
        for y in (-28.0, -12.0, 12.0, 28.0)
    ),
    "counterbores": ((-30.0, 25.0), (30.0, 25.0)),
}


class EvaluationError(ValueError):
    pass


@dataclass(frozen=True)
class Point:
    x: float
    y: float
    z: float


@dataclass
class Segment:
    start: Point
    end: Point
    samples: list[Point]
    motion: int
    tool: int | None
    spindle: float | None
    spindle_on: bool
    feed: float | None
    wcs: str | None
    length_comp: bool
    h_offset: int | None


@dataclass
class Program:
    segments: list[Segment]
    tools: list[int]
    programs: list[int]
    terminated: bool
    executable_lines: int


def close(actual: float, expected: float, tolerance: float) -> bool:
    return abs(actual - expected) <= tolerance


def distance(a: Point, b: Point) -> float:
    return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z))


def path_length(points: list[Point]) -> float:
    return sum(distance(a, b) for a, b in zip(points, points[1:]))


def dense_line(a: Point, b: Point, spacing: float = 0.5) -> list[Point]:
    count = max(1, int(math.ceil(distance(a, b) / spacing)))
    return [
        Point(
            a.x + (b.x - a.x) * index / count,
            a.y + (b.y - a.y) * index / count,
            a.z + (b.z - a.z) * index / count,
        )
        for index in range(count + 1)
    ]


def arc_points(a: Point, b: Point, i: float, j: float, clockwise: bool) -> list[Point]:
    cx, cy = a.x + i, a.y + j
    radius = math.hypot(a.x - cx, a.y - cy)
    end_radius = math.hypot(b.x - cx, b.y - cy)
    if radius <= 1e-6 or not close(end_radius, radius, 0.25):
        raise EvaluationError("invalid I/J arc")
    start = math.atan2(a.y - cy, a.x - cx)
    finish = math.atan2(b.y - cy, b.x - cx)
    sweep = (start - finish) % (2 * math.pi) if clockwise else (finish - start) % (2 * math.pi)
    if sweep <= 1e-9:
        sweep = 2 * math.pi
    direction = -1.0 if clockwise else 1.0
    count = max(16, int(math.ceil(radius * sweep / 0.35)))
    return [
        Point(
            cx + radius * math.cos(start + direction * sweep * index / count),
            cy + radius * math.sin(start + direction * sweep * index / count),
            a.z + (b.z - a.z) * index / count,
        )
        for index in range(count + 1)
    ]


def strip_comments(src: str) -> list[str]:
    lines: list[str] = []
    depth = 0
    for raw in src.upper().splitlines():
        clean: list[str] = []
        for char in raw:
            if char == ";" and depth == 0:
                break
            if char == "(":
                depth += 1
            elif char == ")":
                if depth == 0:
                    raise EvaluationError("unmatched comment")
                depth -= 1
            elif depth == 0:
                clean.append(char)
        lines.append("".join(clean).strip())
    if depth:
        raise EvaluationError("unterminated comment")
    return lines


def parse_program(src: str) -> Program:
    units: str | None = None
    absolute: bool | None = None
    motion: int | None = None
    current = Point(0.0, 0.0, 0.0)
    pending_tool: int | None = None
    tool: int | None = None
    spindle: float | None = None
    feed: float | None = None
    spindle_on = False
    wcs: str | None = None
    length_comp = False
    h_offset: int | None = None
    cycle: int | None = None
    cycle_z: float | None = None
    cycle_r: float | None = None
    terminated = False
    executable = 0
    tools: list[int] = []
    programs: list[int] = []
    segments: list[Segment] = []

    for line in strip_comments(src):
        if not line or line == "%":
            continue
        if any(char in line for char in "#[]="):
            raise EvaluationError("macros and expressions are unsupported")
        if re.fullmatch(r"O\d+", line):
            if terminated:
                raise EvaluationError("code after M30")
            programs.append(int(line[1:]))
            executable += 1
            continue
        words = WORD_RE.findall(line)
        remainder = re.sub(r"[\s/]+", "", WORD_RE.sub("", line))
        if not words or remainder:
            raise EvaluationError("unknown executable text")
        if terminated:
            raise EvaluationError("code after M30")
        executable += 1
        grouped: dict[str, list[float]] = {}
        for letter, value in words:
            grouped.setdefault(letter, []).append(float(value))
        if any(axis in grouped for axis in ("A", "B", "C")):
            raise EvaluationError("rotary axis is forbidden")
        if any(letter not in "NGMXYZIJRQPTSFHD" for letter in grouped):
            raise EvaluationError("unsupported address word")

        machine_move = False
        set_length: bool | None = None
        for g in grouped.get("G", []):
            rounded = int(round(g))
            if close(g, 20.0, 1e-6):
                units = "inch"
            elif close(g, 21.0, 1e-6):
                units = "mm"
            elif close(g, 90.0, 1e-6):
                absolute = True
            elif close(g, 91.0, 1e-6):
                absolute = False
            elif rounded in (0, 1, 2, 3) and close(g, float(rounded), 1e-6):
                motion = rounded
            elif rounded in (54, 55, 56, 57, 58, 59) and close(g, float(rounded), 1e-6):
                wcs = f"G{rounded}"
            elif close(g, 54.1, 1e-6):
                p_value = int(round(grouped.get("P", [0.0])[-1]))
                if p_value <= 0:
                    raise EvaluationError("invalid extended WCS")
                wcs = f"G54.1P{p_value}"
            elif close(g, 43.0, 1e-6):
                set_length = True
            elif close(g, 49.0, 1e-6):
                set_length = False
            elif rounded in (81, 82, 83) and close(g, float(rounded), 1e-6):
                cycle = rounded
            elif close(g, 80.0, 1e-6):
                cycle = None
            elif rounded in (28, 53) and close(g, float(rounded), 1e-6):
                machine_move = True
            elif rounded in (17, 40, 41, 42, 94, 98, 99) and close(g, float(rounded), 1e-6):
                pass
            else:
                raise EvaluationError(f"unsupported G{g:g}")

        mcodes = [int(round(value)) for value in grouped.get("M", [])]
        if any(code not in (0, 1, 3, 4, 5, 6, 8, 9, 30) for code in mcodes):
            raise EvaluationError("unsupported M code")
        if "T" in grouped:
            pending_tool = int(round(grouped["T"][-1]))
            if pending_tool <= 0:
                raise EvaluationError("invalid tool number")
        if 6 in mcodes:
            if pending_tool is None:
                raise EvaluationError("M6 without T")
            tool = pending_tool
            tools.append(tool)
            spindle = None
            feed = None
            spindle_on = False
            length_comp = False
            h_offset = None
            cycle = None
            cycle_z = None
            cycle_r = None

        factor = 25.4 if units == "inch" else 1.0
        if "S" in grouped:
            spindle = grouped["S"][-1]
        if "F" in grouped:
            feed = grouped["F"][-1] * factor
        if "H" in grouped:
            h_offset = int(round(grouped["H"][-1]))
        if set_length is True:
            length_comp = True
        elif set_length is False:
            length_comp = False
            h_offset = None
        if 3 in mcodes or 4 in mcodes:
            spindle_on = True
        if 5 in mcodes:
            spindle_on = False
        if 30 in mcodes:
            terminated = True

        has_position = any(axis in grouped for axis in ("X", "Y", "Z"))
        has_arc = motion in (2, 3) and "I" in grouped and "J" in grouped
        if (has_position or has_arc or "F" in grouped) and units is None:
            raise EvaluationError("motion or feed before units")
        if has_position and absolute is None:
            raise EvaluationError("position before distance mode")

        def coordinate(axis: str, old: float) -> float:
            if axis not in grouped:
                return old
            value = grouped[axis][-1] * factor
            return value if absolute else old + value

        new = Point(
            coordinate("X", current.x),
            coordinate("Y", current.y),
            coordinate("Z", current.z),
        )
        if machine_move:
            continue
        if cycle is not None and has_position:
            if "Z" in grouped:
                cycle_z = new.z
            if "R" in grouped:
                r_value = grouped["R"][-1] * factor
                cycle_r = r_value if absolute else current.z + r_value
            if cycle_z is None or cycle_r is None:
                raise EvaluationError("incomplete drill cycle")
            top = Point(new.x, new.y, cycle_r)
            bottom = Point(new.x, new.y, cycle_z)
            segments.append(Segment(current, top, dense_line(current, top), 0, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset))
            segments.append(Segment(top, bottom, dense_line(top, bottom), 1, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset))
            current = top
            continue
        if (has_position or has_arc) and motion is not None:
            if motion in (2, 3):
                if "I" not in grouped or "J" not in grouped:
                    raise EvaluationError("arc requires I/J")
                samples = arc_points(
                    current,
                    new,
                    grouped["I"][-1] * factor,
                    grouped["J"][-1] * factor,
                    motion == 2,
                )
            else:
                samples = dense_line(current, new)
            segments.append(Segment(current, new, samples, motion, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset))
            current = new
    return Program(segments, tools, programs, terminated, executable)


def cutting_segments(program: Program, tool: int) -> list[Segment]:
    spec = CONTRACT["tools"][tool]
    return [
        segment
        for segment in program.segments
        if segment.tool == tool
        and segment.motion in (1, 2, 3)
        and path_length(segment.samples) > 0.01
        and segment.spindle_on
        and segment.spindle is not None
        and close(segment.spindle, spec["spindle"], 1.0)
        and segment.feed is not None
        and close(segment.feed, spec["feed"], 0.8)
        and segment.wcs == "G54"
        and segment.length_comp
        and segment.h_offset is not None
        and segment.h_offset > 0
    ]


def check_face(program: Program) -> None:
    cuts = cutting_segments(program, 1)
    radius = CONTRACT["tools"][1]["diameter"] / 2.0
    if any(point.z < -0.4 for segment in cuts for point in segment.samples):
        raise EvaluationError("face cut is below the part top")
    points = [point for segment in cuts for point in segment.samples if abs(point.z) <= 0.3]
    targets = [
        (x, y)
        for x in (-60.0, -30.0, 0.0, 30.0, 60.0)
        for y in (-40.0, -20.0, 0.0, 20.0, 40.0)
    ]
    if len(points) < 100 or not all(
        any(math.hypot(point.x - x, point.y - y) <= radius + 0.75 for point in points)
        for x, y in targets
    ):
        raise EvaluationError("face coverage is incomplete")


def check_pockets(program: Program) -> None:
    cuts = cutting_segments(program, 2)
    radius = CONTRACT["tools"][2]["diameter"] / 2.0
    points = [
        point
        for segment in cuts
        if abs(segment.start.z + 3.0) <= 0.35 and abs(segment.end.z + 3.0) <= 0.35
        for point in segment.samples
    ]
    if len(points) < 60:
        raise EvaluationError("pocket-bottom cutting is absent")
    for xmin, xmax, ymin, ymax in CONTRACT["pockets"]:
        local = [
            point
            for point in points
            if xmin - 0.75 <= point.x <= xmax + 0.75
            and ymin - 0.75 <= point.y <= ymax + 0.75
        ]
        targets = [
            (x, y)
            for x in (xmin + radius, (xmin + xmax) / 2.0, xmax - radius)
            for y in (ymin + radius, (ymin + ymax) / 2.0, ymax - radius)
        ]
        if not all(
            any(math.hypot(point.x - x, point.y - y) <= radius + 0.75 for point in local)
            for x, y in targets
        ):
            raise EvaluationError("one or more pockets are incomplete")
    if any(
        not any(
            xmin - 0.75 <= point.x <= xmax + 0.75
            and ymin - 0.75 <= point.y <= ymax + 0.75
            for xmin, xmax, ymin, ymax in CONTRACT["pockets"]
        )
        for point in points
    ):
        raise EvaluationError("unexpected T2 cut at pocket depth")


def unique_locations(values: list[tuple[float, float]], tolerance: float = 0.75) -> list[tuple[float, float]]:
    unique: list[tuple[float, float]] = []
    for x, y in values:
        if not any(math.hypot(x - px, y - py) <= tolerance for px, py in unique):
            unique.append((x, y))
    return unique


def check_drilling(program: Program) -> None:
    cuts = cutting_segments(program, 3)
    if any(point.z < -20.0 for segment in cuts for point in segment.samples):
        raise EvaluationError("drill depth is implausibly deep")
    actual = unique_locations([
        (segment.end.x, segment.end.y)
        for segment in cuts
        if math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) <= 0.25
        and min(segment.start.z, segment.end.z) <= -11.9
    ])
    expected = [*CONTRACT["holes"], *CONTRACT["counterbores"]]
    if len(actual) != len(expected):
        raise EvaluationError("T3 must drill exactly 18 physical locations")
    if any(
        not any(math.hypot(x - px, y - py) <= 0.75 for px, py in actual)
        for x, y in expected
    ):
        raise EvaluationError("a required T3 through hole is missing")
    if any(
        not any(math.hypot(x - px, y - py) <= 0.75 for x, y in expected)
        for px, py in actual
    ):
        raise EvaluationError("an unexpected T3 through hole is present")


def check_counterbores(program: Program) -> None:
    cuts = cutting_segments(program, 4)
    if any(point.z < -3.5 for segment in cuts for point in segment.samples):
        raise EvaluationError("counterbore is too deep")
    for center_x, center_y in CONTRACT["counterbores"]:
        candidates = []
        for segment in cuts:
            if segment.motion not in (2, 3):
                continue
            samples = [point for point in segment.samples if abs(point.z + 3.0) <= 0.35]
            if len(samples) < 12 or distance(samples[0], samples[-1]) > 1.0:
                continue
            radii = [math.hypot(point.x - center_x, point.y - center_y) for point in samples]
            mean_radius = sum(radii) / len(radii)
            if 0.5 <= mean_radius <= 5.5 and max(abs(value - mean_radius) for value in radii) <= 0.5:
                bins = {
                    int((math.atan2(point.y - center_y, point.x - center_x) % (2 * math.pi)) / (2 * math.pi) * 12) % 12
                    for point in samples
                }
                if len(bins) >= 10:
                    candidates.append(segment)
        if not candidates:
            raise EvaluationError("counterbore lacks a complete circular T4 cut")
    for segment in cuts:
        for point in segment.samples:
            if point.z <= -0.5 and min(
                math.hypot(point.x - x, point.y - y)
                for x, y in CONTRACT["counterbores"]
            ) > 6.0:
                raise EvaluationError("unexpected T4 cutting location")


def profile_runs(program: Program) -> list[list[Point]]:
    runs: list[list[Point]] = []
    run: list[Point] = []
    for segment in cutting_segments(program, 2):
        horizontal = (
            abs(segment.start.z - segment.end.z) <= 0.3
            and min(segment.start.z, segment.end.z) <= -11.65
        )
        if horizontal:
            if run and distance(run[-1], segment.start) > 0.75:
                runs.append(run)
                run = []
            if not run:
                run.append(segment.start)
            run.extend(segment.samples[1:])
        elif run:
            runs.append(run)
            run = []
    if run:
        runs.append(run)
    return runs


def check_profile(program: Program) -> None:
    cuts = cutting_segments(program, 2)
    if any(point.z < -12.5 for segment in cuts for point in segment.samples):
        raise EvaluationError("outside profile is too deep")
    for run in profile_runs(program):
        for offset in (0.0, 5.0):
            xedge, yedge = 60.0 + offset, 40.0 + offset
            anchors = [
                *[(x, yedge) for x in (-xedge, 0.0, xedge)],
                *[(x, -yedge) for x in (-xedge, 0.0, xedge)],
                *[(-xedge, y) for y in (-yedge, 0.0, yedge)],
                *[(xedge, y) for y in (-yedge, 0.0, yedge)],
            ]
            if path_length(run) >= 320.0 and all(
                any(math.hypot(point.x - x, point.y - y) <= 1.75 for point in run)
                for x, y in anchors
            ):
                return
    raise EvaluationError("full-depth outside profile is incomplete")


def validate_program(program: Program) -> None:
    if not program.terminated or program.executable_lines < 50:
        raise EvaluationError("incomplete program")
    if program.programs != [CONTRACT["program"]]:
        raise EvaluationError("wrong O-number")
    if set(program.tools) != set(CONTRACT["tools"]):
        raise EvaluationError("tool set must be exactly T1 through T4")
    for tool in CONTRACT["tools"]:
        if not cutting_segments(program, tool):
            raise EvaluationError(f"T{tool} lacks valid cutting motion")
    check_face(program)
    check_pockets(program)
    check_drilling(program)
    check_counterbores(program)
    check_profile(program)


def evaluate_text(src: str) -> bool:
    try:
        validate_program(parse_program(src))
        return True
    except (EvaluationError, ValueError, OverflowError):
        return False


def main() -> bool:
    path = TARGET / NC_NAME
    if not path.is_file() or path.stat().st_size <= 0 or path.stat().st_size > 2_000_000:
        return False
    return evaluate_text(path.read_text(encoding="utf-8", errors="strict"))


if __name__ == "__main__":
    try:
        ok = main()
    except Exception:
        ok = False
    print("True" if ok else "False")
    raise SystemExit(0)