package com.kamco.cd.training.train.service;

import com.kamco.cd.training.postgres.core.ModelTrainJobCoreService;
import com.kamco.cd.training.postgres.core.ModelTrainMngCoreService;
import com.kamco.cd.training.train.dto.DockerInspectState;
import com.kamco.cd.training.train.dto.ModelTrainJobDto;
import com.kamco.cd.training.train.dto.OutputResult;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.annotation.Profile;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

/**
 * 서버 재기동 시 "RUNNING 상태로 남아있는 학습 Job"을 복구(정리)하기 위한 서비스.
 *
 * <p>상황 예시: - 서버가 강제 재기동/장애로 내려감 - DB 상에서는 job_state가 RUNNING(진행중)으로 남아있음 - 실제 docker 컨테이너는: 1) 아직
 * 살아있거나(running=true) 2) 종료되었거나(exited) 3) --rm 옵션으로 인해 컨테이너가 이미 삭제되어 존재하지 않을 수 있음
 *
 * <p>이 클래스는 ApplicationReadyEvent(스프링 부팅 완료) 시점에 실행되어, DB의 RUNNING 잡들을 조회한 뒤 컨테이너 상태를 점검하고,
 * SUCCESS/FAILED 처리를 수행합니다.
 */
@Profile("!local")
@Component
@RequiredArgsConstructor
@Log4j2
public class JobRecoveryOnStartupService {

  private final ModelTrainJobCoreService modelTrainJobCoreService;
  private final ModelTrainMngCoreService modelTrainMngCoreService;
  private final ModelTrainMetricsJobService modelTrainMetricsJobService;
  private final TrainUtilService trainUtilService;

  /**
   * 스프링 부팅 완료 시점(빈 생성/초기화 모두 끝난 뒤)에 복구 로직 실행.
   *
   * <p>@Transactional: - recover() 메서드 전체가 하나의 트랜잭션으로 감싸집니다. - Job 하나씩 처리하다가 예외가 발생하면 전체 롤백이 될 수
   * 있으므로 "잡 단위로 확실히 커밋"이 필요하면 (권장) 잡 단위로 분리 트랜잭션(REQUIRES_NEW) 고려하세요.
   */
  @EventListener(ApplicationReadyEvent.class)
  @Transactional
  public void recover() {

    // 1) DB에서 "RUNNING(진행중) 상태"로 남아있는 job 목록을 조회
    List<ModelTrainJobDto> runningJobs = modelTrainJobCoreService.findRunningJobs();

    // 실행중 job이 없으면 할 일 없음
    if (runningJobs == null || runningJobs.isEmpty()) {
      return;
    }

    // 2) 각 job에 대해 docker 컨테이너 상태를 확인하고, 상태에 따라 조치
    for (ModelTrainJobDto job : runningJobs) {
      String containerName = job.getContainerName();

      try {
        // 2-1) docker inspect로 컨테이너 상태 조회
        DockerInspectState state = trainUtilService.inspectContainer(containerName);

        // 3) 컨테이너가 "없음"
        //    - docker run --rm 로 실행한 컨테이너는 정상 종료 시 바로 삭제될 수 있음
        //    - 즉 "컨테이너 없음"이 무조건 실패는 아님
        if (!state.exists()) {
          log.warn(
              "[RECOVERY] container missing. try file-based reconcile. container={}",
              containerName);

          // 3-1) 컨테이너가 없을 때는 산출물(responseDir)을 보고 완료 여부를 "추정"
          OutputResult out = trainUtilService.probeOutputs(job);

          // 3-2) 산출물이 충분하면 성공 처리
          if (out.completed()) {
            log.info("[RECOVERY] outputs look completed. mark SUCCESS. jobId={}", job.getId());
            modelTrainJobCoreService.markSuccess(job.getId(), 0);
            // model 상태 변경
            markStepSuccessByJobType(job);
            // 결과 csv 파일 정보 등록
            modelTrainMetricsJobService.findTrainValidMetricCsvFiles();

          } else {

            // 3-3) 산출물이 부족하면 중단처리
            // 산출물이 부족하면 "중단/보류"로 처리
            // 운영자가 재시작 할 수 있게 한다.
            log.warn(
                "[RECOVERY] outputs incomplete. mark PAUSED/STOP for restart. jobId={} reason={}",
                job.getId(),
                out.reason());

            //  PAUSED/STOP
            modelTrainJobCoreService.markPaused(
                job.getId(), -1, "SERVER_RESTART_CONTAINER_MISSING_OUTPUT_INCOMPLETE");

            // 모델도 에러가 아니라 STOP으로
            markStepStopByJobType(
                job, "SERVER_RESTART_CONTAINER_MISSING_OUTPUT_INCOMPLETE: " + out.reason());
          }
          continue;
        }

        // 4) 컨테이너는 존재하고, 아직 running=true
        //    - 서버만 재기동됐고 컨테이너는 그대로 살아있는 케이스
        //    - 실행중 docker 를 kill 하고 이어하기를 한다,
        if (state.running()) {
          log.warn("[RECOVERY] container still running. force kill. container={}", containerName);

          try {
            // ============================================================
            // 1) docker kill (SIGKILL) 바로 전송
            //    - kill은 즉시 종료
            // ============================================================
            ProcessBuilder pb = new ProcessBuilder("docker", "kill", containerName);
            pb.redirectErrorStream(true);

            Process p = pb.start();

            boolean finished = p.waitFor(20, TimeUnit.SECONDS);
            if (!finished) {
              p.destroyForcibly();
              throw new IOException("docker kill timeout");
            }

            int code = p.exitValue();
            if (code != 0) {
              throw new IOException("docker kill failed. exit=" + code);
            }

            // ============================================================
            // 2) kill 후 실제로 죽었는지 확인
            // ============================================================
            DockerInspectState after = trainUtilService.inspectContainer(containerName);
            if (after.exists() && after.running()) {
              throw new IOException("docker kill returned 0 but container still running");
            }

            log.info("[RECOVERY] container killed successfully. container={}", containerName);

            // ============================================================
            // 3) job 상태를 PAUSED로 변경 (서버 재기동으로 강제 중단)
            // ============================================================

            modelTrainJobCoreService.markPaused(job.getId(), -1, "AUTO_KILLED_ON_SERVER_RESTART");

            log.info("job = {}", job);
            markStepStopByJobType(job, "AUTO_KILLED_ON_SERVER_RESTART");

          } catch (Exception e) {

            log.error("[RECOVERY] docker kill failed. container={}", containerName, e);

            modelTrainJobCoreService.markFailed(
                job.getId(), -1, "AUTO_KILL_FAILED_ON_SERVER_RESTART");

            markStepErrorByJobType(job, "AUTO_KILL_FAILED_ON_SERVER_RESTART");
          }

          continue;
        }

        // 5) 컨테이너는 존재하지만 running=false
        //    - exited / dead 등의 상태
        Integer exitCode = state.exitCode();
        String status = state.status();

        // 5-1) exitCode=0이면 정상 종료로 간주 → SUCCESS 처리
        if (exitCode != null && exitCode == 0) {
          log.info("[RECOVERY] container exited(0). mark SUCCESS. container={}", containerName);
          modelTrainJobCoreService.markSuccess(job.getId(), 0);
          // model 상태 변경
          markStepSuccessByJobType(job);
          // 결과 csv 파일 정보 등록
          modelTrainMetricsJobService.findTrainValidMetricCsvFiles();

        } else {
          // 5-2) exitCode != 0 이거나 null이면 실패로 간주 → FAILED 처리
          log.warn(
              "[RECOVERY] container exited non-zero. mark FAILED. container={} status={} exitCode={}",
              containerName,
              status,
              exitCode);

          modelTrainJobCoreService.markFailed(
              job.getId(), exitCode, "SERVER_RESTART_CONTAINER_EXIT_NONZERO");
          // model 상태 변경
          markStepErrorByJobType(job, "exit=" + exitCode + " status=" + status);
        }

      } catch (Exception e) {
        // 6) docker inspect 자체가 실패한 경우
        //    - docker 데몬 문제/권한 문제/일시적 오류 가능
        //    - 운영 정책에 따라 "바로 실패" 대신 "유예" 처리도 고려 가능
        log.error("[RECOVERY] container inspect failed. container={}", containerName, e);

        modelTrainJobCoreService.markFailed(
            job.getId(), -1, "SERVER_RESTART_CONTAINER_INSPECT_ERROR");
        // model 상태 변경
        markStepErrorByJobType(job, "inspect-error");
      }
    }
  }

