ERP-node/frontend/lib/api/screen.ts

import { apiClient } from "./client";
import {
  ScreenDefinition,
  CreateScreenRequest,
  UpdateScreenRequest,
  PaginatedResponse,
  ScreenTemplate,
  LayoutData,
} from "@/types/screen";

// 화면 정의 관련 API
export const screenApi = {
  // 화면 목록 조회
  getScreens: async (params: {
    page?: number;
    size?: number;
    companyCode?: string;
    searchTerm?: string;
  }): Promise<PaginatedResponse<ScreenDefinition>> => {
    const response = await apiClient.get("/screen-management/screens", { params });
    const raw = response.data || {};
    const items: any[] = (raw.data ?? raw.items ?? []) as any[];
    const mapped: ScreenDefinition[] = items.map((it) => ({
      ...it,
      // 문자열로 온 날짜를 Date 객체로 변환 (이미 Date이면 그대로 유지)
      createdDate: it.createdDate ? new Date(it.createdDate) : undefined,
      updatedDate: it.updatedDate ? new Date(it.updatedDate) : undefined,
    }));

    const page = raw.page ?? params.page ?? 1;
    const size = raw.size ?? params.size ?? mapped.length;
    const total = raw.total ?? mapped.length;
    const totalPages = raw.totalPages ?? Math.max(1, Math.ceil(total / (size || 1)));

    return { data: mapped, total, page, size, totalPages };
  },

  // 화면 상세 조회
  getScreen: async (screenId: number): Promise<ScreenDefinition> => {
    const response = await apiClient.get(`/screen-management/screens/${screenId}`);
    const raw = response.data?.data || response.data;
    return {
      ...raw,
      createdDate: raw?.createdDate ? new Date(raw.createdDate) : undefined,
      updatedDate: raw?.updatedDate ? new Date(raw.updatedDate) : undefined,
    } as ScreenDefinition;
  },

  // 화면 생성
  createScreen: async (screenData: CreateScreenRequest): Promise<ScreenDefinition> => {
    const response = await apiClient.post("/screen-management/screens", screenData);
    return response.data.data;
  },

  // 화면 코드 자동 생성 (회사코드 + 순번)
  generateScreenCode: async (companyCode: string): Promise<string> => {
    const response = await apiClient.get(`/screen-management/generate-screen-code/${companyCode}`);
    return response.data.data.screenCode;
  },

  // 화면 수정
  updateScreen: async (screenId: number, screenData: UpdateScreenRequest): Promise<ScreenDefinition> => {
    const response = await apiClient.put(`/screen-management/screens/${screenId}`, screenData);
    return response.data.data;
  },

  // 화면 삭제
  deleteScreen: async (screenId: number): Promise<void> => {
    await apiClient.delete(`/screen-management/screens/${screenId}`);
  },

  // 화면 레이아웃 저장
  saveLayout: async (screenId: number, layoutData: LayoutData): Promise<void> => {
    await apiClient.post(`/screen-management/screens/${screenId}/layout`, layoutData);
  },

  // 화면 레이아웃 조회
  getLayout: async (screenId: number): Promise<LayoutData> => {
    const response = await apiClient.get(`/screen-management/screens/${screenId}/layout`);
    return response.data.data;
  },
};

// 템플릿 관련 API
export const templateApi = {
  // 템플릿 목록 조회
  getTemplates: async (params: {
    companyCode?: string;
    templateType?: string;
    isPublic?: boolean;
  }): Promise<ScreenTemplate[]> => {
    const response = await apiClient.get("/screen-management/templates", { params });
    return response.data.data;
  },

  // 템플릿 상세 조회
  getTemplate: async (templateId: number): Promise<ScreenTemplate> => {
    const response = await apiClient.get(`/screen-management/templates/${templateId}`);
    return response.data.data;
  },

  // 템플릿 생성
  createTemplate: async (templateData: Partial<ScreenTemplate>): Promise<ScreenTemplate> => {
    const response = await apiClient.post("/screen-management/templates", templateData);
    return response.data.data;
  },

  // 템플릿 수정
  updateTemplate: async (templateId: number, templateData: Partial<ScreenTemplate>): Promise<ScreenTemplate> => {
    const response = await apiClient.put(`/screen-management/templates/${templateId}`, templateData);
    return response.data.data;
  },

  // 템플릿 삭제
  deleteTemplate: async (templateId: number): Promise<void> => {
    await apiClient.delete(`/screen-management/templates/${templateId}`);
  },
};

