Aislo/M02_MasterTemplete/DataFlow/M02_DF_Api.ts

/* =============================================================================
 * M02_DF_Api.ts
 * 단가산출 흐름도 Api — 목록(내 것 + 견본) · 열기 · 저장(서버가 입력 값을 마스터에서 다시 받아 화면과
 * 같은 차례 · 같은 규칙으로 셈하고 받는 칸에 값만 되돌려 넣음) · 지우기 · 입력 값 한 번에 받기 · 사용자 요소 ·
 * 자재 찾기 · 다른 로직 값 · 설계 때 정할 것 · 단위 · 금액 표준 표. 모양 = sub7 Model · 아래는 Api 몫만.
 * 서버 = `M02_DF_Router.py`(`/api/m02/df/*`) · 정함 `docs/raw/M01_쉬운단가/흐름도_정함.md`
 * ========================================================================== */

import { API_BASE_URL } from "@config/config_frontend";
import type { CfDesign, CfElementRef, CfGroup, CfLogic, CfUserElement } from "./M02_DF_Model";

/** 돈 로직 결과에서 꺼낼 칸(기계 시간당 경비) */
export type CfField = "노무비" | "재료비" | "경비" | "계";

/** 입력 값 물음 한 줄 — 값은 열 때 · 저장 때 마스터(사용자 요소 `UE-…` 는 다이어그램 안 · `_data`)에서
 * · 인력 · 재료 ref = 키 → 그 줄 단가(기존 계산과 같은 셈) · 재료 ref = 검색어 묶음 JSON 글도 됨(unit 을 주면
 *   기존 로직 재료 줄과 같은 단가)
 * · 유가전력 · 환율 = 그 줄 값 · 요율 = 값 묶음의 field(기본 rate_percent · %)
 * · 기계 ref = EQ 키 + field(값 칸 — 가격 · 손료계수 …) 또는 `로직(GC…, 기계='…', 지역=지역)` + inputs → 한 시간 값
 * · 소요량 · 계수 table = {key, row?} → 표 블록(머리 줄 포함 · 조건 칸 → 값 칸 · 범위는 「·아래」 「·위」)
 * · 재료 자리 slot = 요소 그대로(mode fixed · choice · rule · scope · default) + field · op(조건 찾기 규칙) ·
 *   value = 이어진 알약 값(조건 찾기) · pick = 고른 품목 키(선택) → 단가 · 여럿이면 candidates */
export interface CfQuery {
  id: string;
  group: CfGroup;
  ref?: string;
  table?: { key: string; row?: number };
  unit?: string;
  field?: string;
  inputs?: Record<string, unknown>;
  slot?: Partial<CfElementRef> & { field?: "규격" | "이름"; op?: "포함" | "같음" };
  value?: unknown;
  pick?: string;
}

/** 입력 값 답 — 표는 `rows` · 그 밖은 `value` · 못 구하면 ok false + 쉬운 말 */
export interface CfAnswer {
  id: string;
  ok: boolean;
  value?: number | string | null;
  rows?: (string | number | null)[][];
  name?: string;
  unit?: string;
  reason?: string;
  /** 재료 조건 찾기가 여럿 맞을 때 후보 다섯 */
  candidates?: CfMaterial[];
}

/** 자재 찾기 한 줄 */
export interface CfMaterial {
  ref: string;
  name: string;
  spec: string;
  unit: string;
  price: number | null;
  구분: string;
  상세구분: string;
}

/** 단위 · 금액 표준 표 — 고친 것(`_data`)이 있으면 saved */
export interface CfStandards {
  unit: { 이름: string; 줄: Record<string, unknown>[]; [k: string]: unknown };
  money: { 이름: string; 줄: Record<string, unknown>[]; [k: string]: unknown };
  saved: boolean;
}

/** 서버 계산 결과 — 저장 답(화면 Eval 과 같은 차례 · 같은 규칙 · arrived = 상자마다 받은 값 · breaks = 끊긴 곳) */
export interface CfComputed {
  arrived?: Record<string, Record<string, unknown>>;
  breaks?: { kind: string; box: string; port?: string; link?: string; text: string }[];
  /** 상자 id → 내보내는 알약 이름 → 값(표는 칸 덩어리) */
  ports: Record<string, Record<string, unknown>>;
  /** 출력 상자 id → 값 */
  outputs: Record<string, number | string | boolean | null>;
  cost: {
    노무비: number;
    재료비: number;
    경비: number;
    값들: Record<string, number | string | boolean | null>;
    계: number;
  };
  /** 쉬운 말 */
  errors: string[];
}

/** 목록 한 줄 — `sample` = `_sample` 견본(읽기만 · 저장하면 새 번호) */
export interface CfListItem {
  key: string;
  name: string;
  resultUnit: string;
  saved: string;
  sample: boolean;
}

/** 저장 답 — `logic` 은 받는 칸에 서버 값이 들어간 다이어그램 */
export interface CfSaved {
  key: string;
  logic: CfLogic;
  values: CfComputed;
}

/** 서버가 준 몸과 상태 번호 — 0 = 서버에 못 닿음 */
export class CfError extends Error {
  constructor(
    public status: number,
    public detail: unknown,
  ) {
    super(typeof detail === "string" ? detail : JSON.stringify(detail));
  }
}

