"""M02 일위대가 실무자료 단가산출 블록 글 → 절 나무 · 선택값 · 상수 · 대입식 · 몫(PLAN 785-1 ·
요구 642 · 설계 642-A 2-2 ⓑ · 2-5 ④-2 · ④-3 B2~B4).

글 먼저 · 찾기 없음 — 글에 적힌 것만 꼴로 옮김(값을 짓지 않음 · 못 읽은 것은 안 냄) ·
M01 · 엔진 안 부름.

절 나무 `tree(글, 글행, 항목)` → [절] — 절 = {번, 층, 제목, 갈래, 행 [시작, 끝], 글 [첫, 끝],
    상수, 식, 선택값, 몫, 소계, 항목, 아래}:
    층 1 「1.」 · 2 「가.」 · 3 「1)」 · 빠진 번호 그대로(단산6 1 → 3) ·
    갈래 = 합계(합계 · 소계 · 총계) · 비목(재료비 · 인건비 · 노무비 · 경비 …) · 일(그 밖) ·
    상수 = 「q = 0.6㎥    K = 0.55」 · 「L = 6m {경사도 = 35°(α=8)}」 · 「운반회수 : n = 42회/일」 →
        {기호, 값, 단위, 덧?, 이름?, 행} ·
    식 = 「기호 = 식 = … = 값」 → {기호, 글, 값, 단위, 꼴 곱|합|분수, 분자, 분모, 대입, 행} —
        곱 = 「×」 「÷」 「/」 만 · 괄호 뒤 「÷」 는 괄호 안 모두 분모 ·
        대입 = 기호 식과 수 식의 인자 자리가 같을 때 {기호: 수} ·
        합(「+」) · 분수(「──」 그림 줄)는 값만 ·
    선택값 = 「※ …」 · 작업조건 줄 {글, 행} ·
    몫 = 그 절 비목 줄(노무비 · 재료비 · 경비) 「단가 ÷ Q」 · 「단가 × Q」 뒤 곱수(모두 같을 때) ·
        없으면 직종 줄 「단가 × 품」 뒤 % 곱수 → {글, 값, 행} ·
    소계 = 합계 갈래 아래 절(없으면 그 절 「소계」 줄) 비목 값 {노무비, 재료비, 경비, 계} ·
    항목 = 행이 그 절(아래 절 뺌) 안인 단위 줄 차례.
머리 `head(글, 글행)` = 첫 절 앞 줄 {행, 상수, 식, 선택값}.
일 절 `works(나무)` = 일 갈래 중 아래에 일 절이 없는 절 · 하나도 없으면 [](블록 통째 한 일).
"""

from __future__ import annotations

import re
from typing import Any

NUM = r"[\d,]+(?:\.\d+)?"
_LEVELS = (
    (1, re.compile(r"^\s*(\d+)\s*\.\s*(.*)$")),
    (2, re.compile(r"^\s*([가-하])\s*\.\s*(.*)$")),
    (3, re.compile(r"^\s*(\d+)\)\s*(.*)$")),
)
_DECIMAL = re.compile(r"^\s*\d+\.\d")
_TOTAL = re.compile(r"(합\s*계|소\s*계|총\s*계)")
_COSTS = ("재료비", "인건비", "노무비", "경비", "기계경비", "자재비", "재료", "인건", "노무")
_SEG = re.compile(
    r"(?:^\s*|(?<=\s\s)|(?<=[{(]))(?:(?P<label>[가-힣]{2,8})\s*[:：]\s*)?"
    r"(?P<sym>[A-Za-z][A-Za-z0-9]{0,3}|[가-힣]{2,6}|[α-ωΑ-Ω])\s*=(?!=)\s*"
)
_UNIT = r"[^\s\d×xX*÷/()=+,{}\[\]─]+(?:/[^\s\d×xX*÷/()=+,{}\[\]─]+)?"
_VALUE = re.compile(
    r"^\s*(?P<num>" + NUM + r")\s*(?P<unit>" + _UNIT + r")?\s*(?:\((?P<note>[^()]*)\))?"
    r"[\s)}\]]*$"
)
_TOKEN = re.compile(
    r"\s*(?P<op>[×*÷/])?\s*(?:(?P<open>\()|(?P<close>\))|(?P<num>"
    + NUM
    + r")\s*(?P<unit>"
    + _UNIT
    + r")?|(?P<sym>[A-Za-z][A-Za-z0-9]*))"
)
_COLON = re.compile(
    r"^\s*(?:\d+\)|[0-9가-힣]\.)?\s*(?P<name>[^:：=]{1,20}?)\s*[:：]\s*(?P<rhs>.*)$"
)
_CHOICE = re.compile(r"^\s*※|작업\s*조건")
_MONEY = {"노무비": "노무비", "재료비": "재료비", "경비": "경비", "계": "계", "소계": "계"}


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