// 테이블 타입 관련 API
export const tableTypeApi = {
  // 테이블 목록 조회
  getTables: async (): Promise<
    Array<{ tableName: string; displayName: string; description: string; columnCount: string }>
  > => {
    const response = await apiClient.get("/table-management/tables");
    return response.data.data;
  },

  // 테이블 컬럼 정보 조회
  getColumns: async (tableName: string): Promise<any[]> => {
    const response = await apiClient.get(`/table-management/tables/${tableName}/columns`);
    return response.data.data;
  },

  // 컬럼 웹 타입 설정
  setColumnWebType: async (
    tableName: string,
    columnName: string,
    webType: string,
    detailSettings?: Record<string, any>,
  ): Promise<void> => {
    await apiClient.put(`/table-management/tables/${tableName}/columns/${columnName}/web-type`, {
      webType,
      detailSettings,
    });
  },

  // 테이블 데이터 조회 (페이지네이션 + 검색)
  getTableData: async (
    tableName: string,
    params: {
      page?: number;
      size?: number;
      search?: Record<string, any>; // 검색 조건
      sortBy?: string;
      sortOrder?: "asc" | "desc";
    } = {},
  ): Promise<{
    data: Record<string, any>[];
    total: number;
    page: number;
    size: number;
    totalPages: number;
  }> => {
    const response = await apiClient.post(`/table-management/tables/${tableName}/data`, params);
    const raw = response.data?.data || response.data;

    return {
      data: raw.data || [],
      total: raw.total || 0,
      page: raw.page || params.page || 1,
      size: raw.size || params.size || 10,
      totalPages: raw.totalPages || Math.ceil((raw.total || 0) / (params.size || 10)),
    };
  },

  // 데이터 추가
  addTableData: async (tableName: string, data: Record<string, any>): Promise<void> => {
    await apiClient.post(`/table-management/tables/${tableName}/add`, data);
  },

  // 데이터 수정
  editTableData: async (
    tableName: string,
    originalData: Record<string, any>,
    updatedData: Record<string, any>,
  ): Promise<void> => {
    await apiClient.put(`/table-management/tables/${tableName}/edit`, {
      originalData,
      updatedData,
    });
  },

  // 데이터 삭제 (단일 또는 다중)
  deleteTableData: async (tableName: string, data: Record<string, any>[] | { ids: string[] }): Promise<void> => {
    await apiClient.delete(`/table-management/tables/${tableName}/delete`, { data });
  },
};

// 메뉴-화면 할당 관련 API
export const menuScreenApi = {
  // 화면을 메뉴에 할당
  assignScreenToMenu: async (screenId: number, menuObjid: number, displayOrder?: number): Promise<void> => {
    await apiClient.post(`/screen-management/screens/${screenId}/assign-menu`, {
      menuObjid,
      displayOrder,
    });
  },

  // 메뉴별 할당된 화면 목록 조회
  getScreensByMenu: async (menuObjid: number): Promise<ScreenDefinition[]> => {
    const response = await apiClient.get(`/screen-management/menus/${menuObjid}/screens`);
    return response.data.data.map((screen: any) => ({
      ...screen,
      createdDate: screen.createdDate ? new Date(screen.createdDate) : new Date(),
      updatedDate: screen.updatedDate ? new Date(screen.updatedDate) : new Date(),
    }));
  },

  // 화면-메뉴 할당 해제
  unassignScreenFromMenu: async (screenId: number, menuObjid: number): Promise<void> => {
    await apiClient.delete(`/screen-management/screens/${screenId}/menus/${menuObjid}`);
  },
};