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

import com.kamco.cd.training.model.dto.ModelTrainMngDto;
import com.kamco.cd.training.postgres.core.ModelTrainJobCoreService;
import com.kamco.cd.training.postgres.core.ModelTrainMngCoreService;
import com.kamco.cd.training.train.dto.ModelTrainJobDto;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Value;
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;

  /**
   * Docker 컨테이너가 쓰는 response(산출물) 디렉토리의 "호스트 측" 베이스 경로. 예) /data/train/response
   *
   * <p>컨테이너가 --rm 으로 삭제된 경우에도 이 경로에 val.csv / *.pth 등이 남아있으면 정상 종료 여부를 "파일 기반"으로 판정합니다.
   */
  @Value("${train.docker.responseDir}")
  private String responseDir;

  /**
   * 스프링 부팅 완료 시점(빈 생성/초기화 모두 끝난 뒤)에 복구 로직 실행.
   *
   * <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 = 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 = 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());

            Integer modelId = job.getModelId() == null ? null : Math.toIntExact(job.getModelId());

            //  PAUSED/STOP
            modelTrainJobCoreService.markPaused(
                job.getId(), modelId, "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 = 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로 변경 (서버 재기동으로 강제 중단)
            // ============================================================
            Integer modelId = job.getModelId() == null ? null : Math.toIntExact(job.getModelId());

            modelTrainJobCoreService.markPaused(
                job.getId(), modelId, "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);
    }
  }

  /**
   * docker inspect를 사용해서 컨테이너 상태를 조회합니다.
   *
   * <p>사용하는 템플릿: {{.State.Status}} {{.State.Running}} {{.State.ExitCode}}
   *
   * <p>예상 출력 예: - "running true 0" - "exited false 0" - "exited false 137"
   *
   * <p>주의: - 컨테이너가 없거나 inspect 실패 시 exitCode != 0 또는 output이 비어서 missing() 반환 - 무한 대기 방지를 위해 5초
   * 타임아웃을 둠
   */
  private DockerInspectState inspectContainer(String containerName)
      throws IOException, InterruptedException {

    ProcessBuilder pb =
        new ProcessBuilder(
            "docker",
            "inspect",
            "-f",
            "{{.State.Status}} {{.State.Running}} {{.State.ExitCode}}",
            containerName);

    // stderr를 stdout으로 합쳐서 한 스트림으로 읽기(에러 메시지도 함께 받음)
    pb.redirectErrorStream(true);

    Process p = pb.start();

    // inspect 출력은 1줄이면 충분하므로 readLine()만 수행
    String output;
    try (BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()))) {
      output = br.readLine();
    }

    // 무한대기 방지: 5초 내에 종료되지 않으면 강제 종료
    boolean finished = p.waitFor(5, TimeUnit.SECONDS);
    if (!finished) {
      p.destroyForcibly();
      throw new IOException("docker inspect timeout");
    }

    // docker inspect 자체의 프로세스 exit code
    int code = p.exitValue();

    // 실패(코드 !=0) 또는 출력이 없으면 "컨테이너 없음"으로 간주
    if (code != 0 || output == null || output.isBlank()) {
      return DockerInspectState.missing();
    }

    // "status running exitCode" 형태로 split
    String[] parts = output.trim().split("\\s+");

    // status: running/exited/dead 등
    String status = parts.length > 0 ? parts[0] : "unknown";

    // running: true/false
    boolean running = parts.length > 1 && Boolean.parseBoolean(parts[1]);

    // exitCode: 정수 파싱(파싱 실패하면 null)
    Integer exitCode = null;
    if (parts.length > 2) {
      try {
        exitCode = Integer.parseInt(parts[2]);
      } catch (Exception ignore) {
        // ignore
      }
    }

    return new DockerInspectState(true, running, exitCode, status);
  }

  /**
   * docker inspect 결과를 담는 레코드.
   *
   * <p>exists: - true : docker inspect 성공 (컨테이너 존재) - false : 컨테이너 없음(또는 inspect 실패를 missing으로 간주)
   */
  private record DockerInspectState(
      boolean exists, boolean running, Integer exitCode, String status) {
    static DockerInspectState missing() {
      return new DockerInspectState(false, false, null, "missing");
    }
  }

  // ============================================================================================
  // 컨테이너가 "없을 때" 파일 기반으로 완료/미완료를 판정하는 로직
  // ============================================================================================

  /**
   * 컨테이너가 없을 때(responseDir 산출물만 남아있는 상태) 완료 여부를 파일 기반으로 판정합니다.
   *
   * <p>판정 규칙(보수적으로 설계): 1) total_epoch가 paramsJson에 있어야 함 (없으면 완료 판단 불가) 2) val.csv 존재 + 헤더 제외 라인 수
   * >= total_epoch 이어야 함 3) *.pth 파일이 total_epoch 이상 존재하거나, best*.pth(또는 *best*.pth)가 존재해야 함
   *
   * <p>왜 이렇게? - 어떤 학습은 epoch마다 pth를 남기고 - 어떤 학습은 best만 남기기도 해서 "pthCount >= total_epoch"만 쓰면 정상 종료를
   * 실패로 오판할 수 있음.
   */
  private OutputResult probeOutputs(ModelTrainJobDto job) {
    try {

      log.info(
          "[RECOVERY] probeOutputs start. jobId={}, modelId={}", job.getId(), job.getModelId());

      // 1) 출력 디렉토리 확인
      Path outDir = resolveOutputDir(job);
      if (outDir == null || !Files.isDirectory(outDir)) {
        log.warn("[RECOVERY] output directory missing. jobId={}, path={}", job.getId(), outDir);
        return new OutputResult(false, "output-dir-missing");
      }

      log.info("[RECOVERY] output directory found. jobId={}, path={}", job.getId(), outDir);

      // 2) totalEpoch 확인
      Integer totalEpoch = extractTotalEpoch(job).orElse(null);
      if (totalEpoch == null || totalEpoch <= 0) {
        log.warn(
            "[RECOVERY] totalEpoch missing or invalid. jobId={}, totalEpoch={}",
            job.getId(),
            totalEpoch);
        return new OutputResult(false, "total-epoch-missing");
      }

      log.info("[RECOVERY] totalEpoch={}. jobId={}", totalEpoch, job.getId());

      // 3) val.csv 존재 확인
      Path valCsv = outDir.resolve("val.csv");
      if (!Files.exists(valCsv)) {
        log.warn("[RECOVERY] val.csv missing. jobId={}, path={}", job.getId(), valCsv);
        return new OutputResult(false, "val.csv-missing");
      }

      // 4) val.csv 라인 수 확인
      long lines = countNonHeaderLines(valCsv);

      log.info(
          "[RECOVERY] val.csv lines counted. jobId={}, lines={}, expected={}",
          job.getId(),
          lines,
          totalEpoch);

      // 5) 완료 판정
      if (lines == totalEpoch) {
        log.info("[RECOVERY] outputs look COMPLETE. jobId={}", job.getId());
        return new OutputResult(true, "ok");
      }

      log.warn(
          "[RECOVERY] val.csv line mismatch. jobId={}, lines={}, expected={}",
          job.getId(),
          lines,
          totalEpoch);

      return new OutputResult(
          false, "val.csv-lines-mismatch lines=" + lines + " expected=" + totalEpoch);

    } catch (Exception e) {

      log.error("[RECOVERY] probeOutputs error. jobId={}", job.getId(), e);

      return new OutputResult(false, "probe-error");
    }
  }

  /**
   * responseDir 아래에서 job 산출물 디렉토리를 찾습니다.
   *
   * <p>가장 중요한 커스터마이징 포인트: - 실제 운영 환경에서 산출물이 어떤 경로 규칙으로 저장되는지에 따라 여기만 수정하면 됩니다.
   *
   * <p>현재 기본 탐색 순서: 1) {responseDir}/{jobId} 2) {responseDir}/{modelId} 3)
   * {responseDir}/{containerName} 4) 마지막 fallback: responseDir 자체
   *
   * <p>추천: - 여러분 규칙이 "{responseDir}/{modelId}/{jobId}" 같은 형태라면 base.resolve(modelId).resolve(jobId)
   * 형태를 1순위로 두세요.
   */
  private Path resolveOutputDir(ModelTrainJobDto job) {
    ModelTrainMngDto.Basic model = modelTrainMngCoreService.findModelById(job.getModelId());

    Path base = Paths.get(responseDir, model.getUuid().toString(), "metrics");

    return Files.isDirectory(base) ? base : null;
  }

  /**
   * paramsJson에서 total_epoch 값을 추출합니다.
   *
   * <p>키 후보: - "total_epoch" (snake_case) - "totalEpoch" (camelCase)
   *
   * <p>예: paramsJson = {"jobType":"TRAIN","total_epoch":50,...}
   */
  private Optional<Integer> extractTotalEpoch(ModelTrainJobDto job) {
    Map<String, Object> params = job.getParamsJson();
    if (params == null) return Optional.empty();

    Object v = params.get("total_epoch");
    if (v == null) v = params.get("totalEpoch");
    if (v == null) return Optional.empty();

    try {
      return Optional.of(Integer.parseInt(String.valueOf(v)));
    } catch (Exception ignore) {
      return Optional.empty();
    }
  }

  /**
   * CSV 파일에서 "헤더(첫 줄)"를 제외한 라인 수를 계산합니다.
   *
   * <p>가정: - val.csv 첫 줄은 헤더 - 이후 라인들이 epoch별 기록(또는 유사한 누적 기록)
   *
   * <p>주의: - 파일 인코딩은 UTF-8로 가정 - 빈 줄은 제외
   */
  private long countNonHeaderLines(Path csv) throws IOException {
    try (Stream<String> lines = Files.lines(csv, StandardCharsets.UTF_8)) {
      return lines.skip(1).filter(s -> s != null && !s.isBlank()).count();
    }
  }

  /**
   * 디렉토리에서 glob 패턴에 맞는 파일 수를 셉니다.
   *
   * <p>예: - "*.pth" - "best*.pth"
   */
  private long countFilesByGlob(Path dir, String glob) throws IOException {
    try (DirectoryStream<Path> ds = Files.newDirectoryStream(dir, glob)) {
      long cnt = 0;
      for (Path p : ds) {
        if (Files.isRegularFile(p)) cnt++;
      }
      return cnt;
    }
  }

  /** 디렉토리에서 glob 패턴에 맞는 파일이 "하나라도" 존재하는지 체크합니다. */
  private boolean existsByGlob(Path dir, String glob) throws IOException {
    try (DirectoryStream<Path> ds = Files.newDirectoryStream(dir, glob)) {
      return ds.iterator().hasNext();
    }
  }

  // ============================================================================================
  // probeOutputs() 결과 객체
  // ============================================================================================

  /**
   * 컨테이너가 없을 때(responseDir 기반) 완료 여부 판정 결과.
   *
   * <p>completed: - true : 산출물이 완료로 보임(성공 처리 가능) - false : 산출물이 부족/불명확(실패 또는 유예 판단)
   *
   * <p>reason: - 실패/미완료 사유(로그/DB 메시지로 남기기 용도)
   */
  private static final class OutputResult {

    private final boolean completed;
    private final String reason;

    private OutputResult(boolean completed, String reason) {
      this.completed = completed;
      this.reason = reason;
    }

    boolean completed() {
      return completed;
    }

    String reason() {
      return reason;
    }
  }
}
