// 배치관리 전용 컨트롤러 (기존 소스와 완전 분리)
// 작성일: 2024-12-24

import { Response } from "express";
import { AuthenticatedRequest } from "../types/auth";
import { BatchManagementService, BatchConnectionInfo, BatchTableInfo, BatchColumnInfo } from "../services/batchManagementService";
import { BatchService } from "../services/batchService";
import { BatchSchedulerService } from "../services/batchSchedulerService";
import { CreateBatchConfigRequest, BatchConfig } from "../types/batchTypes";

export class BatchManagementController {
  /**
   * 사용 가능한 커넥션 목록 조회
   */
  static async getAvailableConnections(req: AuthenticatedRequest, res: Response) {
    try {
      const result = await BatchManagementService.getAvailableConnections();
      if (result.success) {
        res.json(result);
      } else {
        res.status(500).json(result);
      }
    } catch (error) {
      console.error("커넥션 목록 조회 오류:", error);
      res.status(500).json({
        success: false,
        message: "커넥션 목록 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }

  /**
   * 특정 커넥션의 테이블 목록 조회
   */
  static async getTablesFromConnection(req: AuthenticatedRequest, res: Response) {
    try {
      const { type, id } = req.params;
      
      if (type !== 'internal' && type !== 'external') {
        return res.status(400).json({
          success: false,
          message: "올바른 연결 타입을 지정해주세요. (internal 또는 external)"
        });
      }

      const connectionId = type === 'external' ? Number(id) : undefined;
      const result = await BatchManagementService.getTablesFromConnection(type, connectionId);
      
      if (result.success) {
        return res.json(result);
      } else {
        return res.status(500).json(result);
      }
    } catch (error) {
      console.error("테이블 목록 조회 오류:", error);
      return res.status(500).json({
        success: false,
        message: "테이블 목록 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }

  /**
   * 특정 테이블의 컬럼 정보 조회
   */
  static async getTableColumns(req: AuthenticatedRequest, res: Response) {
    try {
      const { type, id, tableName } = req.params;
      
      if (type !== 'internal' && type !== 'external') {
        return res.status(400).json({
          success: false,
          message: "올바른 연결 타입을 지정해주세요. (internal 또는 external)"
        });
      }

      const connectionId = type === 'external' ? Number(id) : undefined;
      const result = await BatchManagementService.getTableColumns(type, connectionId, tableName);
      
      if (result.success) {
        return res.json(result);
      } else {
        return res.status(500).json(result);
      }
    } catch (error) {
      console.error("컬럼 정보 조회 오류:", error);
      return res.status(500).json({
        success: false,
        message: "컬럼 정보 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }

  /**
   * 배치 설정 생성
   * POST /api/batch-management/batch-configs
   */
  static async createBatchConfig(req: AuthenticatedRequest, res: Response) {
    try {
      const { batchName, description, cronSchedule, mappings, isActive } = req.body;
      
      if (!batchName || !cronSchedule || !mappings || !Array.isArray(mappings)) {
        return res.status(400).json({
          success: false,
          message: "필수 필드가 누락되었습니다. (batchName, cronSchedule, mappings)"
        });
      }

      const batchConfig = await BatchService.createBatchConfig({
        batchName,
        description,
        cronSchedule,
        mappings,
        isActive: isActive !== undefined ? isActive : true
      } as CreateBatchConfigRequest);
      
      return res.status(201).json({
        success: true,
        data: batchConfig,
        message: "배치 설정이 성공적으로 생성되었습니다."
      });
    } catch (error) {
      console.error("배치 설정 생성 오류:", error);
      return res.status(500).json({
        success: false,
        message: "배치 설정 생성에 실패했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }

  /**
   * 배치 설정 목록 조회
   * GET /api/batch-management/batch-configs
   */
  static async getBatchConfigs(req: AuthenticatedRequest, res: Response) {
    try {
      const { page = 1, limit = 10, search, isActive } = req.query;
      
      const filter = {
        page: Number(page),
        limit: Number(limit),
        search: search as string,
        is_active: isActive as string
      };

      const result = await BatchService.getBatchConfigs(filter);
      
      res.json({
        success: true,
        data: result.data,
        pagination: result.pagination
      });
    } catch (error) {
      console.error("배치 설정 목록 조회 오류:", error);
      res.status(500).json({
        success: false,
        message: "배치 설정 목록 조회에 실패했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }

  /**
   * 배치 수동 실행
   * POST /api/batch-management/batch-configs/:id/execute
   */
  static async executeBatchConfig(req: AuthenticatedRequest, res: Response) {
    try {
      const { id } = req.params;
      
      if (!id || isNaN(Number(id))) {
        return res.status(400).json({
          success: false,
          message: "올바른 배치 설정 ID를 제공해주세요."
        });
      }

      // 배치 설정 조회
      const batchConfigResult = await BatchService.getBatchConfigById(Number(id));
      if (!batchConfigResult.success || !batchConfigResult.data) {
        return res.status(404).json({
          success: false,
          message: "배치 설정을 찾을 수 없습니다."
        });
      }

      const batchConfig = batchConfigResult.data as BatchConfig;

      // 배치 실행 로직 (간단한 버전)
      const startTime = new Date();
      let totalRecords = 0;
      let successRecords = 0;
      let failedRecords = 0;

      try {
        console.log(`배치 실행 시작: ${batchConfig.batch_name} (ID: ${id})`);

        // 실행 로그 생성
        const executionLog = await BatchService.createExecutionLog({
          batch_config_id: Number(id),
          execution_status: 'RUNNING',
          start_time: startTime,
          total_records: 0,
          success_records: 0,
          failed_records: 0
        });

        // 실제 배치 실행 (매핑이 있는 경우)
        if (batchConfig.batch_mappings && batchConfig.batch_mappings.length > 0) {
          // 테이블별로 매핑을 그룹화
          const tableGroups = new Map<string, typeof batchConfig.batch_mappings>();
          
          for (const mapping of batchConfig.batch_mappings) {
            const key = `${mapping.from_connection_type}:${mapping.from_connection_id || 'internal'}:${mapping.from_table_name}`;
            if (!tableGroups.has(key)) {
              tableGroups.set(key, []);
            }
            tableGroups.get(key)!.push(mapping);
          }

          // 각 테이블 그룹별로 처리
          for (const [tableKey, mappings] of tableGroups) {
            try {
              const firstMapping = mappings[0];
              console.log(`테이블 처리 시작: ${tableKey} -> ${mappings.length}개 컬럼 매핑`);
              
              // FROM 테이블에서 매핑된 컬럼들만 조회
              const fromColumns = mappings.map(m => m.from_column_name);
              const fromData = await BatchService.getDataFromTableWithColumns(
                firstMapping.from_table_name,
                fromColumns,
                firstMapping.from_connection_type as 'internal' | 'external',
                firstMapping.from_connection_id || undefined
              );
              totalRecords += fromData.length;

              // 컬럼 매핑 적용하여 TO 테이블 형식으로 변환
              const mappedData = fromData.map(row => {
                const mappedRow: any = {};
                for (const mapping of mappings) {
                  mappedRow[mapping.to_column_name] = row[mapping.from_column_name];
                }
                return mappedRow;
              });

              // TO 테이블에 데이터 삽입
              const insertResult = await BatchService.insertDataToTable(
                firstMapping.to_table_name,
                mappedData,
                firstMapping.to_connection_type as 'internal' | 'external',
                firstMapping.to_connection_id || undefined
              );
              successRecords += insertResult.successCount;
              failedRecords += insertResult.failedCount;

              console.log(`테이블 처리 완료: ${insertResult.successCount}개 성공, ${insertResult.failedCount}개 실패`);
            } catch (error) {
              console.error(`테이블 처리 실패: ${tableKey}`, error);
              failedRecords += 1;
            }
          }
        } else {
          console.log("매핑이 없어서 데이터 처리를 건너뜁니다.");
        }

        // 실행 로그 업데이트 (성공)
        await BatchService.updateExecutionLog(executionLog.id, {
          execution_status: 'SUCCESS',
          end_time: new Date(),
          duration_ms: Date.now() - startTime.getTime(),
          total_records: totalRecords,
          success_records: successRecords,
          failed_records: failedRecords
        });

        return res.json({
          success: true,
          message: "배치가 성공적으로 실행되었습니다.",
          data: {
            batchId: id,
            totalRecords,
            successRecords,
            failedRecords,
            duration: Date.now() - startTime.getTime()
          }
        });
      } catch (error) {
        console.error(`배치 실행 실패: ${batchConfig.batch_name}`, error);
        
        return res.status(500).json({
          success: false,
          message: "배치 실행에 실패했습니다.",
          error: error instanceof Error ? error.message : "알 수 없는 오류"
        });
      }
    } catch (error) {
      console.error("배치 실행 오류:", error);
      return res.status(500).json({
        success: false,
        message: "배치 실행 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }

  /**
   * 배치 설정 업데이트
   * PUT /api/batch-management/batch-configs/:id
   */
  static async updateBatchConfig(req: AuthenticatedRequest, res: Response) {
    try {
      const { id } = req.params;
      const updateData = req.body;

      if (!id || isNaN(Number(id))) {
        return res.status(400).json({
          success: false,
          message: "올바른 배치 설정 ID를 제공해주세요."
        });
      }

      const batchConfig = await BatchService.updateBatchConfig(Number(id), updateData);
      
      // 스케줄러에서 배치 스케줄 업데이트
      await BatchSchedulerService.updateBatchSchedule(Number(id));
      
      return res.json({
        success: true,
        data: batchConfig,
        message: "배치 설정이 성공적으로 업데이트되었습니다."
      });
    } catch (error) {
      console.error("배치 설정 업데이트 오류:", error);
      return res.status(500).json({
        success: false,
        message: "배치 설정 업데이트에 실패했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류"
      });
    }
  }
}