def _num(text: str | None) -> float | None:
    try:
        return float(str(text).replace(",", ""))
    except (TypeError, ValueError):
        return None


def _kind(title: str) -> str:
    flat = _flat(title)
    if _TOTAL.search(flat):
        return "합계"
    head = re.split(r"[(:：]", flat)[0]
    return "비목" if head in _COSTS or head.endswith(_COSTS[:5]) and len(head) <= 6 else "일"


# ── 줄 하나 → 상수 · 식 ─────────────────────────────────────────────────
def factors(expr: str) -> list[tuple[str, dict[str, Any]]] | None:
    """「1 ㎡ × 575㎏/㎡ ÷ (qs × K)」 → [(곱|나눔, {수|기호, 단위})] · 「+」 · 못 읽으면 None."""
    if "+" in expr or "─" in expr:
        return None
    out: list[tuple[str, dict[str, Any]]] = []
    stack = [1]  # 괄호마다 부호(1 곱 · -1 나눔)
    need = False  # 다음 인자 · 괄호 앞에 연산이 있어야 함
    at, text = 0, expr.strip()
    while at < len(text):
        hit = _TOKEN.match(text, at)
        if not hit or hit.end() == at:
            return None
        at = hit.end()
        op = hit.group("op")
        sign = -1 if op in ("÷", "/") else 1
        if hit.group("close"):
            if len(stack) == 1 or op:
                return None
            stack.pop()
            need = True
            continue
        if need != bool(op):
            return None  # 두 인자 사이 연산 없음 · 연산 뒤 인자 없음
        if hit.group("open"):
            stack.append(stack[-1] * sign)
            need = False
            continue
        need = True
        one: dict[str, Any] = {}
        if hit.group("num"):
            one["수"] = _num(hit.group("num"))
            one["단위"] = hit.group("unit") or ""
        else:
            one["기호"], one["단위"] = hit.group("sym"), ""
        out.append(("곱" if stack[-1] * sign > 0 else "나눔", one))
    return out if out and len(stack) == 1 else None


def _value(text: str) -> dict[str, Any] | None:
    hit = _VALUE.match(text)
    if not hit:
        return None
    out = {"값": _num(hit.group("num")), "단위": hit.group("unit") or ""}
    if hit.group("note"):
        out["덧"] = hit.group("note").strip()
    return out


def _last_value(text: str) -> dict[str, Any] | None:
    """식 끝 「= 23.1 ㎥/hr」 · 「= 5분(왕복)」 · 「= 7.79 회」."""
    hit = re.search(r"(" + NUM + r")\s*(" + _UNIT + r")?\s*(?:\(([^()]*)\))?\s*$", text)
    if not hit:
        return None
    out = {"값": _num(hit.group(1)), "단위": hit.group(2) or ""}
    if hit.group(3):
        out["덧"] = hit.group(3).strip()
    return out


