# -*- coding: utf-8 -*-
"""수식 나무(PLAN 796-1 · 요구 655 · 657 · 요구서_655 0 장) — 로직 줄 → 그림용 나무 · 변수 표.

수식 = 계산 로직 그 자체 — 나무는 엔진 식 나무(`master_formula.parse`)를 그대로 옮긴 것이고
`master_equation_edit.engine_text` 가 나무를 엔진 식 글로 되돌림(왕복 = 같은 금액).

줄마다 `이름식`(변수 = 이름 · 기호 · 첨자) · `값식`(같은 나무의 값 꼴) · `값` · 오른쪽 `풀이`(입력 ·
찾기 · 요소 값 + 표 · 행) · 하위 로직 부르기 = `블록`(접힘 · 노재경 소계 보이기만 · 금액 그대로).

나무 마디(`꼴`):
    수 {글, 값} · 글 {글} · 변수 {열쇠, 이름, 기호, 위, 아래, 단위, 갈래, 값, 글, 식?}
    (갈래 = 입력 · 중간 · 찾기 · 요소 · 합 — 찾기 · 요소 `식` = 엔진 원문 · 찾기 `표` · `행` · `칸`)
    연산 {기호, 좌, 우} · 분수 {위, 아래, 사슬?} · 괄호 {안} · 퍼센트 {안} · 음 {안}
    조건 {조건, 참, 거짓, 걸림(1 참 · 2 거짓 · 0 모름), 글} · 함수 {이름, 인자}
    블록 {열쇠, 이름, 결과단위, 칸, 값, 묶음, 식, 접힘, 나무}
변수 표 = 입력 · 중간마다 {열쇠, 이름, 기호, 위, 아래, 단위, 갈래, 기본값, 설명} — 열쇠 = 엔진 이름
(안 바뀜) · 이름 · 기호 · 첨자 고침은 로직 줄 새 칸 `변수표` {열쇠: {이름?, 기호?, 위?, 아래?}}
(바꾼 것만 · 셈에 안 씀) · 기호 초기값 = 품셈 원문 「여기서 q : 버킷용량(㎥)」 후보(`symbols`).
셈 = `master_formula.run` · 끝수 `master_cut.engine` 한 벌 · eval 없음.
"""

from __future__ import annotations

import functools
import re
from decimal import Decimal
from pathlib import Path

import master_auto as ma
import master_cut as mcut
import master_equation_group as grp
import master_equation_view as view
import master_formula as mf
import master_material as mm
import master_symbol as msym

from common_util.common_util_money import fmt

FIELD = "변수표"  # 로직 줄 새 칸(`_틀.md` 2 장 열 차례 끝)
LOOK = ("이름", "기호", "위", "아래")  # 변수표에 두는 꼴 칸
SHOW = 4  # 값 칸 보이는 자리 — 고친 중간 줄 `표시`(보이는 자리에서 잘라 셈 · 요구 658)
DEEP = 1  # 블록 안 나무를 펼칠 깊이(그 아래는 값 · 묶음만)
PREC = {"또는": 1, "그리고": 2, "==": 3, "!=": 3, "<": 3, "<=": 3, ">": 3, ">=": 3}
PREC |= {"+": 4, "-": 4, "*": 5, "/": 5}
SIGN = {"*": "×", "/": "÷", "-": "−"}
_ERR = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, IndexError)
_BOOK = Path(mf.mk.MASTER).parents[1] / "resources/knowledge/original/원가계산"
_DEF = re.compile(r"^(?:여기서\s*[,:]?\s*)?([A-Za-z][A-Za-z0-9′'ˊ]{0,5})\s*[:：]\s*(.+?)\s*$")


# ── 변수 표 ────────────────────────────────────────────────────────────
def _norm(text: str) -> str:
    """원문 풀이 · 변수 이름 맞대기 — 괄호 · 빈칸 · 「1일 · 1회」 머리 뺌 · 「횟수」 = 「회수」."""
    text = re.sub(r"\([^)]*\)|（[^）]*）|\s", "", str(text or ""))
    return re.sub(r"^(1일|1회|일|회당)", "", text).replace("횟수", "회수")