async function send<T>(path: string, body?: unknown, method?: string): Promise<T> {
  let response: Response;
  try {
    response = await fetch(`${API_BASE_URL}/m02/df${path}`, {
      method: method ?? (body === undefined ? "GET" : "POST"),
      credentials: "include",
      headers: { "Content-Type": "application/json" },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
  } catch {
    throw new CfError(0, "");
  }
  const data = (await response.json().catch(() => ({}))) as { detail?: unknown } & T;
  if (!response.ok) throw new CfError(response.status, data.detail ?? response.statusText);
  return data;
}

/** 내 다이어그램(저장 차례) + 견본 */
export async function cfList(): Promise<CfListItem[]> {
  return (await send<{ logics: CfListItem[] }>("/list")).logics;
}

export async function cfGet(key: string): Promise<CfLogic> {
  return (await send<{ logic: CfLogic }>(`/get?${new URLSearchParams({ key }).toString()}`)).logic;
}

/** 저장 — 서버가 입력 값을 마스터에서 다시 넣고 같은 엔진으로 다시 셈(브라우저 계산값은 버림) ·
 * 견본을 저장하면 새 번호 */
export async function cfSave(logic: CfLogic): Promise<CfSaved> {
  return send<CfSaved>("/save", { logic });
}

export async function cfDelete(key: string): Promise<void> {
  await send<{ key: string }>("/delete", { key });
}

/** 입력 값 한 번에 — 열 때 · 예시값을 바꿀 때 화면이 받아 시트에 넣음 ·
 * userElements = 이 다이어그램 안 사용자 요소(ref 가 `UE-…` 일 때 먼저 봄) */
export async function cfValues(
  items: CfQuery[],
  userElements: CfUserElement[] = [],
): Promise<CfAnswer[]> {
  return (await send<{ values: CfAnswer[] }>("/values", { items, userElements })).values;
}

/** 사용자 요소 목록 */
export async function cfUserElements(): Promise<CfUserElement[]> {
  return (await send<{ elements: CfUserElement[] }>("/user-elements")).elements;
}

/** 사용자 요소 만들기(공용 목록 `_data`) — id(`UE-0001`)는 서버가 줌 · 마스터에 안 씀 */
export async function cfUserElementAdd(element: Omit<CfUserElement, "id">): Promise<CfUserElement> {
  return (await send<{ element: CfUserElement }>("/user-elements", { op: "add", element })).element;
}

export async function cfUserElementDelete(id: string): Promise<void> {
  await send<{ id: string }>("/user-elements", { op: "delete", id });
}

const PLAIN: Record<number, string> = {
  0: "서버와 이어지지 않음 — 잠시 뒤 다시 해 주세요",
  400: "넣은 값의 모양이 맞지 않음",
  403: "견본은 바꾸거나 지울 수 없음 — 저장하면 새 다이어그램으로 남음",
  404: "찾을 수 없음 — 이미 지워졌을 수 있음 · 목록을 다시 열어 주세요",
  503: "엑셀 계산을 서버에서 못 함 — 잠시 뒤 다시 해 주세요",
};

/** 실패 → 쉬운 말(키 · 날 글이 섞인 서버 글은 뭉뚱그림) */
export function cfPlain(e: unknown): string {
  if (!(e instanceof CfError)) return e instanceof Error ? e.message : PLAIN[0];
  const text = typeof e.detail === "string" ? e.detail : "";
  if (e.status === 400 && text && !/[A-Z]{2}\d{6}|[{}]/.test(text)) return text;
  return PLAIN[e.status] ?? "저장하지 못함 — 잠시 뒤 다시 해 주세요";
}

/** 자재 찾기 — 띄어쓰기로 나눈 말을 모두 포함(이름 · 규격 · 키 · 원문번호) · 쪽 넘기기 */
export async function cfMaterials(q: {
  q?: string;
  sub?: string;
  detail?: string;
  page?: number;
  size?: number;
}): Promise<{ total: number; page: number; size: number; items: CfMaterial[] }> {
  const qs = new URLSearchParams(
    Object.entries(q).flatMap(([k, v]) => (v === undefined || v === "" ? [] : [[k, String(v)]])),
  );
  return send(`/materials?${qs.toString()}`);
}

/** 다른 로직 값 — 저장 로직 · 견본을 받은 설계 값(없으면 예시값)으로 서버가 셈 · 출력 이름 → 값 */
export async function cfLogicValue(
  key: string,
  designs: Record<string, unknown> = {},
): Promise<{ outputs: Record<string, unknown>; cost: CfComputed["cost"]; errors: string[] }> {
  return send("/logic-value", { key, designs });
}

/** 설계 때 정할 것 — 변수 · 재료 자리 · 다른 로직 받는 알약(프로젝트 일위대가가 쓸 꼴) */
export async function cfDesignInputs(key: string): Promise<CfDesign[]> {
  const qs = new URLSearchParams({ key }).toString();
  return (await send<{ designs: CfDesign[] }>(`/design-inputs?${qs}`)).designs;
}

/** 단위 · 금액 표준 표 읽기 · 고치기(시스템 관리자) · 처음 값으로 */
export const cfStandards = (): Promise<CfStandards> => send("/standards");
export const cfStandardsSave = (body: Omit<CfStandards, "saved">): Promise<CfStandards> =>
  send("/standards", body, "PUT");
export const cfStandardsReset = (): Promise<CfStandards> => send("/standards", undefined, "DELETE");