from __future__ import annotations

import os
import re
import math
from pathlib import Path


TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop"))
OUTPUT = "task-14.nc"
TOL = 0.75
FORBIDDEN_EXTENSIONS = {
    ".py", ".pyw", ".ipynb", ".sh", ".bat", ".cmd", ".ps1", ".vbs",
    ".js", ".mjs", ".ts", ".rb", ".lua", ".tcl", ".ahk", ".scr",
}


def strip_comments(line: str) -> str:
    line = re.sub(r"\([^)]*\)", " ", line)
    return line.split(";", 1)[0].strip().upper()


def no_bypass_files(root: Path) -> bool:
    try:
        return not any(
            path.is_file()
            and path.name.lower() != "eval.py"
            and path.suffix.lower() in FORBIDDEN_EXTENSIONS
            for path in root.rglob("*")
        )
    except Exception:
        return False


def close(a: float, b: float, tol: float = TOL) -> bool:
    return abs(float(a) - float(b)) <= tol


def parse_program(src: str):
    raw_lines = src.upper().splitlines()
    executable = []
    for index, raw in enumerate(raw_lines):
        code = strip_comments(raw)
        if code and code != "%":
            executable.append((index, code))
    if not executable:
        raise ValueError("empty program")

    m30_positions = [pos for pos, (_, code) in enumerate(executable) if re.search(r"\bM0*30\b", code)]
    if len(m30_positions) != 1 or m30_positions[0] != len(executable) - 1:
        raise ValueError("M30 must be the final executable block")

    program_words = [int(value) for _, code in executable for value in re.findall(r"\bO0*(\d+)\b", code)]
    if program_words != [2034]:
        raise ValueError("expected exactly O2034")
    if any(re.search(r"\bG0*20\b", code) for _, code in executable):
        raise ValueError("inch mode is forbidden")
    if not any(re.search(r"\bG0*21\b", code) for _, code in executable):
        raise ValueError("metric mode is required")

    numbered = []
    for _, code in executable:
        if re.search(r"\bO0*2034\b", code) and not re.match(r"^N\d+\b", code):
            continue
        match = re.match(r"^N(\d+)\b", code)
        if match is None:
            raise ValueError("every executable block after O2034 must be numbered")
        numbered.append(int(match.group(1)))
    if len(numbered) < 30 or numbered[0] != 1:
        raise ValueError("sequence must start at N1")
    if any(right - left != 1 for left, right in zip(numbered, numbered[1:])):
        raise ValueError("sequence increment must be 1")

    state = {"x": None, "y": None, "z": None, "motion": None, "tool": None}
    pending_tool = None
    tool_order = []
    records = []
    flags = {"g90": False, "wcs": False, "g43": False, "spindle": False}
    for index, code in executable:
        tool_match = re.search(r"\bT0*(\d+)\b", code)
        if tool_match:
            pending_tool = int(tool_match.group(1))
        if re.search(r"\bM0*6\b", code):
            if pending_tool is None:
                raise ValueError("M6 without a selected tool")
            state["tool"] = pending_tool
            if pending_tool not in tool_order:
                tool_order.append(pending_tool)
        if re.search(r"\bG0*90\b", code):
            flags["g90"] = True
        if re.search(r"\bG5[4-9]\b", code):
            flags["wcs"] = True
        if re.search(r"\bG0*43\b", code) and re.search(r"\bH\d+\b", code):
            flags["g43"] = True
        if re.search(r"\bM0*[34]\b", code) and re.search(r"\bS\d+(?:\.\d+)?\b", code):
            flags["spindle"] = True

        g_codes = [int(value) for value in re.findall(r"\bG0*(\d+)\b", code)]
        if 80 in g_codes:
            state["motion"] = None
        explicit_motion = next((value for value in g_codes if value in {0, 1, 2, 3, 81, 82, 83}), None)
        if explicit_motion is not None:
            state["motion"] = explicit_motion
        explicit = {}
        for axis in "XYZQRF":
            match = re.search(rf"\b{axis}([+-]?\d+(?:\.\d+)?)", code)
            if match:
                explicit[axis.lower()] = float(match.group(1))
        if state["motion"] is None or not any(axis in explicit for axis in ("x", "y", "z")):
            continue
        start = {axis: state[axis] for axis in ("x", "y", "z")}
        for axis in ("x", "y", "z"):
            if axis in explicit:
                state[axis] = explicit[axis]
        records.append(
            {
                "index": index,
                "code": state["motion"],
                "tool": state["tool"],
                "start": start,
                "end": {axis: state[axis] for axis in ("x", "y", "z")},
                "explicit": explicit,
            }
        )
    return raw_lines, tool_order, records, flags


def xy_changed(record) -> bool:
    start, end = record["start"], record["end"]
    return (
        None not in (start["x"], start["y"], end["x"], end["y"])
        and (not close(start["x"], end["x"], 1e-6) or not close(start["y"], end["y"], 1e-6))
    )