@functools.lru_cache(maxsize=256)
def _section(book: str, number: str) -> tuple[tuple[str, str], ...]:
    """원문 절의 「여기서 기호 : 풀이」 목록 — 절 머리(`### 8-2-3 …`) 아래 다음 머리까지."""
    root = _BOOK / ("산림_표준품셈/본문" if book == "산림품셈" else "건설공사_표준품셈/본문")
    head = re.compile(rf"^#+\s*{re.escape(number)}\s")
    out: list[tuple[str, str]] = []
    for path in sorted(root.rglob("*.md")) if number else []:
        try:
            text = path.read_text(encoding="utf-8")
        except OSError:
            continue
        if number not in text:
            continue
        inside, block = False, False
        for line in text.splitlines():
            if line.startswith("#"):
                if inside:
                    break
                inside = bool(head.match(line))
                continue
            if not inside:
                continue
            line = re.sub(r"<!--.*?-->", "", line).strip()
            m = _DEF.match(line) if (block or line.startswith("여기서")) else None
            block = bool(m) or (block and not line)
            if m:
                out.append((m.group(1), m.group(2)))
        if out:
            break
    return tuple(out)


def symbols(row: dict) -> dict[str, str]:
    """{열쇠: 원문 기호 후보} — 이름 · 설명 「(q)」 · 풀이 맞대기가 하나일 때만(796-3 확정 전)."""
    book = "산림품셈" if str(row.get("구분") or "").startswith("산림") else "건설품셈"
    defs = _section(book, str(row.get("원문번호") or ""))
    keys = {str(s.get("이름")) for k in ("입력", "중간") for s in row.get(k) or []}
    got: dict[str, list[tuple[str, str]]] = {}  # 기호 → [(열쇠, 갈래)]
    for kind in ("입력", "중간"):
        for spec in row.get(kind) or []:
            key = str(spec.get("이름"))
            if re.fullmatch(r"[A-Za-z][\w′']{0,5}", key):
                continue  # 이름이 이미 기호(K · E · f · cm)
            said = re.findall(
                rf"{re.escape(key)}\(([A-Za-z][\w′']{{0,5}})\)", str(spec.get("설명") or "")
            )
            hits = {s for s, d in defs if s in said} or {
                s for s, d in defs if _norm(d) == _norm(key)
            }
            if len(hits) == 1 and (sign := hits.pop()) not in keys:
                got.setdefault(sign, []).append((key, kind))
    out = {}
    for sign, owners in got.items():  # 한 기호는 한 변수 — 여럿이면 중간 하나일 때만
        mids = [k for k, kind in owners if kind == "중간"]
        one = owners[0][0] if len(owners) == 1 else mids[0] if len(mids) == 1 else None
        if one:
            out[one] = sign
    if "결과" in row and defs and defs[0][0] not in keys and defs[0][0] not in out.values():
        out["결과"] = defs[0][0]  # 「여기서 Q : 시간당 작업량」 — 첫 풀이 = 결과
    return out


def table(row: dict, master=None) -> list[dict]:
    """변수 표 — 입력 · 중간 차례 · 기본값 = 입력 `기본` › 자동 제안(`master_auto.defaults`)."""
    saved = row.get(FIELD) if isinstance(row.get(FIELD), dict) else {}
    auto = ma.defaults(master, row) if master is not None else {}
    found = symbols(row)
    out = []
    for kind in ("입력", "중간"):
        for spec in row.get(kind) or []:
            key = str(spec.get("이름"))
            look = saved.get(key) if isinstance(saved.get(key), dict) else {}
            out.append(
                {
                    "열쇠": key,
                    "이름": look.get("이름") or key,
                    "기호": look.get("기호") or found.get(key) or key,
                    "위": look.get("위") or "",
                    "아래": look.get("아래") or "",
                    "단위": spec.get("단위") or "",
                    "갈래": kind,
                    "기본값": spec.get("기본", auto.get(key)) if kind == "입력" else None,
                    "설명": spec.get("설명") or "",
                    **({"표시": spec["표시"]} if spec.get("표시") is not None else {}),
                }
            )
    return out


def token(var: dict) -> str:
    """키보드 한 줄 식의 변수 글 — 기호(_아래)(^위) · 기호가 열쇠와 같고 첨자 없으면 열쇠."""
    out = str(var.get("기호") or var["열쇠"])
    if var.get("아래"):
        out += f"_{var['아래']}"
    if var.get("위"):
        out += f"^{var['위']}"
    return out