def _formula(sym: str, body: str) -> dict[str, Any] | None:
    parts = [p.strip() for p in body.split("=")]
    end = _last_value(parts[-1]) if len(parts) > 1 else None
    if end is None:
        return None
    first = parts[0]
    out: dict[str, Any] = {"기호": sym, "글": f"{sym} = {body.strip()}", **end}
    if "─" in first:
        return {**out, "꼴": "분수"}
    got = factors(first)
    if got is None:
        return {**out, "꼴": "합" if "+" in first else "분수"}
    out["꼴"] = "곱"
    out["분자"] = [f for way, f in got if way == "곱"]
    out["분모"] = [f for way, f in got if way == "나눔"]
    numbers = factors(parts[1]) if len(parts) > 2 else None
    if numbers and len(numbers) == len(got):
        out["대입"] = {
            f["기호"]: n["수"]
            for (way, f), (way2, n) in zip(got, numbers, strict=True)
            if "기호" in f and "수" in n and way == way2
        }
    return out


def line_of(text: str, at: int | None = None) -> dict[str, list[dict[str, Any]]]:
    """줄 하나 → {상수 [..], 식 [..]} — 「기호 = 」 마디(줄 머리 · 두 빈칸 · 「{」 「(」 뒤)마다."""
    out: dict[str, list[dict[str, Any]]] = {"상수": [], "식": []}
    hits = list(_SEG.finditer(text))
    for i, hit in enumerate(hits):
        end = hits[i + 1].start() if i + 1 < len(hits) else len(text)
        body = text[hit.end() : end]
        sym, label = hit.group("sym"), hit.group("label")
        if (got := _value(body.strip().rstrip("{(").strip())) is not None:
            one = {"기호": sym, **got, **({"이름": label} if label else {}), "행": at}
            out["상수"].append(one)
        elif (got := _formula(sym, body)) is not None:
            out["식"].append({**got, **({"이름": label} if label else {}), "행": at})
    return out


# ── 절 몫 · 소계 ───────────────────────────────────────────────────────
def _share(lines: list[tuple[str, int | None]]) -> dict[str, Any] | None:
    """비목 줄 「단가 ÷ Q × 575 / 1750 × 90%」 → 「÷ Q」 뒤 곱수(비목 줄 모두 같을 때) ·
    없으면 직종 줄 「단가 × 품인 × 10%」 품 뒤 % 곱수."""
    costs: list[tuple[str, float, int | None]] = []
    trades: list[tuple[str, float, int | None]] = []
    for text, at in lines:
        hit = _COLON.match(text)
        if not hit or "=" not in hit.group("rhs"):
            continue
        name, rhs = _flat(hit.group("name")), hit.group("rhs").split("=")[0]
        got = factors(rhs)
        if not got or len(got) < 3 or any("수" not in f for _, f in got):
            continue
        tail = got[2:]
        if name in ("노무비", "재료비", "경비"):
            pass
        elif got[1][1]["단위"].startswith("인"):
            tail = [t for t in tail if t[1]["단위"] == "%"]
            if not tail or len(tail) != len(got) - 2:
                continue
        else:
            continue
        value = 1.0
        for way, f in tail:
            n = f["수"] / 100 if f["단위"] == "%" else f["수"]
            value = value * n if way == "곱" else value / n
        words = " ".join(f"{'×' if way == '곱' else '/'} {f['수']:g}{f['단위']}" for way, f in tail)
        (costs if name in ("노무비", "재료비", "경비") else trades).append((words, value, at))
    for group in (costs, trades):
        if group and len({w for w, _, _ in group}) == 1:
            words, value, at = group[0]
            return {"글": words, "값": round(value, 6), "행": at}
    return None


def _totals(lines: list[tuple[str, int | None]], only_sum: bool) -> dict[str, float | None]:
    out: dict[str, float | None] = {}
    for text, _ in lines:
        hit = _COLON.match(text)
        if not hit:
            continue
        key = _MONEY.get(_flat(hit.group("name")))
        if not key or (only_sum and key != "계"):
            continue
        rhs = hit.group("rhs")
        if re.search(r"[×*÷]", rhs.split("=")[0]):
            continue
        nums = re.findall(NUM, rhs)
        out[key] = _num(nums[-1]) if nums else None
    return out


