ERP-node/backend-node/src/controllers/screenManagementController.ts

import { Response } from "express";
import { screenManagementService } from "../services/screenManagementService";
import { AuthenticatedRequest } from "../types/auth";

// 화면 목록 조회
export const getScreens = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const { companyCode } = req.user as any;
    const { page = 1, size = 20, searchTerm } = req.query;

    const result = await screenManagementService.getScreensByCompany(
      companyCode,
      parseInt(page as string),
      parseInt(size as string)
    );

    res.json({
      success: true,
      data: result.data,
      total: result.pagination.total,
      page: result.pagination.page,
      size: result.pagination.size,
      totalPages: result.pagination.totalPages,
    });
  } catch (error) {
    console.error("화면 목록 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 목록 조회에 실패했습니다." });
  }
};

// 단일 화면 조회
export const getScreen = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { id } = req.params;
    const { companyCode } = req.user as any;
    const screen = await screenManagementService.getScreen(
      parseInt(id),
      companyCode
    );

    if (!screen) {
      res.status(404).json({
        success: false,
        message: "화면을 찾을 수 없습니다.",
      });
      return;
    }

    res.json({ success: true, data: screen });
  } catch (error) {
    console.error("화면 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 조회에 실패했습니다." });
  }
};

// 화면 생성
export const createScreen = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { companyCode } = req.user as any;
    const screenData = { ...req.body, companyCode };
    const newScreen = await screenManagementService.createScreen(
      screenData,
      companyCode
    );
    res.status(201).json({ success: true, data: newScreen });
  } catch (error) {
    console.error("화면 생성 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 생성에 실패했습니다." });
  }
};

// 화면 수정
export const updateScreen = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { id } = req.params;
    const { companyCode } = req.user as any;
    const updateData = { ...req.body, companyCode };
    const updatedScreen = await screenManagementService.updateScreen(
      parseInt(id),
      updateData,
      companyCode
    );
    res.json({ success: true, data: updatedScreen });
  } catch (error) {
    console.error("화면 수정 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 수정에 실패했습니다." });
  }
};

// 화면 정보 수정 (메타데이터만)
export const updateScreenInfo = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { id } = req.params;
    const { companyCode } = req.user as any;
    const { screenName, description, isActive } = req.body;

    await screenManagementService.updateScreenInfo(
      parseInt(id),
      { screenName, description, isActive },
      companyCode
    );
    res.json({ success: true, message: "화면 정보가 수정되었습니다." });
  } catch (error) {
    console.error("화면 정보 수정 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 정보 수정에 실패했습니다." });
  }
};

// 화면 의존성 체크
export const checkScreenDependencies = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { id } = req.params;
    const { companyCode } = req.user as any;

    const result = await screenManagementService.checkScreenDependencies(
      parseInt(id),
      companyCode
    );
    res.json({ success: true, ...result });
  } catch (error) {
    console.error("화면 의존성 체크 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "의존성 체크에 실패했습니다." });
  }
};

// 화면 삭제 (휴지통으로 이동)
export const deleteScreen = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { id } = req.params;
    const { companyCode, userId } = req.user as any;
    const { deleteReason, force } = req.body;

    await screenManagementService.deleteScreen(
      parseInt(id),
      companyCode,
      userId,
      deleteReason,
      force || false
    );
    res.json({ success: true, message: "화면이 휴지통으로 이동되었습니다." });
  } catch (error: any) {
    console.error("화면 삭제 실패:", error);

    // 의존성 오류인 경우 특별 처리
    if (error.code === "SCREEN_HAS_DEPENDENCIES") {
      res.status(409).json({
        success: false,
        message: error.message,
        code: error.code,
        dependencies: error.dependencies,
      });
      return;
    }

    res
      .status(500)
      .json({ success: false, message: "화면 삭제에 실패했습니다." });
  }
};

