# -*- coding: utf-8 -*-
u"""刀片**位号丝印**的重排与下发（照 `silk_base.py` 移植，四处刀片专属改动）。

    /c/Python314/python .claude/r2/silk_blade.py            # 只算 + 改前/改后对照
    /c/Python314/python .claude/r2/silk_blade.py --push     # 下发 + 读回核对

## 判据（同底板）

位号文字框（字高 `fs`、字宽 ≈ 0.62×字高×字符数、`alignMode=3` 居中）不许：
① 压同面焊盘 ② 压过孔 ③ 越板框 ④ 与别的位号重叠

## ⛔ 刀片与底板不同的四点

1. **板框是凸字形，不是矩形** —— 不能像底板那样用 `BW×BH` 判越界，
   必须对 `pcb_blade.outline_polygon()` 做「四角在多边形内 + 到轮廓 ≥ EDGE」。
2. **金手指区 y < STEP_H(12) 整体禁止放丝印** —— `fp_edge` 写明指区不许有丝印，
   嘉立创的金手指工艺也要求指区无丝印。底板没有这条。
3. **两条铣穿槽（BAT / TAIL）要避开** —— 丝印落在铣掉的开口上等于没有。
4. `KEEP` 白名单只放 `J1`：它的位号是**手工**摆的，不能让算法再挪回去。
   坐标沿革：28.50 →（舌头收窄到 34.5，原位离板边只剩 0.75）→ 38.30 →
   （`NOTCH_D` 加深到 8.3 后框 y 7.81~8.95 与缺口重叠 0.49、x 又蹭到口部）→ **(37.84, 8.378)**。
   ⚠ 现值对缺口左壁 38.70 只余 **0.151**（判据要 `GAP` 0.15），**再往 +x 挪就压缺口**。

## ⚠ `rotation` 归一化

快照实测取值含 `-2340.0000000000005 / -720 / -360 / -180 / -90` —— **有负值、有浮点误差**。
必须 `((v mod 360) + 360) mod 360` 再 `round`。
（`silk_base` 的注释只提到「900 = 180」这种正的大数，负值和浮点误差是刀片这边新遇到的。）

## ⛔⛔ 焊盘尺寸只能读缓存 `_blade_pads.json`，**别用实时 `getAll()` 取 width/height**

实测：`eda.pcb_PrimitivePad.getAll()` 回来的对象上 **`o.width` / `o.height` 一律是
`undefined`**（362 个焊盘无一例外）。照这个算半宽会得到 0 ⇒ 焊盘退化成**点** ⇒
「压焊盘」几乎永远判 0。本会话就是这么先得出一个假的「压焊盘 0」，
直到改用缓存才看到真值 **68**。

⇒ 本脚本的 `audit()` / `plan()` 一律从 `_blade_pads.json` 取焊盘
（9 元组 `[位号, 脚, x, y, w, h, 层, 网, 形状]`，与 `_base_pads.json` 同构）。
⇒ 判据教训：**过滤条件只会让命中变少**。若「加了层过滤反而变多」，
  那一定是没过滤的那一版算错了，不是过滤写反了。

## ⚠ 本脚本**看不见封装内部的丝印**（判据边界，不是 bug）

`eda.pcb_PrimitiveString.getAll()` 在 **PCB 文档级**枚举**不到封装内部**画的字符串：
刀片上那行 `NOT PCIe — PhoneRail blade` 明明在板上，文档级却返回 **0 条自由丝印**
（六种图元全查过，只有 J1 的 `key=Footprint` / `key=Device` 两条属性命中关键字，
位置都在 (0,0)，不是它）。它是 `fp_edge.py` 用 `create(layer, x, y, text, …)`
画在 **J1 封装里**的，`fp_edge` 自己的自检也是在**封装文档内**读的。

⇒ 所以 `audit()` 的「越框 / 重叠」只覆盖**文档级** Designator，
  封装内丝印（金手指区那行警告、缺口线）不在统计内。

⛔ **2026-09-12 深夜更正：「y≈8 是有意放行的」这句话曾经害了一次。**
原来的理由是「`fp_edge` 的自检只禁止 y 0~5.6（指区本身）」——但那条断言判的是**指区**，
而真正该判的是**缺口**：缺口是铣穿的，字压上去会被切掉。当时丝印在 7.20、缺口顶 7.45，
**已经重叠 0.75，两边的自检却都不报**（指区断言看 5.6，缺口没人看）。
`NOTCH_D` 加深到 8.3 后恶化到 1.00，是**截图**才看出来的。
⇒ 已在 `fp_edge.selfcheck()` 补断言 `SILK_Y - SILK_SIZE/2 >= NOTCH_D`，
  并把那行字抬到 `SILK_Y = NOTCH_D + 0.6 = 8.90`（字带 8.40~9.40）。
  教训：**「某条断言没报」不等于「这件事被检查过」** —— 先确认判据判的是不是同一个东西。

⛔⛔ **由此引出第三个盲区：位号 ↔ 封装内丝印的互相重叠，没有任何判据覆盖。**
本脚本的 `audit()` 只看**文档级** Designator（看不见封装内那行字），
而 `fp_edge.selfcheck()` 只在**封装文档内**读（看不见文档级位号），
DRC 也不管（丝印非铜）⇒ **两者撞在一起时三方全部沉默**。
2026-09-12 深夜就这么撞了一次：把封装丝印从 7.20 抬到 8.90 避开缺口之后，
字带变成 8.40~9.40，而 `J1` 位号框是 7.81~8.95 —— **重叠 x 1.417 / y 0.550**，
而改动前两者间隙 0.11、本来不压。同样是**截图**才看出来的。
⇒ 已把 `J1` 位号抬到 **(37.84, 10.13)**（框 9.56~10.70）：
  离丝印带顶 9.40 留 **0.159**、离外层铜下沿 `pcb_pour.TOP_POUR_Y` 11.50 还有 0.798。
  ⚠ 第一次取 10.12 时间隙是 **0.149**，差 0.001 没过 `GAP` —— 候选 y 按 0.1 步进取整
    低于真正需要的 `9.40 + GAP + fs/2 = 10.1215`。工程上无意义，但让判据干净地过，
    省得以后每次跑都看见一个 [X]。
⚠ **动这两处中的任何一处，都要手算另一处**：`fp_edge.SILK_Y` 与 `KEEP` 里 J1 的坐标
  是一对**互相牵制但没有共同判据**的数。
"""
import io
import json
import math
import os
import sys

