from __future__ import annotations

import hashlib
import json
import re
from datetime import datetime
from pathlib import Path
from typing import Any

TARGET = Path(__import__("os").environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop"))
EXPECTED_INIT_SHA256 = "57ca918f0e5f6f050c5da942ff9037bd3b8dad17dbf0d0a98726ac9572e4c70b"
EXPECTED_OPERATIONS = [
    "ROUGH MILL1", "ROUGH MILL2", "CONTOUR MILL1", "ROUGH MILL3", "ROUGH MILL4", "CONTOUR MILL2",
    "ROUGH MILL5", "ROUGH MILL6", "CONTOUR MILL3", "ROUGH MILL7", "ROUGH MILL8", "CONTOUR MILL4",
    "ROUGH MILL9", "ROUGH MILL10", "CONTOUR MILL5", "CENTER DRILL1", "DRILL1",
]
EXPECTED_TOOLS = {1, 2, 3, 4, 5, 15, 16}
EXPECTED_TOOL_BY_OPERATION = {
    "ROUGH MILL1": 5, "ROUGH MILL2": 2, "CONTOUR MILL1": 2, "ROUGH MILL3": 5,
    "ROUGH MILL4": 2, "CONTOUR MILL2": 2, "ROUGH MILL5": 5, "ROUGH MILL6": 3,
    "CONTOUR MILL3": 4, "ROUGH MILL7": 4, "ROUGH MILL8": 3, "CONTOUR MILL4": 4,
    "ROUGH MILL9": 5, "ROUGH MILL10": 3, "CONTOUR MILL5": 1, "CENTER DRILL1": 15, "DRILL1": 16,
}
EXPECTED_FEATURES = {
    "IRREGULAR POCKET1", "IRREGULAR POCKET2", "RECTANGULAR POCKET1",
    "IRREGULAR POCKET3", "IRREGULAR POCKET4", "HOLE GROUP1",
}
NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
WORD_RE = re.compile(rf"([A-Z])({NUMBER})")
OP_RE = re.compile(
    r"^\s*(?:(?:N\d+)\s*)?\(\s*((?:ROUGH|CONTOUR)\s+MILL\d+|CENTER\s+DRILL\d+|DRILL\d+)\s*\)\s*$",
    re.IGNORECASE,
)

def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()

def strip_comments(line: str) -> tuple[str, bool]:
    out: list[str] = []
    depth = 0
    for char in line:
        if char == ";" and depth == 0:
            break
        if char == "(":
            depth += 1
        elif char == ")":
            if depth == 0:
                return "", False
            depth -= 1
        elif depth == 0:
            out.append(char)
    return "".join(out), depth == 0

def normalize_code(line: str) -> tuple[str, bool]:
    code, balanced = strip_comments(line.upper())
    if not balanced:
        return "", False
    code = code.strip().strip("%").strip()
    code = re.sub(r"^N\d+\s*", "", code)
    return code.strip(), True

def words(code: str) -> list[tuple[str, float]]:
    return [(letter, float(number)) for letter, number in WORD_RE.findall(code)]

def g_codes(code: str) -> set[int]:
    return {int(value) for letter, value in words(code) if letter == "G" and value.is_integer()}

def m_codes(code: str) -> set[int]:
    return {int(value) for letter, value in words(code) if letter == "M" and value.is_integer()}

def extract_operations(raw_lines: list[str]) -> list[tuple[str, int]]:
    found: list[tuple[str, int]] = []
    for index, line in enumerate(raw_lines):
        match = OP_RE.match(line)
        if match:
            found.append((re.sub(r"\s+", " ", match.group(1).upper()), index))
    return found

def check_operation_sections(raw_lines: list[str], markers: list[tuple[str, int]]) -> bool:
    current_tool: int | None = None
    for marker_index, (name, start) in enumerate(markers):
        end = markers[marker_index + 1][1] if marker_index + 1 < len(markers) else len(raw_lines)
        section_motion = 0
        section_cycle_points = 0
        for line in raw_lines[start:end]:
            code, balanced = normalize_code(line)
            if not balanced:
                return False
            if not code:
                continue
            parsed = words(code)
            for letter, value in parsed:
                if letter == "T":
                    current_tool = int(round(value))
            axes = {letter for letter, _value in parsed if letter in {"X", "Y", "Z"}}
            codes = g_codes(code)
            if axes and (codes & {0, 1, 2, 3} or not codes):
                section_motion += 1
            if axes and codes & {81, 82, 83}:
                section_cycle_points += 1
        if current_tool != EXPECTED_TOOL_BY_OPERATION[name]:
            return False
        minimum = 4 if name in {"CENTER DRILL1", "DRILL1"} else 8
        if section_motion + section_cycle_points < minimum:
            return False
    return True

def check_nc(path: Path) -> bool:
    if not path.is_file() or not (30000 <= path.stat().st_size <= 2_000_000):
        return False
    raw = path.read_text(encoding="utf-8", errors="strict")
    if "\x00" in raw:
        return False
    raw_lines = raw.splitlines()
    markers = extract_operations(raw_lines)
    if [name for name, _index in markers] != EXPECTED_OPERATIONS:
        return False
    executable: list[str] = []
    for line in raw_lines:
        code, balanced = normalize_code(line)
        if not balanced:
            return False
        if code and not re.fullmatch(r"O\d+", code):
            executable.append(code)
    if not executable:
        return False
    m30_positions = [i for i, code in enumerate(executable) if 30 in m_codes(code)]
    if len(m30_positions) != 1 or m30_positions[0] != len(executable) - 1:
        return False
    executable = executable[:m30_positions[0] + 1]
    all_code = "\n".join(executable)
    all_g = set().union(*(g_codes(line) for line in executable))
    all_m = set().union(*(m_codes(line) for line in executable))
    if not {21, 54, 90}.issubset(all_g) or not {3, 6, 8, 9, 30}.issubset(all_m):
        return False
    if not {40, 43, 80, 82, 83}.issubset(all_g):
        return False
    tools = {int(value) for value in re.findall(r"\bT0*(\d+)(?![\d.])", all_code)}
    length_offsets = {int(value) for value in re.findall(r"\bH0*(\d+)(?![\d.])", all_code)}
    if tools != EXPECTED_TOOLS or not EXPECTED_TOOLS.issubset(length_offsets):
        return False
    if sum(6 in m_codes(line) for line in executable) < 7 or sum(43 in g_codes(line) for line in executable) < 7:
        return False
    motion_mode: int | None = None
    cycle_mode: int | None = None
    absolute = True
    x = y = z = 0.0
    points: list[tuple[float, float, float]] = []
    explicit_arcs = 0
    feed_values: list[float] = []
    spindle_values: list[float] = []
    cycle_points = {82: 0, 83: 0}
    for code in executable:
        parsed = words(code)
        codes = g_codes(code)
        if 90 in codes: absolute = True
        if 91 in codes: absolute = False
        for candidate in (0, 1, 2, 3):
            if candidate in codes: motion_mode = candidate
        if 80 in codes: cycle_mode = None
        for candidate in (81, 82, 83):
            if candidate in codes: cycle_mode = candidate
        explicit_arcs += int(bool(codes & {2, 3}))
        for letter, value in parsed:
            if letter == "F" and value > 0: feed_values.append(value)
            if letter == "S" and value > 0: spindle_values.append(value)
        axis_values = {letter: value for letter, value in parsed if letter in {"X", "Y", "Z"}}
        if not axis_values:
            continue
        nx, ny, nz = x, y, z
        for letter, value in axis_values.items():
            if absolute:
                if letter == "X": nx = value
                if letter == "Y": ny = value
                if letter == "Z": nz = value
            else:
                if letter == "X": nx += value
                if letter == "Y": ny += value
                if letter == "Z": nz += value
        if cycle_mode in cycle_points:
            cycle_points[cycle_mode] += 1
        if motion_mode in {0, 1, 2, 3} or cycle_mode in {81, 82, 83}:
            if (nx, ny, nz) != (x, y, z):
                points.append((nx, ny, nz))
        x, y, z = nx, ny, nz
    if len(points) < 1200 or len(set(points)) < 700 or explicit_arcs < 300:
        return False
    if len(feed_values) < 20 or len(spindle_values) < 7:
        return False
    if cycle_points[82] < 5 or cycle_points[83] < 5 or min(point[2] for point in points) > -39.5:
        return False
    xs = [point[0] for point in points]
    ys = [point[1] for point in points]
    if max(xs) - min(xs) < 300 or max(ys) - min(ys) < 180:
        return False
    return check_operation_sections(raw_lines, markers)

def parse_time(value: Any) -> datetime | None:
    if not isinstance(value, str):
        return None
    try:
        return datetime.fromisoformat(value.replace("Z", "+00:00"))
    except ValueError:
        return None

def check_audit(path: Path, nc_path: Path, init_path: Path) -> bool:
    if not path.is_file() or path.stat().st_size > 1_000_000:
        return False
    data = json.loads(path.read_text(encoding="utf-8"))
    if not isinstance(data, dict) or data.get("schema_version") != 2 or data.get("ok") is not True:
        return False
    if data.get("engine") != "SOLIDWORKS CAM 2025 / CAMWorks API":
        return False
    if not init_path.is_file() or sha256(init_path) != EXPECTED_INIT_SHA256:
        return False
    artifacts = data.get("artifacts")
    if not isinstance(artifacts, dict):
        return False
    input_artifact = artifacts.get("input")
    output_artifact = artifacts.get("output")
    if not isinstance(input_artifact, dict) or not isinstance(output_artifact, dict):
        return False
    if not str(input_artifact.get("path", "")).lower().endswith(r"\cam_part.sldprt"):
        return False
    if str(input_artifact.get("sha256", "")).lower() != EXPECTED_INIT_SHA256:
        return False
    if int(input_artifact.get("size", 0)) != init_path.stat().st_size:
        return False
    if not str(output_artifact.get("path", "")).lower().endswith(r"\task-01.nc"):
        return False
    if str(output_artifact.get("sha256", "")).lower() != sha256(nc_path):
        return False
    if int(output_artifact.get("size", 0)) != nc_path.stat().st_size:
        return False
    job = data.get("parsed_job")
    tools_csv = data.get("parsed_tools")
    if not isinstance(job, dict) or not isinstance(tools_csv, list) or len(tools_csv) < 3:
        return False
    if not str(job.get("model", "")).lower().endswith(r"\cam_part.sldprt"):
        return False
    if not str(job.get("output", "")).lower().endswith(r"\task-01.nc"):
        return False
    machine = data.get("machine")
    if not isinstance(machine, dict) or machine.get("binding") != "IOpenDocument":
        return False
    if machine.get("setup_count") != 1 or machine.get("operation_setup_count") != 1 or machine.get("operation_count") != 17:
        return False
    if machine.get("work_coordinate") != 54 or machine.get("origin") != [0.0, 10.0, 50.0]:
        return False
    if machine.get("controller_sha256", "").lower() != "98976cc31ac9dd35f42daab9a14b483b1a45fe40b74bb33ab6a02936954811f0":
        return False
    features = data.get("features")
    if not isinstance(features, list) or {str(item.get("name", "")).upper() for item in features if isinstance(item, dict)} != EXPECTED_FEATURES:
        return False
    operations = data.get("operations")
    if not isinstance(operations, list) or len(operations) != 17:
        return False
    if [str(item.get("name", "")).upper() for item in operations if isinstance(item, dict)] != EXPECTED_OPERATIONS:
        return False
    total_segments = 0
    for item in operations:
        if not isinstance(item, dict) or item.get("generated") is not True or int(item.get("total_segments", 0)) <= 0:
            return False
        tool = item.get("tool")
        name = str(item.get("name", "")).upper()
        if not isinstance(tool, dict) or int(tool.get("station", -1)) != EXPECTED_TOOL_BY_OPERATION[name]:
            return False
        total_segments += int(item["total_segments"])
    if total_segments < 1800 or int(machine.get("total_segments", 0)) != total_segments:
        return False
    calls = data.get("calls")
    if not isinstance(calls, list):
        return False
    call_names = [str(item.get("name", "")) for item in calls if isinstance(item, dict) and item.get("ok") is True]
    if not {"IOpenDocument", "IGetMachine", "PostProcess"}.issubset(set(call_names)):
        return False
    gop_features = {
        str(item.get("feature", "")).upper() for item in calls
        if isinstance(item, dict) and item.get("name") == "GenerateOpPlan" and item.get("ok") is True
    }
    generation_policy = data.get("generation_policy")
    if generation_policy == "regenerated":
        if gop_features != EXPECTED_FEATURES or "GenerateToolpath" not in call_names:
            return False
    elif generation_policy == "reuse_generated":
        if gop_features or any(item.get("name") == "GenerateToolpath" for item in calls if isinstance(item, dict)):
            return False
    else:
        return False
    post_calls = [item for item in calls if isinstance(item, dict) and item.get("name") == "PostProcess"]
    if len(post_calls) != 1 or post_calls[0].get("return") != 0:
        return False
    opened = [item for item in calls if isinstance(item, dict) and item.get("name") == "OpenDoc6"]
    if not opened or opened[-1].get("errors") != 0 or opened[-1].get("warnings") != 0:
        return False
    started = parse_time(data.get("started_utc"))
    finished = parse_time(data.get("finished_utc"))
    return started is not None and finished is not None and finished >= started

def main() -> bool:
    nc_path = TARGET / "task-01.nc"
    return check_nc(nc_path) and check_audit(
        TARGET / "solidcam_cli_run.json", nc_path, TARGET / "cam_part.sldprt"
    )

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