Aislo/M02_MasterTemplete/M02_Hopyo_Fixed.py

"""M02 실무자료 줄 → 고정 줄(PLAN 705-3 · 요구서 1장 · 4장 2 · 3 · 7) — 엑셀 숫자 그대로 · 빠짐 0.

맞춤 확인 안 한 줄 · 노임 · % · 「우리에 없음」 줄 = 빠진 줄 대신 고정 줄(705-1 그릇 `M02_Labor_Fixed`).
숫자는 서버가 실무자료 파일에서 읽음(브라우저 값 안 받음).
    단가 = 엑셀 단가 노무비 · 재료비 · 경비(빈 칸 0) · 합계만 있는 줄 = 재료비(4장 3) ·
    수량 없음 = 수량 1 · 단가 = 엑셀 금액(「금액만」).
    이음 = 노임(LB) · 자재(MT) = 이름 · 규격 · 단위 · 단가 다 같은 것만 · `by_name`(729-2 불러오기 길 ·
    요구서 내역19 3장 7) = 노임 = 이름 같은 LB 하나(값 = 지금 단가 책) · 기계 = 이름(갈래) · 규격 수 같은 EQ
    하나 · 못 이은 짝 = `후보` 수만 · 사용자가 고른 이음(`force` {노임|기계|자재: 키} · {비율: 기준}) = 그대로.
    % 줄 = 비율 줄 `비율 {기준, 비목}` — 엑셀 밑수(단가 계) = 다른 줄 금액[기준] 합일 때만 ·
    아니면(주재료비 등) 수량 1 · 「식」 · 단가 = 엑셀 금액.
    같은 이름 · 규격 · 단위 둘째부터 = 이름 끝 「 (2)」(줄 가름 · 705-1 400 피함).
출처 = `{파일, 호표, 줄}`(줄 = 엑셀 줄 차례 0부터 · [품셈으로 바꾸기] 짝).
"""

from __future__ import annotations

import re
from decimal import Decimal
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 import M02_Hopyo_Shares as shares
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Fixed as fixed
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, specnums

COSTS = ("노무비", "재료비", "경비")
_BASE = re.compile(r"(?<!주)(노무비|재료비|경비|인건비)\s*의")
GAP = Decimal(1)  # 밑수 · 단가 같음 판정 끝수(원)


_d, _plain = fixed._num, fixed._plain
mm_plain = m01.cm.mf.mp.mm.plain


def _parts(money: Any) -> dict[str, Decimal]:
    """엑셀 단가 · 금액 → 세 비목(빈 칸 0) · 합계만 있으면 재료비(4장 3)."""
    money = money if isinstance(money, dict) else {}
    out = {k: _d(money.get(k)) or Decimal(0) for k in COSTS}
    total = _d(money.get("계"))
    if total and not any(_d(money.get(k)) is not None for k in COSTS):
        out["재료비"] = total
    return out


def _ratio(line: dict[str, Any], others: list[dict[str, Any]]) -> dict[str, str] | None:
    """% 줄 → `{기준, 비목}` — 밑수 = 다른 줄 엑셀 금액[기준] 합(끝수 1 원 안) · 금액 비목 하나."""
    hit = _BASE.search(f"{line.get('규격') or ''} {line.get('이름') or ''}")
    under = _d((line.get("단가") or {}).get("계"))
    paid = [k for k, v in _parts(line.get("금액")).items() if v]
    if not hit or under is None or len(paid) != 1:
        return None
    base = "노무비" if hit.group(1) == "인건비" else hit.group(1)
    total = sum((_parts(x.get("금액"))[base] for x in others), Decimal(0))
    return {"기준": base, "비목": paid[0]} if abs(total - under) <= GAP else None


def linked(one: dict[str, Any], decided: bool = False) -> bool:
    """일위대가 줄 하나가 M01 · 기초 · SK 에 이어짐 — 로직 · 참조 · 비율 · 이음 있는 고정 줄 ·
    `decided` = 사용자가 「우리에 없음」으로 고른 줄."""
    fx = one.get("고정") if isinstance(one, dict) else None
    if not isinstance(fx, dict):
        return True
    return decided or bool(fx.get("비율")) or any((fx.get("이음") or {}).values())