sys.stdout.reconfigure(encoding='utf-8')
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.dirname(HERE))
sys.path.insert(0, HERE)
from eda import run                                              # noqa: E402
import pcb_blade as B                                            # noqa: E402
import pcb_place as PL                                           # noqa: E402

MIL = 0.0254
SNAP = os.path.join(HERE, '_blade_silk.json')
PLAN = os.path.join(HERE, '_blade_silk_plan.json')
PADS = os.path.join(HERE, '_blade_pads.json')
CHAR_W, EDGE, GAP, MAXD = 0.62, 0.5, 0.15, 2.2
KEEP = {'J1'}

OUTLINE = [(p[0], p[1]) for p in B.outline_polygon()]
OSEGS = list(zip(OUTLINE, OUTLINE[1:]))
SLOTS = [tuple(w) for w in B.flex_slots().values()]      # (x0, y0, x1, y1)

READ = u"""
await eda.dmt_EditorControl.openDocument('%s');
await new Promise(r=>setTimeout(r,2500));
const M = 0.0254, nrm = v => ((v %% 360) + 360) %% 360;
const A = (await eda.pcb_PrimitiveAttribute.getAll()||[]).filter(a=>a.key==='Designator')
  .map(a=>({ref:a.value, lay:a.layer, x:a.x*M, y:a.y*M, rot:nrm(a.rotation),
            fs:a.fontSize*M, vis:a.valueVisible?1:0, id:a.primitiveId}));
const C = (await eda.pcb_PrimitiveComponent.getAll()||[])
  .map(c=>({ref:c.designator, x:c.x*M, y:c.y*M, rot:nrm(c.rotation||0), lay:c.layer}));
const V = (await eda.pcb_PrimitiveVia.getAll()||[]).map(v=>[v.x*M, v.y*M, String(v.net), v.diameter*M]);
return {attrs:A, comps:C, vias:V};
""" % B.PCB


def snap():
    r = run(READ, timeout=600)
    d = r.get('result')
    assert d, json.dumps(r, ensure_ascii=False)[:400]
    io.open(SNAP, 'w', encoding='utf-8').write(json.dumps(d, ensure_ascii=False))
    return d


def tbox(ref, x, y, rot, fs):
    h = fs
    w = CHAR_W * h * len(ref)
    if int(round(rot)) % 360 in (90, 270):
        w, h = h, w
    return (x - w / 2., y - h / 2., x + w / 2., y + h / 2.)


def ov(p, q):
    return not (p[2] <= q[0] or q[2] <= p[0] or p[3] <= q[1] or q[3] <= p[1])


