Aislo/M02_MasterTemplete/M02_Hopyo_Router.py

"""M02 일위대가 실무자료 길(PLAN 785-5 · 요구 642 · 설계 642-A 2-9) — `/api/m02/layers/{층}/hopyo…`.

[수정] 보기 `hopyo-view/{키}/{번}`(809-1 · `M02_Hopyo_View` · 경쟁사 로직 인정 · 요소만 연결 · 읽기만) ·
엑셀 보기 머리 · 목록 = `View.listing`(줄 표지) · 옮기기 = [내 일위대가로] `hopyo-build-all {번}`(807-1).
옛 판정 · 검산 · 옮기기 · 근거 제안 길(785-5 `hopyo-judge` · `check` · `move` · `price` · 793-3a `hopyo-basis`)은
809-1 에서 지움(요구 703 — 기초로 바꾸기 없음).
그대로 쓰는 길(목록 · 올림 · 엑셀 보기 머리 · 격자 · 지우기 · 장부 · 모두 고정 · 붙여넣기 · 다시 잇기 ·
구조물 조합 · 칠 = B09 · M01 이 씀) · 옛 맞춤 길(호표 하나 맞춤 · 미리 셈 · 실무 호표 · 확인 만들기 · 안 이은 줄 ·
단가산출 만들기)은 785-7 에서 지움.
층 권한 = `Router_Items._root` · ⚠ 등록은 `main.py`(로그인만).
"""

from __future__ import annotations

from pathlib import Path
from typing import Any, Literal

from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
from pydantic import BaseModel, ConfigDict, Field

from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_Hopyo_Build as hopyo_build
from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel
from M02_MasterTemplete import M02_Hopyo_Forget as hopyo_forget
from M02_MasterTemplete import M02_Hopyo_Grid as hopyo_grid
from M02_MasterTemplete import M02_Hopyo_Item as hopyo_item
from M02_MasterTemplete import M02_Hopyo_Ledger as hopyo_ledger
from M02_MasterTemplete import M02_Hopyo_Marks as hopyo_marks
from M02_MasterTemplete import M02_Hopyo_View as hopyo_view_
from M02_MasterTemplete import M02_Hopyo_Paste as hopyo_paste
from M02_MasterTemplete import M02_Hopyo_Relink as hopyo_relink
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_FromHopyo as from_hopyo
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _call, _root

router = APIRouter(prefix="/api/m02", tags=["M02 Hopyo"])


# ── [수정] 보기(809-1) — 경쟁사 로직 인정 · 요소만 연결 · 읽기만 ─────────────────


