Aislo/resources/tester/test_790_2_sangeun_const.py

# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""790-2 단가산출(SK) 숫자 넓힘 — 상수 · 표값 덮개 · 글 줄 · 까닭 · M01 원래로 · 짝잃음(요구서_652).

- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(지붕 감률 17 → 20 = 61,088 · 공구손료 1 → 2 % = 51,802 ·
  인력운반 120 → 100 = 38,696 · 표값 운반량 30 = 35,764) · 옵션 바꿔도 상수 덮개 식 따라감
- 식 속 숫자 차례 = 엔진 파서(찾기 머리 · 키 · EQ: · 따옴표 글 안 셈)
- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · 저장 = M01판 · 셈 답 `원래` · `시트`
- [M01 원래로] · 더한줄 열쇠 옮김 · 덮개 갈래 = 파이썬 `M02_Sangeun_Const` ↔ TS `Const_Model` 거울
- 펼침 = 상수 덮개 SK 안 펼침(참조 그대로 · 값 그대로) · [초기화] = 새 덮개도 걷음
"""

from __future__ import annotations

import json
import subprocess
from pathlib import Path

import pytest

from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from resources.tester.test_m02_labor_ref import MINE, world  # noqa: F401 — 같은 임시 층

ROOT = Path(__file__).resolve().parents[2]
FORM = "GC000211"  # 합판거푸집
CARRY = "GC001140"  # 인력운반(지게)
ROOF = "지붕 슬래브(경사 20˚ 미만)"
TOOL = "pct:공구손료 및 경장비#0"
F211 = {
    "자재지역": "포항",
    "유형": "보통",
    "사용횟수": "6회",
    "높이감률": 0,
    "지붕슬래브": "아님",
    "폼타이": "아님",
    "폼타이규격": "12.7㎜",
    "측압": "3t/㎡",
    "구멍땜": 0,
}


def _whole():
    return m01.loaded()[1]


def _carry():
    return {
        **json.loads(json.dumps(_whole().logic(CARRY)["시험입력"], default=str)),
        "재료종별": "암석",
        "재료형상": "화강암",
        "운반회수": 0,
    }


def _doc(code, given, **more):
    return {
        "키": "SK-000001",
        "이름": "견본",
        "단위": "식",
        "바탕": {"로직": code},
        "입력값": given,
        **more,
    }


def _sum(doc):
    whole = _whole()
    return float(calc.run(sd.clean(doc, None, whole), whole)["기준"]["계"])


# ── 식 속 자리 ────────────────────────────────────────────────────────
def test_scan_엔진_차례():
    t = "찾기(QC000431, 유형=유형).시공량 * (1 - (높이감률 + 만약(지붕슬래브 == '아님', 0, 17)) / 100)"
    got = const.scan(t)
    assert [t[a:b] for a, b in got["num"]] == ["1", "0", "17", "100"]
    assert [t[a:b] for a, b in got["find"]] == ["찾기(QC000431, 유형=유형).시공량"]
    tool = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100"
    assert [tool[a:b] for a, b in const.scan(tool)["num"]] == ["1", "100"]
    assert const.scan("EQ:0201-0012.잡재료율 * 2 + '3t/㎡'")["num"] == [(20, 21)]
    assert const.scan("((((") == {"num": [], "find": []}  # 못 읽는 식 = 빈
    assert const.swap(t, {"2": 20}, {"0": -45}).startswith("(-45) * (1 - ")
    assert ", 0, 20)) / 100)" in const.swap(t, {"2": 20}, {})


# ── 금액 = 견본(서버 셈) ──────────────────────────────────────────────
def test_상수_표값_덮개_견본_금액():
    roof = {**F211, "지붕슬래브": ROOF}
    assert _sum(_doc(FORM, F211)) == 51419
    assert _sum(_doc(FORM, roof)) == 59341
    assert _sum(_doc(FORM, roof, 상수덮개={"mid:시공량": {"2": 20}})) == 61088
    assert _sum(_doc(FORM, F211, 상수덮개={TOOL: {"0": 2}})) == 51802
    assert _sum(_doc(CARRY, _carry())) == 42917
    assert _sum(_doc(CARRY, _carry(), 상수덮개={"mid:일운반회수": {"1": 100}})) == 38696
    assert _sum(_doc(CARRY, _carry(), 표값덮개={"mid:운반량": {"0": 30}})) == 35764


def test_옵션_바꿔도_상수_덮개_따라감():
    """품 덮개(숫자로 굳힘)와 달리 식 구조 그대로 — 유형 복잡 = 손으로 식 고친 줄과 같은 값."""
    from M02_MasterTemplete import M02_Labor_Doc as labor

    whole = _whole()
    given = {**F211, "지붕슬래브": ROOF, "유형": "복잡"}
    got = _sum(_doc(FORM, given, 상수덮개={"mid:시공량": {"2": 20}}))
    row = json.loads(json.dumps(whole.logic(FORM), ensure_ascii=False, default=str))
    for s in row["중간"]:
        if s["이름"] == "시공량":
            s["식"] = s["식"].replace(", 0, 17))", ", 0, 20))")
    hand = labor.run_line(calc._Over(whole, FORM, row), FORM, given)["기준"]["계"]
    assert got == float(hand) and got not in (61088, _sum(_doc(FORM, given)))


# ── 문서 꼴 ──────────────────────────────────────────────────────────
def test_새_칸_꼴_검사():
    whole = _whole()
    doc = _doc(
        FORM,
        F211,
        상수덮개={"mid:시공량": {"2": "20"}, TOOL: {}},
        표값덮개={},
        글줄=[{"자리": "", "글": " 건설표준품셈 6-3-1 "}, {"자리": "mid:시공량", "글": ""}],
        까닭={"mid:시공량": "현장 경사 반영", "add:#0": " ", "add:#1/labor:LB000002#0": "x"},
    )
    got = sd.clean(doc, None, whole)
    assert got["상수덮개"] == {"mid:시공량": {"2": 20}} and "표값덮개" not in got
    assert got["글줄"] == [{"자리": "", "글": "건설표준품셈 6-3-1"}]
    assert got["까닭"] == {"mid:시공량": "현장 경사 반영", "add:#1/labor:LB000002#0": "x"}
    for bad in (
        {"상수덮개": {"엉뚱": {"0": 1}}},
        {"상수덮개": {"mid:시공량": {"a": 1}}},
        {"표값덮개": {"mid:운반량": {"0": "글"}}},
        {"까닭": {"x": "y"}},
        {"글줄": [{"자리": "", "글": "가" * 501}]},
    ):
        with pytest.raises(sd.DocError):
            sd.clean(_doc(FORM, F211, **bad), None, whole)


def test_옛_SK_꼴_금액_그대로():
    whole = _whole()
    old = _doc(FORM, F211, 덮개={"labor:LB000007#0": {"qty": 0.2}}, 뺀줄=["labor:LB000002#0"])
    got = sd.clean(old, None, whole)
    assert not set(got) & {*const.NEW, "M01판"}
    assert const.formulas(whole.logic(FORM), got) is whole.logic(
        FORM
    )  # 새 덮개 없음 = 그 줄 그대로
    assert sd.clean({**old, "M01판": {"mid:시공량": "x"}}, None, whole) == got  # M01판 = 서버 몫


# ── 저장 · 셈 답(임시 storage) ─────────────────────────────────────────
def _sk(folder, **doc):
    with store.at(folder):
        return refs.create("sangeun", {"이름": "내 단가산출", "단위": "식", "더한줄": [], **doc})[
            "이름"
        ]


def _read(folder, key):
    with store.at(folder):
        return store.read("sangeun", key)["문서"]


def _calc(folder, doc, given=None):
    with store.at(folder):
        return calc.calc_doc(doc, given)


def test_저장_M01판_셈답_원래_시트(world):
    mine = world["personal"]
    key = _sk(
        mine,
        바탕={"로직": FORM},
        입력값={**F211, "지붕슬래브": ROOF},
        상수덮개={"mid:시공량": {"2": 20}},
        덮개={"labor:LB000002#0": {"qty": 0.05}},
        글줄=[{"자리": "", "글": "※ 지붕 경사 반영"}],
        까닭={"mid:시공량": "감률 20 % 적용"},
    )
    doc = _read(mine, key)
    assert doc["상수덮개"] == {"mid:시공량": {"2": 20}} and len(doc["바탕판"]) == 16
    assert set(doc["M01판"]) >= {"mid:시공량", TOOL, "labor:LB000007#0"}
    got = _calc(mine, doc)
    assert got["원래"]["계"] == 59341  # 같은 옵션 · 덮개 없음
    assert got["기준"]["계"] != 59341
    no_qty = _calc(mine, {**doc, "덮개": {}})
    assert no_qty["기준"]["계"] == 61088 and no_qty["원래"]["계"] == 59341
    spot = got["시트"]["자리"]["mid:시공량"]
    assert spot["갈래"] == "중간" and spot["덮개"] == ["상수"] and spot["까닭"] == "감률 20 % 적용"
    assert spot["상수"][2] == {"n": 2, "값": 20, "원값": 17}
    assert spot["표값"][0]["글"].startswith("찾기(QC000431") and spot["표값"][0]["값"] == 45
    assert spot["원래"] > spot["지금"] and spot["M01바뀜"] is False
    line = got["시트"]["자리"]["labor:LB000002#0"]
    assert line["덮개"] == ["품"] and line["원래"] != line["지금"]
    assert got["시트"]["글줄"] == [{"자리": "", "글": "※ 지붕 경사 반영"}]
    assert got["시트"]["짝잃음"] == []
    # M01 바뀜 — 저장 지문과 지금 바탕이 다른 자리만 · 사라진 자리 = 짝잃음
    stale = {**doc, "M01판": {**doc["M01판"], "mid:시공량": "000000000000", "mid:없는줄": "1"}}
    got = _calc(mine, stale)
    flags = {s for s, x in got["시트"]["자리"].items() if x.get("M01바뀜")}
    assert flags == {"mid:시공량"}
    assert {"cid": "mid:없는줄", "까닭": "M01 바뀜 — 바탕에 없는 줄"} in got["시트"]["짝잃음"]


def test_짝잃은_새_덮개_알림(world):
    doc = _doc(FORM, F211, 상수덮개={"mid:없음": {"0": 1}, "mid:시공량": {"9": 1}})
    got = _calc(world["personal"], doc)
    assert got["기준"]["계"] == 51419
    why = {(x["cid"], x["까닭"]) for x in got["시트"]["짝잃음"]}
    assert why == {
        ("mid:없음", "상수덮개 — 바탕에 없는 줄"),
        ("mid:시공량", "상수덮개 — 10 번째 없음"),
    }


def test_옛_저장본_셈답(world):
    """새 칸 없는 옛 저장본(M01판 없음) = 금액 그대로 · M01바뀜 없음."""
    got = _calc(world["personal"], {**_doc(FORM, F211), "바탕판": "0" * 16})
    assert got["기준"]["계"] == 51419 == got["원래"]["계"]
    assert not any(x.get("M01바뀜") for x in got["시트"]["자리"].values())


def test_펼침_막음_초기화_걷음(world):
    mine = world["personal"]
    a = _sk(mine, 바탕={"로직": CARRY}, 입력값=_carry(), 상수덮개={"mid:일운반회수": {"1": 100}})
    b = _sk(mine, 바탕=None, 더한줄=[{"참조": {**MINE, "키": a}, "수량": 1}])
    assert _read(mine, b)["더한줄"][0]["참조"]["키"] == a  # 안 펼침 = 참조 그대로
    assert _calc(mine, _read(mine, b))["기준"]["계"] == 38696
    with store.at(mine), pytest.raises(store.StoreError):
        flat.flat_lines("sangeun", {**MINE, "키": a})
    doc, n = flat.reset("sangeun", {**_read(mine, a), "까닭": {"mid:일운반회수": "가정"}})
    assert n == 1 and not set(doc) & {"상수덮개", "까닭"}


# ── 파이썬 ↔ TS 거울 ─────────────────────────────────────────────────
MIRROR_DOC = {
    "덮개": {"labor:LB000002#0": {"qty": 1}, "labor:LB000007#0": {"labor": 5}},
    "뺀줄": ["pct:소모자재#0"],
    "더한줄": [
        {
            "종류": "로직",
            "로직": "GC000001",
            "덮개": {"labor:X#0": {"qty": 1}},
            "뺀줄": ["material:Y#0"],
        },
        {"종류": "인력"},
    ],
    "상수덮개": {"mid:시공량": {"2": 20}, "labor:LB000002#0": {"0": 3}},
    "표값덮개": {"mid:운반량": {"0": 30}},
    "글줄": [{"자리": "add:#1", "글": "a"}, {"자리": "add:#0", "글": "b"}],
    "까닭": {
        "mid:시공량": "c",
        "add:#0": "d",
        "add:#1": "e",
        "add:#0/labor:X#0": "f",
        "pct:소모자재#0": "g",
    },
}
KEYS = [
    None,
    "mid:시공량",
    "labor:LB000002#0",
    "pct:소모자재#0",
    "add:#0/labor:X#0",
    "add:#0/material:Y#0",
    "없음",
]


def _ts(body: str):
    src = (ROOT / "M02_MasterTemplete/logic/M02_Sangeun_Const_Model.ts").read_text("utf-8")
    got = subprocess.run(
        ["node", "--experimental-strip-types", "--no-warnings",
         "--input-type=module-typescript", "-e", src + body],
        capture_output=True, text=True, encoding="utf-8", timeout=60,
    )  # fmt: skip
    assert got.returncode == 0, got.stderr
    return json.loads(got.stdout)


def test_거울_M01원래로_열쇠옮김_갈래():
    d = json.dumps(MIRROR_DOC, ensure_ascii=False)
    keys = json.dumps(KEYS)
    spots = json.dumps(
        ["labor:LB000002#0", "labor:LB000007#0", "pct:소모자재#0", "mid:운반량", "x"]
    )
    ts = _ts(
        f"\nconst d = {d};"
        f"\nconst out = {{r: {keys}.map((k) => restoreM01(d, k ?? undefined)),"
        " a: [0, 1, 5].map((k) => dropAddKeys(d, k)),"
        f" k: {spots}.map((s) => coverKinds(d, s))}};"
        "\nconsole.log(JSON.stringify(out));"
    )
    assert ts["r"] == [const.restore(MIRROR_DOC, k) for k in KEYS]
    assert ts["a"] == [const.drop_add_keys(MIRROR_DOC, k) for k in (0, 1, 5)]
    assert ts["k"] == [const.kinds(MIRROR_DOC, s) for s in json.loads(spots)]
    assert ts["k"][0] == ["품", "상수"] and ts["k"][2] == ["뺌"]


def test_TS_고치기_꼴_서버가_받음():
    """setConst · setTable · addText · editText · dropText · setReason 결과 = 서버 꼴 그대로 통과."""
    ts = _ts(
        "\nlet d = {키: 'SK-000001', 이름: '견본', 단위: '식', 바탕: {로직: 'GC000211'}};"
        "\nd = setConst(d, 'mid:시공량', 2, 20); d = setConst(d, 'mid:시공량', 0, 1);"
        "\nd = setConst(d, 'mid:시공량', 0, null); d = setTable(d, 'mid:시공량', 0, 45);"
        "\nd = setTable(d, 'mid:시공량', 0, null);"
        "\nd = addText(d, '', '근거'); d = addText(d, 'mid:시공량', '※ 조건', 0);"
        "\nd = editText(d, 1, '근거 고침'); d = dropText(d, 0);"
        "\nd = setReason(d, 'mid:시공량', ' 까닭 '); d = setReason(d, 'add:#0', '');"
        "\nconsole.log(JSON.stringify(d));"
    )
    assert ts["상수덮개"] == {"mid:시공량": {"2": 20}} and "표값덮개" not in ts
    assert ts["글줄"] == [{"자리": "", "글": "근거 고침"}] and ts["까닭"] == {"mid:시공량": "까닭"}
    got = sd.clean({**ts, "입력값": F211}, None, _whole())
    assert {k: got[k] for k in const.NEW if k in got} == {k: ts[k] for k in const.NEW if k in ts}