def inside_poly(px, py):
    c = False
    for (ax, ay), (bx, by) in OSEGS:
        if (ay > py) != (by > py) and px < (bx - ax) * (py - ay) / (by - ay + 1e-18) + ax:
            c = not c
    return c


def _dps(px, py, a, b):
    ax, ay = a
    bx, by = b
    dx, dy = bx - ax, by - ay
    L2 = dx * dx + dy * dy
    t = 0.0 if L2 == 0 else max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / L2))
    return math.hypot(px - (ax + t * dx), py - (ay + t * dy))


def d_box_outline(bb):
    u"""文字框到板框轮廓的最小距离（取框四角与轮廓各段的最近值，够用）。"""
    best = 1e9
    for px, py in ((bb[0], bb[1]), (bb[2], bb[1]), (bb[2], bb[3]), (bb[0], bb[3])):
        for a, b in OSEGS:
            d = _dps(px, py, a, b)
            if d < best:
                best = d
    return best


def outside(bb):
    u"""刀片版：凸字形板框 + 金手指区 + 铣穿槽，任一不满足即判「不可用」。"""
    if bb[1] < B.STEP_H:                                  # ② 金手指区整体禁止
        return True
    for px, py in ((bb[0], bb[1]), (bb[2], bb[1]), (bb[2], bb[3]), (bb[0], bb[3])):
        if not inside_poly(px, py):                       # ① 四角必须在板内
            return True
    if d_box_outline(bb) < EDGE:                          # ① 到轮廓留 EDGE
        return True
    for s in SLOTS:                                       # ③ 避开铣穿槽
        if ov(bb, (s[0], s[1], s[2], s[3])):
            return True
    return False


def _pads_by_layer(pads):
    return {3: [p for p in pads if p[6] in (1, 12)],
            4: [p for p in pads if p[6] in (2, 12)]}


def audit(items, pads, vias):
    u"""items: [(ref, lay, bb)] ⇒ 四项体检计数。"""
    padsL = _pads_by_layer(pads)
    n_pad = n_via = n_out = 0
    for ref, lay, bb in items:
        if any(ov(bb, (p[2] - p[4] / 2., p[3] - p[5] / 2., p[2] + p[4] / 2., p[3] + p[5] / 2.))
               for p in padsL.get(lay, [])):
            n_pad += 1
        if any(ov(bb, (v[0] - v[3] / 2., v[1] - v[3] / 2., v[0] + v[3] / 2., v[1] + v[3] / 2.))
               for v in vias):
            n_via += 1
        if outside(bb):
            n_out += 1
    pairs = 0
    for i in range(len(items)):
        for j in range(i + 1, len(items)):
            if items[i][1] == items[j][1] and ov(items[i][2], items[j][2]):
                pairs += 1
    return {u'压焊盘': n_pad, u'压过孔': n_via, u'越框/入禁区': n_out, u'互相重叠(对)': pairs}


def plan(d, pads, sz):
    comp = {c['ref']: c for c in d['comps']}
    V = d['vias']
    padsL = _pads_by_layer(pads)

    def hit_pad(bb, lay):
        return any(ov(bb, (p[2] - p[4] / 2., p[3] - p[5] / 2., p[2] + p[4] / 2., p[3] + p[5] / 2.))
                   for p in padsL.get(lay, []))

    def hit_via(bb):
        return any(ov(bb, (v[0] - v[3] / 2., v[1] - v[3] / 2., v[0] + v[3] / 2., v[1] + v[3] / 2.))
                   for v in V)

    placed, out, stat = [], {}, {}
    for a in d['attrs']:
        if a['vis'] and a['ref'] in KEEP:
            placed.append((a['lay'], tbox(a['ref'], a['x'], a['y'], a['rot'], a['fs'])))
            stat[u'白名单保留'] = stat.get(u'白名单保留', 0) + 1
    small = [a for a in d['attrs'] if a['vis'] and a['ref'] not in KEEP]
    small.sort(key=lambda a: -(sz.get(a['ref'], (1, 1))[0] * sz.get(a['ref'], (1, 1))[1]))
    for a in small:
        ref, c, lay, fs = a['ref'], comp.get(a['ref']), a['lay'], a['fs']
        if not c:
            continue
        w, h = sz.get(ref, (1.0, 1.0))
        if int(round(c['rot'])) % 180:
            w, h = h, w
        best, level = None, None
        for lv in (0, 1, 2):
            r = 0.0
            while r <= MAXD and best is None:
                for ang in (90, 270, 0, 180, 45, 135, 225, 315):
                    for rot in ((0, 90) if ang in (0, 180) else (0,)):
                        tw, th = CHAR_W * fs * len(ref), fs
                        if rot == 90:
                            tw, th = th, tw
                        ca, sa = math.cos(math.radians(ang)), math.sin(math.radians(ang))
                        if abs(ca) <= 0.7 and abs(sa) <= 0.7:
                            off = math.hypot(w / 2. + tw / 2., h / 2. + th / 2.) + GAP + r
                        elif abs(ca) > 0.7:
                            off = w / 2. + tw / 2. + GAP + r
                        else:
                            off = h / 2. + th / 2. + GAP + r
                        x, y = c['x'] + off * ca, c['y'] + off * sa
                        bb = tbox(ref, x, y, rot, fs)
                        if outside(bb) or any(b[0] == lay and ov(bb, b[1]) for b in placed):
                            continue
                        if lv < 2 and hit_pad(bb, lay):
                            continue
                        if lv < 1 and hit_via(bb):
                            continue
                        best, level = (round(x, 4), round(y, 4), rot, bb), lv
                        break
                    if best:
                        break
                r += 0.25
            if best:
                break
        if best:
            placed.append((lay, best[3]))
            out[ref] = {'x': best[0], 'y': best[1], 'rot': best[2], 'id': a['id'], 'lay': lay}
            key = [u'理想位', u'允许压过孔', u'允许压焊盘'][level]
            stat[key] = stat.get(key, 0) + 1
        else:
            stat[u'无解（保留原位）'] = stat.get(u'无解（保留原位）', 0) + 1
    return out, stat


