from __future__ import annotations

import math
import os
import re
from collections import defaultdict
from pathlib import Path


TARGET = Path(os.environ.get("EVAL_TARGET_DIR", "/home/user/Desktop"))
PROGRAM = TARGET / "task-13.nc"
XY_TOL = 0.15
Z_TOL = 0.10
RADIUS_TOL = 0.10
PITCH_TOL = 0.05

HOLES = {
    "H01": (-45.0, -25.0, "through"),
    "H02": (-15.0, -25.0, "through"),
    "H03": (15.0, -25.0, "through"),
    "H04": (45.0, -25.0, "through"),
    "H05": (-45.0, 25.0, "through"),
    "H06": (-15.0, 25.0, "through"),
    "H07": (15.0, 25.0, "through"),
    "H08": (45.0, 25.0, "through"),
    "H09": (-45.0, 0.0, "blind"),
    "H10": (-30.0, 0.0, "blind"),
    "H11": (-15.0, 0.0, "blind"),
    "H12": (0.0, 0.0, "blind"),
    "H13": (0.0, 25.0, "blind"),
    "H14": (15.0, 0.0, "blind"),
    "H15": (30.0, 0.0, "blind"),
    "H16": (45.0, 0.0, "blind"),
    "H17": (-30.0, 15.0, "counterbore"),
    "H18": (-10.0, 15.0, "counterbore"),
    "H19": (10.0, 15.0, "counterbore"),
    "H20": (30.0, 15.0, "counterbore"),
    "H21": (-30.0, -15.0, "threaded_pilot"),
    "H22": (-10.0, -15.0, "threaded_pilot"),
    "H23": (10.0, -15.0, "threaded_pilot"),
    "H24": (30.0, -15.0, "threaded_pilot"),
}

GROUP_IDS = {
    kind: {hole_id for hole_id, (_, _, group) in HOLES.items() if group == kind}
    for kind in {group for _, _, group in HOLES.values()}
}

EXPECTED_DEPTHS = {
    1: {hole_id: -1.0 for hole_id in HOLES},
    2: {
        **{hole_id: -19.0 for hole_id in GROUP_IDS["through"]},
        **{hole_id: -7.0 for hole_id in GROUP_IDS["blind"]},
        **{hole_id: -8.0 for hole_id in GROUP_IDS["counterbore"]},
    },
    3: {hole_id: -19.0 for hole_id in GROUP_IDS["threaded_pilot"]},
}

WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))")


def uncomment(source: str) -> str:
    lines = []
    for raw in source.upper().splitlines():
        depth = 0
        kept = []
        for character in raw:
            if character == ";" and depth == 0:
                break
            if character == "(":
                depth += 1
            elif character == ")" and depth:
                depth -= 1
            elif depth == 0:
                kept.append(character)
        line = "".join(kept).strip()
        if line:
            lines.append(line)
    return "\n".join(lines)


def words(line: str) -> dict[str, list[float]]:
    parsed: dict[str, list[float]] = defaultdict(list)
    for letter, value in WORD_RE.findall(line):
        parsed[letter].append(float(value))
    return parsed


def nearest_hole(x: float | None, y: float | None) -> str | None:
    if x is None or y is None:
        return None
    matches = [
        hole_id
        for hole_id, (hx, hy, _) in HOLES.items()
        if math.hypot(x - hx, y - hy) <= XY_TOL
    ]
    return matches[0] if len(matches) == 1 else None