// 화면 복원 (휴지통에서 복원)
export const restoreScreen = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { id } = req.params;
    const { companyCode, userId } = req.user as any;

    await screenManagementService.restoreScreen(
      parseInt(id),
      companyCode,
      userId
    );
    res.json({ success: true, message: "화면이 복원되었습니다." });
  } catch (error) {
    console.error("화면 복원 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 복원에 실패했습니다." });
  }
};

// 화면 영구 삭제
export const permanentDeleteScreen = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { id } = req.params;
    const { companyCode } = req.user as any;

    await screenManagementService.permanentDeleteScreen(
      parseInt(id),
      companyCode
    );
    res.json({ success: true, message: "화면이 영구적으로 삭제되었습니다." });
  } catch (error) {
    console.error("화면 영구 삭제 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 영구 삭제에 실패했습니다." });
  }
};

// 휴지통 화면 목록 조회
export const getDeletedScreens = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { companyCode } = req.user as any;
    const page = parseInt(req.query.page as string) || 1;
    const size = parseInt(req.query.size as string) || 20;

    const result = await screenManagementService.getDeletedScreens(
      companyCode,
      page,
      size
    );
    res.json({ success: true, ...result });
  } catch (error) {
    console.error("휴지통 화면 목록 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "휴지통 화면 목록 조회에 실패했습니다.",
    });
  }
};

// 휴지통 화면 일괄 영구 삭제
export const bulkPermanentDeleteScreens = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { companyCode } = req.user as any;
    const { screenIds } = req.body;

    if (!Array.isArray(screenIds) || screenIds.length === 0) {
      return res.status(400).json({
        success: false,
        message: "삭제할 화면 ID 목록이 필요합니다.",
      });
    }

    const result = await screenManagementService.bulkPermanentDeleteScreens(
      screenIds,
      companyCode
    );

    let message = `${result.deletedCount}개 화면이 영구 삭제되었습니다.`;
    if (result.skippedCount > 0) {
      message += ` (${result.skippedCount}개 화면은 삭제되지 않았습니다.)`;
    }

    return res.json({
      success: true,
      message,
      result: {
        deletedCount: result.deletedCount,
        skippedCount: result.skippedCount,
        errors: result.errors,
      },
    });
  } catch (error) {
    console.error("휴지통 화면 일괄 삭제 실패:", error);
    return res.status(500).json({
      success: false,
      message: "일괄 삭제에 실패했습니다.",
    });
  }
};

// 화면 복사
export const copyScreen = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { id } = req.params;
    const { screenName, screenCode, description } = req.body;
    const { companyCode, userId } = req.user as any;

    const copiedScreen = await screenManagementService.copyScreen(
      parseInt(id),
      {
        screenName,
        screenCode,
        description,
        companyCode,
        createdBy: userId,
      }
    );

    res.json({
      success: true,
      data: copiedScreen,
      message: "화면이 복사되었습니다.",
    });
  } catch (error: any) {
    console.error("화면 복사 실패:", error);
    res.status(500).json({
      success: false,
      message: error.message || "화면 복사에 실패했습니다.",
    });
  }
};

// 테이블 목록 조회 (모든 테이블)
export const getTables = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const { companyCode } = req.user as any;
    const tables = await screenManagementService.getTables(companyCode);
    res.json({ success: true, data: tables });
  } catch (error) {
    console.error("테이블 목록 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "테이블 목록 조회에 실패했습니다." });
  }
};

// 특정 테이블 정보 조회 (최적화된 단일 테이블 조회)
export const getTableInfo = async (
  req: AuthenticatedRequest,
  res: Response
): Promise<void> => {
  try {
    const { tableName } = req.params;
    const { companyCode } = req.user as any;

    if (!tableName) {
      res.status(400).json({
        success: false,
        message: "테이블명이 필요합니다.",
      });
      return;
    }

    const tableInfo = await screenManagementService.getTableInfo(
      tableName,
      companyCode
    );

    if (!tableInfo) {
      res.status(404).json({
        success: false,
        message: `테이블 '${tableName}'을 찾을 수 없습니다.`,
      });
      return;
    }

    res.json({ success: true, data: tableInfo });
  } catch (error) {
    console.error("테이블 정보 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "테이블 정보 조회에 실패했습니다." });
  }
};

// 테이블 컬럼 정보 조회
export const getTableColumns = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { tableName } = req.params;
    const { companyCode } = req.user as any;
    const columns = await screenManagementService.getTableColumns(
      tableName,
      companyCode
    );
    res.json({ success: true, data: columns });
  } catch (error) {
    console.error("테이블 컬럼 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "테이블 컬럼 조회에 실패했습니다." });
  }
};

