Aislo/M02_MasterTemplete/M02_MasterTemplete_Structure.ts

/* =============================================================================
 * M02_MasterTemplete_Structure.ts
 * 구조물집계표 아래 설계 컨테이너 — 고른 열의 도면 정보 · 면적산출 카드(보기만 + [수정]).
 * 카드 셋은 좌측 패널과 같은 공용 ui-sidebar 틀 — 고침은 [수정] 이 여는 M02 메인 칸 전체 편집 화면
 * (`M02_MasterTemplete_UI_Main.ts`)이 맡음.
 * 면적산출 = 스프레드시트(`A00_Common/spreadsheet/`) · 열마다 따로 파일(`area/<열 id>.json`) ·
 * 부품은 카드를 열 때만 `import()` 로 받음(다른 페이지 번들에 안 섞임).
 *
 * 구조물 도면은 집계표 열마다 하나(`resources/master_template/structure/<열 id>.json`) ·
 * 서버가 열마다 미리 만들어 둠(번호 자동 · 새 열도 집계표 저장 때 서버가 같이 만듦 — `M02_MasterTemplete_Store.py`).
 * 이 칸은 표 부품 host 밖 형제 자리에 붙음 — 집계표는 그대로 두고 여기만 열마다 다시 그림.
 * 집계표 일위대가 · 도면 · 면적산출 줄의 조회 후 선택(`pick`)도 여기 — 다른 열 것을 골라 내용만
 * 복사해 가져옴(번호 · 열은 그대로 · 서버가 복사 · 일위대가 = 열마다 labor 문서 · 39장).
 * 글자는 이 파일에 둠(도면 부품 `M02_MasterTemplete_Drawing.ts` 와 같은 방식).
 * ========================================================================== */

import { showConfirmDialog, showToast } from "@ui/ui_template_elements";
import type { LinkOptions } from "../A00_Common/spreadsheet/spreadsheet_links";
import {
  copyPartFrom,
  fetchLaborPills,
  fetchStructureNumbers,
  getActiveLayer,
  getActiveOwner,
  saveTemplate,
  type StructureNumbers,
  type TreeEdit,
} from "./M02_MasterTemplete_Api_Fetch";
import {
  createItemCards,
  PART_FIELD,
  PART_WORD,
  type CardKind,
  type SheetCardControl,
  type SheetEditOptions,
  type SheetKind,
} from "./M02_MasterTemplete_ItemCards";
import { layerSource } from "./M02_MasterTemplete_ItemSource";
import { pickHere, pickedName, type From } from "./M02_MasterTemplete_ItemPick";
import "./M02_MasterTemplete_Structure.css";

export type { CardKind, EditKind, SheetKind } from "./M02_MasterTemplete_ItemCards";

/** 구조물 도면이 걸리는 집계표 이름 — 서버 `M02_MasterTemplete_Store.STRUCTURE_TABLE` 과 같은 글 */
export const STRUCTURE_TABLE = "구조물집계표";

const TEXT = {
  saveFirst: "새 열은 구조물 조합을 먼저 저장해야 번호가 생김",
  overwrite: "{from} 의 {what} 내용을 {to} 에 덮어씀 — 번호 · 열은 그대로",
  pickCopy: "{value} 복사해 가져오기",
  copied: "복사해 가져옴",
  copyFailed: "복사 실패 — {value}",
  noPills: "이 열 일위대가에 담은 로직 · 자재가 없어 알약 없음 — 일위대가 상세에서 담음",
  pillsFailed: "일위대가 알약을 못 받음 — {value}",
  discardCards: "카드(도면 · 면적산출)에 저장 안 한 고침이 있음 — 버리고 넘어갈까?",
};

/** 집계표 줄 열쇠 → 문서 */
const ROW_KIND: Record<string, CardKind> = {
  "s:price": "labor", // 일위대가 = 열마다 문서(39장) — 다른 항목 것을 복사해 옴
  "s:drawing": "structure",
  "s:area": "area",
};

const why = (error: unknown): string => (error instanceof Error ? error.message : "");
const fill = (text: string, value: string): string => text.replace("{value}", value);

/** `{열 id: {도번, 면적번}}` — 집계표 번호 줄(없는 열은 키 없음 = 「없음」) */
export type ColumnNumbers = Record<string, StructureNumbers>;

/** 집계표 열 — 머리 글(제목행 종류 · 분류1 · 분류2 · 분류3) · 꼴만 씀 */
export interface StructureColumn {
  id: string;
  머리: (string | null)[];
  꼴?: string | null;
}

