# -*- coding: utf-8 -*-
"""줄로 적은 식 → 변수 뽑기 · 검사 · 단위 맞춤 · 로직 틀로 옮기기 (`_화면_계약.md` 7장).

  수량 = 길이 * 폭
  자재비 = 수량 * 시멘트

· 줄마다 「이름 = 식」 · 빈 줄과 `#` 는 건너뜀 · 마지막 줄 왼쪽이 결과 변수
· 식 글자는 `_틀.md` 8장 범위만 — 읽기는 `master_formula` 가 함
· 표 찾기는 글자로 치지 않음 — 변수 하나로 두고 「무엇」 을 `표찾기` 로 정할 때 이음
· 값은 안 씀 — 검사만 하고 `옮기기` 가 로직 한 줄을 만듦(저장은 `Store_Make.logic_new`)
"""

from __future__ import annotations

import re

import master_formula as mf
import master_keys as mk

WHAT = ("마스터요소", "설계입력", "고정값", "표찾기")
COST_ITEMS = mf.COST_ITEMS
BUNDLE = mf.BUNDLE  # 노무비 · 재료비 · 경비 · 계 — 덧줄에서만 쓰는 비목 합
MONEY = {"원": 1}
# 같은 단위의 다른 표기 — 넓이·부피는 길이의 제곱으로 펴서 「m * m」 과 「㎡」 가 같아지게
ALIAS = {
    "㎡": ("m", 2),
    "m²": ("m", 2),
    "m2": ("m", 2),
    "㎥": ("m", 3),
    "m³": ("m", 3),
    "m3": ("m", 3),
    "M": ("m", 1),
}
SQUARED = {2: "㎡", 3: "㎥"}
DIMLESS = ("%", "할")  # 비율은 단위가 없음 — 「1 + 증가율 / 100」 이 안 걸리게
_ASSIGN = re.compile(r"^\s*([\w가-힣]+)\s*=(?!=)\s*(.*)$")


# ── 자리를 적어 두는 읽기 ──────────────────────────────────────────────
class _Pos(mf._Parser):
    """`master_formula` 와 같은 식 문법 · 단위가 어긋난 자리를 짚으려고 마디에 글자 자리를 붙임."""

    def add(self):
        node = self.mul()
        while True:
            self.ws()
            at = self.i
            if self.take("+"):
                node = ("bin", "+", node, self.mul(), at)
            elif self.take("-"):
                node = ("bin", "-", node, self.mul(), at)
            else:
                return node

    def compare(self):
        node = self.add()
        for op in mf._OPS:
            self.ws()
            at = self.i
            if self.take(op):
                return ("bin", op, node, self.add(), at)
        return node

    def primary(self):
        self.ws()
        at = self.i
        node = super().primary()
        return (*node, at) if node[0] == "call" else node


def _at(node):
    """마디에 붙여 둔 글자 자리 — 자리를 안 적은 마디는 None."""
    want = {"bin": 4, "call": 3}.get(node[0])
    return node[want] if want is not None and len(node) > want else None


# ── 단위 셈 ───────────────────────────────────────────────────────────
def unit_of(text) -> dict[str, int] | None:
    """단위 글 → {밑 단위: 제곱} — 「원/㎥」 = {원: 1, ㎥: -1}.

    빈 글은 무차원 · 안 정했으면 None.
    """
    if text is None:
        return None
    out: dict[str, int] = {}
    sign = 1
    for token in re.split(r"([*/])", str(text).replace("·", "*")):
        token = token.strip()
        if token in ("*", "/"):
            sign = 1 if token == "*" else -1
        elif token and token not in DIMLESS:
            base, power = ALIAS.get(token, (token, 1))
            out[base] = out.get(base, 0) + sign * power
    return {k: v for k, v in out.items() if v}


def _one_text(base: str, power: int) -> str:
    if base == "m" and power in SQUARED:
        return SQUARED[power]
    return base if power == 1 else f"{base}{power}"


def unit_text(unit) -> str | None:
    """{밑 단위: 제곱} → 단위 글 · 무차원은 빈 글."""
    if unit is None:
        return None
    up = [_one_text(k, v) for k, v in unit.items() if v > 0]
    down = [_one_text(k, -v) for k, v in unit.items() if v < 0]
    if not up and not down:
        return ""
    return ("*".join(up) or "1") + ("/" + "/".join(down) if down else "")


def _show(unit) -> str:
    return "모름" if unit is None else (unit_text(unit) or "없음")


def _merge(a: dict, b: dict, sign: int) -> dict:
    out = dict(a)
    for k, v in b.items():
        out[k] = out.get(k, 0) + sign * v
    return {k: v for k, v in out.items() if v}


