Aislo/M02_MasterTemplete/M02_Doc_Sk_Path.py

"""M02 단가산출(SK) 수식 길 — 읽기 · 미리 셈 · 저장(PLAN 802-4a 4 · 요구 664) — 서버 단독.

M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서} → {셈} · 저장 {문서} → {문서, 셈}.
몸 칸 — `문서`(이 SK 수식 문서 · 키 = SK 키) · `끊음` {키: 문서}(이 사본에 굳힌 부름 · 고칠 수 있음 ·
    없는 키 = 다시 이음) · `할일` 단가갱신 | 재생성 · `판`(저장 · 그 SK 파일 판).
셈 = 서버 정본(`M02_Doc_Copy.run`) — 화면이 보낸 값 · 사본은 안 받음(문서 · 끊음 글만).
저장 = 그 SK 저장(`store.write` — 층 쓰기 권한 · 판 409 · 옛 칸 · 로직 사본 그대로) ·
    문서 고침 = 따로(이 문서가 정본) · 재생성 = 지금 M01 로 다시 찍어 파생으로(고친 문서 · 끊음 버림) ·
    단가갱신 = 값 줄만 지금 M01(문서 그대로).
가져온 식 SK(엑셀) = 802-4b 몫(400) · 바탕 참조 SK = 값 사본 없음(400).
"""

from __future__ import annotations

import json
from typing import Any

from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Sk as dsk
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd

MAX = 2_000_000  # 문서 글 크기(바이트) 상한
JOBS = (skc.PRICE, skc.REGEN)


def _bad(why: str, status: int = 400) -> store.StoreError:
    return store.StoreError(status, why)


def _file(key: str) -> dict[str, Any]:
    if not sd.KEY.match(str(key or "")):
        raise _bad("키(SK-######)")
    return store.read(sd.KIND, key)


def _settled(doc: dict, job: Any = None) -> tuple[dict, Any]:
    """옛 셈 길 첫머리(`calc_doc`)와 같게 — (정리한 문서, 사본 색인)."""
    from M01_MasterData import M01_MasterData_Store as m01
    from M02_MasterTemplete import M02_Sangeun_Calc as calc

    raw = {**doc, skc.JOB: job} if job else doc
    whole = skc.over(doc := skc.settle(raw), m01.loaded()[1])
    try:
        return sd.clean(doc, None, whole), whole
    except sd.DocError as e:
        raise calc._fail(e) from e


def current(doc: dict, job: Any = None) -> dict:
    """그 SK 의 지금 수식 사본(할일 적용 · 저장 없음) — 따로 = 저장한 문서 · 파생 = 옛 칸으로 지음."""
    from M02_MasterTemplete import M02_Sangeun_Calc as calc

    if not dsk.own(doc):
        if doc.get("가져온"):
            raise _bad("가져온 식 단가산출 — 수식 문서는 엑셀 불러오기 몫(802-4b)")
        raise _bad("바탕 참조 단가산출 — 수식 사본 없음")
    clean, whole = _settled(doc, job)
    if not dc.has(clean):  # 옮기기 전 · 새 SK — 저장 때 지을 사본을 미리
        seed = dsk.settle(clean, whole, job, doc).get(dsk.KEY)
        if seed is None:
            raise _bad("수식 사본을 지을 수 없음 — 바탕 로직 · 줄 없음")
        clean = {**clean, dsk.KEY: seed}
    box: list = []
    try:
        calc.run(clean, whole, catch=box)
    except sd.DocError as e:
        raise calc._fail(e) from e
    got = dsk.copy_of(clean, box[-1] if box else None)
    return got if got is not None else clean[dsk.KEY]


def answer(copy: dict) -> dict[str, Any]:
    """{문서, 부름, 끊음, 셈, 사본 표지} — 글 · 수는 JSON 꼴."""
    got = dc.run(copy["문서"], copy)
    head = {k: copy.get(k) for k in ("시점", "단가시점")}
    mark = {**head, "따로": bool(copy.get("따로")), **dc.state(copy)}
    body = {
        "문서": copy["문서"],
        "부름": copy.get("부름") or {},
        "끊음": copy.get("끊음") or {},
        "셈": got,
        "사본": mark,
    }
    return json.loads(json.dumps(dc.ml._norm(body), ensure_ascii=False, default=str))