# ── 나무 ──────────────────────────────────────────────────────────────
class _Ctx:
    def __init__(self, master, row: dict, env: dict, depth: int):
        self.master, self.row, self.env, self.depth = master, row, env, depth
        self.vars = {v["열쇠"]: v for v in table(row)}
        self.used: dict[str, dict] = {}  # 풀이 — 쓰인 입력 · 찾기 · 요소

    def value(self, node):
        try:
            got = mf.evaluate(node, self.env, self.master, self.depth)
        except _ERR:
            return None
        return got


def _num(value) -> dict:
    if isinstance(value, Decimal):
        return {"꼴": "수", "글": fmt(value), "값": value}
    return {"꼴": "글", "글": "" if value is None else str(value)}


def _var(ctx: _Ctx, key: str, kind: str, value, **more) -> dict:
    look = ctx.vars.get(key) or {"열쇠": key, "이름": key, "기호": key, "위": "", "아래": ""}
    node = {
        "꼴": "변수",
        "열쇠": key,
        **{k: look.get(k, "") for k in LOOK},
        "단위": look.get("단위", more.pop("단위", "")),
        "갈래": kind,
        "값": value if not isinstance(value, dict) else None,
        "글": "" if value is None or isinstance(value, dict) else fmt(value),
        **more,
    }
    if kind in ("입력", "찾기", "요소"):
        ctx.used.setdefault(more.get("식") or key, {k: v for k, v in node.items() if k != "꼴"})
    return node


def _raw(node) -> str:
    """마디 → 엔진 식 글(찾기 · 요소 · 로직 부르기 원문 보관용)."""
    import master_equation_edit as me  # 서로 부름 — 늦게

    return me.raw_text(node)


def me_keyboard(ctx: _Ctx, node) -> str:
    """조건 식 마디 → 키보드 한 줄 글(변수 = 기호) — 정의 영역 「조건 규격 = 폼타이규격」."""
    import master_equation_edit as me

    return me.keyboard_of(_raw(node), ctx.row)


def _find(ctx: _Ctx, node, column: str) -> dict:
    """찾기(표, 조건).칸 → 찾기 변수 · 표 · 고른 행."""
    raw = _raw(("field", node, column))
    more = {"식": raw, "칸": column}
    more["조건식"] = {k: me_keyboard(ctx, c) for k, c in node[2]}
    try:
        ref = mf.fill(node[1], ctx.env)
        table_row = ctx.master.get(ref)
        conds = {k: mf.evaluate(v, ctx.env, ctx.master, ctx.depth) for k, v in node[2]}
        more |= {"표": ref, "표이름": table_row.get("이름") or "", "행": conds}
        more["단위"] = (table_row.get("값칸") or {}).get(column) or ""
    except _ERR:
        pass
    name = f"{more.get('표이름') or node[1]}.{column}"
    look = {"열쇠": raw, "이름": name, "기호": column, "위": "", "아래": ""}
    ctx.vars.setdefault(raw, look)
    return _var(ctx, raw, "찾기", ctx.value(("field", node, column)), **more)


def _block(ctx: _Ctx | None, node, column: str | None) -> dict:
    """로직 부르기 → 블록 — 묶음(노 · 재 · 경 · 계) · 결과 수 · 접힌 하위 나무(`DEEP` 까지)."""
    raw = _raw(node if column is None else ("field", node, column))
    out = {"꼴": "블록", "열쇠": node[1], "칸": column, "식": raw, "접힘": True}
    if ctx is None:
        return out
    try:
        ref = mf.fill(node[1], ctx.env)
        sub = ctx.master.logic(ref)
        given = {k: mf.evaluate(v, ctx.env, ctx.master, ctx.depth) for k, v in node[2]}
        out |= {"열쇠": ref, "이름": sub.get("이름") or ref, "결과단위": sub.get("결과단위") or ""}
    except _ERR:
        return out
    got = ctx.value(node)
    if isinstance(got, dict):
        out["묶음"] = got
        got = got.get(column) if column else got.get("계")
    elif column is not None:
        got = None
    out |= {"값": got, "글": fmt(got) if isinstance(got, Decimal) else ""}
    if ctx.depth < DEEP:
        try:
            out["나무"] = export(ctx.master, ref, given, ctx.depth + 1)
        except _ERR:
            out["나무"] = None
    return out


