import { Request, Response } from "express";
import { PrismaClient } from "@prisma/client";
import { logger } from "../utils/logger";

const prisma = new PrismaClient();

export interface EntityReferenceOption {
  value: string;
  label: string;
}

export interface EntityReferenceData {
  options: EntityReferenceOption[];
  referenceInfo: {
    referenceTable: string;
    referenceColumn: string;
    displayColumn: string | null;
  };
}

export interface CodeReferenceData {
  options: EntityReferenceOption[];
  codeCategory: string;
}

export class EntityReferenceController {
  /**
   * 엔티티 참조 데이터 조회
   * GET /api/entity-reference/:tableName/:columnName
   */
  static async getEntityReferenceData(req: Request, res: Response) {
    try {
      const { tableName, columnName } = req.params;
      const { limit = 100, search } = req.query;

      logger.info(`엔티티 참조 데이터 조회 요청: ${tableName}.${columnName}`, {
        limit,
        search,
      });

      // 컬럼 정보 조회
      const columnInfo = await prisma.column_labels.findFirst({
        where: {
          table_name: tableName,
          column_name: columnName,
        },
      });

      if (!columnInfo) {
        return res.status(404).json({
          success: false,
          message: `컬럼 정보를 찾을 수 없습니다: ${tableName}.${columnName}`,
        });
      }

      // webType 확인
      if (columnInfo.web_type !== "entity") {
        return res.status(400).json({
          success: false,
          message: `컬럼 '${tableName}.${columnName}'은 entity 타입이 아닙니다. webType: ${columnInfo.web_type}`,
        });
      }

      // column_labels에서 직접 참조 정보 가져오기
      const referenceTable = columnInfo.reference_table;
      const referenceColumn = columnInfo.reference_column;
      const displayColumn = columnInfo.display_column || "name";

      // entity 타입인데 참조 테이블 정보가 없으면 오류
      if (!referenceTable || !referenceColumn) {
        return res.status(400).json({
          success: false,
          message: `Entity 타입 컬럼 '${tableName}.${columnName}'에 참조 테이블 정보가 설정되지 않았습니다. column_labels에서 reference_table과 reference_column을 확인해주세요.`,
        });
      }

      // 참조 테이블이 실제로 존재하는지 확인
      try {
        await prisma.$queryRawUnsafe(`SELECT 1 FROM ${referenceTable} LIMIT 1`);
        logger.info(
          `Entity 참조 설정: ${tableName}.${columnName} -> ${referenceTable}.${referenceColumn} (display: ${displayColumn})`
        );
      } catch (error) {
        logger.error(
          `참조 테이블 '${referenceTable}'이 존재하지 않습니다:`,
          error
        );
        return res.status(400).json({
          success: false,
          message: `참조 테이블 '${referenceTable}'이 존재하지 않습니다. column_labels의 reference_table 설정을 확인해주세요.`,
        });
      }

      // 동적 쿼리로 참조 데이터 조회
      let query = `SELECT ${referenceColumn}, ${displayColumn} as display_name FROM ${referenceTable}`;
      const queryParams: any[] = [];

      // 검색 조건 추가
      if (search) {
        query += ` WHERE ${displayColumn} ILIKE $1`;
        queryParams.push(`%${search}%`);
      }

      query += ` ORDER BY ${displayColumn} LIMIT $${queryParams.length + 1}`;
      queryParams.push(Number(limit));

      logger.info(`실행할 쿼리: ${query}`, {
        queryParams,
        referenceTable,
        referenceColumn,
        displayColumn,
      });

      const referenceData = await prisma.$queryRawUnsafe(query, ...queryParams);

      // 옵션 형태로 변환
      const options: EntityReferenceOption[] = (referenceData as any[]).map(
        (row) => ({
          value: String(row[referenceColumn]),
          label: String(row.display_name || row[referenceColumn]),
        })
      );

      logger.info(`엔티티 참조 데이터 조회 완료: ${options.length}개 항목`);

      return res.json({
        success: true,
        data: {
          options,
          referenceInfo: {
            referenceTable,
            referenceColumn,
            displayColumn,
          },
        },
      });
    } catch (error) {
      logger.error("엔티티 참조 데이터 조회 실패:", error);
      return res.status(500).json({
        success: false,
        message: "엔티티 참조 데이터 조회 중 오류가 발생했습니다.",
      });
    }
  }

  /**
   * 공통 코드 데이터 조회
   * GET /api/entity-reference/code/:codeCategory
   */
  static async getCodeData(req: Request, res: Response) {
    try {
      const { codeCategory } = req.params;
      const { limit = 100, search } = req.query;

      logger.info(`공통 코드 데이터 조회 요청: ${codeCategory}`, {
        limit,
        search,
      });

      // code_info 테이블에서 코드 데이터 조회
      let whereCondition: any = {
        code_category: codeCategory,
        is_active: "Y",
      };

      if (search) {
        whereCondition.code_name = {
          contains: String(search),
          mode: "insensitive",
        };
      }

      const codeData = await prisma.code_info.findMany({
        where: whereCondition,
        select: {
          code_value: true,
          code_name: true,
        },
        orderBy: {
          code_name: "asc",
        },
        take: Number(limit),
      });

      // 옵션 형태로 변환
      const options: EntityReferenceOption[] = codeData.map((code) => ({
        value: code.code_value,
        label: code.code_name,
      }));

      logger.info(`공통 코드 데이터 조회 완료: ${options.length}개 항목`);

      return res.json({
        success: true,
        data: {
          options,
          codeCategory,
        },
      });
    } catch (error) {
      logger.error("공통 코드 데이터 조회 실패:", error);
      return res.status(500).json({
        success: false,
        message: "공통 코드 데이터 조회 중 오류가 발생했습니다.",
      });
    }
  }
}