PUSH = u"""
await eda.dmt_EditorControl.openDocument('%s');
await new Promise(r=>setTimeout(r,1500));
const R = %s;
let n = 0;
for (const [id, x, y, rot] of R) {
  try { await eda.pcb_PrimitiveAttribute.modify(id, {x: x, y: y, rotation: rot}); n++; } catch (e) {}
}
return n;
"""


def main():
    d = snap()
    pads = json.load(io.open(PADS, encoding='utf-8'))
    sz = PL.sizes()
    vis = [a for a in d['attrs'] if a['vis']]
    before = [(a['ref'], a['lay'], tbox(a['ref'], a['x'], a['y'], a['rot'], a['fs'])) for a in vis]
    print(u'板框 %d 点；金手指禁区 y<%.1f；铣穿槽 %d 条' % (len(OUTLINE), B.STEP_H, len(SLOTS)))
    print(u'位号 %d（可见 %d）\n' % (len(d['attrs']), len(vis)))
    print(u'改前体检: %s' % json.dumps(audit(before, pads, d['vias']), ensure_ascii=False))

    p, stat = plan(d, pads, sz)
    io.open(PLAN, 'w', encoding='utf-8').write(json.dumps(p, ensure_ascii=False, indent=0))
    print(u'\n重排 %d 个：' % len(p))
    for k, v in sorted(stat.items(), key=lambda t: -t[1]):
        print(u'   %-16s %d' % (k, v))

    after = []
    for a in vis:
        q = p.get(a['ref'])
        if q:
            after.append((a['ref'], a['lay'], tbox(a['ref'], q['x'], q['y'], q['rot'], a['fs'])))
        else:
            after.append((a['ref'], a['lay'], tbox(a['ref'], a['x'], a['y'], a['rot'], a['fs'])))
    print(u'\n改后体检: %s' % json.dumps(audit(after, pads, d['vias']), ensure_ascii=False))

    if '--push' not in sys.argv:
        print(u'\n（只算；加 --push 下发）')
        return

    rows = [[v['id'], v['x'] / MIL, v['y'] / MIL, v['rot']] for v in p.values()]
    n = 0
    for k in range(0, len(rows), 60):
        r = run(PUSH % (B.PCB, json.dumps(rows[k:k + 60])), timeout=600)
        n += r.get('result') or 0
    run(u"await eda.pcb_Document.save(); return 1;", timeout=300)
    print(u'  modify 成功 %d / %d' % (n, len(rows)))
    d2 = snap()
    now = {a['ref']: a for a in d2['attrs']}
    bad = [k for k, v in p.items()
           if k not in now or abs(now[k]['x'] - v['x']) > 0.02 or abs(now[k]['y'] - v['y']) > 0.02
           or int(round(now[k]['rot'])) % 360 != v['rot'] % 360]
    print(u'读回核对：%d 个对上，%d 个没对上 %s' % (len(p) - len(bad), len(bad), bad[:10]))


if __name__ == '__main__':
    main()