def _paren(child: dict, op: str, right: bool) -> dict:
    """연산 자식 괄호 — 낮은 세기 · 오른쪽 같은 세기(엔진은 왼쪽부터 묶음 — 나무 그대로)."""
    if child.get("꼴") != "연산":
        return child
    mine, up = PREC[child["_op"]], PREC[op]
    if mine < up or (mine == up and right):
        return {"꼴": "괄호", "안": child}
    return child


def build(node, ctx: _Ctx | None) -> dict:
    """엔진 식 마디 → 나무 마디(이름 꼴) · ctx 없으면 값 · 풀이 없이 꼴만."""
    kind = node[0]
    if kind == "num":
        return _num(node[1])
    if kind == "str":
        return {"꼴": "글", "글": node[1], "따옴": True}
    if kind == "name":
        key = node[1]
        if ctx is None:
            return {"꼴": "변수", "열쇠": key, "갈래": "합"}
        where = ctx.vars.get(key, {}).get("갈래") or "합"
        return _var(ctx, key, where, ctx.env.get(key) if ctx else None)
    if kind == "ref":
        if ctx is None:
            return {"꼴": "변수", "열쇠": node[1], "갈래": "요소", "식": node[1]}
        return _elem(ctx, node[1])
    if kind == "neg":
        inner = build(node[1], ctx)
        return {"꼴": "음", "안": {"꼴": "괄호", "안": inner} if inner["꼴"] == "연산" else inner}
    if kind == "field" and node[1][0] == "find":
        if ctx is None:
            return {"꼴": "변수", "갈래": "찾기", "식": _raw(node), "열쇠": _raw(node)}
        return _find(ctx, node[1], node[2])
    if kind == "field" and node[1][0] == "logic":
        return _block(ctx, node[1], node[2])
    if kind == "logic":
        return _block(ctx, node, None)
    if kind in ("field", "find"):  # 그 밖의 칸 꺼냄(요소 묶음 · 찾기 줄째) — 원문 그대로 변수
        raw = _raw(node)
        if ctx is None:
            return {"꼴": "변수", "갈래": "요소", "식": raw, "열쇠": raw}
        return _var(ctx, raw, "요소", ctx.value(node), 식=raw)
    if kind == "call" and node[1] == "만약":
        cond, yes, no = (build(x, ctx) for x in node[2])
        hit = ctx.value(node[2][0]) if ctx else None
        at = 0 if hit is None else 1 if hit else 2
        return {"꼴": "조건", "조건": cond, "참": yes, "거짓": no, "걸림": at}
    if kind == "call":
        return {"꼴": "함수", "이름": node[1], "인자": [build(x, ctx) for x in node[2]]}
    if kind == "bin":
        return _bin(node, ctx)
    raise mf.FormulaError(f"모르는 마디 {kind}")


def _elem(ctx: _Ctx, ref: str) -> dict:
    import master_text as mt

    value = ctx.value(("ref", ref))
    name = mt._elem_name(ctx.master, ref, ctx.env)
    look = {"열쇠": ref, "이름": name, "기호": name, "위": "", "아래": ""}
    ctx.vars.setdefault(ref, look)
    return _var(ctx, ref, "요소", value, 식=ref)


def _bin(node, ctx: _Ctx | None) -> dict:
    _, op, left, right = node
    if op == "/" and right == ("num", Decimal(100)):  # 「… / 100」 = 퍼센트
        inner = _paren(build(left, ctx), "*", False)
        return {"꼴": "퍼센트", "안": inner}
    if op == "/":
        if left[0] == "bin" and left[1] == "/" and left[3] != ("num", Decimal(100)):
            top, mid = build(left[2], ctx), build(left[3], ctx)  # a/b/c → a/(b×c) 모양만
            low = {"꼴": "연산", "기호": "×", "_op": "*", "좌": mid, "우": build(right, ctx)}
            low["좌"], low["우"] = _paren(mid, "*", False), _paren(low["우"], "*", True)
            return {"꼴": "분수", "위": top, "아래": low, "사슬": True}
        return {"꼴": "분수", "위": build(left, ctx), "아래": build(right, ctx)}
    a, b = build(left, ctx), build(right, ctx)
    return {
        "꼴": "연산",
        "기호": SIGN.get(op, op),
        "_op": op,
        "좌": _paren(a, op, False),
        "우": _paren(b, op, True),
    }