def parse_program(source: str) -> tuple[
    dict[int, list[str]],
    dict[int, dict[str, list[float]]],
    dict[int, list[dict[str, float | int | str]]],
    dict[int, bool],
    list[int],
    bool,
]:
    tool_lines: dict[int, list[str]] = defaultdict(list)
    plunges: dict[int, dict[str, list[float]]] = defaultdict(lambda: defaultdict(list))
    arcs: dict[int, list[dict[str, float | int | str]]] = defaultdict(list)
    unexpected_plunge: dict[int, bool] = defaultdict(bool)
    tool_order: list[int] = []
    unsafe_rapid = False
    current_tool: int | None = None
    x = y = z = None

    for line in source.splitlines():
        parsed = words(line)
        if parsed.get("T"):
            current_tool = int(round(parsed["T"][-1]))
            if not tool_order or tool_order[-1] != current_tool:
                tool_order.append(current_tool)
        if current_tool is not None:
            tool_lines[current_tool].append(line)

        g_codes = [int(round(value)) for value in parsed.get("G", [])]
        motion = next((code for code in reversed(g_codes) if code in {0, 1, 2, 3, 81, 82, 83}), None)
        previous_x, previous_y, previous_z = x, y, z
        if parsed.get("X"):
            x = parsed["X"][-1]
        if parsed.get("Y"):
            y = parsed["Y"][-1]
        if parsed.get("Z"):
            z = parsed["Z"][-1]

        if current_tool in {1, 2, 3} and motion in {1, 81, 82, 83} and parsed.get("Z") and z is not None and z < -Z_TOL:
            hole_id = nearest_hole(x, y)
            if hole_id is None:
                unexpected_plunge[current_tool] = True
            else:
                plunges[current_tool][hole_id].append(z)

        if current_tool is not None and motion == 0 and parsed.get("Z") and z is not None and z < -Z_TOL:
            unsafe_rapid = True

        if current_tool is not None and motion in {2, 3} and previous_x is not None and previous_y is not None:
            i = parsed.get("I", [None])[-1]
            j = parsed.get("J", [None])[-1]
            if i is None or j is None:
                continue
            end_x = x if x is not None else previous_x
            end_y = y if y is not None else previous_y
            start_z = previous_z if previous_z is not None else z
            end_z = z if z is not None else previous_z
            if start_z is None or end_z is None:
                continue
            center_x = previous_x + i
            center_y = previous_y + j
            arcs[current_tool].append(
                {
                    "code": motion,
                    "start_x": previous_x,
                    "start_y": previous_y,
                    "start_z": start_z,
                    "end_x": end_x,
                    "end_y": end_y,
                    "end_z": end_z,
                    "center_x": center_x,
                    "center_y": center_y,
                    "radius": math.hypot(i, j),
                    "end_radius": math.hypot(end_x - center_x, end_y - center_y),
                    "hole_id": nearest_hole(center_x, center_y) or "",
                }
            )

    return tool_lines, plunges, arcs, unexpected_plunge, tool_order, unsafe_rapid


def has_setting(lines: list[str], letter: str, value: int) -> bool:
    pattern = re.compile(rf"\b{letter}\s*0*{value}(?:\.0+)?\b")
    return any(pattern.search(line) for line in lines)


def has_word_value(lines: list[str], letter: str, value: float) -> bool:
    return any(
        any(abs(actual - value) <= 1e-6 for actual in words(line).get(letter, []))
        for line in lines
    )


def has_tool_change(lines: list[str], tool: int) -> bool:
    return any(
        any(abs(actual - tool) <= 1e-6 for actual in words(line).get("T", []))
        and any(abs(actual - 6.0) <= 1e-6 for actual in words(line).get("M", []))
        for line in lines
    )


def check_plunges(
    plunges: dict[int, dict[str, list[float]]],
    unexpected: dict[int, bool],
) -> bool:
    for tool, expected in EXPECTED_DEPTHS.items():
        if unexpected.get(tool, False) or set(plunges.get(tool, {})) != set(expected):
            return False
        for hole_id, target_z in expected.items():
            actual = min(plunges[tool][hole_id])
            if abs(actual - target_z) > Z_TOL:
                return False
    return True


def arc_sweep(arc: dict[str, float | int | str]) -> float:
    start = math.atan2(
        float(arc["start_y"]) - float(arc["center_y"]),
        float(arc["start_x"]) - float(arc["center_x"]),
    )
    end = math.atan2(
        float(arc["end_y"]) - float(arc["center_y"]),
        float(arc["end_x"]) - float(arc["center_x"]),
    )
    if int(arc["code"]) == 3:
        sweep = (end - start) % (2.0 * math.pi)
    else:
        sweep = (start - end) % (2.0 * math.pi)
    return 2.0 * math.pi if sweep < 1e-6 else sweep