/** 구조물 열 = 꼴=수 — NO · 측점 · 비고 같은 글 열은 도면 · 면적산출 · 번호가 없음(서버와 같은 규칙) */
export const isStructureColumn = (col: StructureColumn): boolean => col.꼴 === "수";

/** 관리 화면 「구조물 조합」에서 숨기는 것(PLAN 26-7b · 30-7) — NO · 측점 · 비고 열 · 전구간 줄(본문 줄) ·
 * 합계 줄. 양식 파일은 그대로 — 보일 문서에서만 빼고 [저장] 때 저장본 것을 다시 끼움(`comboMerge`) ·
 * 틀고정 열 수는 숨긴 열만큼 줄여 보이고 [저장] 때 저장본 값으로 되돌림. */
const HIDDEN_COLUMNS = ["no", "sta", "memo"];
type ComboView = { 틀고정?: { 열?: number } } & Record<string, unknown>;
type ComboDoc = { 열: StructureColumn[]; 줄?: unknown[]; 합계줄?: unknown[]; 보기?: ComboView };

export function comboView<T>(doc: T): T {
  const d = doc as unknown as ComboDoc;
  const all = d.열 ?? [];
  const 열 = all.filter((c) => !HIDDEN_COLUMNS.includes(c.id));
  const frozen = d.보기?.틀고정?.열;
  const 보기 =
    d.보기 && typeof frozen === "number"
      ? {
          ...d.보기,
          틀고정: {
            ...d.보기.틀고정,
            열: frozen - all.slice(0, frozen).filter((c) => HIDDEN_COLUMNS.includes(c.id)).length,
          },
        }
      : d.보기;
  return { ...d, 열, 줄: [], 합계줄: [], ...(보기 ? { 보기 } : {}) } as unknown as T;
}

/** 보인 표 고침 + 저장본의 숨긴 것 — 열 차례 · 틀고정은 저장본(표에서 열을 더하거나 지우지 않음 · 26-7d) */
export function comboMerge<T>(stored: unknown, edited: T): T {
  const s = stored as ComboDoc;
  const e = edited as unknown as ComboDoc;
  const byId = new Map(e.열.map((c) => [c.id, c]));
  const kept = (s.열 ?? []).flatMap((c) =>
    HIDDEN_COLUMNS.includes(c.id) ? [c] : byId.has(c.id) ? [byId.get(c.id)!] : [],
  );
  const known = new Set(kept.map((c) => c.id));
  const 열 = [...kept, ...e.열.filter((c) => !known.has(c.id))];
  const 보기 = e.보기 && s.보기?.틀고정 ? { ...e.보기, 틀고정: s.보기.틀고정 } : e.보기;
  return {
    ...e,
    열,
    줄: s.줄 ?? [],
    합계줄: s.합계줄 ?? [],
    ...(보기 ? { 보기 } : {}),
  } as unknown as T;
}

/** 표 머리 이름 칸 고침 → 나무 이름 바꾸기(PLAN 31-1 · 한 정본 = 나무) — 칸이 항목 이름(가장 깊은 칸)이면
 * 항목(열 id 로 부름) · 위 칸이면 그 폴더(머리 앞마디 경로). */
export function headRenameEdit(col: StructureColumn, level: number, name: string): TreeEdit {
  const named = (parts: (string | null)[]): string[] =>
    parts.filter((p): p is string => !!p && p.trim() !== "");
  const path = named(col.머리);
  const upto = named(col.머리.slice(0, level + 1));
  return upto.length >= path.length
    ? { op: "rename", 경로: path.slice(0, -1), 키: col.id, 이름: name }
    : { op: "rename", 경로: upto, 이름: name };
}

/** 구조물 이름 + 변수값 — 제목행 층을 빈칸으로 이음(빈 층은 건너뜀 · 다 비면 열 id) */
export const columnHead = (col: StructureColumn): string =>
  col.머리.filter((part): part is string => !!part && part.trim() !== "").join(" ") || col.id;

/** 번호가 맨 앞 — 「SD010101 돌기슭막이 H=1.0」(번호가 없으면 이름만) */
export const structureLabel = (number: string, col: StructureColumn): string =>
  [number, columnHead(col)].filter(Boolean).join(" ");

/** 면적산출 편집 화면 아래 알약 막대 — 그 열 일위대가의 로직 물량 「이름|단위」 + 자재 「자재|MT키」
 * (서버 pills 길 · 39-4 · 다 `고정` — 더하기 · 빼기는 일위대가 쪽).
 * 알약이 없으면 까닭 글(`notice`)을 같이 돌려줌 */
