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

// 데이터 흐름 관리 관련 타입 정의
export interface ScreenDefinition {
  screenId: number;
  screenName: string;
  screenCode: string;
  tableName: string;
  companyCode: string;
  description?: string;
  isActive: string;
  createdDate: string;
  createdBy?: string;
  updatedDate: string;
  updatedBy?: string;
}

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 ScreenWithFields extends ScreenDefinition {
  fields: ColumnInfo[];
}

export interface ScreenRelationship {
  relationshipId?: number;
  relationshipName: string;
  fromScreenId: number;
  fromFieldName: string;
  toScreenId: number;
  toFieldName: string;
  relationshipType: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";
  connectionType: "simple-key" | "data-save" | "external-call";
  settings?: Record<string, any>;
  companyCode: string;
  isActive?: string;
}

// 데이터 흐름 관리 API 클래스
export class DataFlowAPI {
  /**
   * 회사별 화면 목록 조회
   */
  static async getScreensByCompany(companyCode: string): Promise<ScreenDefinition[]> {
    try {
      const response = await apiClient.get<ApiResponse<ScreenDefinition[]>>("/screen-management/screens", {
        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 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 getScreenWithFields(screenId: number, tableName: string): Promise<ScreenWithFields | null> {
    try {
      // 화면 정보와 컬럼 정보를 병렬로 조회
      const [screensResponse, columnsResponse] = await Promise.all([
        this.getScreensByCompany("*"), // 전체 화면 목록에서 해당 화면 찾기
        this.getTableColumns(tableName),
      ]);

      const screen = screensResponse.find((s) => s.screenId === screenId);
      if (!screen) {
        return null;
      }

      return {
        ...screen,
        fields: columnsResponse,
      };
    } catch (error) {
      console.error("화면 및 필드 정보 조회 오류:", error);
      throw error;
    }
  }

  /**
   * 화면 관계 생성
   */
  static async createRelationship(
    relationship: Omit<ScreenRelationship, "relationshipId">,
  ): Promise<ScreenRelationship> {
    try {
      const response = await apiClient.post<ApiResponse<ScreenRelationship>>("/dataflow/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<ScreenRelationship[]> {
    try {
      const response = await apiClient.get<ApiResponse<ScreenRelationship[]>>("/dataflow/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<ScreenRelationship>,
  ): Promise<ScreenRelationship> {
    try {
      const response = await apiClient.put<ApiResponse<ScreenRelationship>>(
        `/dataflow/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/relationships/${relationshipId}`);

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