package com.kamco.cd.kamcoback.geojson.controller;

import com.kamco.cd.kamcoback.geojson.service.GeoJsonFileMonitorService;
import com.kamco.cd.kamcoback.geojson.service.GeometryConversionService;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

/** GeoJSON 파일 모니터링 및 처리 API 컨트롤러 */
@Slf4j
@RequiredArgsConstructor
public class GeoJsonMonitorController {

  private final GeoJsonFileMonitorService monitorService;
  private final GeometryConversionService geometryConversionService;

  /** 모니터링 상태 조회 */
  @GetMapping("/monitor/status")
  public Map<String, Object> getMonitorStatus() {
    return monitorService.getMonitorStatus();
  }

  /** 시스템 통계 정보 조회 */
  @GetMapping("/monitor/stats")
  public ResponseEntity<Map<String, Object>> getSystemStats() {
    try {
      Map<String, Object> stats = monitorService.getSystemStats();
      return ResponseEntity.ok(stats);
    } catch (Exception e) {
      log.error("시스템 통계 조회 실패", e);
      return ResponseEntity.internalServerError()
          .body(Map.of("error", "시스템 통계 조회 실패: " + e.getMessage(), "status", "error"));
    }
  }

  /** 디렉토리 초기화 (수동 실행) */
  @PostMapping("/monitor/init-directories")
  public ResponseEntity<Map<String, Object>> initializeDirectories() {
    try {
      log.info("디렉토리 초기화 수동 실행 요청");
      monitorService.initializeDirectoriesManually();

      return ResponseEntity.ok(
          Map.of(
              "message", "디렉토리 초기화가 완료되었습니다.",
              "status", "success"));
    } catch (Exception e) {
      log.error("디렉토리 초기화 실패", e);
      return ResponseEntity.internalServerError()
          .body(Map.of("error", "디렉토리 초기화 실패: " + e.getMessage(), "status", "error"));
    }
  }

  /** 수동으로 특정 파일 처리 */
  @PostMapping("/process/file")
  public ResponseEntity<Map<String, Object>> processFileManually(@RequestParam String filePath) {
    try {
      log.info("수동 파일 처리 요청: {}", filePath);
      monitorService.processFileManually(filePath);

      return ResponseEntity.ok(
          Map.of(
              "message", "파일 처리가 완료되었습니다.",
              "filePath", filePath,
              "status", "success"));
    } catch (Exception e) {
      log.error("수동 파일 처리 실패: {}", filePath, e);
      return ResponseEntity.internalServerError()
          .body(
              Map.of(
                  "error", "파일 처리 실패: " + e.getMessage(), "filePath", filePath, "status", "error"));
    }
  }

  /** 미처리된 Geometry 데이터 수동 변환 */
  @PostMapping("/process/geometry")
  public ResponseEntity<Map<String, Object>> processUnprocessedGeometry() {
    try {
      log.info("미처리 Geometry 변환 수동 실행 요청");
      List<Long> processedIds = geometryConversionService.processUnprocessedLearnData();

      return ResponseEntity.ok(
          Map.of(
              "message",
              "Geometry 변환이 완료되었습니다.",
              "processedCount",
              processedIds.size(),
              "processedIds",
              processedIds,
              "status",
              "success"));
    } catch (Exception e) {
      log.error("Geometry 변환 실패", e);
      return ResponseEntity.internalServerError()
          .body(Map.of("error", "Geometry 변환 실패: " + e.getMessage(), "status", "error"));
    }
  }

  /** 특정 학습 데이터의 Geometry 변환 */
  @PostMapping("/process/geometry/convert")
  public ResponseEntity<Map<String, Object>> convertSpecificGeometry(
      @RequestBody List<Long> learnDataIds) {
    try {
      if (learnDataIds == null || learnDataIds.isEmpty()) {
        return ResponseEntity.badRequest().body(Map.of("error", "변환할 학습 데이터 ID가 없습니다."));
      }

      log.info("특정 학습 데이터 Geometry 변환 요청: {}", learnDataIds);
      List<Long> geometryIds = geometryConversionService.convertToGeometryData(learnDataIds);

      return ResponseEntity.ok(
          Map.of(
              "message",
              "Geometry 변환이 완료되었습니다.",
              "inputCount",
              learnDataIds.size(),
              "outputCount",
              geometryIds.size(),
              "geometryIds",
              geometryIds,
              "status",
              "success"));
    } catch (Exception e) {
      log.error("특정 Geometry 변환 실패: {}", learnDataIds, e);
      return ResponseEntity.internalServerError()
          .body(Map.of("error", "Geometry 변환 실패: " + e.getMessage(), "status", "error"));
    }
  }
}
