Aislo/B09_Estimation/B09_Estimation_ResourceAxis_Transposed.py

"""B09 원가계산 — **열이 자원인 표** 읽기 (자원 축 보조, 2026-09-08).

품셈 표에는 자원이 **행**이 아니라 **열 머리**에 오는 모양이 따로 있다 (39 표).

    구 분        | 콘크리트공(인) | 보통인부(인)
    무근구조물   |     0.12       |    0.15
    철근구조물   |     0.14       |    0.16

행은 **규격 갈래**(무근·철근·소형구조물)이고 갈래마다 품이 다르다. 이 모양을 행-자원
표로 읽으면 통째로 안 맞는다 — 콘크리트 타설(12-1)이 그래서 하나도 안 서고 있었다.

⚠ **자리 밀림을 고쳐 읽지 않는다.** 첫 칸이 병합된 표는 값이 한 칸씩 밀려 오는데
(목재틀흙막이가 「건축목공 8.760」 자리에 등급 글자를 두어 단가가 503만원으로 섰다),
밀린 행은 **버리고 `unmatched` 에 남긴다.** 어느 칸이 어느 자원인지 단정할 수 없다.

`B09_Estimation_ResourceAxis` 가 700줄 제한에 걸려 이 표 모양만 떼어 낸 파일이다.
"""

from __future__ import annotations

from decimal import Decimal
from typing import Any

from B09_Estimation.B09_Estimation_ResourceAxis import (
    AxisResult,
    ResourceCatalog,
    ResourceRow,
    UnmatchedRow,
    parse_amount,
    split_name_and_spec,
)

#: 갈래 이름 자리에서 걸러 낼 말 — **합계 줄만**이다. 넓게 잡으면 등급이 지워진다.
_TOTAL_LABELS = ("계", "합계", "소계", "총계", "구분")


def _normalize_label(text: str) -> str:
    return "".join(str(text).split())


def transposed_columns(table: dict[str, Any], catalog: ResourceCatalog) -> list[tuple[int, Any]]:
    """열 머리에서 자원을 찾는다. `[(열 번호, 카탈로그 줄)]`.

    첫 칸은 갈래 이름(「구 분」)이라 **1번 열부터** 본다. 카탈로그에 있는 이름만
    자원으로 본다 — 필터로 거르지 않는다(넓은 필터가 정상 자원을 지운 전례).
    """
    headers = table.get("condition_note") or []
    found: list[tuple[int, Any]] = []
    for position, header in enumerate(headers[1:], start=1):
        name, spec = split_name_and_spec(str(header))
        entry = catalog.resolve(name, spec)
        if entry is None and not spec:
            candidates = catalog.by_name(name)
            entry = candidates[0] if len(candidates) == 1 else None
        if entry is not None:
            found.append((position, entry))
    return found