def _trouble(line: int, at, kind: str, say: str) -> dict:
    return {"줄": line, "자리": at, "갈래": kind, "말": say}


def _same(units: list, line: int, at, where: str, out: list):
    """여럿이 같은 단위여야 하는 자리 — 다르면 문제 한 줄 · 모르는 것은 넘김."""
    known = [u for u in units if u is not None]
    if known and any(u != known[0] for u in known):
        out.append(
            _trouble(
                line,
                at,
                "단위",
                f"「{where}」 의 단위가 서로 다름 — {' · '.join(_show(u) for u in known)}",
            )
        )
    return known[0] if known else None


def _unit(node, units: dict, line: int, head: int, out: list):
    """식 나무의 단위 — 모르면 None · 어긋나면 `out` 에 그 줄과 자리를 적음."""
    kind = node[0]
    if kind == "num":
        return {}
    if kind == "name":
        return units.get(node[1])
    if kind == "neg":
        return _unit(node[1], units, line, head, out)
    if kind in ("str", "ref", "field", "find", "logic"):
        return None  # 글자 · 요소 · 표 찾기 · 로직 — 단위는 마스터가 앎
    if kind == "bin":
        op = node[1]
        a = _unit(node[2], units, line, head, out)
        b = _unit(node[3], units, line, head, out)
        at = None if _at(node) is None else head + _at(node)
        if op in ("*", "/"):
            return None if a is None or b is None else _merge(a, b, 1 if op == "*" else -1)
        if op in ("+", "-"):
            if a is None or b is None:
                return a if b is None else b
            if a != b:
                out.append(
                    _trouble(
                        line, at, "단위", f"「{op}」 양쪽 단위가 다름 — {_show(a)} {op} {_show(b)}"
                    )
                )
            return a
        if op in mf._OPS and a and b:  # 맨 수와 대보는 것은 늘 됨(「높이 <= 3」)
            _same([a, b], line, at, op, out)
        return {}
    if kind == "call":
        name, items = node[1], node[2]
        at = None if _at(node) is None else head + _at(node)
        kids = [_unit(x, units, line, head, out) for x in items]
        if name == "만약":
            return _same(kids[1:], line, at, "만약", out)
        if name in ("최소", "최대"):
            return _same(kids, line, at, name, out)
        return kids[0]  # 올림 · 버림 · 반올림 — 자리 인자는 무차원
    return None


# ── 식 되쓰기 ─────────────────────────────────────────────────────────
def _text(node) -> str:
    """나무 → 식 글자(다시 읽으면 같은 나무) — 사칙은 괄호로 묶음."""
    kind = node[0]
    if kind == "num":
        return format(node[1].normalize(), "f")
    if kind == "str":
        return f"'{node[1]}'"
    if kind in ("name", "ref"):
        return node[1]
    if kind == "neg":
        return f"-{_text(node[1])}"
    if kind == "field":
        tail = node[2] if mf._NAME.fullmatch(node[2]) else f"'{node[2]}'"
        return f"{_text(node[1])}.{tail}"
    if kind == "bin":
        return f"({_text(node[2])} {node[1]} {_text(node[3])})"
    if kind == "call":
        return f"{node[1]}({', '.join(_text(x) for x in node[2])})"
    if kind in ("find", "logic"):
        args = "".join(f", {k}={_text(v)}" for k, v in node[2])
        return f"{'찾기' if kind == 'find' else '로직'}({node[1]}{args})"
    raise mf.FormulaError(f"모르는 마디 {kind}")


def _expr(node) -> str:
    """식 한 벌 — 맨 바깥 괄호는 뺌(사람이 읽는 자리에 그대로 들어감)."""
    text = _text(node)
    return text[1:-1] if node[0] == "bin" else text


def find_text(pick: dict) -> str:
    """표 찾기 자리 → `찾기(표, 조건=값).값칸` — 모달이 채운 묶음을 글자로."""
    conds = "".join(f", {k}={v}" for k, v in (pick.get("조건") or {}).items())
    col = str(pick.get("값칸") or "")
    tail = col if mf._NAME.fullmatch(col) else f"'{col}'"
    return f"찾기({pick.get('표')}{conds}).{tail}"


# ── 읽기 · 검사 ───────────────────────────────────────────────────────
def _cut(text: str):
    """(줄 번호, 왼쪽 이름, 식, 식이 시작하는 자리) — 빈 줄과 `#` 는 건너뜀."""
    for at, raw in enumerate(str(text).split("\n"), 1):
        if not raw.strip() or raw.lstrip().startswith("#"):
            continue
        m = _ASSIGN.match(raw)
        yield (
            at,
            (m.group(1) if m else ""),
            (m.group(2).strip() if m else raw.strip()),
            (m.start(2) if m else len(raw) - len(raw.lstrip())),
        )


