# -*- coding: utf-8 -*-
"""M01 · M02 셈 끝수(PLAN 751-3) — 품셈 1-2-2 금액의 단위표준
(일위대가 금액란 0.1 원 · 계금 1 원 · 미만버림).

규칙 = B09 일위대가 · 산근과 같은 함수 `rounddown`(`B09_Estimation_Calc_Base` · 엑셀 ROUNDDOWN):
  줄 금액 = 비목마다 ROUNDDOWN(·, 1) · 금액 = 그 합
  하위 로직 줄(값묶음 없음) = 하위 로직도 같은 끝수로 다시 셈한 노 · 재 · 경 × 수량
  덧줄 = 버린 줄 합(노무비 · 재료비 · 경비 · `줄.'이름'`)으로 식을 다시 셈 → ROUNDDOWN 1
  비목 합 = ROUNDDOWN(Σ 줄, 0)(+ 로직 `끝수` 묶음) · 계 = 셋 합
엔진 줄 덧칸(단위 · 수량 · 단가 · 출처 · 까닭 · 묶음 · 옵션꺼짐 …) · 수량 · 품 자리는 그대로.
쓰는 곳 = M01 시험 계산(`check_master.calc`) · 읽는 식(`master_text.lines`) · M02 로직 줄
(`M02_Labor_Doc.run_line` — 단가산출 · 일위대가 · 펼침이 모두 거침) · 일위대가 반영(`row` · `sums` ·
TS 짝 `M02_MasterTemplete_Labor_Calc.ts` · 거울 시험 `test_m02_labor_calc_mirror.py`).
B09 는 제 단가로 다시 버리므로 엔진 날 값(`run_line(raw=True)`)을 받음.
ponytail: 흐름 로직 · 돈 결과 로직(결과 하나)은 끝수 없음 — 그 로직이 돈을 내면 여기에 더함.
"""

from __future__ import annotations

import sys
from decimal import Decimal
from pathlib import Path

import master_formula as mf

_ROOT = str(Path(__file__).resolve().parents[3])
if _ROOT not in sys.path:  # 스크립트 · 시험 길 — 서버는 이미 뿌리에서 돎
    sys.path.insert(0, _ROOT)
from B09_Estimation.B09_Estimation_Calc_Base import rounddown  # noqa: E402

COSTS = mf.COST_ITEMS
_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)


def down(value, places: int):
    """ROUNDDOWN(value, places) — Decimal 로 · 빈 값 = None."""
    if value is None:
        return None
    return Decimal(str(rounddown(float(value), places)))


def _parts(split: dict) -> tuple[dict, Decimal | None]:
    """줄 비목 → (비목마다 0.1 원 버림, 금액 = 그 합 · 모두 빈 값 = None)."""
    cut = {k: down(v, 1) for k, v in split.items()}
    kept = [v for v in cut.values() if v is not None]
    return cut, (sum(kept, Decimal(0)) if kept else None)


def row(money: dict | None) -> dict | None:
    """반영 한 줄 `{노무비, 재료비, 경비, 계}` — 비목마다 0.1 원 버림 · 계 = 셋 합."""
    if money is None:
        return None
    cut = {k: down(money.get(k) or 0, 1) for k in COSTS}
    return {**cut, "계": sum(cut.values(), Decimal(0))}


def sums(rows: list) -> dict:
    """비목 합 — 비목마다 ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합(빈 줄 = 뺌)."""
    cut = {k: down(sum((Decimal(str(r[k])) for r in rows if r), Decimal(0)), 0) for k in COSTS}
    return {**cut, "계": sum(cut.values(), Decimal(0))}


def _sub(master, item: dict, env: dict, depth: int) -> dict | None:
    """하위 로직 줄 노 · 재 · 경 — 같은 끝수로 다시 셈 · 로직 부르기가 아니거나 못 셈 = None."""
    if item.get("값묶음") is not None or item.get("종류") != "로직":
        return None
    try:
        node = mf.parse(item["요소"])
        if node[0] != "logic":
            return None
        given = {k: mf.evaluate(v, env, master, depth) for k, v in node[2]}
        ref = mf.fill(node[1], env)
        got = engine(master, ref, mf.run(master, ref, given, depth + 1), depth + 1)
    except _ERRORS:
        return None
    return None if "결과" in got else got


def engine(master, ref: str, got: dict, depth: int = 0) -> dict:
    """엔진 답(`mf.run` 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}`) → 끝수 입힌 답(새 묶음)."""
    if "결과" in got or "줄" not in got:
        return got
    logic = master.logic(ref)
    if isinstance(logic.get("흐름"), dict):
        return got
    items, adds = logic.get("호표") or [], logic.get("덧줄") or []
    env = dict(got.get("중간") or {})
    total = dict.fromkeys(COSTS, Decimal(0))
    lines = []
    for n, line in enumerate(got["줄"]):
        split, more = dict(line.get("비목") or {}), {}
        if n == len(items):  # 덧줄이 부르는 `줄.'이름'` = 버린 호표 줄 금액(엔진과 같이 한 번)
            env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
        if n < len(items):
            sub = _sub(master, items[n], env, depth) if line.get("수량") is not None else None
            if sub is not None:
                qty, one = line["수량"], items[n].get("비목")
                split = {one: qty * sub["계"]} if one else {k: qty * sub[k] for k in COSTS}
                more = {"단가": sub["계"]}  # 하위 로직 계(1 원 버림) = 이 줄 단가
        elif n - len(items) < len(adds) and line.get("금액") is not None:
            add = adds[n - len(items)]
            env.update(total)
            try:
                value = mf.evaluate(mf.parse(add["식"]), env, master, depth)
            except _ERRORS:
                value = line["금액"]
            env[add["이름"]] = down(value, 1)  # 뒤 덧줄 · 중간 칸 = 버린 값
            split = {add["비목"]: value}
        cut, money = _parts(split)
        for k, v in cut.items():
            total[k] += v or 0
        if n >= len(items) and money is not None:
            more = {"단가": money}
        lines.append({**line, "비목": cut, "금액": money, **more})
    costs = {k: mf.cut(logic, down(v, 0), "계") for k, v in total.items()}
    # 중간 = 덧줄이 본 값(버린 줄 합 · 덧줄 값 · `줄`) — 시험 계산 중간 칸
    return {**got, "줄": lines, **costs, "계": sum(costs.values()), "중간": env}


def plain(got: dict) -> dict:
    """로직 줄 답(`run_line` 꼴 `{기준, 줄, 재료}`)을 줄만 다시 버림 —
    켜쌓기율 곱 · 별도계상 뺀 뒤 · 기준 = 남은 줄 비목 합 ROUNDDOWN 0."""
    if not got.get("기준"):
        return got
    lines, total = [], dict.fromkeys(COSTS, Decimal(0))
    for line in got.get("줄") or []:
        cut, money = _parts(dict(line.get("비목") or {}))
        for k, v in cut.items():
            total[k] += Decimal(str(v or 0))
        lines.append({**line, "비목": cut, "금액": money})
    mats = [{**m, "금액": down(m.get("금액"), 1)} for m in got.get("재료") or []]
    base = {k: down(v, 0) for k, v in total.items()}
    return {**got, "줄": lines, "재료": mats, "기준": {**base, "계": sum(base.values())}}