#Step 05 — 재시도와 실패 처리

RetryOptions retry = RetryOptions.newBuilder()
        .setInitialInterval(Duration.ofSeconds(1))     // 첫 재시도까지 대기
        .setBackoffCoefficient(2.0)                    // 매 재시도마다 간격에 곱할 배수
        .setMaximumInterval(Duration.ofSeconds(100))   // 간격 상한
        .setMaximumAttempts(5)                         // 총 시도 횟수 (첫 시도 포함)
        .setDoNotRetry("InvalidCardError")             // 이 타입은 재시도하지 않음
        .build();

// 권장 형태 — 둘 중 하나는 반드시 있어야 합니다
ActivityOptions opts = ActivityOptions.newBuilder()
        .setStartToCloseTimeout(Duration.ofSeconds(10))   // 1회 실행의 상한
        .setScheduleToCloseTimeout(Duration.ofMinutes(5)) // 재시도 전체의 상한  ← 안전망
        .setRetryOptions(RetryOptions.newBuilder()
                .setMaximumAttempts(5)                    // 또는 이것            ← 안전망
                .build())
        .build();

// PaymentActivityImpl 안
@Override
public String charge(String orderId, long amount) {
    log.info("[{}] 결제 시도 amount={}", orderId, amount);
    throw new RuntimeException("payment gateway unreachable: connect timed out");
}

private final PaymentActivity payment = Workflow.newActivityStub(
        PaymentActivity.class,
        ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(5))   // 재시도 상한이 아무것도 없다
                .build());

// [5-4] 예외를 제대로 벗겨 내는 catch
try {
    payment.charge(req.orderId(), req.amount());
} catch (ActivityFailure af) {
    log.info("겉껍질  : {} / {}", af.getClass().getSimpleName(), af.getMessage());
    Throwable cause = af.getCause();
    log.info("한 겹 벗김: {} / {}", cause.getClass().getSimpleName(), cause.getMessage());
    if (cause instanceof ApplicationFailure appFailure) {
        log.info("원래 타입 : {} / 재시도 금지: {}",
                appFailure.getType(), appFailure.isNonRetryable());
    }
}

// [5-5] 재시도되는 실패 vs 재시도되지 않는 실패
@Override
public String charge(String orderId, long amount) {
    Account acct = accounts.get(orderId);

    if (acct == null) {   // 재시도 불가 — 계정이 없는 건 다시 해도 없다
        throw ApplicationFailure.newNonRetryableFailure(
                "account not found for order " + orderId, "AccountNotFoundError",
                orderId);                                    // details (가변 인자)
    }
    if (acct.balance() < amount) {   // 재시도 불가 — 잔액은 재시도로 늘지 않는다
        throw ApplicationFailure.newNonRetryableFailure(
                "insufficient balance", "InsufficientBalanceError",
                acct.balance(), amount);                     // details 2개
    }
    if (!gateway.isHealthy()) {      // 재시도 가치 있음 — 곧 돌아올 수 있다
        throw ApplicationFailure.newFailure(
                "gateway temporarily unavailable", "GatewayUnavailableError");
    }
    return gateway.charge(orderId, amount);
}

try {
    payment.charge(req.orderId(), req.amount());
} catch (ActivityFailure af) {
    if (af.getCause() instanceof ApplicationFailure appFailure
            && "InsufficientBalanceError".equals(appFailure.getType())) {
        long balance = appFailure.getDetails().get(0, Long.class);
        long needed  = appFailure.getDetails().get(1, Long.class);
        notification.notifyCustomer(req.orderId(),
                "잔액이 %,d원 부족합니다".formatted(needed - balance));
        return req.orderId() + " PAYMENT_DECLINED";
    }
    throw af;
}

ActivityOptions opts = ActivityOptions.newBuilder()
        .setStartToCloseTimeout(Duration.ofSeconds(10))
        .setRetryOptions(RetryOptions.newBuilder()
                .setMaximumAttempts(5)
                .setDoNotRetry(
                        "InvalidCardError",                       // ApplicationFailure 의 type
                        "java.lang.IllegalArgumentException")     // 일반 예외는 FQCN
                .build())
        .build();

WorkflowOptions options = WorkflowOptions.newBuilder()
        .setWorkflowId("order-5004")
        .setTaskQueue(ORDER_TASK_QUEUE)
        .setRetryOptions(RetryOptions.newBuilder()
                .setMaximumAttempts(3)
                .build())
        .build();

// 아무것도 안 하면 이것입니다
String paymentId = payment.charge(req.orderId(), req.amount());

// [5-8b] 주 배송사가 실패하면 대체 배송사로
String shipmentId;
try {
    shipmentId = shipping.requestShipment(req.orderId(), req.address());
} catch (ActivityFailure af) {
    log.warn("[{}] 주 배송사 실패, 대체 경로로 전환", req.orderId());
    shipmentId = backupShipping.requestShipment(req.orderId(), req.address());
}

// [5-8c] 이미 한 일을 되돌린다 (Step 09 에서 Saga 클래스로 정식화)
String paymentId = payment.charge(req.orderId(), req.amount());
try {
    String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
    try {
        return shipping.requestShipment(req.orderId(), req.address());
    } catch (ActivityFailure af) {
        inventory.release(reservationId);   // 재고 되돌리기
        throw af;
    }
} catch (ActivityFailure af) {
    payment.refund(paymentId);              // 결제 되돌리기
    throw af;
}

package com.example.order;