def _order(defined: dict, deps: dict) -> list[str]:
    """중간 차례 — 먼저 쓰는 값이 앞에 오게(돌고 도는 것은 검사가 이미 잡음)."""
    out, seen = [], set()

    def visit(name: str, path: tuple):
        if name in seen or name in path or name not in defined:
            return
        for nxt in deps.get(name, ()):
            visit(nxt, path + (name,))
        seen.add(name)
        out.append(name)

    for name in sorted(defined, key=lambda n: defined[n]):
        visit(name, ())
    return out


def _scan(text: str, 정함: dict | None = None) -> dict:
    """줄 가르기 · 변수 · 검사 · 단위 — `read` 와 `옮기기` 가 같이 씀(나무를 들고 있음)."""
    정함 = 정함 or {}
    lines, 문제 = [], []
    for at, name, body, head in _cut(text):
        one = {"줄": at, "이름": name, "식": body, "앞": head}
        if not name:
            문제.append(_trouble(at, head, "못읽음", "「이름 = 식」 이 아님"))
        elif not body:
            문제.append(_trouble(at, head, "못읽음", f"「{name}」 오른쪽이 빔"))
        else:
            try:
                one["나무"] = _Pos(body).parse()
            except mf.FormulaError as e:
                문제.append(_trouble(at, head, "못읽음", str(e)))
        lines.append(one)

    정의: dict[str, int] = {}
    for one in lines:
        if "나무" not in one:
            continue
        if one["이름"] in BUNDLE:
            문제.append(
                _trouble(
                    one["줄"], 0, "이름", f"「{one['이름']}」 은 비목 합 이름 — 다른 이름을 쓸 것"
                )
            )
            continue
        if one["이름"] in 정의:
            문제.append(
                _trouble(
                    one["줄"],
                    0,
                    "두번정의",
                    f"「{one['이름']}」 을 {정의[one['이름']]}줄에서 이미 정함",
                )
            )
            continue
        정의[one["이름"]] = one["줄"]

    쓰임: dict[str, list[int]] = {}
    deps: dict[str, set[str]] = {}
    for one in lines:
        if "나무" not in one:
            continue
        used = {p[1] for p in mf.walk(one["나무"]) if p[0] == "name"}
        if 정의.get(one["이름"]) == one["줄"]:  # 두 번 정의한 뒷줄은 딸림에 안 넣음
            deps[one["이름"]] = used
        for name in sorted(used):
            쓰임.setdefault(name, []).append(one["줄"])

    돎 = mf.find_loops({k: v & set(정의) for k, v in deps.items()})
    for loop in 돎:
        문제.append(
            _trouble(정의.get(loop[0], 0), 0, "돌고돎", "서로 물고 돎 — " + " → ".join(loop))
        )

    성함 = [one for one in lines if "나무" in one]
    결과 = 성함[-1]["이름"] if 성함 else ""
    if not 성함:
        문제.append(_trouble(0, 0, "빔", "읽을 식이 없음"))
    for name, at in sorted(정의.items(), key=lambda kv: kv[1]):
        if name != 결과 and not [x for x in 쓰임.get(name, []) if x != at]:
            문제.append(
                _trouble(at, 0, "안쓰임", f"「{name}」 을 어디서도 안 씀 — 결과는 「{결과}」 하나")
            )

    units: dict[str, dict | None] = {k: MONEY for k in BUNDLE}
    for name in set(쓰임) | set(정의):
        if name in 정의 or name in BUNDLE:
            continue
        spec = 정함.get(name) or {}
        one = unit_of(spec.get("단위"))
        # 마스터요소 변수는 식에서 단가로 셈 — 정한 단위가 「포」 면 식에서는 「원/포」
        units[name] = (
            _merge(MONEY, one, -1) if one is not None and spec.get("무엇") == "마스터요소" else one
        )
    loops = {n for loop in 돎 for n in loop}
    order = _order(정의, deps)
    by = {one["이름"]: one for one in 성함}
    for name in order:
        if name in loops:
            continue
        pinned = unit_of((정함.get(name) or {}).get("단위"))
        one = by[name]
        got = _unit(one["나무"], units, one["줄"], one["앞"], 문제)
        units[name] = pinned if pinned is not None else got

    변수 = []
    for name in sorted(
        set(쓰임) | set(정의), key=lambda n: (min([쓰임.get(n, [10**9])[0], 정의.get(n, 10**9)]), n)
    ):
        spec = 정함.get(name) or {}
        갈래 = "비목합" if name in BUNDLE else ("정의됨" if name in 정의 else "미정")
        변수.append(
            {
                "이름": name,
                "처음": min([*쓰임.get(name, []), 정의.get(name, 10**9)]),
                "갈래": 갈래,
                "정의줄": 정의.get(name),
                "쓰임": 쓰임.get(name, []),
                "무엇": spec.get("무엇") if 갈래 == "미정" else None,
                "단위": unit_text(units.get(name)),
                "비목": spec.get("비목"),
                "정할것": _todo(갈래, spec, units.get(name)),
            }
        )
    return {"줄": lines, "변수": 변수, "결과": 결과, "문제": 문제, "차례": order, "정의": 정의}


