"""가져온 식 SK ↔ 우리 M01 기초 — 연결 찾기 기록 · 「확정」 때만 우리 기초 사본으로 바꾸기 · 되돌리기
(PLAN 810-4 · 요구 707 · 708 · 709 · 703) — 서버 단독.

    찾기(`find`)  = 가져온 식 문서(우리 단가로 셈) → `M02_Doc_Match.match` → SK `가져온.원본.연결후보` 에 적음.
    바꾸기(`swap`) = 서버가 다시 찾아 「확정」 일 때만 — 같은 SK 키에 M01 사본 SK(바탕 = 그 기초 ·
        입력값 = 찾은 옵션 · 802-4a 꼴 · 수식 사본은 저장 때 서버가 찍음)를 씀 · 원래 가져온 식 SK 몸은
        `가져온보관` 칸에 그대로 둠 · 일위대가 줄 참조 = 키 그대로(SK 내용만 바뀜 → 금액 다시 셈).
        + 찾은 `바꿈`(같은 기종 규격만 다른 기계 줄 · 812-11 · 요구 733-2) = 사본 문서 그 줄 기계 입력(원문번호)을
        가져온 규격의 우리 기계로 갈아 끼움(수식 길 저장 = 따로) · 품 · 율 · 단가 · 조건 값은 우리 값 그대로 ·
        기계가 옵션 기호 · 식이면 안 바꿈.
    되돌리기(`back`) = `가져온보관` 몸을 그 키에 다시 씀(가져온 식 금액 그대로 · 수식 사본도 보관 몸 그대로).
우리 M01 기초는 어느 갈래에서도 안 바뀜(708) · 근접 · 없음 · 기계 작업 = 바꾸기 409(703).
"""

from __future__ import annotations

import copy as cp
import re
from typing import Any

from common_util.common_util_time import utc_now_text
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Import as dim
from M02_MasterTemplete import M02_Doc_Match as dm
from M02_MasterTemplete import M02_Doc_Sk as dsk
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Imported as imp

KEEP = "가져온보관"  # 바꾼 SK 의 원래 가져온 식 몸(되돌리기)
_INDEX: dict[str, Any] = {"문서": None, "색인": None}


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


def index() -> dm.Index:
    """M01 수식 문서 색인 — 폴더가 바뀌면(M01 관리자 고침) 다시."""
    docs = dc.folder()
    if _INDEX["문서"] is not docs:
        aims = {k: d for k, d in docs.items() if not d.get("부품")}  # 부품 문서 = 과녁 아님(813-2)
        _INDEX["문서"], _INDEX["색인"] = docs, dm.Index(aims)
    return _INDEX["색인"]


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


def judge(sk: dict) -> dict[str, Any]:
    """가져온 식 SK → 연결후보(저장 없음)."""
    whole = imp._whole()
    links_imp = dim.Links(whole, "우리")
    doc = dim.of(sk)
    links_imp.learn(doc)
    got = dm.match(doc, links_imp, index(), dm.ml.Links(whole, dc.folder()))
    return {**got, "때": utc_now_text()}


def find(key: str, version: str) -> dict[str, Any]:
    """연결 찾기 → SK `가져온.원본.연결후보` 에 적음 → {연결후보, 판}."""
    got = _read(key)
    sk = got["문서"]
    if not dim.is_imported(sk):
        raise _bad("가져온 식 단가산출만 연결을 찾음")
    found = judge(sk)
    meta = sk[imp.KEY]
    new = {**sk, imp.KEY: {**meta, "원본": {**(meta.get("원본") or {}), dm.KEY: found}}}
    info = store.write(sd.KIND, key, version or got["판"], new)
    return {dm.KEY: found, "판": info.get("판")}


def copy_body(sk: dict, found: dict) -> dict[str, Any]:
    """M01 사본 SK 몸(이름 · 단위 · 구분 그대로 · 바탕 = 찾은 기초 · 입력값 = 찾은 옵션)."""
    keep = {k: sk.get(k) for k in ("키", "이름", "단위", "구분", "상세구분") if sk.get(k)}
    old = {k: v for k, v in sk.items() if k not in ("키", "종류", KEEP)}
    body = {
        "덮개": {},
        "뺀줄": [],
        "더한줄": [],
        "고름": {},
        "자재표시": {},
    }  # M01 그대로(고침 없음)
    base = {"바탕": {"로직": found["키"]}, "입력값": dict(found.get("옵션") or {})}
    return {**keep, **body, **base, KEEP: old}


def swap(key: str, version: str) -> dict[str, Any]:
    """「확정」 일 때만 우리 기초 사본으로 — 서버가 다시 찾음(화면 판정을 믿지 않음)."""
    got = _read(key)
    sk = got["문서"]
    if not dim.is_imported(sk):
        raise _bad("가져온 식 단가산출만 바꿈")
    found = judge(sk)
    if found.get("판정") != dm.SURE:
        raise _bad(f"우리 기초와 「확정」 일치가 아님({found.get('판정')}) — 바꾸지 않음", 409)
    info = store.write(sd.KIND, key, version or got["판"], copy_body(sk, found))
    done = refit(key, found.get("바꿈") or [])
    return {dm.KEY: found, "판": done[0] or info.get("판"), "바꾼기계": done[1]}


def refit(key: str, swaps: list[dict]) -> tuple[str | None, list[dict]]:
    """사본 문서 기계 줄 → 가져온 규격 우리 기계(그 줄 단가 기호 연결의 입력 「기계」 · 줄 이름 · 규격) →
    수식 길 저장 · (판, 바꾼 것)."""
    from M02_MasterTemplete import M02_Doc_Sk_Path as path  # 수식 길 — 늦게(돌아 부름 피함)

    if not swaps:
        return None, []
    got = path.read(key)
    doc = cp.deepcopy(got["문서"])
    done = []
    for one in swaps:
        var = next((v for v in doc.get("변수") or [] if dm.md.var_id(v) == one["기호"]), None)
        link = (var or {}).get("연결") or {}
        given = link.get("입력") or {}
        if link.get("갈래") != "단가산출" or not re.fullmatch(r"'[^']+'", str(given.get("기계"))):
            continue
        link["입력"] = {**given, "기계": f"'{one['기계']}'"}
        for line in doc.get("금액") or []:
            if dm._single(line.get("단가")) == one["기호"]:
                if line.get("묶음") == line.get("이름"):  # 그 줄 이름을 단 묶음 제목도
                    line["묶음"] = f"{one['이름']} {one['규격']}".strip()
                line["이름"], line["규격"] = one["이름"], one["규격"]
        done.append(one)
    if not done:
        return None, []
    return path.save(key, {"문서": doc, "판": got["판"]})["판"], done


def back(key: str, version: str) -> dict[str, Any]:
    """우리 기초 사본 → 원래 가져온 식(보관 몸 그대로)."""
    got = _read(key)
    old = got["문서"].get(KEEP)
    if not isinstance(old, dict) or not old.get(imp.KEY):
        raise _bad("되돌릴 가져온 식 없음")
    keep = (
        old.get(dc.KEY) if dc.has(old) else None
    )  # 보관 몸 수식 사본 그대로(바꾼 기계 = 따로 버림)
    token = dsk.SAVING.set({"키": key, "사본": keep}) if keep else None
    try:
        info = store.write(sd.KIND, key, version or got["판"], {**old, "키": key})
    finally:
        if token is not None:
            dsk.SAVING.reset(token)
    return {"판": info.get("판")}