"""M02 일위대가 불러오기 — 못옮김 · 안 이은 기계 줄 → M01 요소 후보 셋(PLAN 746-1 · 요구 585).

후보 = `[{키, 갈래 노임|기계|자재, 이름, 규격, 단위, 단가}]` 셋까지 — 보여주기만(자동 이음 없음 · 고르면 지금
잇기 길 `{노임|기계|자재: 키}`).
    자재 = `M02_Hopyo_Material.candidates` 점수(이름 글자 묶음 · 규격) · 단가 = M01 자재 값(엑셀 줄 단위)
    노임 = LB 이름 글자 묶음 닮음 · 단가 = LB 값
    기계 = EQ 갈래 겹침 · 규격 수(같음 1 · 겹침 0.5) · 이름 낱말 덤 · 단가 없음(기계경비는 로직 셈)
차례 = 점수(0.1 단위로 접음) › 엑셀 단가에 가까운 것(엑셀 단가 = 블록 글 「이름 단가 × 식 = 금액」 · 모르면 점수만).
서버 단독 · 읽기만.
"""

from __future__ import annotations

import math
import re
from typing import Any

from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Finger as finger
from M02_MasterTemplete import M02_Hopyo_Match as hm
from M02_MasterTemplete import M02_Hopyo_Material as hmat
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, parse_rhs, specnums

TOP = 3
POOL = 5


def prices(block: dict[str, Any] | None) -> dict[str, float]:
    """블록 글 → `{이름: 엑셀 단가}`(직종 줄 「직종 : 단가 × 식」 · 자재 줄 「이름 단가 × 식 = 금액」)."""
    out: dict[str, float] = {}
    for raw in (block or {}).get("글") or []:
        row = str(raw).rstrip()
        cm = finger._COLON.match(row)
        mm = None if cm else finger._MAT.match(row)
        name = (cm or mm).group("name").strip() if (cm or mm) else ""
        got = parse_rhs((cm or mm).group("rhs")) if name else None
        if got and got.get("단가"):
            out.setdefault(re.sub(r"^[0-9가-힣]\.", "", name).strip(), float(got["단가"]))
    return out


def _gap(price: Any, want: float | None) -> float:
    try:
        p = float(price)
    except (TypeError, ValueError):
        return math.inf
    return abs(math.log(p / want)) if want and p > 0 else math.inf


def _order(rows: list[tuple[float, dict]], want: float | None) -> list[dict]:
    rows.sort(key=lambda x: -x[0])
    pool = rows[:POOL]
    pool.sort(key=lambda x: (-round(x[0], 1), _gap(x[1].get("단가"), want)))
    return [one for _, one in pool[:TOP]]


def _num(x: Any) -> int | float | None:
    if x is None:
        return None
    f = float(x)
    return int(f) if f == int(f) else round(f, 4)


def materials(name: str, unit: str = "", want: float | None = None) -> list[dict[str, Any]]:
    whole = m01.loaded()[1]
    rows = []
    for c in hmat.candidates({"이름": name, "규격": "", "단위": unit}, POOL):
        code = c.get("자재")
        if not code:
            continue
        try:
            price = hmat.mm.element(whole, code, {}, unit or None)[0]
        except Exception:  # noqa: BLE001 — 값 못 읽음 = 단가 없음
            price = None
        one = {"키": code, "갈래": "자재", "이름": c.get("이름"), "규격": c.get("규격") or ""}
        rows.append((c.get("점수") or 0.0, {**one, "단위": c.get("단위"), "단가": _num(price)}))
    return _order(rows, want)


def labor(name: str, want: float | None = None) -> list[dict[str, Any]]:
    whole = m01.loaded()[1]
    me = hm._grams(re.sub(r"\s", "", name))
    rows = []
    for row in whole.numbers.get("LB", {}).values():
        them = hm._grams(re.sub(r"\s", "", str(row.get("이름") or "")))
        score = 2 * len(me & them) / (len(me) + len(them))
        if score > 0:
            one = {"키": str(row.get("키")), "갈래": "노임", "이름": row.get("이름"), "규격": ""}
            rows.append((score, {**one, "단위": "인", "단가": _num(row.get("값"))}))
    return _order(rows, want)


def machines(text: str, kinds: set | None = None, nums: set | None = None) -> list[dict]:
    """기계 글(이름 규격) → EQ 후보 — 갈래 · 규격 수가 없으면 글에서 읽음."""
    whole = m01.loaded()[1]
    kinds = set(kinds or ()) or mtypes(text)
    nums = set(nums or ()) or set(specnums(text))
    mine = hm.words(text)
    rows = []
    for row in whole.numbers.get("EQ", {}).values():
        types = mtypes(f"{row.get('상세구분')} {row.get('이름')}")
        if not kinds & types:
            continue
        spec = set(specnums(row.get("규격")))
        score = len(kinds & types) / len(kinds | types)
        score += 1.0 if nums and nums == spec else 0.5 if nums & spec else 0.0
        score += 0.3 * len(mine & hm.words(row.get("이름")))
        one = {"키": str(row.get("키")), "갈래": "기계", "이름": row.get("이름")}
        unit = (row.get("단위") or {}).get("내용시간") if isinstance(row.get("단위"), dict) else ""
        rows.append(
            (score, {**one, "규격": row.get("규격") or "", "단위": unit or "시간", "단가": None})
        )
    return _order(rows, None)


def lost(one: dict[str, Any], want: float | None = None) -> list[dict[str, Any]]:
    """못옮김 한 줄(`M02_Hopyo_SkPatch` 꼴) → 후보."""
    kind, name = one.get("갈래"), str(one.get("이름") or "")
    if kind == "자재":
        return materials(name, str(one.get("단위") or ""), want)
    if kind == "노임":
        return labor(name, want)
    if kind == "기계":
        return machines(f"{name} {one.get('규격') or ''}", set(name.split("·")))
    return []