import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

export interface DataflowDiagram {
  diagram_id: number;
  diagram_name: string;
  relationships: any; // JSON 타입
  company_code: string;
  created_at?: Date;
  updated_at?: Date;
  created_by?: string;
  updated_by?: string;
}

export interface CreateDataflowDiagramData {
  diagram_name: string;
  relationships: any;
  company_code: string;
  created_by?: string;
}

export interface UpdateDataflowDiagramData {
  diagram_name?: string;
  relationships?: any;
  updated_by?: string;
}

export class DataflowDiagramService {
  /**
   * 관계도 목록 조회 (페이지네이션)
   */
  async getDataflowDiagrams(
    companyCode: string,
    page: number = 1,
    size: number = 20,
    searchTerm: string = ""
  ) {
    const skip = (page - 1) * size;

    const whereClause: any = {
      company_code: companyCode,
    };

    if (searchTerm) {
      whereClause.diagram_name = {
        contains: searchTerm,
        mode: "insensitive",
      };
    }

    const [diagrams, total] = await Promise.all([
      prisma.dataflow_diagrams.findMany({
        where: whereClause,
        orderBy: { created_at: "desc" },
        skip,
        take: size,
      }),
      prisma.dataflow_diagrams.count({
        where: whereClause,
      }),
    ]);

    return {
      diagrams,
      pagination: {
        page,
        size,
        total,
        totalPages: Math.ceil(total / size),
      },
    };
  }

  /**
   * 특정 관계도 조회
   */
  async getDataflowDiagramById(
    diagramId: number,
    companyCode: string
  ): Promise<DataflowDiagram | null> {
    return await prisma.dataflow_diagrams.findFirst({
      where: {
        diagram_id: diagramId,
        company_code: companyCode,
      },
    });
  }

  /**
   * 관계도 생성
   */
  async createDataflowDiagram(
    data: CreateDataflowDiagramData
  ): Promise<DataflowDiagram> {
    return await prisma.dataflow_diagrams.create({
      data: {
        diagram_name: data.diagram_name,
        relationships: data.relationships,
        company_code: data.company_code,
        created_by: data.created_by,
      },
    });
  }

  /**
   * 관계도 수정
   */
  async updateDataflowDiagram(
    diagramId: number,
    companyCode: string,
    data: UpdateDataflowDiagramData
  ): Promise<DataflowDiagram | null> {
    // 먼저 해당 관계도가 존재하는지 확인
    const existingDiagram = await this.getDataflowDiagramById(
      diagramId,
      companyCode
    );
    if (!existingDiagram) {
      return null;
    }

    return await prisma.dataflow_diagrams.update({
      where: {
        diagram_id: diagramId,
      },
      data: {
        ...(data.diagram_name && { diagram_name: data.diagram_name }),
        ...(data.relationships && { relationships: data.relationships }),
        ...(data.updated_by && { updated_by: data.updated_by }),
        updated_at: new Date(),
      },
    });
  }

  /**
   * 관계도 삭제
   */
  async deleteDataflowDiagram(
    diagramId: number,
    companyCode: string
  ): Promise<boolean> {
    // 먼저 해당 관계도가 존재하는지 확인
    const existingDiagram = await this.getDataflowDiagramById(
      diagramId,
      companyCode
    );
    if (!existingDiagram) {
      return false;
    }

    await prisma.dataflow_diagrams.delete({
      where: {
        diagram_id: diagramId,
      },
    });

    return true;
  }

  /**
   * 관계도 복제
   */
  async copyDataflowDiagram(
    diagramId: number,
    companyCode: string,
    newName?: string,
    createdBy?: string
  ): Promise<DataflowDiagram | null> {
    const originalDiagram = await this.getDataflowDiagramById(
      diagramId,
      companyCode
    );
    if (!originalDiagram) {
      return null;
    }

    // 복제본 이름 생성
    let copyName = newName;
    if (!copyName) {
      // "(1)", "(2)" 형식으로 이름 생성
      const baseName = originalDiagram.diagram_name;
      let counter = 1;

      while (true) {
        copyName = `${baseName} (${counter})`;
        const existing = await prisma.dataflow_diagrams.findFirst({
          where: {
            company_code: companyCode,
            diagram_name: copyName,
          },
        });

        if (!existing) break;
        counter++;
      }
    }

    return await this.createDataflowDiagram({
      diagram_name: copyName,
      relationships: originalDiagram.relationships,
      company_code: companyCode,
      created_by: createdBy,
    });
  }
}