from __future__ import annotations

import json
import math
import os
import re
import sys
from collections import Counter
from pathlib import Path


DESKTOP = Path("/home/user/Desktop")
HERE = Path(__file__).resolve().parent
TASK_ID = "kicad-7"

SLOTS = [
    ("A1", "A.kicad_pcb", (10.0, 10.0), ""),
    ("A2", "A.kicad_pcb", (53.0, 10.0), "_2"),
    ("B1", "B.kicad_pcb", (10.0, 60.0), ""),
    ("B2", "B.kicad_pcb", (53.0, 60.0), "_2"),
    ("B3", "B.kicad_pcb", (96.0, 10.0), "_3"),
    ("B4", "B.kicad_pcb", (96.0, 60.0), "_4"),
]
EXPECTED_RECTS = [
    (0.0, 0.0, 146.0, 110.0),
    (10.0, 10.0, 50.0, 50.0),
    (53.0, 10.0, 93.0, 50.0),
    (10.0, 60.0, 50.0, 100.0),
    (53.0, 60.0, 93.0, 100.0),
    (96.0, 10.0, 136.0, 50.0),
    (96.0, 60.0, 136.0, 100.0),
]
EXPECTED_VSCORE = {
    ((50.0, 10.0), (50.0, 100.0)),
    ((93.0, 10.0), (93.0, 100.0)),
    ((10.0, 55.0), (136.0, 55.0)),
}
EXPECTED_LABELS = {
    "A1": (30.0, 30.0), "A2": (73.0, 30.0),
    "B1": (30.0, 80.0), "B2": (73.0, 80.0),
    "B3": (116.0, 30.0), "B4": (116.0, 80.0),
}
EXPECTED_FID = {"FID1": (5.0, 5.0), "FID2": (141.0, 5.0), "FID3": (5.0, 105.0)}
EXPECTED_TOOL = {"TOOL1": (5.0, 55.0), "TOOL2": (141.0, 55.0),
                 "TOOL3": (73.0, 5.0), "TOOL4": (73.0, 105.0)}


TOKEN_RE = re.compile(r'"(?:\\.|[^"\\])*"|[()]|[^\s()]+')


def parse_sexp(text: str):
    stack = []
    root = None
    for token in TOKEN_RE.findall(text):
        if token == "(":
            node = []
            if stack:
                stack[-1].append(node)
            stack.append(node)
        elif token == ")":
            if not stack:
                raise ValueError("unbalanced closing parenthesis")
            root = stack.pop()
        else:
            if not stack:
                raise ValueError("atom outside list")
            stack[-1].append(json.loads(token) if token.startswith('"') else token)
    if stack or not isinstance(root, list):
        raise ValueError("unbalanced s-expression")
    return root


def direct(node, tag):
    return [child for child in node if isinstance(child, list) and child and child[0] == tag]


def first(node, tag):
    items = direct(node, tag)
    return items[0] if items else None


def number(value):
    return round(float(value), 6)


def point(node):
    return (number(node[1]), number(node[2]))


def norm_edge(a, b):
    return tuple(sorted((a, b)))


def expand_rect(rect):
    start, end = first(rect, "start"), first(rect, "end")
    if not start or not end:
        return []
    x1, y1 = point(start)
    x2, y2 = point(end)
    corners = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
    return [norm_edge(corners[i], corners[(i + 1) % 4]) for i in range(4)]


def edges_on_layer(board, layer_name):
    edges = []
    for line in direct(board, "gr_line"):
        layer = first(line, "layer")
        start, end = first(line, "start"), first(line, "end")
        if layer and layer[1] == layer_name and start and end:
            edges.append(norm_edge(point(start), point(end)))
    for rect in direct(board, "gr_rect"):
        layer = first(rect, "layer")
        if layer and layer[1] == layer_name:
            edges.extend(expand_rect(rect))
    return Counter(edges)


def expected_rectangle_edges():
    edges = []
    for x1, y1, x2, y2 in EXPECTED_RECTS:
        corners = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
        edges.extend(norm_edge(corners[i], corners[(i + 1) % 4]) for i in range(4))
    return Counter(edges)


def property_value(footprint, name):
    for prop in direct(footprint, "property"):
        if len(prop) >= 3 and prop[1] == name:
            return str(prop[2])
    return ""


def footprint_info(footprint):
    at = first(footprint, "at")
    pads = []
    for pad in direct(footprint, "pad"):
        pad_at, size, layers, net = first(pad, "at"), first(pad, "size"), first(pad, "layers"), first(pad, "net")
        pads.append((
            str(pad[1]), str(pad[2]), str(pad[3]),
            tuple(number(v) for v in pad_at[1:]) if pad_at else (),
            tuple(number(v) for v in size[1:]) if size else (),
            tuple(str(v) for v in layers[1:]) if layers else (),
            str(net[2]) if net and len(net) >= 3 else "",
        ))
    layer = first(footprint, "layer")
    return {
        "library": str(footprint[1]) if len(footprint) >= 2 else "",
        "layer": str(layer[1]) if layer and len(layer) >= 2 else "",
        "at": point(at) if at else (0.0, 0.0),
        "reference": property_value(footprint, "Reference"),
        "value": property_value(footprint, "Value"),
        "pads": Counter(pads),
        "node": footprint,
    }


def source_path(name, output_path):
    beside_output = output_path.parent / name
    return beside_output if beside_output.exists() else HERE / "init_file" / name