# ── 절 나무 ────────────────────────────────────────────────────────────
def _title(text: str) -> tuple[int, str, str] | None:
    if _DECIMAL.match(text):
        return None
    for depth, pattern in _LEVELS:
        if hit := pattern.match(text):
            return depth, hit.group(1), hit.group(2).strip()
    return None


def _fill(one: dict[str, Any], lines: list[tuple[str, int | None]]) -> None:
    for text, at in lines:
        got = line_of(text, at)
        one["상수"] += got["상수"]
        one["식"] += got["식"]
        if _CHOICE.search(text):
            one["선택값"].append({"글": text.strip(), "행": at})


def head(text: list[str], rows: list[int] | None = None) -> dict[str, Any]:
    """첫 절 앞 머리 줄 → {행, 상수, 식, 선택값}."""
    rows = rows or [None] * len(text)
    lines = []
    for raw, at in zip(text, rows, strict=True):
        if _title(str(raw)):
            break
        lines.append((str(raw), at))
    out: dict[str, Any] = {"행": [lines[0][1], lines[-1][1]] if lines else None}
    out |= {"상수": [], "식": [], "선택값": []}
    _fill(out, lines)
    return out


def tree(
    text: list[str], rows: list[int] | None = None, items: list[dict[str, Any]] | None = None
) -> list[dict[str, Any]]:
    """블록 몸 글(머리 줄 뺌) → 절 나무 — 꼴은 머리 글."""
    rows = list(rows) if rows else [None] * len(text)
    roots: list[dict[str, Any]] = []
    path: list[dict[str, Any]] = []
    own: dict[int, list[tuple[str, int | None]]] = {}
    for at, (raw, row) in enumerate(zip(text, rows, strict=True)):
        line = str(raw)
        if got := _title(line):
            depth, no, title = got
            while path and path[-1]["층"] >= depth:
                path.pop()
            one = {"번": no, "층": depth, "제목": title, "갈래": _kind(title), "행": [row, row]}
            one |= {"글": [at, at], "상수": [], "식": [], "선택값": [], "몫": None, "소계": {}}
            one |= {"항목": [], "아래": []}
            (path[-1]["아래"] if path else roots).append(one)
            path.append(one)
            own[id(one)] = [(line, row)]
            continue
        if not path:
            continue
        own[id(path[-1])].append((line, row))
        for one in path:
            one["행"][1], one["글"][1] = row, at
    for one in _walk(roots):
        lines = own[id(one)]
        _fill(one, lines)
        one["몫"] = _share(lines)
        total = next((k for k in one["아래"] if k["갈래"] == "합계"), None)
        if one["갈래"] == "합계":
            one["소계"] = _totals(lines, False)
        elif total is not None:
            one["소계"] = _totals(own[id(total)], False)
        else:
            one["소계"] = _totals(lines, True)
    if items:
        _attach(roots, items)
    return roots


def _walk(nodes: list[dict[str, Any]]) -> list[dict[str, Any]]:
    out = []
    for one in nodes:
        out.append(one)
        out += _walk(one["아래"])
    return out


def _attach(roots: list[dict[str, Any]], items: list[dict[str, Any]]) -> None:
    """단위 줄 차례 → 행이 든 가장 깊은 절."""
    for at, item in enumerate(items):
        row = item.get("행")
        if not isinstance(row, int):
            continue
        best = None
        for one in _walk(roots):
            lo, hi = one["행"]
            if isinstance(lo, int) and isinstance(hi, int) and lo <= row <= hi:
                if best is None or one["층"] > best["층"]:
                    best = one
        if best is not None:
            best["항목"].append(at)


def works(nodes: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """일 절 — 일 갈래 중 아래에 일 절이 없는 절(비목 · 합계 아래만 있으면 그 절)."""
    out = []
    for one in nodes:
        if one["갈래"] != "일":
            continue
        kids = works(one["아래"])
        out += kids or [one]
    return out


def find(nodes: list[dict[str, Any]], path: str) -> dict[str, Any] | None:
    """「1」 · 「1.가」 → 절."""
    first, _, rest = path.partition(".")
    for one in nodes:
        if one["번"] == first:
            return find(one["아래"], rest) if rest else one
    return None