import express, { Request, Response } from "express";
import externalCallConfigService, {
  ExternalCallConfigFilter,
} from "../services/externalCallConfigService";
import { logger } from "../utils/logger";
import { authenticateToken } from "../middleware/authMiddleware";

const router = express.Router();

// 모든 라우트에 인증 미들웨어 적용
router.use(authenticateToken);

/**
 * 외부 호출 설정 목록 조회
 * GET /api/external-call-configs
 */
router.get("/", async (req: Request, res: Response) => {
  try {
    const filter: ExternalCallConfigFilter = {
      company_code: req.query.company_code as string,
      call_type: req.query.call_type as string,
      api_type: req.query.api_type as string,
      is_active: (req.query.is_active as string) || "Y",
      search: req.query.search as string,
    };

    const configs = await externalCallConfigService.getConfigs(filter);

    return res.json({
      success: true,
      data: configs,
      message: `외부 호출 설정 ${configs.length}개 조회 완료`,
    });
  } catch (error) {
    logger.error("외부 호출 설정 목록 조회 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error
          ? error.message
          : "외부 호출 설정 목록 조회 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_LIST_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 단일 조회
 * GET /api/external-call-configs/:id
 */
router.get("/:id", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    const config = await externalCallConfigService.getConfigById(id);
    if (!config) {
      return res.status(404).json({
        success: false,
        message: "외부 호출 설정을 찾을 수 없습니다.",
        errorCode: "CONFIG_NOT_FOUND",
      });
    }

    return res.json({
      success: true,
      data: config,
      message: "외부 호출 설정 조회 완료",
    });
  } catch (error) {
    logger.error("외부 호출 설정 조회 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 조회 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_GET_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 생성
 * POST /api/external-call-configs
 */
router.post("/", async (req: Request, res: Response) => {
  try {
    const {
      config_name,
      call_type,
      api_type,
      config_data,
      description,
      company_code,
    } = req.body;

    // 필수 필드 검증
    if (!config_name || !call_type || !config_data) {
      return res.status(400).json({
        success: false,
        message:
          "필수 필드가 누락되었습니다. (config_name, call_type, config_data)",
        errorCode: "MISSING_REQUIRED_FIELDS",
      });
    }

    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";

    const newConfig = await externalCallConfigService.createConfig({
      config_name,
      call_type,
      api_type,
      config_data,
      description,
      company_code: company_code || "*",
      created_by: userId,
      updated_by: userId,
    });

    return res.status(201).json({
      success: true,
      data: newConfig,
      message: "외부 호출 설정이 성공적으로 생성되었습니다.",
    });
  } catch (error) {
    logger.error("외부 호출 설정 생성 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 생성 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_CREATE_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 수정
 * PUT /api/external-call-configs/:id
 */
router.put("/:id", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";

    const updatedConfig = await externalCallConfigService.updateConfig(id, {
      ...req.body,
      updated_by: userId,
    });

    return res.json({
      success: true,
      data: updatedConfig,
      message: "외부 호출 설정이 성공적으로 수정되었습니다.",
    });
  } catch (error) {
    logger.error("외부 호출 설정 수정 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 수정 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_UPDATE_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 삭제 (논리 삭제)
 * DELETE /api/external-call-configs/:id
 */
router.delete("/:id", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";

    await externalCallConfigService.deleteConfig(id, userId);

    return res.json({
      success: true,
      message: "외부 호출 설정이 성공적으로 삭제되었습니다.",
    });
  } catch (error) {
    logger.error("외부 호출 설정 삭제 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 삭제 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_DELETE_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 테스트
 * POST /api/external-call-configs/:id/test
 */
router.post("/:id/test", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    const testResult = await externalCallConfigService.testConfig(id);

    return res.json({
      success: testResult.success,
      message: testResult.message,
      data: testResult,
    });
  } catch (error) {
    logger.error("외부 호출 설정 테스트 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 테스트 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_TEST_ERROR",
    });
  }
});

/**
 * 🔥 개선된 외부호출 실행 (데이터 매핑 통합)
 * POST /api/external-call-configs/:id/execute
 */
router.post("/:id/execute", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    const { requestData, contextData } = req.body;
    
    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";
    const companyCode = userInfo?.companyCode || "*";

    const executionResult = await externalCallConfigService.executeConfigWithDataMapping(
      id,
      requestData || {},
      {
        ...contextData,
        userId,
        companyCode,
        executedAt: new Date().toISOString(),
      }
    );

    return res.json({
      success: executionResult.success,
      message: executionResult.message,
      data: executionResult.data,
      executionTime: executionResult.executionTime,
      error: executionResult.error,
    });
  } catch (error) {
    logger.error("외부호출 실행 API 오류:", error);
    return res.status(500).json({
      success: false,
      message: error instanceof Error ? error.message : "외부호출 실행 실패",
      errorCode: "EXTERNAL_CALL_EXECUTE_ERROR",
    });
  }
});

/**
 * 🔥 버튼 제어용 외부호출 목록 조회 (간소화된 정보)
 * GET /api/external-call-configs/for-button-control
 */
router.get("/for-button-control", async (req: Request, res: Response) => {
  try {
    const userInfo = (req as any).user;
    const companyCode = userInfo?.companyCode || "*";

    const configs = await externalCallConfigService.getConfigsForButtonControl(companyCode);

    return res.json({
      success: true,
      data: configs,
      message: `버튼 제어용 외부호출 설정 ${configs.length}개 조회 완료`,
    });
  } catch (error) {
    logger.error("버튼 제어용 외부호출 설정 조회 API 오류:", error);
    return res.status(500).json({
      success: false,
      message: error instanceof Error ? error.message : "외부호출 설정 조회 실패",
      errorCode: "EXTERNAL_CALL_BUTTON_CONTROL_LIST_ERROR",
    });
  }
});

export default router;