@router.get("/layers/{layer}/hopyo-view/{key}/{no}")
def hopyo_view(
    layer: Layer,
    key: str,
    no: int,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """호표 하나 → 일위대가 문서 미리보기(엑셀 숫자 그대로 고정 줄) + 줄 표지(로직 · 요소) — 저장 없음."""
    folder = _root(session, layer, owner)
    return _call(folder, hopyo_view_.view, folder, key, no)


# ── 그대로 쓰는 길 ─────────────────────────────────────────────────────
HOPYO_MAX_BYTES = 20 * 1024 * 1024


def _who(session: Session) -> dict[str, Any]:
    return {"id": session.get("user_id"), "이름": session.get("name")}


def _upload(name: str, data: bytes, who: dict[str, Any]) -> dict[str, Any]:
    mark = hopyo_store.fingerprint(data)
    hopyo_forget.sweep(store.root())  # 하루 지난 작업 중 HP 끝냄(743-1)
    if same := next((r for r in hopyo_store.rows(store.root()) if r.get("지문") == mark), None):
        cannot = None
        if not from_hopyo.has(store.root(), same["키"]):  # 793-3b 전에 올린 HP
            cannot = from_hopyo.keep(store.root(), same["키"], name, data)
        return {**same, "이어서": True, **({"읽기불가": cannot} if cannot else {})}
    try:
        parsed = hopyo_excel.read_book(name, data)
    except hopyo_excel.ExcelError as error:
        raise store.StoreError(400, str(error)) from error
    try:
        grid = hopyo_grid.read(name, data, parsed)
    except Exception:  # 격자는 보기용 덤 — 못 만들어도 올리기는 됨(보기 창 404)
        grid = None
    row = hopyo_store.save(store.root(), name, parsed, who, grid, mark)
    cannot = from_hopyo.keep(
        store.root(), row["키"], name, data
    )  # 산근 시트(793-3b 가져온 식 열기)
    return (
        {**row, "읽기불가": cannot} if cannot else row
    )  # 797-1 가져온 식 못 씀 사유 → 화면 토스트


@router.get("/layers/{layer}/hopyo")
def hopyo_list(
    layer: Layer, owner: str | None = None, session: Session = Depends(verify_session)
) -> dict:
    """실무자료 목록 `{줄: [{키, 파일, 올린때, 올린이, 시트, 호표수, 어긋남}]}`."""
    return {"줄": hopyo_store.rows(_root(session, layer, owner))}


@router.post("/layers/{layer}/hopyo")
def hopyo_upload(
    layer: Layer,
    file: UploadFile = File(...),
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """엑셀(xls · xlsx) 올리기 — 「일위대가」 시트를 읽어 결과 · 격자 저장 · 20 MB ·
    엉터리 · 시트 없음 400."""
    folder = _root(session, layer, owner, write=True)
    data = file.file.read(HOPYO_MAX_BYTES + 1)
    if len(data) > HOPYO_MAX_BYTES:
        raise HTTPException(status_code=400, detail="파일이 너무 큼(20 MB 넘음)")
    name = Path(file.filename or "실무자료").name[:120]
    return _call(folder, _upload, name, data, _who(session))


@router.get("/layers/{layer}/hopyo/{key}")
def hopyo_read(
    layer: Layer, key: str, owner: str | None = None, session: Session = Depends(verify_session)
) -> dict:
    """실무자료 하나(엑셀 보기 머리 · 목록) — 검산 · 호표마다 `맞춤` [연결됨 + 로직 줄, 줄 수] · `줄상태` ·
    `만든`(`M02_Hopyo_View.listing` · 809-1)."""
    folder = _root(session, layer, owner)
    return _call(folder, hopyo_view_.listing, folder, key, folder)


@router.get("/layers/{layer}/hopyo-grid/{key}")
def hopyo_grid_read(
    layer: Layer, key: str, owner: str | None = None, session: Session = Depends(verify_session)
) -> dict:
    """엑셀꼴 격자(329-1) `{책: Workbook, 호표: [{번, 이름, 행}], 단산: [{번, 이름, 행}]}` ·
    옛 파일 404."""
    folder = _root(session, layer, owner)
    return _call(folder, hopyo_store.grid, folder, key)


class _Strict(BaseModel):
    model_config = ConfigDict(extra="forbid")  # 금액 · 품 칸 = 400(서버가 셈)


class BuildTarget(_Strict):
    """대상 하나 — 로직 · 자재 · 호표 중 하나 · 배 = 우리 수량 ÷ 엑셀 수량 · 몫 = 섞인 줄 몫."""

    로직: str | None = None
    자재: str | None = None
    호표: int | None = None
    전국: bool | None = None  # 「전국」 자재(361-1 · 키 없음 · 서버가 줄에서 다시 셈)
    노임: str | None = None  # 729-2 사용자 이음 — LB 키(엑셀 숫자 + 이음)
    기계: str | None = None  # EQ 키
    비율: Literal["노무비", "재료비", "경비"] | None = None  # % 줄 밑수
    입력값: dict[str, Any] = Field(default_factory=dict)
    배: float = 1
    몫: float | None = None


class BuildLine(_Strict):
    """확인한 줄 — `차례` = 호표 안 줄(0부터) · `대상` 목록 또는 `뺌` 까닭."""

    차례: int
    대상: list[BuildTarget] = Field(default_factory=list)
    뺌: Literal["우리에 없음", "안 씀"] | None = None


class BuildWhole(_Strict):
    대상: list[BuildTarget]


class BuildBody(_Strict):
    """실무 호표 → 이 층 사전조합 — 파일 층 `층` · `주인` · `키` + 호표 `번` + 확인한 `줄` ·
    직접 줄 호표 = `통째` · 같은 본뜬은 늘 덮음."""

    층: Layer
    주인: str | None = None
    키: str
    번: int
    줄: list[BuildLine] = Field(default_factory=list, max_length=500)
    통째: BuildWhole | None = None


class BuildAllBody(_Strict):
    """시트 통째(705-3) — 파일 층 `층` · `주인` · `키` 만(숫자 · 줄 칸 없음 · 서버가 파일에서 읽음) ·
    `번` = 그 호표 하나 + 하위(807-1 [내 일위대가로])."""

    층: Layer
    주인: str | None = None
    키: str
    번: int | None = None


@router.post("/layers/{layer}/hopyo-build-all")
def hopyo_make_all(
    layer: Layer,
    body: BuildAllBody,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """[모두 고정으로 들여오기] — 시트 호표 모두 고정 줄로 · 하위 먼저 · 확인된 호표 그대로 →
    `{호표, 줄, 품셈, 고정, 호표참조, 빠짐, 이음, 이음후보, 같음, 그대로, 다름, 실패}`."""
    folder = _root(session, layer, owner, write=True)
    source = _root(session, body.층, body.주인)
    args = (
        folder,
        source,
        body.키,
        _who(session),
        True,
        body.번,
    )  # 729-2 남은 줄 = 실패(번 = 고정)
    return _call(folder, hopyo_build.build_all, *args)


@router.get("/layers/{layer}/hopyo-ledger")
def hopyo_ledger_read(
    layer: Layer, owner: str | None = None, session: Session = Depends(verify_session)
) -> dict:
    """별칭 장부 — 이 층 + 위 층 줄 `{열쇠, 원래, 갈래, 짝, 누가, 때, 처음파일, 층, 주인, 고침}`
    (고침 = 이 층 · 쓰기 권한)."""
    folder = _root(session, layer, owner)
    writable = access.grant(session, layer, owner).write
    return {"줄": _call(folder, hopyo_ledger.rows, folder, writable)}


class LedgerBody(_Strict):
    """`줄` = {열쇠: 장부 줄 | null(지움)} — 이 층만 · 서버가 짝을 다시 검사."""

    줄: dict[str, Any]


@router.put("/layers/{layer}/hopyo-ledger")
def hopyo_ledger_write(
    layer: Layer,
    body: LedgerBody,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """별칭 장부 [저장] — 고친 줄 · 지운 줄(층 쓰기) → `{씀, 줄}`."""
    folder = _root(session, layer, owner, write=True)
    return _call(folder, hopyo_ledger.put, folder, body.줄, _who(session))


@router.delete("/layers/{layer}/hopyo/{key}")
def hopyo_delete(
    layer: Layer, key: str, owner: str | None = None, session: Session = Depends(verify_session)
) -> dict:
    """실무자료 지우기 = [끝내기](718-1 · 743-1 · 화면 떠남도) — HP · 격자 · 맞춤셈 캐시 지움 ·
    만든 일위대가 · 단가산출은 엑셀 사본만 걷고 남음 · 별칭 장부 그대로 → `{지움, 만든}`."""
    folder = _root(session, layer, owner, write=True)
    got = _call(folder, hopyo_forget.finish, folder, key)
    return got


class PasteBody(_Strict):
    """엑셀 붙여넣기(705-2) — `글` = 붙인 글 그대로 · `열` = 기억한 열 짝(없으면 머리 글 · 짐작 + 물음) ·
    `줄만` = 열린 문서에 줄로 · `있음` = 문서의 고정 줄 가름(이름 겹침 피함)."""

    글: str = Field(max_length=hopyo_paste.TEXT_MAX)
    열: dict[str, int] | None = None
    줄만: bool = False
    있음: list[str] = Field(default_factory=list, max_length=500)


@router.post("/layers/{layer}/hopyo-paste")
def hopyo_paste_run(
    layer: Layer,
    body: PasteBody,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """[Ctrl+V] — `갈래` 물음(열 짝) · 줄(고정 줄 · 저장은 문서 [저장]) · 만듦(실무자료 + 호표마다 사전조합 ·
    층 쓰기 · `build_all` 답 + 키)."""
    folder = _root(session, layer, owner, write=True)
    args = (folder, body.글, body.열, _who(session), body.줄만, body.있음)
    return _call(folder, hopyo_paste.paste, *args)


class RelinkRowsBody(BaseModel):
    """다시 잇기 표(705-2) — `키` = 이 층 사전조합들 · `문서` = 열린 문서(저장 전 · 줄 · 후보만)."""

    키: list[str] = Field(default_factory=list, max_length=500)
    문서: dict[str, Any] | None = None


@router.post("/layers/{layer}/hopyo-relink/rows")
def hopyo_relink_rows(
    layer: Layer,
    body: RelinkRowsBody,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """「이 공사 단가로 다시 잇기」 표 — 고정 줄마다 붙인 단가 · 이은 단가 · 후보(층 읽기)."""
    folder = _root(session, layer, owner)
    return _call(folder, hopyo_relink.rows, body.키, body.문서)


class RelinkBody(_Strict):
    """바꿈 `[{키, 줄, 노임?, 자재?}]` — 이음 키만(숫자 칸 없음 · 값 null = 풂)."""

    바꿈: list[dict[str, Any]] = Field(max_length=hopyo_relink.CHANGES_MAX)


@router.post("/layers/{layer}/hopyo-relink")
def hopyo_relink_apply(
    layer: Layer,
    body: RelinkBody,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """[바꿈] · [되돌리기] — 이 층 사전조합 이음 칸 고쳐 씀(층 쓰기) → `{바뀜, 문서, 되돌림}`."""
    folder = _root(session, layer, owner, write=True)
    return _call(folder, hopyo_relink.apply, body.바꿈)


@router.get("/layers/{layer}/hopyo/{key}/{no}/siblings")
def hopyo_siblings(
    layer: Layer,
    key: str,
    no: int,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """규격 묶음 제안(704-4) — 이름 · 단위 · 줄 구성 같고 규격만 다른 호표 `{묶음 [{번, 규격, 열}], 이름}`."""
    folder = _root(session, layer, owner)
    return _call(folder, hopyo_item.siblings, folder, key, no)


class ItemBody(BuildBody):
    """[구조물 조합으로](704-4) — 확인 창 몸 그대로 + `묶음` = 규격 열로 묶을 호표 번 · `이름` = 항목 이름."""

    묶음: list[int] = Field(default_factory=list, max_length=20)
    이름: str | None = Field(None, max_length=120)
    새로: bool = False  # 같은 내용 항목 409 뒤 — 그래도 새로(733-2)
    씀: str | None = Field(None, max_length=80)  # 같은 내용 409 뒤 — 그 항목 씀


@router.post("/layers/{layer}/hopyo-item")
def hopyo_to_item(
    layer: Layer,
    body: ItemBody,
    owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """실무 호표 → 이 층 구조물 조합 항목(사전조합 안 만듦 · 이 층 쓰기 · 파일 층 읽기) →
    `{key, 열, 이름, 줄수, 열수, 빠진줄}`."""
    folder = _root(session, layer, owner, write=True)
    source = _root(session, body.층, body.주인)
    lines = [one.model_dump(exclude_none=True) for one in body.줄]
    whole = body.통째.model_dump(exclude_none=True) if body.통째 else None
    args = (folder, source, body.키, body.번, lines, whole, body.묶음, body.이름, _who(session))
    args += (body.새로, body.씀)
    return _call(folder, hopyo_item.make_item, *args)


@router.get("/layers/{layer}/hopyo-marks/{key}")
def hopyo_marks_read(
    layer: Layer,
    key: str,
    owner: str | None = None,
    to: Layer | None = None,
    to_owner: str | None = None,
    session: Session = Depends(verify_session),
) -> dict:
    """하이라이트 재료(779-2 · 읽기만) — `블록 [{번, 판정, SK, 갈래, 못옮김}]` · `to` = SK 를 볼 층."""
    folder = _root(session, layer, owner)
    target = _root(session, to, to_owner) if to else folder
    return _call(folder, lambda: {"블록": hopyo_marks.blocks(folder, key, target)})