/*
 * Step 05 — 재시도와 실패 처리 / 실습 코드
 *
 * 실행 방법
 *   1) Temporal 서버 기동:  docker compose up -d        (temporalio/auto-setup:1.22.4)
 *   2) 절 단위 실행:
 *        ./gradlew run -PmainClass=com.example.order.Practice --args="5-2"
 *        ./gradlew run -PmainClass=com.example.order.Practice --args="5-3"
 *        ./gradlew run -PmainClass=com.example.order.Practice --args="5-4"
 *        ./gradlew run -PmainClass=com.example.order.Practice --args="5-5"
 *        ./gradlew run -PmainClass=com.example.order.Practice --args="5-8"
 *   3) 인자를 주지 않으면 [5-2] 백오프 시뮬레이터만 돌고 끝납니다.
 *
 * 환경
 *   Temporal Server 1.22.4 / Java SDK 1.22.3 / temporal CLI 0.11.0 / Java 21
 *   gRPC 127.0.0.1:7233 / Namespace default / Task Queue ORDER_TASK_QUEUE
 *
 * 주의
 *   [5-3] 은 "영원히 실패하는" 워크플로우를 띄웁니다. 관찰이 끝나면 반드시 정리하세요.
 *        temporal workflow terminate -w order-5001 --reason "실습 종료"
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowOptions;
import io.temporal.common.RetryOptions;
import io.temporal.failure.ActivityFailure;
import io.temporal.failure.ApplicationFailure;
import io.temporal.serviceclient.WorkflowServiceStubs;
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.slf4j.Logger;

import java.time.Duration;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

public class Practice {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    // 공통 DTO (코스 규격)
    public record OrderRequest(String orderId, String customerId, String sku,
                               int qty, long amount, String address) {}

    // ------------------------------------------------------------------
    // [5-2] 백오프 시뮬레이터 — Temporal 서버 없이 돌아가는 순수 계산
    //       본문 표의 "10번째 시도 = 누적 327초" 를 손으로 확인하는 용도입니다.
    //       coeff 를 1.0(고정 간격) / 3.0(급격한 백오프)으로 바꿔 보세요.
    // ------------------------------------------------------------------
    static void printBackoff(Duration initial, double coeff, Duration max, int attempts) {
        System.out.printf("initialInterval=%s backoffCoefficient=%.1f maximumInterval=%s%n",
                initial, coeff, max);
        long cumulative = 0;
        for (int n = 1; n <= attempts; n++) {
            long interval = Math.min(
                    (long) (initial.toMillis() * Math.pow(coeff, n - 1)),
                    max.toMillis());
            System.out.printf("attempt %2d 시작 t=%,6ds  (직전 대기 %,4ds)%n",
                    n, cumulative / 1000, n == 1 ? 0 : interval / 1000);
            cumulative += interval;
        }
        System.out.printf("→ %d회 시도까지 누적 대기 %,ds%n%n", attempts, cumulative / 1000);
    }

    // ------------------------------------------------------------------
    // 액티비티 인터페이스 (코스 규격 4종 중 이 스텝에서 쓰는 2종)
    // ------------------------------------------------------------------
    @ActivityInterface
    public interface PaymentActivity {
        @ActivityMethod String charge(String orderId, long amount);
        @ActivityMethod void refund(String paymentId);
    }

    @ActivityInterface
    public interface ShippingActivity {
        @ActivityMethod String requestShipment(String orderId, String address);
        @ActivityMethod void cancelShipment(String shipmentId);
    }

    // ------------------------------------------------------------------
    // [5-3] 항상 실패하는 결제 액티비티 — 무한 재시도를 눈으로 보기 위한 것
    // ------------------------------------------------------------------
    public static class AlwaysFailingPaymentActivityImpl implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(AlwaysFailingPaymentActivityImpl.class);

        @Override
        public String charge(String orderId, long amount) {
            log.info("[{}] 결제 시도 amount={}", orderId, amount);
            throw new RuntimeException("payment gateway unreachable: connect timed out");
        }

        @Override
        public void refund(String paymentId) { /* no-op */ }
    }

    // ------------------------------------------------------------------
    // [5-5] 실패 종류를 구분해서 던지는 결제 액티비티
    // ------------------------------------------------------------------
    public record Account(String customerId, long balance) {}

    public static class RealisticPaymentActivityImpl implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(RealisticPaymentActivityImpl.class);

        // orderId → 계정. 5003 은 잔액이 12,000원뿐입니다.
        private final Map<String, Account> accounts = Map.of(
                "5002", new Account("C-1", 12_000L),
                "5003", new Account("C-9", 12_000L),
                "5005", new Account("C-2", 999_000L),
                "5006", new Account("C-3", 999_000L));

        private final AtomicInteger gatewayCalls = new AtomicInteger();

        @Override
        public String charge(String orderId, long amount) {
            log.info("[{}] 결제 시도 amount={}", orderId, amount);
            Account acct = accounts.get(orderId);

            // (a) 재시도 불가 — 계정이 없는 것은 다시 해도 없습니다.
            if (acct == null) {
                throw ApplicationFailure.newNonRetryableFailure(
                        "account not found for order " + orderId,
                        "AccountNotFoundError",
                        orderId);
            }
            // (b) 재시도 불가 — 잔액은 재시도로 늘지 않습니다. details 로 숫자를 넘깁니다.
            if (acct.balance() < amount) {
                throw ApplicationFailure.newNonRetryableFailure(
                        "insufficient balance",
                        "InsufficientBalanceError",
                        acct.balance(), amount);
            }
            // (c) 재시도 가치 있음 — 처음 두 번은 게이트웨이 장애를 흉내 냅니다.
            if (gatewayCalls.incrementAndGet() <= 2) {
                throw ApplicationFailure.newFailure(
                        "gateway temporarily unavailable",
                        "GatewayUnavailableError");
            }
            String paymentId = "PAY-" + orderId;
            log.info("[{}] 결제 완료 {}", orderId, paymentId);
            return paymentId;
        }

        @Override
        public void refund(String paymentId) {
            log.info("결제 취소 {}", paymentId);
        }
    }

    // ------------------------------------------------------------------
    // [5-6] 재시도가 "안 먹는" 잘못된 구현 — 주석을 풀고 직접 확인해 보세요
    // ------------------------------------------------------------------
    public static class BrokenPaymentActivityImpl implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(BrokenPaymentActivityImpl.class);

        @Override
        public String charge(String orderId, long amount) {
            // (1) Error 를 던지면 액티비티 실패로 보고되지 않고
            //     StartToCloseTimeout 이 지날 때까지 아무 일도 일어나지 않습니다.
            //     주석을 풀고 describe 로 Attempt 가 언제 올라가는지 보세요.
            // throw new AssertionError("이러면 안 됩니다");

            // (2) 예외를 삼키고 정상 반환하면 재시도가 한 번도 일어나지 않습니다.
            //     ActivityTaskCompleted 가 기록되고 워크플로우는 결제됐다고 믿습니다.
            //     이 스텝에서 가장 위험한 함정입니다.
            try {
                throw new RuntimeException("payment gateway 500");
            } catch (Exception e) {
                log.error("결제 실패", e);
                return null;                // ← "성공"으로 완료됨. 올바른 코드는 throw e;
            }
        }

        @Override
        public void refund(String paymentId) { /* no-op */ }
    }

    // ------------------------------------------------------------------
    // 배송 액티비티 — 주 배송사는 항상 실패, 대체 배송사는 성공
    // ------------------------------------------------------------------
    public static class ShippingActivityImpl implements ShippingActivity {
        private static final Logger log = Workflow.getLogger(ShippingActivityImpl.class);

        @Override
        public String requestShipment(String orderId, String address) {
            log.warn("[{}] 배송 요청 실패", orderId);
            throw ApplicationFailure.newFailure("carrier 503", "CarrierUnavailableError");
        }

        @Override
        public void cancelShipment(String shipmentId) {
            log.info("배송 취소 {}", shipmentId);
        }
    }

    // ------------------------------------------------------------------
    // 워크플로우 인터페이스
    // ------------------------------------------------------------------
    @WorkflowInterface
    public interface OrderWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    // [5-3] RetryOptions 를 일부러 지정하지 않은 워크플로우 = 무한 재시도
    public static class InfiniteRetryWorkflowImpl implements OrderWorkflow {
        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class,
                ActivityOptions.newBuilder()
                        .setStartToCloseTimeout(Duration.ofSeconds(5))
                        // setRetryOptions 없음 → maximumAttempts=0 = 무제한
                        .build());

        @Override
        public String processOrder(OrderRequest req) {
            return req.orderId() + " " + payment.charge(req.orderId(), req.amount());
        }
    }

    // [5-4] 예외를 제대로 벗겨 내는 워크플로우
    public static class UnwrapWorkflowImpl implements OrderWorkflow {
        private static final Logger log = Workflow.getLogger(UnwrapWorkflowImpl.class);

        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class,
                ActivityOptions.newBuilder()
                        .setStartToCloseTimeout(Duration.ofSeconds(5))
                        .setRetryOptions(RetryOptions.newBuilder()
                                .setMaximumAttempts(2)
                                .build())
                        .build());

        @Override
        public String processOrder(OrderRequest req) {
            try {
                return payment.charge(req.orderId(), req.amount());
            } catch (ActivityFailure af) {
                unwrap(log, af);
                return req.orderId() + " PAYMENT_DECLINED";
            }
        }
    }

    /**
     * [5-4] 실무에서 그대로 복사해 쓸 수 있는 예외 해부 헬퍼.
     * ActivityFailure.getMessage() 는 언제나 "Activity task failed" 이므로
     * 반드시 getCause() 를 한 겹 벗겨야 원인이 보입니다.
     */
    static void unwrap(Logger log, ActivityFailure af) {
        log.info("겉껍질   : {} / {}", af.getClass().getSimpleName(), af.getMessage());

        Throwable cause = af.getCause();
        log.info("한 겹 벗김: {} / {}", cause.getClass().getSimpleName(), cause.getMessage());

        if (cause instanceof ApplicationFailure appFailure) {
            log.info("원래 타입 : {}", appFailure.getType());
            log.info("재시도 금지: {}", appFailure.isNonRetryable());
            if ("InsufficientBalanceError".equals(appFailure.getType())) {
                long balance = appFailure.getDetails().get(0, Long.class);
                long needed = appFailure.getDetails().get(1, Long.class);
                log.info("details   : 잔액 {}원, 필요 {}원, 부족 {}원",
                        balance, needed, needed - balance);
            }
        }
    }

    // ------------------------------------------------------------------
    // [5-8] 실패를 다루는 3가지 방식
    // ------------------------------------------------------------------

    // (1) 전파 — 아무것도 하지 않으면 워크플로우가 FAILED 로 끝납니다.
    public static class PropagateWorkflowImpl implements OrderWorkflow {
        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class, shortRetry());

        @Override
        public String processOrder(OrderRequest req) {
            String paymentId = payment.charge(req.orderId(), req.amount());
            return req.orderId() + " COMPLETED payment=" + paymentId;
        }
    }

    // (2) 대안 경로 — 주 배송사가 실패하면 대체 배송사로 전환합니다. 결과는 COMPLETED.
    public static class FallbackWorkflowImpl implements OrderWorkflow {
        private static final Logger log = Workflow.getLogger(FallbackWorkflowImpl.class);

        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class, shortRetry());
        private final ShippingActivity shipping = Workflow.newActivityStub(
                ShippingActivity.class, shortRetry());

        @Override
        public String processOrder(OrderRequest req) {
            payment.charge(req.orderId(), req.amount());
            String shipmentId;
            try {
                shipmentId = shipping.requestShipment(req.orderId(), req.address());
            } catch (ActivityFailure af) {
                log.warn("[{}] 주 배송사 실패, 대체 경로로 전환", req.orderId());
                shipmentId = "SHIP-BK-" + req.orderId();   // 대체 배송사 (여기선 즉시 성공)
            }
            log.info("[{}] 완료 shipmentId={}", req.orderId(), shipmentId);
            return req.orderId() + " COMPLETED shipment=" + shipmentId;
        }
    }

    // (3) 보상 — 이미 한 일을 되돌리고 다시 던집니다. 중첩이 깊어지는 것을 체감하세요.
    //     Step 09 에서 io.temporal.workflow.Saga 로 정식화합니다.
    public static class CompensateWorkflowImpl implements OrderWorkflow {
        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class, shortRetry());
        private final ShippingActivity shipping = Workflow.newActivityStub(
                ShippingActivity.class, shortRetry());

        @Override
        public String processOrder(OrderRequest req) {
            String paymentId = payment.charge(req.orderId(), req.amount());
            try {
                return shipping.requestShipment(req.orderId(), req.address());
            } catch (ActivityFailure af) {
                payment.refund(paymentId);   // 되돌리기
                throw af;                    // 그리고 다시 던져 워크플로우를 실패시킵니다
            }
        }
    }

    /** 실습이 오래 걸리지 않도록 재시도를 3회로 제한한 공통 옵션. */
    static ActivityOptions shortRetry() {
        return ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(5))
                .setScheduleToCloseTimeout(Duration.ofMinutes(1))   // 안전망
                .setRetryOptions(RetryOptions.newBuilder()
                        .setInitialInterval(Duration.ofMillis(200))
                        .setBackoffCoefficient(2.0)
                        .setMaximumAttempts(3)                      // 안전망
                        .build())
                .build();
    }

    // ------------------------------------------------------------------
    // 실행부
    // ------------------------------------------------------------------
    public static void main(String[] args) throws Exception {
        String section = args.length > 0 ? args[0] : "5-2";

        // [5-2] 는 서버가 필요 없습니다.
        if (section.equals("5-2")) {
            printBackoff(Duration.ofSeconds(1), 2.0, Duration.ofSeconds(100), 10);
            printBackoff(Duration.ofSeconds(1), 1.0, Duration.ofSeconds(100), 6);   // 고정 간격
            return;
        }

        WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();
        WorkflowClient client = WorkflowClient.newInstance(service);
        WorkerFactory factory = WorkerFactory.newInstance(client);
        Worker worker = factory.newWorker(TASK_QUEUE);

        String workflowId;
        OrderRequest req;

        switch (section) {
            case "5-3" -> {
                worker.registerWorkflowImplementationTypes(InfiniteRetryWorkflowImpl.class);
                worker.registerActivitiesImplementations(new AlwaysFailingPaymentActivityImpl());
                workflowId = "order-5001";
                req = new OrderRequest("5001", "C-1", "SKU-A", 1, 39_000, "서울시 강남구");
            }
            case "5-4" -> {
                worker.registerWorkflowImplementationTypes(UnwrapWorkflowImpl.class);
                worker.registerActivitiesImplementations(new RealisticPaymentActivityImpl());
                workflowId = "order-5002";
                req = new OrderRequest("5002", "C-1", "SKU-A", 1, 39_000, "서울시 강남구");
            }
            case "5-5" -> {
                worker.registerWorkflowImplementationTypes(PropagateWorkflowImpl.class);
                worker.registerActivitiesImplementations(new RealisticPaymentActivityImpl());
                workflowId = "order-5003";
                req = new OrderRequest("5003", "C-9", "SKU-A", 1, 990_000, "서울시 강남구");
            }
            case "5-6" -> {
                worker.registerWorkflowImplementationTypes(PropagateWorkflowImpl.class);
                worker.registerActivitiesImplementations(new BrokenPaymentActivityImpl());
                workflowId = "order-5004";
                req = new OrderRequest("5004", "C-1", "SKU-A", 1, 39_000, "서울시 강남구");
            }
            case "5-8" -> {
                // 세 워크플로우를 한 Worker 에 등록하고 연달아 실행합니다.
                worker.registerWorkflowImplementationTypes(
                        PropagateWorkflowImpl.class, FallbackWorkflowImpl.class,
                        CompensateWorkflowImpl.class);
                worker.registerActivitiesImplementations(
                        new RealisticPaymentActivityImpl(), new ShippingActivityImpl());
                factory.start();
                runAll(client);
                return;
            }
            default -> throw new IllegalArgumentException("알 수 없는 절: " + section);
        }

        factory.start();
        OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
                WorkflowOptions.newBuilder()
                        .setWorkflowId(workflowId)
                        .setTaskQueue(TASK_QUEUE)
                        .build());

        System.out.println("=== " + section + " 실행: " + workflowId + " ===");
        System.out.println("다른 터미널에서: temporal workflow describe -w " + workflowId);
        try {
            System.out.println("결과: " + wf.processOrder(req));
        } catch (Exception e) {
            System.out.println("워크플로우 실패: " + e);
            if (e.getCause() != null) System.out.println("  cause: " + e.getCause());
        }
    }

    /** [5-8] 세 방식을 연달아 돌려 Status 가 어떻게 갈리는지 비교합니다. */
    static void runAll(WorkflowClient client) {
        record Case(String id, Class<? extends OrderWorkflow> type) {}
        var cases = new Case[]{
                new Case("order-5004", PropagateWorkflowImpl.class),
                new Case("order-5005", FallbackWorkflowImpl.class),
                new Case("order-5006", CompensateWorkflowImpl.class)};

        for (Case c : cases) {
            OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
                    WorkflowOptions.newBuilder()
                            .setWorkflowId(c.id())
                            .setTaskQueue(TASK_QUEUE)
                            .build());
            String oid = c.id().substring("order-".length());
            try {
                System.out.printf("%-12s → %s%n", c.id(),
                        wf.processOrder(new OrderRequest(oid, "C-1", "SKU-A", 1, 39_000, "서울시 강남구")));
            } catch (Exception e) {
                System.out.printf("%-12s → FAILED (%s)%n", c.id(),
                        e.getCause() == null ? e.getMessage() : e.getCause().getMessage());
            }
        }
        System.out.println();
        System.out.println("확인: temporal workflow list --query 'WorkflowId STARTS_WITH \"order-500\"'");
    }
}