def values(tree: dict) -> dict:
    """이름 꼴 나무 → 값 꼴 나무 — 변수 · 블록은 값 수로(열쇠 남김) · 조건은 걸린 쪽만."""
    kind = tree.get("꼴")
    if kind in ("변수", "블록"):
        value = tree.get("값")
        got = _num(value) if value is not None else {"꼴": "글", "글": "?"}
        return {**got, "열쇠": tree.get("열쇠"), "갈래": tree.get("갈래") or "블록"}
    if kind == "조건":
        if tree.get("걸림"):
            return values(tree["참" if tree["걸림"] == 1 else "거짓"])
        return {**tree, **{k: values(tree[k]) for k in ("조건", "참", "거짓")}}
    out = dict(tree)
    for k in ("좌", "우", "위", "아래", "안"):
        if k in tree:
            out[k] = values(tree[k])
    if "인자" in tree:
        out["인자"] = [values(x) for x in tree["인자"]]
    return out


def _clean(tree):
    """밖으로 내보낼 나무 — 안쪽 칸(`_op`) 뺌."""
    if isinstance(tree, dict):
        return {k: _clean(v) for k, v in tree.items() if k != "_op"}
    if isinstance(tree, list):
        return [_clean(x) for x in tree]
    return tree


# ── 로직 한 줄 → 수식 ─────────────────────────────────────────────────
def given_of(master, row: dict, given: dict | None = None) -> dict:
    """셈 입력 — 자동값 · 기본 제안 · 시험입력 · 받은 값 차례로 덮음."""
    out = ma.values(master, row)
    out.update({k: v for k, v in ma.defaults(master, row).items() if v is not None})
    out.update(row.get("시험입력") or {})
    out.update(given or {})
    names = {s["이름"] for s in row.get("입력") or []}
    return {k: v for k, v in out.items() if k in names}


def _line(ctx: _Ctx, kind: str, key: str, text: str, value, **more) -> dict:
    try:
        tree = build(mf.parse(text), ctx)
    except mf.FormulaError as e:
        return {"갈래": kind, "열쇠": key, "식": text, "까닭": str(e), **more}
    head = _var(ctx, key, kind if kind in ("중간",) else "합", value)
    if kind == "결과":
        head |= {"이름": "결과", "기호": symbols(ctx.row).get("결과") or "결과"}
    return {
        "갈래": kind,
        "열쇠": key,
        "식": text,
        "결과": head,
        "이름식": tree,
        "값식": values(tree),
        "값": value,
        "글": fmt(value) if isinstance(value, Decimal) else "",
        **more,
    }


def subtotals(logic: dict, cut: dict, total: dict) -> dict:
    """호표 줄 → 소계 묶음(799-1 · 801-3 · 보이기만) — 부른 단가산출 = 묶음 하나씩 · 직접 줄 = 한 묶음 + 끝수.

    값 = `master_cut.engine` 이 버린 줄 비목(0.1 원) 그대로 · 합계 = 엔진 비목 합(1 원 버림) ·
    끝수 = 합계 − 묶음 합(금액 셈은 안 바꿈 · 사용자 확정 뒤에 정함). 묶음 꼴 = `master_equation_group`.
    """
    items = logic.get("호표") or []
    skip = mcut.ms.skipped(logic) if mcut.ms.uses(logic) else set()
    rows: list[dict] = []
    for n, line in enumerate(cut.get("줄") or []):
        if n in skip:
            continue
        split = {k: line.get("비목", {}).get(k) or Decimal(0) for k in mf.COST_ITEMS}
        item = items[n] if n < len(items) else {}
        kind = "블록" if item.get("종류") == "로직" else "자원" if item else "덧줄"
        rows.append(
            {"갈래": kind, "이름": str(item.get("이름") or ""), "종류": item.get("종류"), **split}
            | {"계": sum(split.values(), Decimal(0))}
        )
    got = grp.bundles(rows)
    rest = {
        k: (total.get(k) or Decimal(0)) - sum((one[k] for one in got["줄"]), Decimal(0))
        for k in mf.BUNDLE
    }
    return {"줄": got["줄"], "끝수": rest}