def _todo(갈래: str, spec: dict, unit) -> list[str]:
    """그 변수에 아직 안 정한 것 — 무엇 · 요소·찾기·값 · 단위 · 비목."""
    if 갈래 != "미정":
        return []
    what, need = spec.get("무엇"), []
    if what not in WHAT:
        need.append("무엇")
    elif what == "마스터요소":
        if not spec.get("요소"):
            need.append("요소")
        if spec.get("비목") not in COST_ITEMS:
            need.append("비목")
    elif what == "표찾기" and not (spec.get("찾기") or {}).get("표"):
        need.append("찾기")
    elif what == "고정값" and spec.get("값") in (None, ""):
        need.append("값")
    if unit is None:
        need.append("단위")
    return need


def read(text: str, 정함: dict | None = None) -> dict:
    """줄로 적은 식 → `{줄, 변수, 결과, 문제, 다됨}` — 화면이 그대로 받는 모양(나무는 뺌)."""
    got = _scan(text, 정함)
    다됨 = not got["문제"] and not any(v["정할것"] for v in got["변수"])
    return {
        "줄": [{k: v for k, v in one.items() if k != "나무"} for one in got["줄"]],
        "변수": got["변수"],
        "결과": got["결과"],
        "문제": got["문제"],
        "다됨": 다됨,
    }


# ── 로직 틀로 옮기기 ───────────────────────────────────────────────────
def _terms(node) -> list:
    return _terms(node[2]) + _terms(node[3]) if node[0] == "bin" and node[1] == "+" else [node]


def _factors(node) -> list:
    return _factors(node[2]) + _factors(node[3]) if node[0] == "bin" and node[1] == "*" else [node]


def _spread(node, by: dict, 정함: dict, 편: set) -> list:
    """결과 항 — 항이 이름 하나이고 비목을 안 정했으면 그 식으로 펼침.

    호표 줄을 항 안에서 찾으려는 것.
    """
    out = []
    for term in _terms(node):
        name = term[1] if term[0] == "name" else ""
        if name in by and name not in 편 and not (정함.get(name) or {}).get("비목"):
            편.add(name)
            out += _spread(by[name]["나무"], by, 정함, 편)
        else:
            out.append(term)
    return out


def _kind_of(요소) -> str:
    if isinstance(요소, dict):
        return "재료"
    return mk.GROUP_OF.get(mk.id_of(str(요소)), "")


def _input_of(name: str, spec: dict, unit) -> dict:
    one = {"이름": name}
    for k in ("설명", "단위", "고르기", "범위", "출처"):
        if spec.get(k) not in (None, ""):
            one[k] = spec[k]
    one.setdefault("단위", unit_text(unit) or "")
    return {k: one[k] for k in ("이름", "설명", "단위", "고르기", "범위", "출처") if k in one}