def match_transposed_table(
    node: dict[str, Any],
    table: dict[str, Any],
    catalog: ResourceCatalog,
    result: AxisResult,
    basis_quantity: Decimal | None,
    unit: str,
) -> bool:
    """열이 자원인 표를 읽는다. 그런 표가 아니면 `False` 를 돌려 원래 길로 보낸다.

    행마다 **규격 갈래 하나**가 되므로 `variant` 를 달아 둔다 — 「무근구조물」과
    「철근구조물」은 품이 달라 **한 일위대가로 뭉치면 안 된다**.
    """
    columns = transposed_columns(table, catalog)
    if not columns:
        return False

    # ⚠ **좌우로 두 판이 붙은 표는 통째로 버린다.** 열 머리가 되풀이되면
    # (「거리 | 보통인부 | 거리 | 보통인부」) 오른쪽 판의 **거리값이 인원으로** 읽힌다
    # — 2026-09-08 실측: 소운반이 「보통인부 60인」이 되어 단가가 1,553만원으로 섰다.
    # 판 경계를 짐작해 읽지 않는다.
    codes = [entry.code for _, entry in columns]
    if len(codes) != len(set(codes)):
        result.unmatched.append(
            UnmatchedRow(
                work_item_code=node.get("work_item_code", ""),
                pum_table_id=str(table.get("pum_table_id", "")),
                cell=" | ".join(str(c) for c in (table.get("condition_note") or [])),
                reason="열 머리가 되풀이되는 두 판 짜리 표 — 자리를 단정할 수 없어 버렸습니다.",
            )
        )
        return True

    # ⚠ **갈래 이름이 되풀이되면 그 줄들을 버린다.** 첫 칸이 병합된 표에서 상위 등급이
    # 떨어져 나가면 「상」이 두 번 나오고, 그대로 두면 서로 다른 등급의 품이 **합산**된다
    # (2026-09-08 실측: 목재틀흙막이 「상」이 8.760 + 13.767 = 22.5 인이 되어 단가가
    # 667만원으로 섰다). 어느 등급인지 단정할 수 없으므로 고쳐 읽지 않는다.
    labels = [str(row[0]).strip() for row in (table.get("raw_row") or []) if row]
    repeated = {label for label in labels if label and labels.count(label) > 1}

    work_item_code = node.get("work_item_code", "")
    table_id = str(table.get("pum_table_id", ""))
    form = str(table.get("pum_form", ""))
    matched_any = False

    for index, row in enumerate(table.get("raw_row", [])):
        cells = [str(c) for c in row]
        if not cells:
            continue
        variant = cells[0].strip()
        # ⚠ 첫 칸은 **갈래 이름**이지 자원 이름이 아니다 — 자원용 머리글 필터를 여기 쓰면
        # 「중」·「상」 같은 정상 등급이 통째로 지워진다(2026-09-08 실측: 목재틀흙막이의
        # 중·상 등급이 사라지고 상등구조만 남았다). 합계 줄만 걸러 낸다.
        if not variant or _normalize_label(variant) in _TOTAL_LABELS:
            continue
        if variant in repeated:
            result.unmatched.append(
                UnmatchedRow(
                    work_item_code=work_item_code,
                    pum_table_id=table_id,
                    cell=variant,
                    reason="같은 갈래 이름이 두 번 나오는 표 — 등급을 단정할 수 없어 버렸습니다.",
                )
            )
            continue
        # ⚠ **자리 밀림 검사** — 자원 열 가운데 하나라도 수가 아니면 그 행은 밀린 것이다.
        # 첫 칸이 병합된 표에서 값이 한 칸씩 밀려 들어온다(2026-09-08 실측: 목재틀흙막이가
        # 「건축목공 8.760」 자리에 등급 글자를 두어 단가가 503만원으로 섰다).
        # **밀린 행은 고쳐 읽지 않고 버린다** — 어느 칸이 어느 자원인지 단정할 수 없다.
        readable = [
            parse_amount(cells[position]) if position < len(cells) else None
            for position, _ in columns
        ]
        if any(value is None for value in readable) and any(
            value is not None for value in readable
        ):
            result.unmatched.append(
                UnmatchedRow(
                    work_item_code=work_item_code,
                    pum_table_id=table_id,
                    cell=variant,
                    reason="자원 열의 값이 한 칸 밀린 행 — 자리를 단정할 수 없어 버렸습니다.",
                )
            )
            continue

        for position, entry in columns:
            if position >= len(cells):
                # 칸이 모자란 행 — **자리를 밀어 읽지 않는다**. 밀려 읽으면 다른 직종의
                # 품이 붙는다(기계경비 표에서 실제로 겪은 사고).
                result.unmatched.append(
                    UnmatchedRow(
                        work_item_code=work_item_code,
                        pum_table_id=table_id,
                        cell=f"{variant} / {entry.name}",
                        reason="칸 수가 열 머리와 안 맞아 버렸습니다(자리 밀림 방지).",
                    )
                )
                continue
            amount = parse_amount(cells[position])
            if amount is None:
                continue
            if basis_quantity not in (None, 0, Decimal(1)):
                amount = amount / basis_quantity
            result.rows.append(
                ResourceRow(
                    work_item_code=work_item_code,
                    pum_table_id=table_id,
                    pum_form=form,
                    resource_kind=entry.kind,
                    resource_code=entry.code,
                    resource_name=entry.name,
                    resource_spec=entry.spec,
                    amount=amount,
                    amount_unit=unit,
                    raw_row_index=index,
                    variant=variant,
                )
            )
            matched_any = True
    return matched_any