def _unique_points(records) -> list[tuple[float, float]]:
    points: list[tuple[float, float]] = []
    for record in records:
        end = record["end"]
        if end["x"] is None or end["y"] is None:
            continue
        point = (float(end["x"]), float(end["y"]))
        if not any(close(point[0], old[0]) and close(point[1], old[1]) for old in points):
            points.append(point)
    return points


def _drill_frame(points: list[tuple[float, float]]):
    """Return the center and local long/short axes of a 50 x 30 hole rectangle."""
    if len(points) != 4:
        return None
    center = (
        sum(point[0] for point in points) / 4.0,
        sum(point[1] for point in points) / 4.0,
    )
    if any(
        not any(
            close(other[0], 2 * center[0] - point[0])
            and close(other[1], 2 * center[1] - point[1])
            for other in points
        )
        for point in points
    ):
        return None

    origin = points[0]
    vectors = []
    for point in points[1:]:
        dx, dy = point[0] - origin[0], point[1] - origin[1]
        vectors.append((math.hypot(dx, dy), dx, dy))
    vectors.sort()
    short, long, diagonal = vectors
    if not (
        close(short[0], 30.0)
        and close(long[0], 50.0)
        and close(diagonal[0], math.hypot(30.0, 50.0))
    ):
        return None
    dot = short[1] * long[1] + short[2] * long[2]
    if abs(dot) > 30.0 * 50.0 * 0.02:
        return None
    long_axis = (long[1] / long[0], long[2] / long[0])
    short_axis = (short[1] / short[0], short[2] / short[0])
    return center, long_axis, short_axis


def _project(point, center, long_axis, short_axis):
    dx, dy = point[0] - center[0], point[1] - center[1]
    return (
        dx * long_axis[0] + dy * long_axis[1],
        dx * short_axis[0] + dy * short_axis[1],
    )


def _vertical_plunge(record) -> bool:
    if record["code"] != 1:
        return False
    start, end = record["start"], record["end"]
    return (
        None not in (start["x"], start["y"], start["z"], end["x"], end["y"], end["z"])
        and close(start["x"], end["x"])
        and close(start["y"], end["y"])
        and float(end["z"]) < float(start["z"]) - 0.5
    )


def validate(path: Path) -> bool:
    if not path.is_file() or path.stat().st_size < 500:
        return False
    src = path.read_text(encoding="utf-8", errors="ignore")
    _raw_lines, tools, records, flags = parse_program(src)
    if len(tools) < 2 or not all(flags.values()):
        return False

    drill_candidates = []
    for tool in tools:
        visits = [
            record
            for record in records
            if record["tool"] == tool
            and record["end"]["z"] is not None
            and (record["code"] in {81, 83} or _vertical_plunge(record))
        ]
        points = _unique_points(visits)
        frame = _drill_frame(points)
        if frame is not None:
            drill_candidates.append((min(float(record["end"]["z"]) for record in visits), tool, visits, frame))
    if not drill_candidates:
        return False
    drill_z, drill_tool, drill_records, frame = min(drill_candidates)
    center, long_axis, short_axis = frame

    pocket_tools = []
    for tool in tools:
        if tool == drill_tool:
            continue
        pocket_cuts = [
            record
            for record in records
            if record["tool"] == tool
            and record["code"] in {1, 2, 3}
            and xy_changed(record)
            and record["end"]["z"] is not None
        ]
        if not pocket_cuts:
            continue
        pocket_z = min(float(record["end"]["z"]) for record in pocket_cuts)
        deep = [record for record in pocket_cuts if close(record["end"]["z"], pocket_z)]
        if len(deep) < 10:
            continue
        projected = [
            _project(
                (float(record["end"]["x"]), float(record["end"]["y"])),
                center,
                long_axis,
                short_axis,
            )
            for record in deep
        ]
        longs = [point[0] for point in projected]
        shorts = [point[1] for point in projected]
        if max(longs) - min(longs) < 30.0 or max(shorts) - min(shorts) < 12.0:
            continue
        long_tracks = {round(value, 1) for value in longs}
        short_tracks = {round(value, 1) for value in shorts}
        if max(len(long_tracks), len(short_tracks)) < 4:
            continue
        if any(abs(long) > 21.5 or abs(short) > 12.5 for long, short in projected):
            continue
        if not all(
            any(
                (long >= 0) == long_positive and (short >= 0) == short_positive
                for long, short in projected
            )
            for long_positive in (False, True)
            for short_positive in (False, True)
        ):
            continue
        if not 6.0 <= pocket_z - drill_z <= 11.0:
            continue
        pocket_tools.append(tool)
    if not pocket_tools:
        return False
    if any(
        record["code"] == 83
        and "q" in record["explicit"]
        and record["explicit"]["q"] <= 0
        for record in drill_records
    ):
        return False
    return True


def main() -> bool:
    return no_bypass_files(TARGET) and validate(TARGET / OUTPUT)


if __name__ == "__main__":
    try:
        result = main()
    except Exception:
        result = False
    print("True" if result else "False")