Aislo/M02_MasterTemplete/M02_Hopyo_Basis.py

"""M02 일위대가 실무자료 단가산출 근거(PLAN 330) — 엑셀 「단가산출」 블록 → 출처 · 직종 ·
우리 돈 로직과 견준 근거 후보.

읽기(`read`) = B열(머리 「산출근거」) 머리 줄 「N.이름[단위]」(앞 빈칸 없음)부터
다음 머리 앞까지 한 블록 ·
출처 = 「…품셈」(오타 「품줌」) 뒤 20 글자 안 절 번호 — 앞 글에 산림 · 임도 = 산림품셈 ·
그 밖 = 건설품셈 ·
직종 = 「이름 : 수」 줄의 빈칸 뺀 이름이 우리 인력(LB) 이름 · 옛이름일 때만(지금 이름으로).
견줌(`candidates`) = 같은 책 조항 같음 1.0 · 앞 마디 같음 0.5(조항이 안 맞으면 후보 아님) ·
건설 공통 · 토목 덤 0.1 · 직종 겹침(보통인부 뺌) 0.5 · 단위 0.15 · 직종도 뜻 낱말도 안 겹치면 버림 ·
같은 점수는 글자 두 개 묶음(괄호 글 포함)이 가름. 자동 확정 없음 — 맞춤 차례는 `M02_Hopyo_Match`.
M01 · 원본 로직은 읽기만.
"""

from __future__ import annotations

import re
from functools import lru_cache
from typing import Any

from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Match as hopyo_match  # 서로 부름 — 부를 때만 씀
from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs

SHEET = "단가산출"
COMMON = "보통인부"
BONUS_PARTS = ("공통", "토목")
_HEAD = re.compile(r"^(\d+)\.\s*(.*?)\s*\[([^\[\]]*)\]\s*$")
_BOOK = re.compile(r"품[셈줌]")
_TRADE = re.compile(r"^[\s*·\-]*([가-힣][가-힣\s]*?)\s*:\s*[\d,]")
_TYPOS = (("깍기", "깎기"),)
_MONEY = {"합계": "계", "노무비": "노무비", "재료비": "재료비", "경비": "경비"}


def _flat(value: Any) -> str:
    return re.sub(r"\s+", "", str(value or ""))


# ── 엑셀 블록 읽기 ─────────────────────────────────────────────────────
@lru_cache(maxsize=2)
def _trade_names(whole_id: int) -> dict[str, str]:
    """{빈칸 뺀 이름 · 옛이름: 지금 이름} — 우리 인력(LB)."""
    out: dict[str, str] = {}
    for row in m01.loaded()[1].numbers.get("LB", {}).values():
        name = str(row.get("이름") or "")
        out[_flat(name)] = name
        for old in row.get("옛이름") or []:
            out.setdefault(_flat(old), name)
    return out


def trade_names() -> dict[str, str]:
    return _trade_names(id(m01.loaded()[1]))


def sources(text: str) -> list[list[str]]:
    """글 → [[책, 절 번호]] — 「건설공사표준품셈 3-2-1」 · 「산림사업표준품셈(9-14)」."""
    out = []
    for hit in _BOOK.finditer(text):
        num = labor_inputs._NUMBER.search(text, hit.end())
        if not num or num.start() - hit.end() > 20:
            continue
        before = text[max(0, hit.start() - 12) : hit.start()]
        book = "산림품셈" if "산림" in before or "임도" in before else "건설품셈"
        if [book, num.group()] not in out:
            out.append([book, num.group()])
    return out


def _columns(rows: list[list[Any]]) -> tuple[int, int, dict[str, int]]:
    """(자료 첫 줄, 산출근거 열, {계 · 노무비 · 재료비 · 경비: 열}) — 머리 없으면 (0, 1, {})."""
    for at, row in enumerate(rows[:10]):
        flat = [_flat(v) for v in row]
        if "산출근거" in flat:
            money = {key: flat.index(head) for head, key in _MONEY.items() if head in flat}
            return at + 1, flat.index("산출근거"), money
    return 0, 1, {}


def read(rows: list[list[Any]] | None) -> dict[int, dict[str, Any]]:
    """단가산출 시트 줄 → `{N: {번, 이름, 단위, 행: [시작, 끝], 출처, 직종, 금액}}`
    (행 = 엑셀 1부터)."""
    if not rows:
        return {}
    start, col, money = _columns(rows)
    names = trade_names()
    blocks: dict[int, dict[str, Any]] = {}
    block: dict[str, Any] | None = None
    for at, row in enumerate(rows[start:], start + 1):
        text = row[col] if col < len(row) else None
        if not isinstance(text, str) or not text.strip():
            continue
        head = None if text[:1].isspace() else _HEAD.match(text)
        if head:
            block = blocks.setdefault(
                int(head.group(1)),
                {
                    "번": int(head.group(1)),
                    "이름": head.group(2),
                    "단위": head.group(3).strip(),
                    "행": [at, at],
                    "출처": [],
                    "직종": [],
                    "금액": {
                        key: v
                        for key, c in money.items()
                        for v in [row[c] if c < len(row) else None]
                        if isinstance(v, (int, float)) and not isinstance(v, bool)
                    },
                },
            )
            continue
        if block is None:
            continue
        block["행"][1] = at
        block["출처"] += [one for one in sources(text) if one not in block["출처"]]
        trade = _TRADE.match(text)
        name = names.get(_flat(trade.group(1))) if trade else None
        if name and name not in block["직종"]:
            block["직종"].append(name)
    return blocks