package com.example.order;

/*
 * Step 05 — 재시도와 실패 처리 / 연습문제 (6문제)
 *
 * 실행 방법
 *   ./gradlew run -PmainClass=com.example.order.Exercise --args="1"
 *   ./gradlew run -PmainClass=com.example.order.Exercise --args="cleanup"
 *
 * 문제 1 만 Temporal 서버 없이 풀 수 있습니다. 나머지는 서버와 Worker 가 필요합니다.
 * 각 문제의 "// TODO: 여기에 작성" 을 채우세요. 정답은 Solution.java.
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowOptions;
import io.temporal.common.RetryOptions;
import io.temporal.failure.ActivityFailure;
import io.temporal.failure.ApplicationFailure;
import io.temporal.serviceclient.WorkflowServiceStubs;
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.slf4j.Logger;

import java.time.Duration;

public class Exercise {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    public record OrderRequest(String orderId, String customerId, String sku,
                               int qty, long amount, String address) {}

    @ActivityInterface
    public interface PaymentActivity {
        @ActivityMethod String charge(String orderId, long amount);
        @ActivityMethod void refund(String paymentId);
    }

    @WorkflowInterface
    public interface OrderWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    // ==================================================================
    // 문제 1 — 백오프 계산 (서버 불필요, 자가 채점)
    //
    // RetryOptions:
    //   initialInterval    = 2초
    //   backoffCoefficient = 2.0
    //   maximumInterval    = 30초
    //
    // 8번째 시도가 시작되는 시각(1번째 시도를 t=0 으로 볼 때, 초 단위)은?
    // 손으로 계산해서 아래 상수에 넣고, 검증 루프로 확인하세요.
    // ==================================================================
    static long q1AnswerSeconds() {
        // TODO: 여기에 작성 — 8번째 시도가 시작되는 시각(초)
        return -1;
    }

    static void q1() {
        long expected = 0;
        Duration initial = Duration.ofSeconds(2);
        double coeff = 2.0;
        Duration max = Duration.ofSeconds(30);
        for (int n = 1; n <= 7; n++) {   // 8번째 시도 직전까지의 대기 합
            expected += Math.min((long) (initial.toMillis() * Math.pow(coeff, n - 1)),
                    max.toMillis()) / 1000;
        }
        System.out.println("정답(계산값) = " + expected + "초");
        System.out.println(q1AnswerSeconds() == expected ? "Q1 PASS" : "Q1 FAIL");
    }

    // ==================================================================
    // 문제 2 — 무한 재시도 진단
    //
    // 아래 워크플로우를 실행하면 영원히 끝나지 않습니다.
    //   ./gradlew run -PmainClass=com.example.order.Exercise --args="2"
    // 다른 터미널에서 아래 명령을 2분 간격으로 두 번 실행하고,
    //   temporal workflow describe -w order-6002
    // 관찰한 값을 상수에 채워 넣으세요.
    // ==================================================================
    static final int    Q2_HISTORY_LENGTH = 0;      // TODO: 여기에 작성 — History Length 는 몇인가
    static final String Q2_PENDING_STATE  = "";     // TODO: 여기에 작성 — Pending Activities 의 State
    static final String Q2_FAILURE_TYPE   = "";     // TODO: 여기에 작성 — Last Failure 의 예외 타입

    public static class Q2Activity implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(Q2Activity.class);
        @Override public String charge(String orderId, long amount) {
            log.info("[{}] 결제 시도", orderId);
            throw new IllegalStateException("card network down");
        }
        @Override public void refund(String paymentId) {}
    }

    public static class Q2Workflow implements OrderWorkflow {
        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class,
                ActivityOptions.newBuilder()
                        .setStartToCloseTimeout(Duration.ofSeconds(5))
                        .build());
        @Override public String processOrder(OrderRequest req) {
            return payment.charge(req.orderId(), req.amount());
        }
    }

    // ==================================================================
    // 문제 3 — 예외 벗겨 내기
    //
    // Q3Activity 는 details 두 개(재고 수량, 요청 수량)를 담은
    // ApplicationFailure 를 던집니다. 워크플로우에서 이를 잡아
    // "재고 3개, 요청 10개 — 7개 부족" 형태의 문자열을 반환하세요.
    // ==================================================================
    public static class Q3Activity implements PaymentActivity {
        @Override public String charge(String orderId, long amount) {
            throw ApplicationFailure.newNonRetryableFailure(
                    "not enough stock", "OutOfStockError", 3, 10);
        }
        @Override public void refund(String paymentId) {}
    }

    public static class Q3Workflow implements OrderWorkflow {
        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class,
                ActivityOptions.newBuilder()
                        .setStartToCloseTimeout(Duration.ofSeconds(5))
                        .build());

        @Override
        public String processOrder(OrderRequest req) {
            try {
                return payment.charge(req.orderId(), req.amount());
            } catch (ActivityFailure af) {
                // TODO: 여기에 작성
                //  - af 를 한 겹 벗겨 ApplicationFailure 를 얻고
                //  - getType() 이 "OutOfStockError" 인지 확인하고
                //  - getDetails().get(0, Integer.class) / get(1, Integer.class) 로 숫자를 꺼내
                //  - "재고 3개, 요청 10개 — 7개 부족" 을 반환
                return "";
            }
        }
    }

    // ==================================================================
    // 문제 4 — 실패 분류
    //
    // 아래 액티비티는 세 상황을 전부 RuntimeException 으로 던집니다.
    // 각각 알맞은 ApplicationFailure 로 바꾸세요.
    //   - 카드 번호가 유효하지 않다  → 재시도 불가, type "InvalidCardError"
    //   - 잔액이 부족하다            → 재시도 불가, type "InsufficientBalanceError", details 로 잔액/필요금액
    //   - 게이트웨이가 502 를 뱉는다 → 재시도 가능, type "GatewayUnavailableError"
    //
    // 실행 후 확인:
    //   temporal workflow show -w order-6004 --output json | jq '.events[]
    //     | select(.eventType=="EVENT_TYPE_ACTIVITY_TASK_FAILED") .activityTaskFailedEventAttributes.retryState'
    // 재시도 불가 케이스에서 RETRY_STATE_NON_RETRYABLE_FAILURE 가 나와야 정답입니다.
    // ==================================================================
    public static class Q4Activity implements PaymentActivity {
        @Override
        public String charge(String orderId, long amount) {
            String cardNumber = "4111-XXXX-BAD";
            long balance = 12_000L;
            boolean gatewayUp = false;

            if (!cardNumber.matches("\\d{4}-\\d{4}-\\d{4}-\\d{4}")) {
                // TODO: 여기에 작성
                throw new RuntimeException("invalid card number");
            }
            if (balance < amount) {
                // TODO: 여기에 작성
                throw new RuntimeException("insufficient balance");
            }
            if (!gatewayUp) {
                // TODO: 여기에 작성
                throw new RuntimeException("gateway 502");
            }
            return "PAY-" + orderId;
        }
        @Override public void refund(String paymentId) {}
    }

    // ==================================================================
    // 문제 5 — doNotRetry 가 동작하지 않는다
    //
    // 아래 옵션은 IllegalArgumentException 을 재시도에서 제외하려는 의도이고,
    // Q5Activity 는 실제로 IllegalArgumentException 을 던집니다.
    // 그런데 실행해 보면 5번 다 재시도됩니다. 왜일까요? 고치세요.
    // (힌트가 두 개 있습니다 — 하나는 이름 표기, 하나는 상속)
    // ==================================================================
    static ActivityOptions q5Options() {
        return ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(5))
                .setRetryOptions(RetryOptions.newBuilder()
                        .setInitialInterval(Duration.ofMillis(200))
                        .setMaximumAttempts(5)
                        .setDoNotRetry("RuntimeException")   // TODO: 여기에 작성 — 이 줄을 고치세요
                        .build())
                .build();
    }

    public static class Q5Activity implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(Q5Activity.class);
        @Override public String charge(String orderId, long amount) {
            log.info("[{}] Q5 시도", orderId);
            throw new IllegalArgumentException("amount must be positive: " + amount);
        }
        @Override public void refund(String paymentId) {}
    }

    // ==================================================================
    // 문제 6 — 재시도가 한 번도 일어나지 않는다
    //
    // 아래 액티비티를 쓰는 워크플로우는 COMPLETED 로 끝나고 로그도 깨끗합니다.
    // 그런데 결제는 되지 않았습니다. describe 를 봐도 Attempt 는 1 이고
    // 히스토리에는 ActivityTaskCompleted 가 찍혀 있습니다.
    // 무엇이 잘못됐는지 찾아 고치세요. 이 스텝에서 가장 중요한 함정입니다.
    // ==================================================================
    public static class Q6Activity implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(Q6Activity.class);

        @Override
        public String charge(String orderId, long amount) {
            try {
                throw new RuntimeException("payment gateway 500");
            } catch (Exception e) {
                log.error("[{}] 결제 실패", orderId, e);
                // TODO: 여기에 작성 — 아래 한 줄이 문제입니다
                return null;
            }
        }
        @Override public void refund(String paymentId) {}
    }

    // ------------------------------------------------------------------
    // 실행부
    // ------------------------------------------------------------------
    public static void main(String[] args) {
        String q = args.length > 0 ? args[0] : "1";
        if (q.equals("1")) { q1(); return; }
        if (q.equals("cleanup")) { cleanup(); return; }

        WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();
        WorkflowClient client = WorkflowClient.newInstance(service);
        WorkerFactory factory = WorkerFactory.newInstance(client);
        Worker worker = factory.newWorker(TASK_QUEUE);

        String id = "order-600" + q;
        switch (q) {
            case "2" -> {
                worker.registerWorkflowImplementationTypes(Q2Workflow.class);
                worker.registerActivitiesImplementations(new Q2Activity());
            }
            case "3" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q3Activity());
            }
            case "4" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q4Activity());
            }
            case "5" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q5Activity());
            }
            case "6" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q6Activity());
            }
            default -> throw new IllegalArgumentException("1~6 또는 cleanup");
        }

        factory.start();
        OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
                WorkflowOptions.newBuilder().setWorkflowId(id).setTaskQueue(TASK_QUEUE).build());
        System.out.println("=== Q" + q + " → " + id + " ===");
        System.out.println("확인: temporal workflow describe -w " + id);
        try {
            System.out.println("결과: " + wf.processOrder(
                    new OrderRequest(id.substring(6), "C-1", "SKU-A", 1, 39_000, "서울시 강남구")));
        } catch (Exception e) {
            System.out.println("실패: " + e + (e.getCause() == null ? "" : " / cause=" + e.getCause()));
        }
    }

    /** 이 문제지가 만든 order-6xxx 워크플로우를 정리합니다. */
    static void cleanup() {
        System.out.println("아래 명령으로 남은 워크플로우를 정리하세요.");
        System.out.println("  temporal workflow list --query 'WorkflowId STARTS_WITH \"order-6\"'");
        for (int i = 2; i <= 6; i++) {
            System.out.println("  temporal workflow terminate -w order-600" + i + " --reason \"연습문제 정리\"");
        }
    }
}