// 레이아웃 저장
export const saveLayout = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const { screenId } = req.params;
    const { companyCode } = req.user as any;
    const layoutData = req.body;
    const savedLayout = await screenManagementService.saveLayout(
      parseInt(screenId),
      layoutData,
      companyCode
    );
    res.json({ success: true, data: savedLayout });
  } catch (error) {
    console.error("레이아웃 저장 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "레이아웃 저장에 실패했습니다." });
  }
};

// 레이아웃 조회
export const getLayout = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const { screenId } = req.params;
    const { companyCode } = req.user as any;
    const layout = await screenManagementService.getLayout(
      parseInt(screenId),
      companyCode
    );
    res.json({ success: true, data: layout });
  } catch (error) {
    console.error("레이아웃 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "레이아웃 조회에 실패했습니다." });
  }
};

// 화면 코드 자동 생성
export const generateScreenCode = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { companyCode: paramCompanyCode } = req.params;
    const { companyCode: userCompanyCode } = req.user as any;

    // 사용자의 회사 코드 또는 파라미터의 회사 코드 사용
    const targetCompanyCode = paramCompanyCode || userCompanyCode;

    const generatedCode =
      await screenManagementService.generateScreenCode(targetCompanyCode);
    res.json({ success: true, data: { screenCode: generatedCode } });
  } catch (error) {
    console.error("화면 코드 생성 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면 코드 생성에 실패했습니다." });
  }
};

// 화면-메뉴 할당
export const assignScreenToMenu = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { screenId } = req.params;
    const { companyCode } = req.user as any;
    const assignmentData = { ...req.body, companyCode };

    await screenManagementService.assignScreenToMenu(
      parseInt(screenId),
      assignmentData
    );
    res.json({
      success: true,
      message: "화면이 메뉴에 성공적으로 할당되었습니다.",
    });
  } catch (error) {
    console.error("화면-메뉴 할당 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면-메뉴 할당에 실패했습니다." });
  }
};

// 메뉴별 할당된 화면 목록 조회
export const getScreensByMenu = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { menuObjid } = req.params;
    const { companyCode } = req.user as any;

    const screens = await screenManagementService.getScreensByMenu(
      parseInt(menuObjid),
      companyCode
    );
    res.json({ success: true, data: screens });
  } catch (error) {
    console.error("메뉴별 화면 조회 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "메뉴별 화면 조회에 실패했습니다." });
  }
};

// 화면-메뉴 할당 해제
export const unassignScreenFromMenu = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const { screenId, menuObjid } = req.params;
    const { companyCode } = req.user as any;

    await screenManagementService.unassignScreenFromMenu(
      parseInt(screenId),
      parseInt(menuObjid),
      companyCode
    );
    res.json({ success: true, message: "화면-메뉴 할당이 해제되었습니다." });
  } catch (error) {
    console.error("화면-메뉴 할당 해제 실패:", error);
    res
      .status(500)
      .json({ success: false, message: "화면-메뉴 할당 해제에 실패했습니다." });
  }
};

// 휴지통 화면들의 메뉴 할당 정리 (관리자용)
export const cleanupDeletedScreenMenuAssignments = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    const result =
      await screenManagementService.cleanupDeletedScreenMenuAssignments();

    return res.json({
      success: true,
      message: result.message,
      updatedCount: result.updatedCount,
    });
  } catch (error) {
    console.error("메뉴 할당 정리 실패:", error);
    return res.status(500).json({
      success: false,
      message: "메뉴 할당 정리에 실패했습니다.",
    });
  }
};