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

import { Request, Response } from "express";
import { templateStandardService } from "../services/templateStandardService";

interface AuthenticatedRequest extends Request {
  user?: {
    userId: string;
    companyCode: string;
    company_code?: string;
    [key: string]: any;
  };
}

/**
 * 템플릿 표준 관리 컨트롤러
 */
export class TemplateStandardController {
  /**
   * 템플릿 목록 조회
   */
  async getTemplates(req: AuthenticatedRequest, res: Response): Promise<void> {
    try {
      const {
        active = "Y",
        category,
        search,
        company_code,
        is_public = "Y",
        page = "1",
        limit = "50",
      } = req.query;

      const user = req.user;
      const userCompanyCode = user?.company_code || "DEFAULT";

      const result = await templateStandardService.getTemplates({
        active: active as string,
        category: category as string,
        search: search as string,
        company_code: (company_code as string) || userCompanyCode,
        is_public: is_public as string,
        page: parseInt(page as string),
        limit: parseInt(limit as string),
      });

      res.json({
        success: true,
        data: result.templates,
        pagination: {
          total: result.total,
          page: parseInt(page as string),
          limit: parseInt(limit as string),
          totalPages: Math.ceil(result.total / parseInt(limit as string)),
        },
      });
    } catch (error) {
      console.error("템플릿 목록 조회 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 목록 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 상세 조회
   */
  async getTemplate(req: AuthenticatedRequest, res: Response): Promise<void> {
    try {
      const { templateCode } = req.params;

      if (!templateCode) {
        res.status(400).json({
          success: false,
          error: "템플릿 코드가 필요합니다.",
        });
      }

      const template = await templateStandardService.getTemplate(templateCode);

      if (!template) {
        res.status(404).json({
          success: false,
          error: "템플릿을 찾을 수 없습니다.",
        });
      }

      res.json({
        success: true,
        data: template,
      });
    } catch (error) {
      console.error("템플릿 조회 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 생성
   */
  async createTemplate(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const user = req.user;
      const templateData = req.body;

      // 필수 필드 검증
      if (
        !templateData.template_code ||
        !templateData.template_name ||
        !templateData.category ||
        !templateData.layout_config
      ) {
        res.status(400).json({
          success: false,
          message:
            "필수 필드가 누락되었습니다. (template_code, template_name, category, layout_config)",
        });
      }

      // 회사 코드와 생성자 정보 추가
      const templateWithMeta = {
        ...templateData,
        company_code: user?.company_code || "DEFAULT",
        created_by: user?.user_id || "system",
        updated_by: user?.user_id || "system",
      };

      const newTemplate =
        await templateStandardService.createTemplate(templateWithMeta);

      res.status(201).json({
        success: true,
        data: newTemplate,
        message: "템플릿이 성공적으로 생성되었습니다.",
      });
    } catch (error) {
      console.error("템플릿 생성 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 생성 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 수정
   */
  async updateTemplate(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const { templateCode } = req.params;
      const templateData = req.body;
      const user = req.user;

      if (!templateCode) {
        res.status(400).json({
          success: false,
          error: "템플릿 코드가 필요합니다.",
        });
      }

      // 수정자 정보 추가
      const templateWithMeta = {
        ...templateData,
        updated_by: user?.user_id || "system",
      };

      const updatedTemplate = await templateStandardService.updateTemplate(
        templateCode,
        templateWithMeta
      );

      if (!updatedTemplate) {
        res.status(404).json({
          success: false,
          error: "템플릿을 찾을 수 없습니다.",
        });
      }

      res.json({
        success: true,
        data: updatedTemplate,
        message: "템플릿이 성공적으로 수정되었습니다.",
      });
    } catch (error) {
      console.error("템플릿 수정 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 수정 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 삭제
   */
  async deleteTemplate(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const { templateCode } = req.params;

      if (!templateCode) {
        res.status(400).json({
          success: false,
          error: "템플릿 코드가 필요합니다.",
        });
      }

      const deleted =
        await templateStandardService.deleteTemplate(templateCode);

      if (!deleted) {
        res.status(404).json({
          success: false,
          error: "템플릿을 찾을 수 없습니다.",
        });
      }

      res.json({
        success: true,
        message: "템플릿이 성공적으로 삭제되었습니다.",
      });
    } catch (error) {
      console.error("템플릿 삭제 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 삭제 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 정렬 순서 일괄 업데이트
   */
  async updateSortOrder(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const { templates } = req.body;

      if (!Array.isArray(templates)) {
        res.status(400).json({
          success: false,
          error: "templates는 배열이어야 합니다.",
        });
      }

      await templateStandardService.updateSortOrder(templates);

      res.json({
        success: true,
        message: "템플릿 정렬 순서가 성공적으로 업데이트되었습니다.",
      });
    } catch (error) {
      console.error("템플릿 정렬 순서 업데이트 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 정렬 순서 업데이트 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 복제
   */
  async duplicateTemplate(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const { templateCode } = req.params;
      const { new_template_code, new_template_name } = req.body;
      const user = req.user;

      if (!templateCode || !new_template_code || !new_template_name) {
        res.status(400).json({
          success: false,
          error: "필수 필드가 누락되었습니다.",
        });
      }

      const duplicatedTemplate =
        await templateStandardService.duplicateTemplate({
          originalCode: templateCode,
          newCode: new_template_code,
          newName: new_template_name,
          company_code: user?.company_code || "DEFAULT",
          created_by: user?.user_id || "system",
        });

      res.status(201).json({
        success: true,
        data: duplicatedTemplate,
        message: "템플릿이 성공적으로 복제되었습니다.",
      });
    } catch (error) {
      console.error("템플릿 복제 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 복제 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 카테고리 목록 조회
   */
  async getCategories(req: AuthenticatedRequest, res: Response): Promise<void> {
    try {
      const user = req.user;
      const companyCode = user?.company_code || "DEFAULT";

      const categories =
        await templateStandardService.getCategories(companyCode);

      res.json({
        success: true,
        data: categories,
      });
    } catch (error) {
      console.error("템플릿 카테고리 조회 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 카테고리 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 가져오기 (JSON 파일에서)
   */
  async importTemplate(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const user = req.user;
      const templateData = req.body;

      if (!templateData.layout_config) {
        res.status(400).json({
          success: false,
          error: "유효한 템플릿 데이터가 아닙니다.",
        });
      }

      // 회사 코드와 생성자 정보 추가
      const templateWithMeta = {
        ...templateData,
        company_code: user?.company_code || "DEFAULT",
        created_by: user?.user_id || "system",
        updated_by: user?.user_id || "system",
      };

      const importedTemplate =
        await templateStandardService.createTemplate(templateWithMeta);

      res.status(201).json({
        success: true,
        data: importedTemplate,
        message: "템플릿이 성공적으로 가져왔습니다.",
      });
    } catch (error) {
      console.error("템플릿 가져오기 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 가져오기 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  /**
   * 템플릿 내보내기 (JSON 형태로)
   */
  async exportTemplate(
    req: AuthenticatedRequest,
    res: Response
  ): Promise<void> {
    try {
      const { templateCode } = req.params;

      if (!templateCode) {
        res.status(400).json({
          success: false,
          error: "템플릿 코드가 필요합니다.",
        });
        return;
      }

      const template = await templateStandardService.getTemplate(templateCode);

      if (!template) {
        res.status(404).json({
          success: false,
          error: "템플릿을 찾을 수 없습니다.",
        });
        return;
      }

      // 내보내기용 데이터 (메타데이터 제외)
      const exportData = {
        template_code: template.template_code,
        template_name: template.template_name,
        template_name_eng: template.template_name_eng,
        description: template.description,
        category: template.category,
        icon_name: template.icon_name,
        default_size: template.default_size,
        layout_config: template.layout_config,
      };

      res.json({
        success: true,
        data: exportData,
      });
    } catch (error) {
      console.error("템플릿 내보내기 중 오류:", error);
      res.status(500).json({
        success: false,
        message: "템플릿 내보내기 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }
}

export const templateStandardController = new TemplateStandardController();