from __future__ import annotations

import re
import sys
import xml.etree.ElementTree as ET
from collections import Counter
from pathlib import Path


INIT_BRD_NAME = "mystery.brd"


def _locate_init_board(start: Path) -> Path | None:
    for cand in (
        start / INIT_BRD_NAME,
        start / "init_file" / INIT_BRD_NAME,
        start.parent / "init_file" / INIT_BRD_NAME,
        start.parent.parent / "init_file" / INIT_BRD_NAME,
    ):
        if cand.exists():
            return cand
    return None


def _expected_signals(brd_path: Path) -> list[tuple[str, list[tuple[str, str]]]]:
    root = ET.parse(brd_path).getroot()
    out: list[tuple[str, list[tuple[str, str]]]] = []
    for sig in root.findall(".//signal"):
        name = sig.get("name") or ""
        refs = [(cr.get("element") or "", cr.get("pad") or "") for cr in sig.findall("contactref")]
        out.append((name, refs))
    return out


def _parse_netlist(text: str, signal_names: list[str]) -> list[tuple[str, list[tuple[str, str]]]]:
    sections: list[tuple[str, list[tuple[str, str]]]] = []
    current_name: str | None = None
    current_refs: list[tuple[str, str]] = []
    ordered_names = sorted(signal_names, key=len, reverse=True)
    ref_pat = re.compile(
        r"([A-Za-z0-9_+$./-]+)(?:\s+|\s*\.\s*)([A-Za-z0-9_+$./-]+|[+-])(?=$|\s|[,\);])"
    )

    def flush() -> None:
        nonlocal current_name, current_refs
        if current_name is not None:
            sections.append((current_name, current_refs))
        current_name = None
        current_refs = []

    def collect_refs(fragment: str) -> None:
        nonlocal current_refs
        for match in ref_pat.finditer(fragment):
            current_refs.append((match.group(1), match.group(2)))

    for raw in text.splitlines():
        line = raw.rstrip()
        if not line.strip():
            continue
        if line.startswith("Netlist") or line.startswith("Exported from") or line.startswith("EAGLE Version"):
            continue
        if line.startswith("Net") and "Part" in line and "Pad" in line:
            continue

        matched = None
        for name in ordered_names:
            if re.match(rf"^{re.escape(name)}(?:\s|$)", line):
                matched = name
                break

        if matched is not None:
            flush()
            current_name = matched
            collect_refs(line[len(matched):])
            continue

        if current_name is not None:
            collect_refs(line)

    flush()
    return sections


def evaluate(submission_dir: str) -> bool:
    sub = Path(submission_dir).resolve()
    target = None
    for name in ("mystery_netlist.txt",):
        cand = sub / name
        if cand.is_file():
            target = cand
            break
    if target is None:
        return False

    try:
        text = target.read_text(encoding="utf-8")
    except UnicodeDecodeError:
        text = target.read_text(encoding="latin-1")
    if not text.strip():
        return False

    brd = _locate_init_board(Path(__file__).resolve().parent)
    if brd is None:
        return False

    expected = _expected_signals(brd)
    actual = _parse_netlist(text, [name for name, _ in expected])

    if {name for name, _ in actual} != {name for name, _ in expected}:
        return False

    expected_map = {name: Counter(refs) for name, refs in expected}
    actual_map = {name: Counter(refs) for name, refs in actual}
    if set(actual_map) != set(expected_map):
        return False
    for name, exp_refs in expected_map.items():
        if actual_map.get(name) != exp_refs:
            return False
    return True


def main(argv: list[str]) -> int:
    if len(argv) > 2:
        print("usage: python eval.py SUBMISSION_DIR", file=sys.stderr)
        return 2
    submission_dir = argv[1] if len(argv) == 2 else Path(__file__).resolve().parent
    ok = evaluate(submission_dir)
    print("True" if ok else "False")
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))