// 나쁜 예시: 서비스 레이어에 상태 전이 로직이 흩어짐
public void processNextStep(Long jobId) {
    AnalysisJob job = jobRepository.findById(jobId);
 
    // 상태 전이 조건을 서비스가 직접 판단
    if (job.getAnalysisStatus() == AnalysisStatus.PENDING) {
        job.setAnalysisStatus(AnalysisStatus.PROCESSING);
        job.setAnalysisStep(AnalysisStep.EXTRACT_DOCUMENT);
    } else if (job.getAnalysisStatus() == AnalysisStatus.PROCESSING
            && job.getAnalysisStep() == AnalysisStep.EXTRACT_DOCUMENT) {
        job.setAnalysisStep(AnalysisStep.RECALL_CANDIDATE);
    } else if (job.getAnalysisStatus() == AnalysisStatus.PROCESSING
            && job.getAnalysisStep() == AnalysisStep.RECALL_CANDIDATE) {
        job.setAnalysisStep(AnalysisStep.CHECK_DUPLICATE);
    } else {
        throw new IllegalStateException("Cannot transition");
    }
    // ...
}

public enum AnalysisStatus {
    PENDING("대기 중"),
    PROCESSING("처리 중"),
    COMPLETED("분석 완료"),
    FAILED("분석 실패");
 
    private final String description;
 
    // 허용된 상태 전이 규칙을 Enum 내부에 선언
    private static final Map<AnalysisStatus, Set<AnalysisStatus>> TRANSITIONS = Map.of(
        PENDING,    Set.of(PROCESSING, FAILED),
        PROCESSING, Set.of(PROCESSING, COMPLETED, FAILED),
        COMPLETED,  Set.of(),
        FAILED,     Set.of(PROCESSING)   // 재시도 허용
    );
 
    public void validateTransition(final AnalysisStatus nextStatus) {
        if (!canTransitionTo(nextStatus)) {
            throw new IllegalStateException(
                "Invalid status transition from " + this + " to " + nextStatus
            );
        }
    }
 
    public boolean canTransitionTo(final AnalysisStatus nextStatus) {
        if (this == nextStatus) return true;
        return TRANSITIONS.getOrDefault(this, Collections.emptySet()).contains(nextStatus);
    }
}

public enum AnalysisStep {
    EXTRACT_DOCUMENT("문서 내용 추출"),
    RECALL_CANDIDATE("이미지 후보 추출"),
    CHECK_DUPLICATE("이미지 표절 검사");
 
    private static final Map<AnalysisStep, Set<AnalysisStep>> TRANSITIONS = Map.of(
        EXTRACT_DOCUMENT, Set.of(EXTRACT_DOCUMENT, RECALL_CANDIDATE),
        RECALL_CANDIDATE, Set.of(RECALL_CANDIDATE, CHECK_DUPLICATE),
        CHECK_DUPLICATE,  Set.of(CHECK_DUPLICATE, EXTRACT_DOCUMENT) // 재시작 허용
    );
 
    public void validateTransition(final AnalysisStep nextStep) {
        if (!canTransitionTo(nextStep)) {
            throw new IllegalStateException(
                "Invalid analysis step transition from " + this + " to " + nextStep
            );
        }
    }
 
    public boolean canTransitionTo(final AnalysisStep nextStep) {
        if (this == nextStep) return true;
        return TRANSITIONS.getOrDefault(this, Collections.emptySet()).contains(nextStep);
    }
}

public class AnalysisJob {
    private Long id;
    private Long documentId;
    private String documentKey;
    private DocumentMeta documentMeta;
    private AnalysisStep analysisStep;
    private AnalysisStatus analysisStatus;
    private String errorMessage;
 
    public static AnalysisJob createNew(
            final Long documentId,
            final DocumentMeta documentMeta) {
        return AnalysisJob.builder()
                .documentId(documentId)
                .documentKey(documentMeta.getDocumentKey())
                .documentMeta(documentMeta)
                .analysisStatus(AnalysisStatus.PENDING)      // 초기 상태 고정
                .analysisStep(AnalysisStep.EXTRACT_DOCUMENT)  // 첫 단계 고정
                .build();
    }
 
    // 정상 상태 전이
    public void updateStatus(
            final AnalysisStatus analysisStatus,
            final AnalysisStep analysisStep) {
        // 도메인 규칙 검증을 Enum에 위임
        this.analysisStatus.validateTransition(analysisStatus);
        this.analysisStep.validateTransition(analysisStep);
        this.analysisStatus = analysisStatus;
        this.analysisStep = analysisStep;
    }
 
    // 실패 상태 전이
    public void updateFailStatus(
            final AnalysisStep analysisStep,
            final String errorMessage) {
        this.analysisStep.validateTransition(analysisStep);
        this.analysisStatus = AnalysisStatus.FAILED;
        this.analysisStep = analysisStep;
        this.errorMessage = errorMessage;
    }
 
    public boolean isInProgress() {
        return this.analysisStatus == AnalysisStatus.PENDING
            || this.analysisStatus == AnalysisStatus.PROCESSING;
    }
}

// 서비스 코드 (간략화)
public void completeExtraction(Long jobId) {
    AnalysisJob job = jobRepository.findById(jobId)
        .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND));
 
    // 서비스는 "무엇을 할지"만 지시한다.
    // "할 수 있는지"는 도메인이 판단한다.
    job.updateStatus(AnalysisStatus.PROCESSING, AnalysisStep.RECALL_CANDIDATE);
 
    jobRepository.save(job);
}

@Test
void 유효한_상태_전이는_허용된다() {
    assertDoesNotThrow(() ->
        AnalysisStatus.PENDING.validateTransition(AnalysisStatus.PROCESSING)
    );
}
 
@Test
void 완료_상태에서_다른_상태로_전이하면_예외가_발생한다() {
    assertThrows(IllegalStateException.class, () ->
        AnalysisStatus.COMPLETED.validateTransition(AnalysisStatus.PROCESSING)
    );
}