def read(key: str) -> dict[str, Any]:
    """읽기 — {문서, 부름, 끊음, 셈, 사본, 판}."""
    got = _file(key)
    return {**answer(current(got["문서"])), "판": got["판"]}


# ── 몸 검사 ───────────────────────────────────────────────────────────
def _doc(raw: Any, key: str, where: str) -> dict:
    if not isinstance(raw, dict):
        raise _bad(f"{where} · 묶음 아님")
    if len(json.dumps(raw, ensure_ascii=False, default=str).encode("utf-8")) > MAX:
        raise _bad(f"{where} · 너무 큼")
    for name in ("변수", "식", "금액"):
        if not isinstance(raw.get(name, []), list):
            raise _bad(f"{where} · 「{name}」 목록 아님")
    return {**raw, "키": key}


def edited(copy: dict, body: dict, key: str) -> dict:
    """화면 고침 얹은 사본 — 문서 · 끊음 글만 받음(값 · 부름은 서버 것)."""
    if body.get("할일") not in (None, "", *JOBS):
        raise _bad("할일은 단가갱신 · 재생성")
    if body.get("할일") == skc.REGEN:
        return copy  # 재생성 = 고친 것 버림(그 사본이 이미 새로 찍힌 것)
    out = {**copy}
    if body.get("문서") is not None:
        out["문서"] = _doc(body["문서"], key, "문서")
    cut = body.get("끊음")
    if cut is not None:
        if not isinstance(cut, dict):
            raise _bad("끊음 · {키: 문서} 묶음")
        keys = set(copy.get("부름") or {}) | set(copy.get("끊음") or {})
        if bad := sorted(k for k in cut if k not in keys):
            raise _bad(f"끊음 · 이 사본이 부르지 않는 단가산출 {bad}")
        out["끊음"] = {k: _doc(v, k, f"끊음 「{k}」") for k, v in cut.items()}
    calls = [
        *dc.calls(out["문서"]),
        *(c for d in out.get("끊음", {}).values() for c in dc.calls(d)),
    ]
    whole = dc.over(out)
    out["부름"] = dc.closure(whole, calls, copy.get("부름"))
    out["따로"] = True
    return out


def preview(key: str, body: dict) -> dict[str, Any]:
    """미리 셈(저장 없음) — {셈, 전, 후, 바뀐자원?, 버림?}."""
    doc = _file(key)["문서"]
    before = current(doc)
    job = body.get("할일") or None
    after = edited(current(doc, job) if job else before, body, key)
    out = answer(after)
    out |= {"전": dc.money(dc.run(before["문서"], before)), "후": dc.money(out["셈"])}
    if job == skc.PRICE:
        out["바뀐자원"] = dc.refresh(before)[1]
    if job == skc.REGEN:
        out["버림"] = {
            "문서고침": bool(before.get("따로")),
            "끊음": sorted(before.get("끊음") or {}),
        }
    return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str))


def save(key: str, body: dict) -> dict[str, Any]:
    """저장(층 쓰기) — 서버가 다시 셈한 사본을 그 SK 에 씀 · {문서, 부름, 끊음, 셈, 사본, 판}."""
    got = _file(key)
    if str(body.get("판") or "") != got["판"]:
        raise _bad({"stale": [key], "판": got["판"]}, 409)
    job = body.get("할일") or None
    raw = {**got["문서"], **({skc.JOB: job} if job else {})}
    token = None
    if job != skc.REGEN and (body.get("문서") is not None or body.get("끊음") is not None):
        mine = edited(current(got["문서"], job), body, key)
        token = dsk.SAVING.set({"키": key, "사본": mine})
    try:
        store.write(sd.KIND, key, got["판"], raw)
    finally:
        if token is not None:
            dsk.SAVING.reset(token)
    return read(key)