  /**
   * jobType에 따라 학습 관리 테이블의 "성공 단계"를 업데이트.
   *
   * <p>예: - jobType == "EVAL" → step2(평가 단계) 성공 - 그 외 → step1(학습 단계) 성공
   */
  private void markStepSuccessByJobType(ModelTrainJobDto job) {
    Map<String, Object> params = job.getParamsJson();
    boolean isEval = params != null && "EVAL".equals(String.valueOf(params.get("jobType")));
    if (isEval) {
      modelTrainMngCoreService.markStep2Success(job.getModelId());
    } else {
      modelTrainMngCoreService.markStep1Success(job.getModelId());
    }
  }

  /**
   * jobType에 따라 학습 관리 테이블의 "에러 단계"를 업데이트.
   *
   * <p>예: - jobType == "EVAL" → step2(평가 단계) 에러 - 그 외 → step1 혹은 전체 에러
   */
  private void markStepStopByJobType(ModelTrainJobDto job, String msg) {
    Map<String, Object> params = job.getParamsJson();
    boolean isEval = params != null && "EVAL".equals(String.valueOf(params.get("jobType")));
    if (isEval) {
      modelTrainMngCoreService.markStep2Stop(job.getModelId(), msg);
    } else {
      modelTrainMngCoreService.markStep1Stop(job.getModelId(), msg);
    }
  }

  private void markStepErrorByJobType(ModelTrainJobDto job, String msg) {
    Map<String, Object> params = job.getParamsJson();
    boolean isEval = params != null && "EVAL".equals(String.valueOf(params.get("jobType")));
    if (isEval) {
      modelTrainMngCoreService.markStep2Error(job.getModelId(), msg);
    } else {
      modelTrainMngCoreService.markError(job.getModelId(), msg);
    }
  }
}