export async function pillsFor(
  _kind: SheetKind, // 종류는 면적산출 하나 — 부르는 쪽 모양 그대로
  column: string,
): Promise<{ links: LinkOptions; notice?: string }> {
  const none = (notice: string) => ({ links: { 항목: [], 모드: "입력" as const }, notice });
  try {
    const { 알약 } = await fetchLaborPills(column);
    const 항목 = 알약.map((p) => ({
      키: p.키,
      이름: p.이름,
      단위: p.단위,
      ...(p.자재 ? { 자재: p.자재 } : {}),
      고정: true,
    }));
    return 항목.length ? { links: { 항목, 모드: "입력" } } : none(TEXT.noPills);
  } catch (error) {
    return none(fill(TEXT.pillsFailed, why(error)));
  }
}

/** 카드 미리보기 수정의 알약(31-3) — 전체 편집기(`UI_Main` `mountSheet`)와 같은 부품(`pillsFor`) */
async function cardLinks(
  kind: SheetKind,
  ctl: SheetCardControl,
): ReturnType<SheetEditOptions["links"]> {
  return { links: (await pillsFor(kind, ctl.column)).links };
}

export interface StructurePanelOptions {
  /** 시스템 관리자만 저장함(구조물 도면은 서버가 미리 만들어 둠) */
  isAdmin: boolean;
  /** [도면 수정] · [면적산출 수정] — 그 열을 CAD · 스프레드시트 전체 편집으로 엶
   * (페이지의 `open`) · label 은 화면 제목에 씀 */
  onEdit: (column: string, label: string, kind: CardKind) => void;
  /** 집계표에 저장 안 한 고침이 있으면 버릴지 물음 — 취소면 false */
  confirmLeave: () => Promise<boolean>;
  /** 카드 고침을 버리지 않고 머묾 — 표의 고른 열을 되돌림(31-3) */
  keepColumn?: (colId: string) => void;
}

export interface StructurePanelHandle {
  root: HTMLElement;
  /** `{열 id: {도번, 면적번}}` — 집계표 `drawingLabel` · `areaLabel` 이 씀 */
  numbers: () => ColumnNumbers;
  /** 번호 목록 다시 받기 */
  reload: () => Promise<void>;
  /** 카드에 저장 안 한 고침(도면 31-4 · 면적산출 31-3) — 페이지가 떠날 때 함께 물음 */
  dirty: () => boolean;
  /** 고친 카드 저장(도면 · 엑셀) — 집계표 [저장] 이 카드를 다시 읽기 전에 부름(실패하면 던짐) */
  saveCards: () => Promise<void>;
  /** 고른 열이 바뀜 — 같은 열이면 이름만 새로(CAD 를 다시 안 띄움) */
  show: (colId: string | null, columns: StructureColumn[]) => void;
  /** 보던 열을 다시 읽음 — 집계표 [저장] 뒤(서버가 새 열 파일 · 번호를 만듦) */
  refresh: (columns: StructureColumn[]) => void;
  /** 집계표 조회 후 선택(`onPick`) — 일위대가 = 고른 키(「비움」 = 빈 글 · 닫으면 null) ·
   * 도면 · 면적산출 = 다른 열 것을 복사해 가져옴(돌려주는 글 없음) */
  pick: (row: string, colId: string | null, columns: StructureColumn[]) => Promise<string | null>;
  destroy: () => void;
}