def descending_arcs(arcs: list[dict[str, float | int | str]]) -> list[dict[str, float | int | str]]:
    return [arc for arc in arcs if float(arc["end_z"]) < float(arc["start_z"]) - 1e-5]


def check_counterbores(arcs: dict[int, list[dict[str, float | int | str]]]) -> bool:
    expected = GROUP_IDS["counterbore"]
    descending = descending_arcs(arcs.get(4, []))
    if not descending or {str(arc["hole_id"]) for arc in descending} != expected:
        return False
    grouped: dict[str, list[dict[str, float | int | str]]] = defaultdict(list)
    for arc in descending:
        hole_id = str(arc["hole_id"])
        if hole_id not in expected or abs(float(arc["radius"]) - 3.0) > RADIUS_TOL:
            return False
        if abs(float(arc["end_radius"]) - 3.0) > RADIUS_TOL:
            return False
        grouped[hole_id].append(arc)
    for hole_id in expected:
        path = grouped[hole_id]
        if abs(float(path[0]["start_z"])) > Z_TOL:
            return False
        for previous, current in zip(path, path[1:]):
            if abs(float(previous["end_z"]) - float(current["start_z"])) > Z_TOL:
                return False
        if abs(float(path[-1]["end_z"]) + 3.0) > Z_TOL:
            return False
        if sum(arc_sweep(arc) for arc in path) < 2.0 * math.pi - 0.05:
            return False
    return True


def check_threads(arcs: dict[int, list[dict[str, float | int | str]]]) -> bool:
    expected = GROUP_IDS["threaded_pilot"]
    descending = descending_arcs(arcs.get(5, []))
    if not descending or {str(arc["hole_id"]) for arc in descending} != expected:
        return False
    grouped: dict[str, list[dict[str, float | int | str]]] = defaultdict(list)
    for arc in descending:
        hole_id = str(arc["hole_id"])
        if hole_id not in expected or int(arc["code"]) != 3:
            return False
        if abs(float(arc["radius"]) - 1.5) > RADIUS_TOL:
            return False
        if abs(float(arc["end_radius"]) - 1.5) > RADIUS_TOL:
            return False
        sweep = arc_sweep(arc)
        pitch = (float(arc["start_z"]) - float(arc["end_z"])) * 2.0 * math.pi / sweep
        if abs(pitch - 1.25) > PITCH_TOL:
            return False
        grouped[hole_id].append(arc)

    for hole_id in expected:
        path = grouped[hole_id]
        if abs(float(path[0]["start_z"])) > Z_TOL:
            return False
        for previous, current in zip(path, path[1:]):
            if abs(float(previous["end_z"]) - float(current["start_z"])) > Z_TOL:
                return False
        if abs(float(path[-1]["end_z"]) + 15.0) > Z_TOL:
            return False
        if abs(sum(arc_sweep(arc) for arc in path) - 24.0 * math.pi) > 0.10:
            return False
    return True


def main() -> bool:
    if not PROGRAM.exists() or PROGRAM.stat().st_size < 1000:
        return False
    source = uncomment(PROGRAM.read_text(encoding="utf-8", errors="ignore"))
    source_lines = source.splitlines()
    first_tool = next((index for index, line in enumerate(source_lines) if words(line).get("T")), None)
    if first_tool is None:
        return False
    header = source_lines[:first_tool]
    if not all(has_word_value(header, "G", code) for code in (21.0, 90.0, 91.1, 54.0)):
        return False

    tool_lines, plunges, arcs, unexpected, tool_order, unsafe_rapid = parse_program(source)
    if unsafe_rapid or tool_order != [1, 2, 3, 4, 5] or set(tool_lines) != {1, 2, 3, 4, 5}:
        return False
    for tool in range(1, 6):
        if not has_tool_change(tool_lines[tool], tool):
            return False
        if not has_setting(tool_lines[tool], "S", 7000) or not has_setting(tool_lines[tool], "F", 500):
            return False
    if not has_word_value(tool_lines[5], "M", 30.0):
        return False

    return check_plunges(plunges, unexpected) and check_counterbores(arcs) and check_threads(arcs)


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