# ── 우리 쪽 조항 · 직종 ────────────────────────────────────────────────
@lru_cache(maxsize=2)
def _ours(whole_id: int) -> dict[str, dict[str, Any]]:
    """{로직 키: {책, 부문, 구분, 조항: {절 번호}, 직종: {이름}}} — 조항 = `sources()` 묶음 ·
    직종 = 호표 인력(LB) 요소."""
    files, whole = m01.loaded()
    lb = {str(row.get("키")): str(row.get("이름")) for row in whole.numbers.get("LB", {}).values()}
    out = {}
    for data in files.values():
        if data.get("그룹") != "로직":
            continue
        for row in data.get("줄") or []:
            kind = str(row.get("구분") or "")
            book, _, part = kind.partition(" ")
            trades = {
                lb[str(h.get("요소"))]
                for h in row.get("호표") or []
                if isinstance(h, dict) and str(h.get("요소")) in lb
            }
            clauses = set(labor_inputs._NUMBER.findall(str(labor_inputs.sources(row) or "")))
            out[str(row.get("키"))] = {
                "책": book,
                "부문": part,
                "구분": kind,
                "조항": clauses,
                "직종": trades,
            }
    return out


def ours() -> dict[str, dict[str, Any]]:
    return _ours(id(m01.loaded()[1]))


def _head(number: str) -> str:
    return number.rsplit("-", 1)[0]


def _clause(theirs: list[list[str]], our: dict[str, Any]) -> tuple[float, list[str], str]:
    """(점수, 맞은 우리 조항 글, 꼬리표) — 같은 책만."""
    nums = [n for book, n in theirs if book == our["책"]]
    same = sorted(n for n in nums if n in our["조항"])
    if same:
        return 1.0, [f"{our['구분']} {n}" for n in same], "조항 같음"
    heads = {_head(n) for n in nums}
    near = sorted(n for n in our["조항"] if _head(n) in heads)
    if near:
        return 0.5, [f"{our['구분']} {n}" for n in near], "앞 마디 같음"
    return 0.0, [], ""


def _text(line: dict[str, Any]) -> str:
    text = f"{line.get('이름') or ''} {line.get('규격') or ''}"
    for old, new in _TYPOS:
        text = text.replace(old, new)
    return text


def candidates(line: dict[str, Any], got: dict[str, Any]) -> list[dict[str, Any]]:
    """근거 후보 — 줄 `근거.출처` 가 없으면 빈 것 · `{로직, 이름, 단위, 점수, 근거}` 점수 차례."""
    basis = line.get("근거") or {}
    theirs = [list(one) for one in basis.get("출처") or []]
    if not theirs:
        return []
    trades = set(basis.get("직종") or []) - {COMMON}
    text = _text(line)
    mine = hopyo_match.words(text)  # 괄호 글 뺌 — 「잔토처리(인력)」 ↔ 「철골재 철거(인력)」
    grams = hopyo_match._grams(hopyo_match.mm.plain(text))  # 괄호 글 포함 — 같은 점수 가름
    table = ours()
    scored = []
    for one in got["로직"]:
        our = table.get(one["로직"])
        if not our:
            continue
        score, clauses, tag = _clause(theirs, our)
        if not score:
            continue
        shared = sorted(trades & our["직종"])
        if not shared and not any(a in b or b in a for a in mine for b in one["words"]):
            continue
        tags = [tag]
        if our["책"] == "건설품셈" and our["부문"] in BONUS_PARTS:
            score += 0.1
            tags.append(f"건설 {our['부문']}")
        if shared:
            score += 0.5
            tags.append("직종 " + " · ".join(shared))
        unit = hopyo_match.fits(line.get("단위"), one["단위"])
        if unit:
            score += 0.15
            tags.append("단위 맞음")
        dice = 2 * len(grams & one["grams"]) / (len(grams) + len(one["grams"]))
        why = {"조항": clauses, "직종": shared, "단위": unit, "점수": round(score, 3)}
        scored.append(
            (score, dice, {**hopyo_match._public(one), "근거": {**why, "까닭": " · ".join(tags)}})
        )
    scored.sort(key=lambda x: (-x[0], -x[1]))
    return [one for _, _, one in scored]


def merge(basis: list[dict[str, Any]], named: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """근거 후보 + 이름 후보 → 로직 키로 합침(점수 = 이름 점수 + 근거 점수) · 점수 차례."""
    if not basis:
        return named
    by_name = {c.get("로직"): c["점수"] for c in named}
    out = [{**c, "점수": round(c["근거"]["점수"] + by_name.pop(c["로직"], 0), 3)} for c in basis]
    out += [c for c in named if c.get("로직") in by_name]
    return sorted(out, key=lambda c: -c["점수"])