export function createStructurePanel(opts: StructurePanelOptions): StructurePanelHandle {
  let numbers: ColumnNumbers = {};
  let shown: StructureColumn | null = null;
  let column: string | null = null;
  let columnLabel = "";

  // 카드 셋은 항목 카드 한 벌(`ItemCards`) — 여기서는 지금 층에서 열 하나를 읽어 넘기기만.
  const cards = createItemCards({
    source: layerSource,
    editable: () => opts.isAdmin,
    onEdit: (kind) => void openEdit(kind),
    numberOf: (kind, id) => numbers[id]?.[PART_FIELD[kind]],
    // 도번 목록에 있는 열인데 못 읽으면 알림 — 없는 열은 그냥 「도면 없음」
    warnOnFail: (id) => !!numbers[id],
    // 「복사해 가져오기」 · 빈 카드 [복사 생성](39-5) — 집계표 줄 「조회 후 선택」 과 같은 길
    onImport: (kind) => void pickCopy(kind, shown ?? undefined),
    labor: () => void openEdit("labor"), // 일위대가 카드(보기 갈래 · 39-3) — 도면 다음
    // 면적산출 카드 미리보기 수정(31-3) — 전체 편집기와 같은 알약 · 저장 길
    sheetEdit: {
      can: () => opts.isAdmin,
      links: (kind, ctl) => cardLinks(kind, ctl),
      save: async (kind, at, doc, version) =>
        (await saveTemplate(getActiveLayer(), kind, at, null, version, doc)).판,
    },
  });
  const root = cards.root;

  function load(col: StructureColumn | null): Promise<void> {
    shown = col;
    column = col?.id ?? null;
    columnLabel = col ? columnHead(col) : "";
    return cards.load(col ? { id: col.id, label: columnLabel } : null);
  }

  /** 글 열(NO · 측점 · 비고)은 구조물이 아니라 컨테이너를 닫음 */
  const show = (colId: string | null, columns: StructureColumn[]): void => {
    const col = columns.find((c) => c.id === colId && isStructureColumn(c)) ?? null;
    if ((col?.id ?? null) !== column && cards.dirty()) {
      // 카드에 저장 안 한 고침 — 버릴지 물음 · 머물면 표의 고른 열을 되돌림
      const from = column;
      void showConfirmDialog(TEXT.discardCards).then((ok) => {
        if (!ok) return void (from && opts.keepColumn?.(from));
        cards.discard(); // 한 번 물었음 — 카드가 다시 묻지 않게
        void load(col);
      });
      return;
    }
    if ((col?.id ?? null) !== column) return void load(col);
    if (col) cards.setLabel((columnLabel = columnHead(col))); // 머리를 고쳤을 수 있음
  };

  /** 다른 항목의 도면 · 면적산출(…)을 골라 내용만 복사(39-5) — 탭 = 읽을 수 있는 곳 · 덮어쓰기 확인 ·
   * 번호 · 열은 그대로 · 보고 있던 열이면 다시 읽음 · 집계표 줄 「조회 후 선택」 · 카드 「복사해 가져오기」가 씀 */
  const pickCopy = async (kind: CardKind, to: StructureColumn | undefined): Promise<void> => {
    const word = PART_WORD[kind];
    const toNo = to && numbers[to.id]?.[PART_FIELD[kind]];
    if (!to || !toNo) return void showToast(TEXT.saveFirst, "error");
    // 카드에 저장 안 한 고침 — 가져온 뒤 카드를 다시 읽어 버려지니 먼저 물음
    if (cards.dirty() && !(await showConfirmDialog(TEXT.discardCards))) return;
    const target = `${toNo} ${columnHead(to)}`;
    const here = { layer: getActiveLayer(), owner: getActiveOwner() };
    const same = (from: From): boolean => from.layer === here.layer && from.owner === here.owner;
    const picked = await pickHere({
      title: `${fill(TEXT.pickCopy, word)} — ${target}`,
      kind,
      skip: (from, row) => same(from) && row.열 === to.id,
      ask: (p) =>
        TEXT.overwrite
          .replace("{from}", `${p.from.label} ${pickedName(p)}`)
          .replace("{what}", word)
          .replace("{to}", target),
    });
    if (!picked) return;
    try {
      // 같은 곳 = 다른 열 · 다른 층 · 사람 = 원본 층 · 실무문서 = 조합 키 → 일위대가(39-1b)
      if ("combo" in picked)
        await copyPartFrom(kind, to.id, picked.combo.키, { layer: "practice", owner: null });
      else
        await copyPartFrom(
          kind,
          to.id,
          picked.row.열,
          same(picked.from) ? null : { layer: picked.from.layer, owner: picked.from.owner },
        );
      showToast(TEXT.copied, "success");
      if (column === to.id) void load(shown);
    } catch (error) {
      showToast(fill(TEXT.copyFailed, why(error)), "error");
    }
  };

  const pick = async (
    row: string,
    colId: string | null,
    columns: StructureColumn[],
  ): Promise<string | null> => {
    if (!opts.isAdmin || !colId) return null;
    if (ROW_KIND[row])
      await pickCopy(
        ROW_KIND[row],
        columns.find((c) => c.id === colId),
      );
    return null;
  };

  async function openEdit(kind: CardKind): Promise<void> {
    const at = column;
    if (!at) return;
    // 저장 전 새 열(분류 더하기) — 문서 · 번호가 아직 없음 · 떠나면 집계표 고침까지 버리게 됨
    if (!numbers[at]?.[PART_FIELD[kind]]) return void showToast(TEXT.saveFirst, "info");
    if (!(await opts.confirmLeave())) return;
    opts.onEdit(at, columnLabel, kind);
  }
  return {
    root,
    numbers: () => numbers,
    reload: async () => {
      numbers = await fetchStructureNumbers().catch(() => ({}));
    },
    dirty: () => cards.dirty(),
    saveCards: () => cards.saveAll(),
    show,
    refresh: (columns) => {
      const at = column;
      column = null;
      show(at, columns);
    },
    pick,
    destroy: () => {
      cards.destroy();
    },
  };
}