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

import { apiClient, ApiResponse } from "./client";

// 테이블 간 데이터 관계 설정 관련 타입 정의

export interface ColumnInfo {
  columnName: string;
  columnLabel?: string;
  displayName?: string;
  dataType?: string;
  dbType?: string;
  webType?: string;
  isNullable?: string;
  columnDefault?: string;
  characterMaximumLength?: number;
  numericPrecision?: number;
  numericScale?: number;
  detailSettings?: string;
  codeCategory?: string;
  referenceTable?: string;
  referenceColumn?: string;
  isVisible?: string;
  displayOrder?: number;
  description?: string;
}

export interface TableDefinition {
  tableName: string;
  displayName?: string;
  description?: string;
  columns: ColumnInfo[];
}

export interface TableInfo {
  tableName: string;
  displayName: string;
  description: string;
  columnCount: number;
}

export interface TableRelationship {
  relationshipId?: number;
  relationshipName: string;
  fromTableName: string;
  fromColumnName: string;
  toTableName: string;
  toColumnName: string;
  relationshipType: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";
  connectionType: "simple-key" | "data-save" | "external-call";
  settings?: Record<string, unknown>;
  companyCode: string;
  isActive?: string;
}

// 데이터 연결 중계 테이블 타입
export interface DataBridge {
  bridgeId: number;
  relationshipId: number;
  fromTableName: string;
  fromColumnName: string;
  fromKeyValue: string;
  fromRecordId?: string;
  toTableName: string;
  toColumnName: string;
  toKeyValue: string;
  toRecordId?: string;
  connectionType: string;
  companyCode: string;
  createdAt: string;
  createdBy?: string;
  updatedAt: string;
  updatedBy?: string;
  isActive: string;
  bridgeData?: Record<string, unknown>;
  relationship?: {
    relationshipName: string;
    relationshipType: string;
    connectionType: string;
  };
}

// 테이블 간 데이터 관계 설정 API 클래스
export class DataFlowAPI {
  /**
   * 테이블 목록 조회
   */
  static async getTables(): Promise<TableInfo[]> {
    try {
      const response = await apiClient.get<ApiResponse<TableInfo[]>>("/table-management/tables");

      if (!response.data.success) {
        throw new Error(response.data.message || "테이블 목록 조회에 실패했습니다.");
      }

      return response.data.data || [];
    } catch (error) {
      console.error("테이블 목록 조회 오류:", error);
      throw error;
    }
  }

  /**
   * 테이블 컬럼 정보 조회
   */
  static async getTableColumns(tableName: string): Promise<ColumnInfo[]> {
    try {
      const response = await apiClient.get<ApiResponse<ColumnInfo[]>>(`/table-management/tables/${tableName}/columns`);

      if (!response.data.success) {
        throw new Error(response.data.message || "컬럼 정보 조회에 실패했습니다.");
      }

      return response.data.data || [];
    } catch (error) {
      console.error("컬럼 정보 조회 오류:", error);
      throw error;
    }
  }

  /**
   * 테이블 정보와 컬럼 정보를 함께 조회
   */
  static async getTableWithColumns(tableName: string): Promise<TableDefinition | null> {
    try {
      const columns = await this.getTableColumns(tableName);

      return {
        tableName,
        displayName: tableName,
        description: `${tableName} 테이블`,
        columns,
      };
    } catch (error) {
      console.error("테이블 및 컬럼 정보 조회 오류:", error);
      throw error;
    }
  }

  /**
   * 테이블 관계 생성
   */
  static async createRelationship(relationship: Omit<TableRelationship, "relationshipId">): Promise<TableRelationship> {
    try {
      const response = await apiClient.post<ApiResponse<TableRelationship>>(
        "/dataflow/table-relationships",
        relationship,
      );

      if (!response.data.success) {
        throw new Error(response.data.message || "관계 생성에 실패했습니다.");
      }

      return response.data.data!;
    } catch (error) {
      console.error("관계 생성 오류:", error);
      throw error;
    }
  }

  /**
   * 회사별 테이블 관계 목록 조회
   */
  static async getRelationshipsByCompany(companyCode: string): Promise<TableRelationship[]> {
    try {
      const response = await apiClient.get<ApiResponse<TableRelationship[]>>("/dataflow/table-relationships", {
        params: { companyCode },
      });

      if (!response.data.success) {
        throw new Error(response.data.message || "관계 목록 조회에 실패했습니다.");
      }

      return response.data.data || [];
    } catch (error) {
      console.error("관계 목록 조회 오류:", error);
      throw error;
    }
  }

  /**
   * 테이블 관계 수정
   */
  static async updateRelationship(
    relationshipId: number,
    relationship: Partial<TableRelationship>,
  ): Promise<TableRelationship> {
    try {
      const response = await apiClient.put<ApiResponse<TableRelationship>>(
        `/dataflow/table-relationships/${relationshipId}`,
        relationship,
      );

      if (!response.data.success) {
        throw new Error(response.data.message || "관계 수정에 실패했습니다.");
      }

      return response.data.data!;
    } catch (error) {
      console.error("관계 수정 오류:", error);
      throw error;
    }
  }

  /**
   * 테이블 관계 삭제
   */
  static async deleteRelationship(relationshipId: number): Promise<void> {
    try {
      const response = await apiClient.delete<ApiResponse<null>>(`/dataflow/table-relationships/${relationshipId}`);

      if (!response.data.success) {
        throw new Error(response.data.message || "관계 삭제에 실패했습니다.");
      }
    } catch (error) {
      console.error("관계 삭제 오류:", error);
      throw error;
    }
  }

  // ==================== 데이터 연결 관리 API ====================

  /**
   * 데이터 연결 생성
   */
  static async createDataLink(linkData: {
    relationshipId: number;
    fromTableName: string;
    fromColumnName: string;
    fromKeyValue: string;
    fromRecordId?: string;
    toTableName: string;
    toColumnName: string;
    toKeyValue: string;
    toRecordId?: string;
    connectionType: string;
    bridgeData?: Record<string, unknown>;
  }): Promise<DataBridge> {
    try {
      const response = await apiClient.post<ApiResponse<DataBridge>>("/dataflow/data-links", linkData);

      if (!response.data.success) {
        throw new Error(response.data.message || "데이터 연결 생성에 실패했습니다.");
      }

      return response.data.data as DataBridge;
    } catch (error) {
      console.error("데이터 연결 생성 오류:", error);
      throw error;
    }
  }

  /**
   * 관계별 연결된 데이터 조회
   */
  static async getLinkedDataByRelationship(relationshipId: number): Promise<DataBridge[]> {
    try {
      const response = await apiClient.get<ApiResponse<DataBridge[]>>(
        `/dataflow/data-links/relationship/${relationshipId}`,
      );

      if (!response.data.success) {
        throw new Error(response.data.message || "연결된 데이터 조회에 실패했습니다.");
      }

      return response.data.data as DataBridge[];
    } catch (error) {
      console.error("연결된 데이터 조회 오류:", error);
      throw error;
    }
  }

  /**
   * 데이터 연결 삭제
   */
  static async deleteDataLink(bridgeId: number): Promise<void> {
    try {
      const response = await apiClient.delete<ApiResponse<null>>(`/dataflow/data-links/${bridgeId}`);

      if (!response.data.success) {
        throw new Error(response.data.message || "데이터 연결 삭제에 실패했습니다.");
      }
    } catch (error) {
      console.error("데이터 연결 삭제 오류:", error);
      throw error;
    }
  }
}