package com.example.order;

/*
 * Step 05 — 재시도와 실패 처리 / 정답과 해설
 *
 * 실행 방법
 *   ./gradlew run -PmainClass=com.example.order.Solution --args="1"   (1~6)
 *
 * 각 문제마다 "왜 그 답인가" 를 긴 주석으로 설명합니다.
 * 코드만 읽지 말고, 주석에 적힌 temporal 명령을 실제로 돌려 확인하세요.
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowOptions;
import io.temporal.common.RetryOptions;
import io.temporal.failure.ActivityFailure;
import io.temporal.failure.ApplicationFailure;
import io.temporal.serviceclient.WorkflowServiceStubs;
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.slf4j.Logger;

import java.time.Duration;

public class Solution {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    public record OrderRequest(String orderId, String customerId, String sku,
                               int qty, long amount, String address) {}

    @ActivityInterface
    public interface PaymentActivity {
        @ActivityMethod String charge(String orderId, long amount);
        @ActivityMethod void refund(String paymentId);
    }

    @WorkflowInterface
    public interface OrderWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    // ==================================================================
    // 정답 1 — 백오프 계산
    //
    //   initialInterval=2s, backoffCoefficient=2.0, maximumInterval=30s
    //
    //   interval(n) = min(2 × 2^(n-1), 30)
    //     n=1 → 2      n=2 → 4      n=3 → 8
    //     n=4 → 16     n=5 → min(32,30)=30   ← 여기서부터 상한이 개입
    //     n=6 → 30     n=7 → 30
    //
    //   8번째 시도가 시작되는 시각 = 1~7번째 시도 뒤의 대기 합
    //     2 + 4 + 8 + 16 + 30 + 30 + 30 = 120초
    //
    // 핵심은 "maximumInterval 이 언제부터 개입하는가" 입니다.
    // 2 × 2^4 = 32 > 30 이므로 5번째 대기부터 잘립니다.
    // maximumInterval 을 지정하지 않았다면 기본값이 initialInterval × 100 = 200초라
    // 상한이 훨씬 늦게(2×2^6=128 다음인 256 에서) 개입해 답이 달라집니다.
    // "기본 maximumInterval 은 100초 고정"이 아니라 "initialInterval 의 100배"임에
    // 주의하세요. initialInterval 이 1초일 때만 100초입니다.
    // ==================================================================
    static long q1AnswerSeconds() {
        return 120;
    }

    // ==================================================================
    // 정답 2 — 무한 재시도 진단
    //
    //   Q2_HISTORY_LENGTH = 5
    //   Q2_PENDING_STATE  = "BACKOFF"  (또는 관측 순간에 따라 "STARTED")
    //   Q2_FAILURE_TYPE   = "java.lang.IllegalStateException"
    //
    // History Length 가 5 인 이유가 이 문제의 전부입니다.
    //   1 WorkflowExecutionStarted
    //   2 WorkflowTaskScheduled
    //   3 WorkflowTaskStarted
    //   4 WorkflowTaskCompleted
    //   5 ActivityTaskScheduled
    // 이후 몇 번을 재시도해도 이벤트는 늘지 않습니다. 재시도는 5번 이벤트에 붙은
    // attempt 카운터가 올라갈 뿐입니다. 2분 뒤에 다시 describe 해도 History Length 는
    // 그대로 5 이고 Attempt 만 커져 있습니다. 이것을 직접 본 것이 핵심입니다.
    //
    // State 는 관측 시점에 따라 다릅니다. 백오프 간격이 이미 32초, 64초로 길어졌다면
    // 대부분의 순간에 BACKOFF 로 보이고, 아주 짧은 순간에만 STARTED 입니다.
    //
    // Failure 타입이 FQCN 인 것도 중요합니다. ApplicationFailure 를 명시적으로 던지지
    // 않은 일반 예외는 SDK 가 클래스의 전체 이름을 type 으로 채웁니다. 이 사실이
    // 정답 5 의 doNotRetry 문제로 그대로 이어집니다.
    //
    // 검증:
    //   temporal workflow describe -w order-6002 --output json \
    //     | jq '{len: .workflowExecutionInfo.historyLength,
    //            attempt: .pendingActivities[0].attempt,
    //            state: .pendingActivities[0].state}'
    // ==================================================================

    // ==================================================================
    // 정답 3 — 예외 벗겨 내기
    //
    // 규칙은 하나입니다: ActivityFailure 를 getCause() 로 "한 번만" 벗기면
    // ApplicationFailure 가 나옵니다. 두 번 벗기려 하면 null 이라 NPE 가 납니다.
    // ApplicationFailure 는 체인의 끝이고 그 아래에는 아무것도 없습니다.
    // (원래 예외 객체는 다른 JVM 에 있으므로 전달될 수 없습니다. 스택트레이스는
    //  문자열로만 보존됩니다 — appFailure.getOriginalStackTrace() 로 볼 수 있습니다.)
    //
    // details 의 인덱스와 타입은 던진 쪽과 정확히 맞춰야 합니다.
    // newNonRetryableFailure(msg, type, 3, 10) 로 던졌으니
    // get(0, Integer.class) = 3, get(1, Integer.class) = 10 입니다.
    // Long.class 로 꺼내면 역직렬화 예외가 납니다.
    // ==================================================================
    public static class Q3Activity implements PaymentActivity {
        @Override public String charge(String orderId, long amount) {
            throw ApplicationFailure.newNonRetryableFailure(
                    "not enough stock", "OutOfStockError", 3, 10);
        }
        @Override public void refund(String paymentId) {}
    }

    public static class Q3Workflow implements OrderWorkflow {
        private static final Logger log = Workflow.getLogger(Q3Workflow.class);

        private final PaymentActivity payment = Workflow.newActivityStub(
                PaymentActivity.class,
                ActivityOptions.newBuilder()
                        .setStartToCloseTimeout(Duration.ofSeconds(5))
                        .build());

        @Override
        public String processOrder(OrderRequest req) {
            try {
                return payment.charge(req.orderId(), req.amount());
            } catch (ActivityFailure af) {
                // af.getMessage() 는 언제나 "Activity task failed" 입니다. 쓸모없습니다.
                log.info("겉껍질: {}", af.getMessage());

                if (af.getCause() instanceof ApplicationFailure appFailure
                        && "OutOfStockError".equals(appFailure.getType())) {
                    int stock = appFailure.getDetails().get(0, Integer.class);
                    int requested = appFailure.getDetails().get(1, Integer.class);
                    return "재고 %d개, 요청 %d개 — %d개 부족"
                            .formatted(stock, requested, requested - stock);
                }
                throw af;   // 예상하지 못한 실패는 삼키지 말고 다시 던집니다
            }
        }
    }

    // ==================================================================
    // 정답 4 — 실패 분류
    //
    // 판단 기준은 단 하나입니다: "다시 해 보면 성공할 가능성이 있는가."
    //   - 카드 번호 형식 오류: 입력이 바뀌지 않는 한 100번을 해도 똑같습니다 → 재시도 불가
    //   - 잔액 부족: 재시도로 잔액이 늘지 않습니다 → 재시도 불가
    //     (계좌에 돈이 들어올 때까지 기다리는 게 목적이라면 그건 재시도가 아니라
    //      Step 06 의 타이머·시그널 대기로 풀어야 할 문제입니다.)
    //   - 게이트웨이 502: 몇 초 뒤면 돌아올 수 있습니다 → 재시도
    //
    // details 에 잔액과 필요 금액을 실어 보내는 이유는, 워크플로우가 "얼마가 부족한지"
    // 를 알아야 고객에게 의미 있는 안내를 할 수 있기 때문입니다. 메시지 문자열을
    // 파싱하는 대신 구조화된 값으로 넘기세요.
    //
    // 검증:
    //   temporal workflow show -w order-6004 --output json | jq '.events[]
    //     | select(.eventType=="EVENT_TYPE_ACTIVITY_TASK_FAILED")
    //     .activityTaskFailedEventAttributes.retryState'
    //   → "RETRY_STATE_NON_RETRYABLE_FAILURE"
    // Start Time 과 Close Time 이 같은 초인지도 확인하세요. 백오프 없이 즉시 끝나야 합니다.
    // ==================================================================
    public static class Q4Activity implements PaymentActivity {
        @Override
        public String charge(String orderId, long amount) {
            String cardNumber = "4111-XXXX-BAD";
            long balance = 12_000L;
            boolean gatewayUp = false;

            if (!cardNumber.matches("\\d{4}-\\d{4}-\\d{4}-\\d{4}")) {
                throw ApplicationFailure.newNonRetryableFailure(
                        "invalid card number", "InvalidCardError", cardNumber);
            }
            if (balance < amount) {
                throw ApplicationFailure.newNonRetryableFailure(
                        "insufficient balance", "InsufficientBalanceError", balance, amount);
            }
            if (!gatewayUp) {
                // newFailure = 재시도됩니다. nonRetryable 플래그가 false 입니다.
                throw ApplicationFailure.newFailure(
                        "gateway 502", "GatewayUnavailableError");
            }
            return "PAY-" + orderId;
        }
        @Override public void refund(String paymentId) {}
    }

    // ==================================================================
    // 정답 5 — doNotRetry 가 동작하지 않는 두 가지 이유
    //
    // (1) 이름 표기: doNotRetry 는 ApplicationFailure.getType() 과 "문자열 완전 일치"
    //     로 비교합니다. ApplicationFailure 를 명시적으로 던지지 않은 일반 예외는
    //     SDK 가 FQCN(패키지 포함 클래스명)을 type 으로 채웁니다.
    //       실제 type = "java.lang.IllegalArgumentException"
    //       설정한 값 = "RuntimeException"          → 안 맞음
    //     짧은 이름으로는 절대 매칭되지 않습니다.
    //
    // (2) 상속을 따지지 않음: 설사 "java.lang.RuntimeException" 이라고 정확히 적었어도
    //     IllegalArgumentException 은 걸러지지 않습니다. instanceof 가 아니라
    //     equals 비교이기 때문입니다. 상위 타입을 적어 두고 "하위 클래스도 걸리겠지"
    //     라고 기대하면 조용히 재시도가 계속됩니다.
    //
    // 그래서 정답은 던지는 예외의 FQCN 을 정확히 적는 것입니다.
    // 다만 실무에서는 이 방식 자체가 깨지기 쉽습니다 — 액티비티 구현이 예외 타입을
    // 바꾸면 doNotRetry 목록이 조용히 무효가 되고, 컴파일러도 잡아 주지 않습니다.
    // 가능하면 액티비티 쪽에서 newNonRetryableFailure() 로 명시하는 편이 안전하고,
    // doNotRetry 는 "구현을 고칠 수 없는 외부 라이브러리" 에만 쓰세요.
    //
    // 검증: retryState 가 RETRY_STATE_NON_RETRYABLE_FAILURE 인지,
    //       그리고 Worker 로그에 "Q5 시도" 가 딱 한 번만 찍히는지 보세요.
    // ==================================================================
    static ActivityOptions q5Options() {
        return ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(5))
                .setRetryOptions(RetryOptions.newBuilder()
                        .setInitialInterval(Duration.ofMillis(200))
                        .setMaximumAttempts(5)
                        .setDoNotRetry("java.lang.IllegalArgumentException")   // FQCN
                        .build())
                .build();
    }

    public static class Q5Activity implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(Q5Activity.class);
        @Override public String charge(String orderId, long amount) {
            log.info("[{}] Q5 시도", orderId);
            throw new IllegalArgumentException("amount must be positive: " + amount);
        }
        @Override public void refund(String paymentId) {}
    }

    public static class Q5Workflow implements OrderWorkflow {
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, q5Options());
        @Override public String processOrder(OrderRequest req) {
            return payment.charge(req.orderId(), req.amount());
        }
    }

    // ==================================================================
    // 정답 6 — 재시도가 한 번도 일어나지 않는 이유
    //
    // 고치는 것은 한 줄입니다: return null → throw e.
    // 하지만 원칙이 더 중요합니다.
    //
    //   Temporal 은 액티비티 메서드에서 "예외가 밖으로 나가야만" 실패로 인식합니다.
    //   정상 반환하면 ActivityTaskCompleted 가 기록되고, 재시도는 시작조차 하지 않습니다.
    //
    // 이 코드가 위험한 이유는 조용하기 때문입니다.
    //   - 워크플로우는 COMPLETED 로 끝납니다.
    //   - describe 의 Attempt 는 1 입니다.
    //   - 히스토리는 정상 실행과 완전히 동일합니다.
    //   - 에러 로그는 남지만, 그건 로그일 뿐 흐름에는 아무 영향이 없습니다.
    // 결제가 안 됐는데 워크플로우는 배송을 요청합니다. "에러 없이 조용히 틀리는" 전형입니다.
    //
    // 로그를 남기고 싶다면 남기되, 반드시 다시 던지세요. 아래가 관용구입니다.
    //   catch (Exception e) { log.error("...", e); throw e; }
    // 또는 아예 catch 하지 말고 Temporal 이 기록하게 두는 편이 낫습니다. SDK 가
    // "Activity failure. ActivityId=..., attempt=N" 을 스택트레이스와 함께 찍어 줍니다.
    //
    // 굳이 예외를 잡아야 한다면 — 예컨대 원인을 분류해서 재시도 여부를 정하고 싶다면 —
    // 아래처럼 ApplicationFailure 로 다시 던집니다.
    //   catch (HttpException e) {
    //       if (e.status() == 400) throw ApplicationFailure.newNonRetryableFailure(...);
    //       throw ApplicationFailure.newFailure(...);
    //   }
    // ==================================================================
    public static class Q6Activity implements PaymentActivity {
        private static final Logger log = Workflow.getLogger(Q6Activity.class);

        @Override
        public String charge(String orderId, long amount) {
            try {
                throw new RuntimeException("payment gateway 500");
            } catch (RuntimeException e) {
                log.error("[{}] 결제 실패", orderId, e);
                throw e;                    // ← 반드시 다시 던진다
            }
        }
        @Override public void refund(String paymentId) {}
    }

    // ------------------------------------------------------------------
    // 실행부
    // ------------------------------------------------------------------
    public static void main(String[] args) {
        String q = args.length > 0 ? args[0] : "1";

        if (q.equals("1")) {
            System.out.println("정답 1: 8번째 시도는 t=" + q1AnswerSeconds() + "초에 시작");
            System.out.println("  2 + 4 + 8 + 16 + 30 + 30 + 30 = 120");
            System.out.println("  (5번째 대기부터 maximumInterval=30s 상한이 개입)");
            return;
        }
        if (q.equals("2")) {
            System.out.println("정답 2: History Length=5, State=BACKOFF, "
                    + "Failure Type=java.lang.IllegalStateException");
            System.out.println("  재시도는 이벤트를 만들지 않습니다. attempt 만 올라갑니다.");
            return;
        }

        WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();
        WorkflowClient client = WorkflowClient.newInstance(service);
        WorkerFactory factory = WorkerFactory.newInstance(client);
        Worker worker = factory.newWorker(TASK_QUEUE);

        String id = "order-700" + q;
        switch (q) {
            case "3" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q3Activity());
            }
            case "4" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q4Activity());
            }
            case "5" -> {
                worker.registerWorkflowImplementationTypes(Q5Workflow.class);
                worker.registerActivitiesImplementations(new Q5Activity());
            }
            case "6" -> {
                worker.registerWorkflowImplementationTypes(Q3Workflow.class);
                worker.registerActivitiesImplementations(new Q6Activity());
            }
            default -> throw new IllegalArgumentException("1~6");
        }

        factory.start();
        OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
                WorkflowOptions.newBuilder().setWorkflowId(id).setTaskQueue(TASK_QUEUE).build());
        System.out.println("=== 정답 " + q + " → " + id + " ===");
        try {
            System.out.println("결과: " + wf.processOrder(
                    new OrderRequest(id.substring(6), "C-1", "SKU-A", 1, 39_000, "서울시 강남구")));
        } catch (Exception e) {
            System.out.println("실패: " + e + (e.getCause() == null ? "" : " / cause=" + e.getCause()));
        }
        System.out.println("검증: temporal workflow show -w " + id + " --output json | jq "
                + "'.events[] | select(.eventType==\"EVENT_TYPE_ACTIVITY_TASK_FAILED\") "
                + ".activityTaskFailedEventAttributes.retryState'");
    }
}