class Linker:
    """이음 — 노임(LB 이름) · 기계(EQ 갈래 · 규격) · 자재(이름 · 규격 같은 한 품목 · 단위 · 단가 같음)."""

    def __init__(self, by_name: bool = False) -> None:
        self.by_name = (
            by_name  # 729-2 불러오기 길만 — 붙여넣기 · B09 통째 = 단가 같을 때만(엑셀 합계 그대로)
        )
        self.whole = m01.loaded()[1]
        self.got = hm.targets()
        self.labor: dict[str, list[tuple[str, Decimal | None]]] = {}
        for row in self.whole.numbers.get("LB", {}).values():
            pair = (str(row.get("키")), _d(row.get("값")))
            self.labor.setdefault(str(row.get("이름") or ""), []).append(pair)
        self.machines = [
            (str(row.get("키")), mtypes(f"{row.get('상세구분')} {row.get('이름')}"),
             set(specnums(row.get("규격"))), mm_plain(row.get("이름")), mm_plain(row.get("규격")))
            for row in self.whole.numbers.get("EQ", {}).values()
        ]  # fmt: skip
        self.near = 0  # 못 이은 이음 후보 수

    def link(self, line: dict[str, Any], price: dict[str, Decimal]) -> dict[str, str | None]:
        out: dict[str, str | None] = {"노임": None, "자재": None, "기계": None}
        kind = finger.kind_of(line)
        if kind == "노임":
            pairs = self.labor.get(shares.trade(line.get("이름")) or "", [])
            one = [code for code, _ in pairs]
            same = one[0] if self.by_name and len(one) == 1 else None
            out["노임"] = same or self._same(pairs, price["노무비"])
        elif kind == "기계" and self.by_name:
            out["기계"] = self._machine(line)
        elif kind in hm.MATERIAL_KINDS and price["재료비"]:
            out["자재"] = self._same(self._mats(line), price["재료비"])
        return out

    def _machine(self, line: dict[str, Any]) -> str | None:
        """기계 줄 → EQ 하나 — 이름 · 규격 글 같음 › 갈래 겹침 + 규격 수 같음(하나일 때만)."""
        name, spec = mm_plain(line.get("이름")), mm_plain(line.get("규격"))
        same = [c for c, _, _, n, s in self.machines if n == name and s == spec]
        if len(same) != 1:
            text = f"{line.get('이름') or ''} {line.get('규격') or ''}"
            kinds, nums = mtypes(text), set(specnums(text))
            same = [c for c, t, s, _, _ in self.machines if kinds & t and nums and nums == s]
        if len(same) == 1:
            return same[0]
        self.near += bool(same)
        return None

    def _same(self, pairs: list[tuple[str, Decimal | None]], want: Decimal) -> str | None:
        same = [code for code, value in pairs if value is not None and abs(value - want) < GAP]
        if len(same) == 1:
            return same[0]
        self.near += bool(pairs)
        return None

    def _mats(self, line: dict[str, Any]) -> list[tuple[str, Decimal | None]]:
        me, _ = hmat.clean(line)
        found = hm._exact(me, "자재", self.got)
        if len(found) != 1:
            found = [r["one"] for r in hmat.sure(me)[0]]
        out = []
        for one in found:
            code = one.get("자재")
            if not code or hm.factor(line.get("단위"), one.get("단위"))["배"] != 1:
                continue
            try:
                price = fixed.mm.element(self.whole, code, {}, line.get("단위") or None)[0]
            except fixed.mf.FormulaError:
                price = None
            out.append((code, _d(price)))
        return out


def line_of(
    line: dict[str, Any],
    others: list[dict[str, Any]],
    where: dict[str, Any],
    taken: set[str],
    linker: Linker,
    force: dict[str, str] | None = None,
) -> dict[str, Any]:
    """엑셀 줄 하나 → 일위대가 고정 줄 `{고정, 별칭, 메모, 수량}` — `taken` = 이 호표 줄 가름(채워 감) ·
    `force` = 사용자가 고른 이음 `{노임|기계|자재: 키}` · 비율 `{비율: 기준 비목}`(수량 = 율 %)."""
    qty = _d(line.get("수량"))
    spec, unit = str(line.get("규격") or "").strip(), str(line.get("단위") or "").strip()
    rate = _ratio(line, others) if finger.kind_of(line) == "%" else None
    if force and force.get("비율"):
        paid = [k for k, v in _parts(line.get("금액")).items() if v]
        rate = {"기준": force["비율"], "비목": paid[0] if len(paid) == 1 else force["비율"]}
    memo = f"실무 {qty if qty is not None else ''}{unit} 그대로"
    if rate:
        price = dict.fromkeys(COSTS, Decimal(0))
    elif qty is None or finger.kind_of(line) == "%":  # 금액만 · 밑수 다른 % 줄
        price, qty, memo = _parts(line.get("금액")), Decimal(1), f"{memo} · 금액만"
        unit = "식" if finger.kind_of(line) == "%" else unit
    else:
        price = _parts(line.get("단가"))
    name = str(line.get("이름") or "").strip() or "이름 없음"
    head, n = name, 1
    while fixed.fixed_id({"이름": name, "규격": spec, "단위": unit}) in taken:
        n += 1
        name = f"{head} ({n})"
    fx = {
        "이름": name,
        "규격": spec,
        "단위": unit,
        "단가": {k: _plain(v) for k, v in price.items()},
    }
    fx["이음"] = dict.fromkeys(fixed.LINKS) if rate else linker.link(line, price)
    if force and not rate:
        fx["이음"] = {k: force.get(k) for k in fixed.LINKS}
    fx["출처"] = {**where, "줄": int(line.get("차례", 0))}
    if rate:
        fx["비율"] = rate
    taken.add(fixed.fixed_id(fx))
    alias = str(line.get("이름") or "")[: labor.ALIAS_MAX].strip() or None
    return {"고정": fx, "별칭": alias, "메모": memo, "수량": {"손": _plain(qty)}}