def export(master, key: str, given: dict | None = None, depth: int = 0) -> dict:
    """로직 키 → 수식 {열쇠, 이름, 결과단위, 줄, 풀이, 변수표, 합계 | 결과} — 셈은 엔진 한 벌."""
    row = master.logic(key)
    given = given_of(master, row, given) if depth == 0 else dict(given or {})
    raw = mf.run(master, key, given, depth)
    env = {k: v for k, v in (raw.get("중간") or {}).items()}
    ctx = _Ctx(master, row, env, depth)
    out_lines = []
    for step in row.get("중간") or []:
        name = step["이름"]
        more = {"표시": step["표시"]} if step.get("표시") is not None else {}
        out_lines.append(_line(ctx, "중간", name, step["식"], env.get(name), **more))
    total: dict = {}
    sub: dict = {}
    if "결과" in row:
        out_lines.append(_line(ctx, "결과", "결과", row["결과"]["식"], raw["결과"]))
        total = {"결과": raw["결과"]}
    else:
        cut = mcut.engine(master, key, raw) if depth == 0 else raw
        lines = raw.get("줄") or []
        for at, item in enumerate(row.get("호표") or []):
            out_lines.append(_item(ctx, at, item, lines[at] if at < len(lines) else {}))
        for at, extra in enumerate(row.get("덧줄") or []):
            got = env.get(extra["이름"])
            one = _line(ctx, "덧줄", extra["이름"], extra["식"], got, 차례=at)
            out_lines.append(one | {"비목": extra.get("비목")})
        total = {k: cut.get(k) for k in mf.BUNDLE}
        if depth == 0:
            sub = {"소계": subtotals(row, cut, total)}
    out = msym.apply(  # 기호 먼저(800-1) → 정의는 기호 씌운 줄로(800-2)
        {
            "열쇠": row.get("키"),
            "이름": row.get("이름") or "",
            "결과단위": row.get("결과단위") or "",
            "줄": out_lines,
            "풀이": list(ctx.used.values()),
            "변수표": table(row, master),
            "합계": total,
            **sub,
        }
    )
    if depth == 0:
        out["정의"] = view.definitions(out_lines, row, out["변수표"], _unused(row))
    return _clean(out)


def _unused(row: dict):
    """열쇠 → 어느 식에도 안 쓰이나(정의 영역 · 지울 수 있는 입력)."""
    import master_equation_edit as me

    return lambda key: key != mm.REGION and not me.uses(row, key)


def _item(ctx: _Ctx, at: int, item: dict, line: dict) -> dict:
    """호표 줄 = 「단가 × 수량식 = 금액」 · 로직 줄 단가 = 블록."""
    name = str(item.get("이름") or "")
    try:
        qty = build(mf.parse(item["수량"]), ctx)
    except mf.FormulaError as e:
        return {"갈래": "호표", "차례": at, "열쇠": name, "식": item["수량"], "까닭": str(e)}
    if item.get("종류") == "로직":
        price = build(mf.parse(str(item["요소"])), ctx)
    elif isinstance(item.get("요소"), str):
        price = _elem(ctx, item["요소"])
        price |= {"값": line.get("단가"), "글": fmt(line["단가"]) if line.get("단가") else ""}
    else:  # 재료 고르기 조건 — 단가는 엔진 고름 값
        key, label = f"단가:{name}", f"{name}단가"
        ctx.vars.setdefault(key, {"열쇠": key, "이름": label, "기호": label, "위": "", "아래": ""})
        price = _var(ctx, key, "요소", line.get("단가"), 고르기=item["요소"])
    tree = {
        "꼴": "연산",
        "기호": "×",
        "_op": "*",
        "좌": price,
        "우": _paren(qty, "*", True),
    }
    head = {"꼴": "변수", "열쇠": name, "이름": name, "기호": name, "갈래": "합"}
    head |= {"값": line.get("금액"), "단위": item.get("단위") or ""}
    return {
        "갈래": "호표",
        "차례": at,
        "열쇠": name,
        "식": item["수량"],
        "결과": head,
        "이름식": tree,
        "값식": values(tree),
        "값": line.get("금액"),
        "글": fmt(line["금액"]) if isinstance(line.get("금액"), Decimal) else "",
        "수량": line.get("수량"),
        "비목": line.get("비목") or {},
        **({"까닭": line["까닭"]} if line.get("까닭") else {}),
    }