def 옮기기(text: str, 정함: dict | None = None, 머리: dict | None = None) -> tuple[dict, list]:
    """(로직 한 줄, 문제) — 다 정해졌으면 `_틀.md` 7장 모양 · 문제가 있으면 줄은 빈 묶음.

    돈 로직(`결과단위` 가 「원」 으로 시작)은 결과 식을 `+` 로 갈라 항마다 —
    마스터요소 변수 하나면 호표 줄(나머지 곱이 수량) · 비목만 정한 변수면 덧줄.
    돈 아닌 로직은 호표 없이 `중간` + `결과` 식.
    """
    정함, 머리 = 정함 or {}, dict(머리 or {})
    got = _scan(text, 정함)
    문제 = list(got["문제"])
    for v in got["변수"]:
        if v["정할것"]:
            문제.append(
                _trouble(
                    v["처음"], 0, "덜정함", f"「{v['이름']}」 에 {' · '.join(v['정할것'])} 안 정함"
                )
            )
    if 문제:
        return {}, 문제

    by, 결과 = {one["이름"]: one for one in got["줄"] if "나무" in one}, got["결과"]
    돈 = str(머리.get("결과단위") or "").startswith("원")
    입력, 중간, 호표, 덧줄 = [], [], [], []
    for v in got["변수"]:
        spec = 정함.get(v["이름"]) or {}
        if v["갈래"] != "미정":
            continue
        if spec["무엇"] == "설계입력":
            입력.append(_input_of(v["이름"], spec, unit_of(v["단위"])))
        elif spec["무엇"] == "고정값":
            중간.append({"이름": v["이름"], "식": str(spec["값"])})
        elif spec["무엇"] == "표찾기":
            중간.append({"이름": v["이름"], "식": find_text(spec["찾기"])})

    덧줄이름, 편 = set(), set()
    if 돈:
        for term in _spread(by[결과]["나무"], by, 정함, 편):
            facts = _factors(term)
            picks = [
                f
                for f in facts
                if f[0] == "name" and (정함.get(f[1]) or {}).get("무엇") == "마스터요소"
            ]
            if len(picks) > 1:
                문제.append(
                    _trouble(
                        by[결과]["줄"],
                        0,
                        "항",
                        f"한 항에 마스터요소가 둘 — {' · '.join(p[1] for p in picks)}",
                    )
                )
            elif picks:
                spec = 정함[picks[0][1]]
                rest = [f for f in facts if f is not picks[0]]
                호표.append(
                    {
                        "종류": _kind_of(spec["요소"]),
                        "요소": spec["요소"],
                        "이름": spec.get("이름") or picks[0][1],
                        "단위": spec.get("단위") or "",
                        "수량": (
                            _expr(rest[0]) if len(rest) == 1 else " * ".join(_text(f) for f in rest)
                        )
                        or "1",
                        "비목": spec["비목"],
                    }
                )
            elif (
                len(facts) == 1
                and facts[0][0] == "name"
                and (정함.get(facts[0][1]) or {}).get("비목")
            ):
                name = facts[0][1]
                if name not in by:
                    문제.append(_trouble(by[결과]["줄"], 0, "항", f"덧줄 「{name}」 의 식이 없음"))
                    continue
                덧줄.append(
                    {"이름": name, "식": _expr(by[name]["나무"]), "비목": 정함[name]["비목"]}
                )
                덧줄이름.add(name)
            else:
                문제.append(
                    _trouble(
                        by[결과]["줄"],
                        0,
                        "항",
                        f"「{_text(term)}」 을 호표·덧줄로 못 옮김 — 마스터요소나 비목을 정할 것",
                    )
                )

    쓰임 = {v["이름"]: v["쓰임"] for v in got["변수"]}
    for name in got["차례"]:
        if name in 덧줄이름 or name == 결과:  # 결과 줄은 호표·덧줄로 갈랐거나 「결과」 식이 됨
            continue
        if name in 편 and 쓰임.get(name) == [by[결과]["줄"]]:
            continue  # 결과 항으로 펼쳐 넣었고 다른 데서 안 씀 — 중간에 두지 않음
        쓴비목 = {p[1] for p in mf.walk(by[name]["나무"]) if p[0] == "name"} & set(BUNDLE)
        if 쓴비목:
            문제.append(
                _trouble(
                    by[name]["줄"],
                    0,
                    "비목합",
                    f"「{' · '.join(sorted(쓴비목))}」 은 덧줄에서만 씀",
                )
            )
        중간.append({"이름": name, "식": _expr(by[name]["나무"])})
    if 문제:
        return {}, 문제

    row = {
        "원문번호": 머리.get("원문번호", ""),
        "이름": 머리.get("이름", ""),
        "결과단위": 머리.get("결과단위", ""),
        "출처": 머리.get("출처", "자체"),
        "입력": 입력,
        "중간": 중간,
    }
    row.update({"호표": 호표, "덧줄": 덧줄} if 돈 else {"결과": {"식": _expr(by[결과]["나무"])}})
    row["끝수"] = 머리.get("끝수")  # 틀이 늘 두는 칸 — 안 정했으면 null
    for k in ("비고", "시험입력"):
        if 머리.get(k) not in (None, ""):
            row[k] = 머리[k]
    return row, []


if __name__ == "__main__":  # 견본 한 벌 — `python scripts/master_draft.py`
    import json
    import sys

    sys.stdout.reconfigure(encoding="utf-8")
    print(json.dumps(read(sys.stdin.read()), ensure_ascii=False, indent=2, default=str))