def expected_copies(output_path):
    parsed_sources = {}
    result = {}
    for _, filename, origin, suffix in SLOTS:
        if filename not in parsed_sources:
            source_board = parse_sexp(source_path(filename, output_path).read_text(encoding="utf-8"))
            parsed_sources[filename] = [footprint_info(fp) for fp in direct(source_board, "footprint")]
        for source in parsed_sources[filename]:
            expected_ref = source["reference"] + suffix
            result[expected_ref] = {
                **source,
                "at": (round(source["at"][0] + origin[0], 6),
                       round(source["at"][1] + origin[1], 6)),
                "reference": expected_ref,
            }
    return result


def same_copy(actual, expected, tol=0.01):
    return (
        actual["library"] == expected["library"]
        and actual["layer"] == expected["layer"]
        and actual["value"] == expected["value"]
        and actual["pads"] == expected["pads"]
        and math.dist(actual["at"], expected["at"]) <= tol
    )


def feature_position_ok(info, expected, tol=0.01):
    return info is not None and math.dist(info["at"], expected) <= tol


def evaluate(path: str):
    checks = []
    output_path = Path(path)
    if not output_path.exists():
        return False, [("file_exists", False)]
    try:
        board = parse_sexp(output_path.read_text(encoding="utf-8"))
        if not board or board[0] != "kicad_pcb":
            raise ValueError("root is not kicad_pcb")
    except Exception:
        return False, [("valid_kicad_pcb", False)]
    checks.append(("valid_kicad_pcb", True))

    actual_edges = edges_on_layer(board, "Edge.Cuts")
    expected_edges = expected_rectangle_edges()
    checks.append(("outer_and_slot_geometry", all(actual_edges[e] >= count for e, count in expected_edges.items())))
    edge_points = [point for edge in actual_edges for point in edge]
    checks.append(("edge_cuts_inside_panel", all(0 <= x <= 146 and 0 <= y <= 110 for x, y in edge_points)))

    vscore_edges = edges_on_layer(board, "Dwgs.User")
    checks.append(("vscore_guides", all(vscore_edges[edge] >= 1 for edge in EXPECTED_VSCORE)))

    label_positions = {}
    for label in direct(board, "gr_text"):
        layer, at = first(label, "layer"), first(label, "at")
        if len(label) >= 2 and layer and layer[1] in {"F.Silkscreen", "F.SilkS"} and at:
            label_positions.setdefault(str(label[1]), []).append(point(at))
    labels_ok = all(
        name in label_positions and any(math.dist(pos, center) <= 5.0 for pos in label_positions[name])
        for name, center in EXPECTED_LABELS.items()
    )
    checks.append(("copy_labels_near_centers", labels_ok))

    footprints = [footprint_info(fp) for fp in direct(board, "footprint")]
    by_ref = {}
    for info in footprints:
        by_ref.setdefault(info["reference"], []).append(info)
    expected = expected_copies(output_path)
    copies_ok = all(
        len(by_ref.get(ref, [])) == 1 and same_copy(by_ref[ref][0], expected_info)
        for ref, expected_info in expected.items()
    )
    checks.append(("all_source_footprints_faithfully_copied", copies_ok))

    fid_ok = True
    for ref, pos in EXPECTED_FID.items():
        info = by_ref.get(ref, [None])[0] if len(by_ref.get(ref, [])) == 1 else None
        has_copper_pad = bool(info and any(pad[1] == "smd" and "F.Cu" in pad[5] for pad in direct_pad_signatures(info)))
        fid_ok = fid_ok and feature_position_ok(info, pos) and has_copper_pad
    checks.append(("fiducials", fid_ok))

    tool_ok = True
    for ref, pos in EXPECTED_TOOL.items():
        info = by_ref.get(ref, [None])[0] if len(by_ref.get(ref, [])) == 1 else None
        valid_hole = False
        if info:
            for pad in direct(info["node"], "pad"):
                drill = first(pad, "drill")
                if len(pad) >= 3 and pad[2] == "np_thru_hole" and drill and len(drill) >= 2:
                    try:
                        valid_hole = abs(float(drill[1]) - 3.0) <= 0.01
                    except (TypeError, ValueError):
                        pass
        tool_ok = tool_ok and feature_position_ok(info, pos) and valid_hole
    checks.append(("tooling_holes_3mm_npth", tool_ok))

    expected_refs = set(expected) | set(EXPECTED_FID) | set(EXPECTED_TOOL)
    checks.append(("reference_set_exact", set(by_ref) == expected_refs and all(len(items) == 1 for items in by_ref.values())))
    checks.append(("all_footprint_centers_inside_panel", all(0 <= info["at"][0] <= 146 and 0 <= info["at"][1] <= 110 for info in footprints)))
    return all(value for _, value in checks), checks


def direct_pad_signatures(info):
    return list(info["pads"].elements())


def eval_outputs(output_dir: str = "."):
    passed, checks = evaluate(os.path.join(output_dir, "panel.kicad_pcb"))
    return {
        "task_id": TASK_ID,
        "passed": passed,
        "score": 1.0 if passed else 0.0,
        "total": len(checks),
        "error": None,
        "checks": [{"name": name, "passed": value, "expected": True, "actual": value}
                   for name, value in checks],
        "summary": f"{sum(value for _, value in checks)}/{len(checks)}",
    }


if __name__ == "__main__":
    passed, _ = evaluate(sys.argv[1] if len(sys.argv) > 1 else "panel.kicad_pcb")
    print("True" if passed else "False")