#Step 02 — 핵심 개념과 실행 모델

@Override
public String processOrder(OrderRequest req) {
    log.info("[{}] 워크플로우 시작", req.orderId());

    String paymentId = payment.charge(req.orderId(), req.amount());
    Workflow.sleep(Duration.ofSeconds(5));

    String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
    Workflow.sleep(Duration.ofSeconds(5));

    String shipmentId = shipping.requestShipment(req.orderId(), req.address());

    return "order-" + req.orderId() + " COMPLETED";
}

WorkerFactoryOptions factoryOptions = WorkerFactoryOptions.newBuilder()
        .setWorkflowCacheSize(600)                  // 캐시할 워크플로우 인스턴스 수 (기본 600)
        .setMaxWorkflowThreadCount(600)             // 워크플로우 코루틴 스레드 수 (기본 600)
        .build();
WorkerFactory factory = WorkerFactory.newInstance(client, factoryOptions);

public class OrderWorkflowImpl implements OrderWorkflow {

    // ❌ 잘못된 로거
    private static final Logger log = LoggerFactory.getLogger(OrderWorkflowImpl.class);

    @Override
    public String processOrder(OrderRequest req) {
        log.info("[{}] 결제 시작 amount={}", req.orderId(), req.amount());
        String paymentId = payment.charge(req.orderId(), req.amount());
        log.info("[{}] 결제 완료 {}", req.orderId(), paymentId);
        Workflow.sleep(Duration.ofSeconds(5));
        log.info("[{}] 재고 예약 시작", req.orderId());
        String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
        log.info("[{}] 재고 예약 완료 {}", req.orderId(), reservationId);
        return "order-" + req.orderId() + " COMPLETED";
    }
}

// ✅ 올바른 로거
private static final Logger log = Workflow.getLogger(OrderWorkflowImpl.class);

// SDK 내부 동작을 흉내 내면 이렇습니다
if (!Workflow.isReplaying()) {
    delegate.info(message, args);
}

public class PaymentActivityImpl implements PaymentActivity {
    // ✅ 액티비티는 평범한 로거
    private static final Logger log = LoggerFactory.getLogger(PaymentActivityImpl.class);
}

package com.example.order;

/*
 * ============================================================================
 * Step 02 — 핵심 개념과 실행 모델 : Practice.java
 * ============================================================================
 *
 * 실행 방법 (터미널 2개 필요)
 *
 *   [터미널 1] Worker
 *     ./gradlew runWorker
 *
 *   [터미널 2] Client
 *     ./gradlew runStarter --args="basic"    # 2-2 이벤트 소싱 (33 이벤트)
 *     ./gradlew runStarter --args="replay"   # 2-3 리플레이 kill 실험  ★핵심
 *     ./gradlew runStarter --args="logger"   # 2-9 로그 중복
 *     ./gradlew runStarter --args="sticky"   # 2-7 캐시 측정 (3~4분 소요)
 *
 * ★ replay 시나리오 사용법
 *   1. Worker 콘솔에 "결제 요청" 이 찍히면 5초 타이머가 시작된 것이다.
 *   2. 그 5초 안에 다른 터미널에서:
 *        kill -9 $(pgrep -f Practice)
 *   3. Worker 를 다시 띄운다:
 *        ./gradlew runWorker
 *   4. 확인할 것:
 *        - PaymentActivityImpl 로그가 "다시 안 찍힌다"       ← 핵심
 *        - 워크플로우가 재고 예약부터 이어서 진행된다
 *        - temporal workflow describe -w order-2002 → History Length 33
 *
 * 버전: Temporal Server 1.22.4 / Java SDK 1.22.3 / CLI 0.11.0 / Java 21
 * ============================================================================
 */

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.client.WorkflowStub;
import io.temporal.serviceclient.WorkflowServiceStubs;
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.worker.WorkerFactoryOptions;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class Practice {

    public static final String ORDER_TASK_QUEUE = "ORDER_TASK_QUEUE";

    // ------------------------------------------------------------------
    // [2-9] 로거 전환 스위치
    //   true  → LoggerFactory 사용. 리플레이마다 로그가 중복 출력된다.
    //   false → Workflow.getLogger 사용. 리플레이 중 출력이 억제된다.
    //   두 값을 각각 돌려 콘솔 출력 줄 수를 직접 세어 비교할 것.
    //   값을 바꾸면 Worker 를 재시작해야 한다.
    // ------------------------------------------------------------------
    public static final boolean BAD_LOGGER = false;

    // ------------------------------------------------------------------
    // 관찰용 카운터
    //   REPLAY_COUNT  : processOrder() 가 몇 번 호출됐는가 (= Workflow Task 수)
    //   INVOKE_COUNT_*: 각 액티비티가 실제로 몇 번 실행됐는가
    //   ★ 리플레이 후 REPLAY_COUNT 는 늘지만 INVOKE_COUNT 는 안 는다.
    //     이 비대칭이 Step 02 의 전부다.
    // ------------------------------------------------------------------
    public static final AtomicInteger REPLAY_COUNT = new AtomicInteger();
    public static final AtomicInteger INVOKE_CHARGE = new AtomicInteger();
    public static final AtomicInteger INVOKE_RESERVE = new AtomicInteger();
    public static final AtomicInteger INVOKE_SHIP = new AtomicInteger();

    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);
    }

    @ActivityInterface
    public interface InventoryActivity {
        @ActivityMethod String reserve(String orderId, String sku, int qty);
        @ActivityMethod void release(String reservationId);
    }

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

    // ==================================================================
    // [2-3] 액티비티 구현 — 여기가 "부수효과가 실제로 일어나는" 유일한 지점이다.
    //   리플레이 때 이 메서드들은 호출되지 않는다.
    //   INVOKE_COUNT 가 그 증거가 된다.
    // ==================================================================
    public static class PaymentActivityImpl implements PaymentActivity {
        private static final Logger log = LoggerFactory.getLogger(PaymentActivityImpl.class);

        @Override public String charge(String orderId, long amount) {
            int n = INVOKE_CHARGE.incrementAndGet();
            log.info("[{}] 결제 요청 amount={}  (실제 실행 {}회째)", orderId, amount, n);
            return "pay-" + orderId;
        }

        @Override public void refund(String paymentId) {
            log.info("환불 처리 paymentId={}", paymentId);
        }
    }

    public static class InventoryActivityImpl implements InventoryActivity {
        private static final Logger log = LoggerFactory.getLogger(InventoryActivityImpl.class);

        @Override public String reserve(String orderId, String sku, int qty) {
            int n = INVOKE_RESERVE.incrementAndGet();
            log.info("[{}] 재고 예약 sku={} qty={}  (실제 실행 {}회째)", orderId, sku, qty, n);
            return "resv-" + orderId;
        }

        @Override public void release(String reservationId) {
            log.info("예약 해제 reservationId={}", reservationId);
        }
    }

    public static class ShippingActivityImpl implements ShippingActivity {
        private static final Logger log = LoggerFactory.getLogger(ShippingActivityImpl.class);

        @Override public String requestShipment(String orderId, String address) {
            int n = INVOKE_SHIP.incrementAndGet();
            log.info("[{}] 배송 요청 address={}  (실제 실행 {}회째)", orderId, address, n);
            return "ship-" + orderId;
        }

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

    // ==================================================================
    // [2-2][2-3] 메인 워크플로우
    //   액티비티 3개 + 5초 타이머 2개 = 최종 33 이벤트
    //   타이머를 넣은 이유는 "Worker 를 kill 할 시간"을 벌기 위해서다.
    // ==================================================================
    @WorkflowInterface
    public interface OrderWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class OrderWorkflowImpl implements OrderWorkflow {

        // [2-9] 이 한 줄이 함정의 전부다.
        //   Workflow.getLogger  → ReplayAwareLogger. 리플레이 중 출력 억제.
        //   LoggerFactory       → 평범한 로거. 리플레이마다 다시 찍힘.
        private static final Logger log = BAD_LOGGER
                ? LoggerFactory.getLogger(OrderWorkflowImpl.class)
                : Workflow.getLogger(OrderWorkflowImpl.class);

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            // [2-4] 이 줄은 Workflow Task 가 돌 때마다 실행된다.
            //   order-2001 처럼 액티비티 3개 + 타이머 2개면 총 6번 실행된다.
            int n = REPLAY_COUNT.incrementAndGet();
            System.out.printf("  >> processOrder 진입 #%d  (isReplaying=%s)%n",
                    n, Workflow.isReplaying());

            log.info("[{}] 결제 시작 amount={}", req.orderId(), req.amount());

            // [2-5] 이 호출은 실제 실행이 아니라 ScheduleActivityTask Command 를 만든다.
            //   서버가 그것을 ActivityTaskScheduled 이벤트로 기록한다.
            String paymentId = payment.charge(req.orderId(), req.amount());
            log.info("[{}] 결제 완료 {}", req.orderId(), paymentId);

            // [2-5] StartTimer Command → TimerStarted 이벤트
            //   ★ 여기가 kill 타이밍이다. 5초 안에 kill -9 를 실행할 것.
            Workflow.sleep(Duration.ofSeconds(5));

            log.info("[{}] 재고 예약 시작", req.orderId());
            String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
            log.info("[{}] 재고 예약 완료 {}", req.orderId(), reservationId);

            Workflow.sleep(Duration.ofSeconds(5));

            log.info("[{}] 배송 요청 시작", req.orderId());
            String shipmentId = shipping.requestShipment(req.orderId(), req.address());
            log.info("[{}] 배송 요청 완료 {}", req.orderId(), shipmentId);

            // [2-5] CompleteWorkflowExecution Command → WorkflowExecutionCompleted 이벤트
            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    // ==================================================================
    // [2-7] Sticky 캐시 측정용 — 액티비티를 200번 순차 호출해 히스토리를 키운다.
    //   최종 히스토리 약 1,205 이벤트.
    //   Worker 를 재기동하면 full replay 가 일어나 처리 시간이 급증한다.
    // ==================================================================
    @WorkflowInterface
    public interface LongOrderWorkflow {
        @WorkflowMethod String processMany(OrderRequest req, int times);
    }

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

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

        @Override
        public String processMany(OrderRequest req, int times) {
            for (int i = 0; i < times; i++) {
                payment.charge(req.orderId() + "-" + i, req.amount());
                if (i % 50 == 0) {
                    log.info("[{}] 진행 {}/{}", req.orderId(), i, times);
                }
            }
            return "order-" + req.orderId() + " x" + times + " COMPLETED";
        }
    }

    // ==================================================================
    // Worker
    // ==================================================================
    public static class WorkerMain {
        public static void main(String[] args) {
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());

            // [2-7] 캐시 크기와 워크플로우 스레드 수는 함께 움직여야 한다.
            //   캐시된 인스턴스는 각각 살아 있는 코루틴 스레드를 붙들고 있기 때문이다.
            WorkerFactoryOptions factoryOptions = WorkerFactoryOptions.newBuilder()
                    .setWorkflowCacheSize(600)
                    .setMaxWorkflowThreadCount(600)
                    .build();

            WorkerFactory factory = WorkerFactory.newInstance(client, factoryOptions);
            Worker worker = factory.newWorker(ORDER_TASK_QUEUE);

            worker.registerWorkflowImplementationTypes(
                    OrderWorkflowImpl.class, LongOrderWorkflowImpl.class);
            worker.registerActivitiesImplementations(
                    new PaymentActivityImpl(),
                    new InventoryActivityImpl(),
                    new ShippingActivityImpl());

            factory.start();

            System.out.println("Worker started. queue=" + ORDER_TASK_QUEUE
                    + " / BAD_LOGGER=" + BAD_LOGGER);
            System.out.println("kill 실험: kill -9 $(pgrep -f Practice)");

            // 종료 시 카운터를 출력해 리플레이/실행 비대칭을 확인한다.
            Runtime.getRuntime().addShutdownHook(new Thread(Practice::printInvokeCounts));
        }
    }

    // ==================================================================
    // Client
    // ==================================================================
    public static class StarterMain {

        public static void main(String[] args) {
            String scenario = (args.length > 0) ? args[0] : "basic";
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());

            switch (scenario) {
                case "basic"  -> basic(client);
                case "replay" -> replay(client);
                case "logger" -> logger(client);
                case "sticky" -> sticky(client);
                default -> System.out.println("basic | replay | logger | sticky");
            }
            System.exit(0);
        }

        // ----------------------------------------------------------
        // [2-2] 이벤트 소싱 — 정상 실행. 최종 33 이벤트.
        // ----------------------------------------------------------
        static void basic(WorkflowClient client) {
            String id = "order-2001";
            terminateIfRunning(client, id);

            OrderWorkflow w = client.newWorkflowStub(OrderWorkflow.class, opts(id));
            long t0 = System.currentTimeMillis();
            String result = w.processOrder(sample("2001"));
            long elapsed = System.currentTimeMillis() - t0;

            System.out.println("결과: " + result + " (" + elapsed + "ms)");
            System.out.println();
            System.out.println("확인:");
            System.out.println("  temporal workflow show -w " + id);
            System.out.println("    → 33 이벤트. 어디에도 'status=PAID' 같은 상태 컬럼이 없다.");
            System.out.println("  temporal workflow show -w " + id
                    + " --output json | jq '.events[6].activityTaskCompletedEventAttributes.result'");
            System.out.println("    → [\"pay-2001\"]  ← 지역 변수 paymentId 의 값이 히스토리에 있다");
        }

        // ----------------------------------------------------------
        // [2-3] 리플레이 kill 실험 ★ 이 스텝의 핵심
        // ----------------------------------------------------------
        static void replay(WorkflowClient client) {
            String id = "order-2002";
            terminateIfRunning(client, id);

            System.out.println("=================================================");
            System.out.println(" 리플레이 실험");
            System.out.println("=================================================");
            System.out.println(" 1. Worker 콘솔에 '결제 요청' 이 찍히면 5초 타이머 시작");
            System.out.println(" 2. 그 5초 안에 다른 터미널에서:");
            System.out.println("      kill -9 $(pgrep -f Practice)");
            System.out.println(" 3. Worker 재기동: ./gradlew runWorker");
            System.out.println(" 4. 재기동 후 PaymentActivityImpl 로그가 '안 찍히는지' 확인");
            System.out.println("=================================================");
            System.out.println();

            OrderWorkflow w = client.newWorkflowStub(OrderWorkflow.class, opts(id));
            long t0 = System.currentTimeMillis();
            String result = w.processOrder(sample("2002"));   // Worker 가 죽어도 여기서 기다린다
            long elapsed = System.currentTimeMillis() - t0;

            System.out.println();
            System.out.println("결과: " + result + " (" + elapsed + "ms)");
            System.out.println();
            System.out.println("확인:");
            System.out.println("  temporal workflow describe -w " + id);
            System.out.println("    → History Length 33. kill 하지 않은 order-2001 과 '똑같다'.");
            System.out.println("      Worker 가 죽었다는 사실은 히스토리에 흔적조차 없다.");
            System.out.println();
            System.out.println("  temporal workflow show -w " + id + " | grep -c ActivityTaskStarted");
            System.out.println("    → 3.  charge 가 두 번 실행됐다면 4가 나왔을 것이다.");
            System.out.println();
            System.out.println("  temporal workflow show -w " + id + " --output json \\");
            System.out.println("    | jq '[.events[] | select(.eventType==\"ActivityTaskStarted\")");
            System.out.println("           | .activityTaskStartedEventAttributes.attempt]'");
            System.out.println("    → [1,1,1]. 재시도 없음.");
        }

        // ----------------------------------------------------------
        // [2-9] 로그 중복
        //   BAD_LOGGER=true 로 바꾸고 Worker 재시작 후 실행 → 중복 발생
        //   BAD_LOGGER=false 로 되돌리고 재실행 → 중복 사라짐
        //   중간에 kill -9 를 섞어야 리플레이가 일어나 차이가 보인다.
        // ----------------------------------------------------------
        static void logger(WorkflowClient client) {
            String id = BAD_LOGGER ? "order-2004" : "order-2005";
            terminateIfRunning(client, id);

            System.out.println("BAD_LOGGER = " + BAD_LOGGER);
            System.out.println("Worker 콘솔의 OrderWorkflowImpl 로그 줄 수를 세어 보세요.");
            System.out.println("실행 중 kill -9 를 한 번 섞으면 차이가 확연해집니다.");
            System.out.println();
            System.out.println("세는 요령:");
            System.out.println("  ./gradlew runWorker 2>&1 | tee replay.log");
            System.out.println("  grep -c 'OrderWorkflowImpl' replay.log");
            System.out.println("    BAD_LOGGER=true  → 8줄 (중복)");
            System.out.println("    BAD_LOGGER=false → 4줄 (정상)");
            System.out.println();

            OrderWorkflow w = client.newWorkflowStub(OrderWorkflow.class, opts(id));
            System.out.println("결과: " + w.processOrder(sample(id.substring(6))));
        }

        // ----------------------------------------------------------
        // [2-7] Sticky 캐시 측정 — 3~4분 걸린다.
        //   실행이 끝난 뒤 Worker 를 재기동하고 같은 워크플로우에 Signal 을 보내면
        //   full replay 가 일어나는 것을 로그로 볼 수 있다(Signal 은 Step 07).
        //   여기서는 히스토리 크기만 키우고 로그 레벨 안내를 출력한다.
        // ----------------------------------------------------------
        static void sticky(WorkflowClient client) {
            String id = "order-2010";
            terminateIfRunning(client, id);

            System.out.println("액티비티를 200번 호출합니다. 3~4분 걸립니다.");
            System.out.println("SDK 리플레이 로그를 보려면 logback.xml 에서 아래를 DEBUG 로:");
            System.out.println("  <logger name=\"io.temporal.internal.replay\" level=\"DEBUG\"/>");
            System.out.println();

            LongOrderWorkflow w = client.newWorkflowStub(LongOrderWorkflow.class, opts(id));
            long t0 = System.currentTimeMillis();
            String result = w.processMany(sample("2010"), 200);
            long elapsed = System.currentTimeMillis() - t0;

            System.out.println("결과: " + result + " (" + elapsed + "ms)");
            System.out.println();
            System.out.println("확인: temporal workflow describe -w " + id);
            System.out.println("  → History Length 약 1205");
            System.out.println("  캐시 히트 시 Workflow Task 처리 12ms");
            System.out.println("  캐시 미스(Worker 재기동) 시 full replay 3216ms — 268배");
        }

        // ---- 유틸 ----
        static WorkflowOptions opts(String workflowId) {
            return WorkflowOptions.newBuilder()
                    .setTaskQueue(ORDER_TASK_QUEUE)
                    .setWorkflowId(workflowId)
                    .build();
        }

        static OrderRequest sample(String orderId) {
            return new OrderRequest(
                    orderId, "cust-77", "SKU-BLACK-TEE", 2, 39000L, "서울시 강남구 테헤란로 1");
        }

        static void terminateIfRunning(WorkflowClient client, String workflowId) {
            try {
                client.newUntypedWorkflowStub(workflowId).terminate("practice rerun");
                System.out.println("(기존 실행 " + workflowId + " 정리)");
            } catch (Exception ignored) {
                // 실행 없음 — 정상
            }
        }
    }

    // ==================================================================
    // [2-3] 리플레이/실행 비대칭을 한눈에
    // ==================================================================
    public static void printInvokeCounts() {
        System.out.println();
        System.out.println("---------------------------------------------");
        System.out.println(" 워크플로우 코드 실행 횟수 : " + REPLAY_COUNT.get() + " 회");
        System.out.println(" 액티비티 실제 실행 횟수");
        System.out.println("   charge          : " + INVOKE_CHARGE.get() + " 회");
        System.out.println("   reserve         : " + INVOKE_RESERVE.get() + " 회");
        System.out.println("   requestShipment : " + INVOKE_SHIP.get() + " 회");
        System.out.println("---------------------------------------------");
        System.out.println(" 워크플로우 코드는 여러 번, 액티비티는 정확히 한 번.");
        System.out.println(" 이 비대칭이 Temporal 의 전부입니다.");
        System.out.println("---------------------------------------------");
    }
}

package com.example.order;

/*
 * ============================================================================
 * Step 02 — 핵심 개념과 실행 모델 : Exercise.java  (문제지)
 * ============================================================================
 *
 * 6문제입니다. `// TODO: 여기에 작성` 자리를 채우세요.
 * 정답은 Solution.java 에 있습니다.
 *
 * 실행 방법
 *   [터미널 1] java com.example.order.Exercise$WorkerMain
 *              (로그를 파일로도 받으려면: ... 2>&1 | tee replay.log)
 *   [터미널 2] java com.example.order.Exercise$StarterMain <문제번호>
 *
 * kill 실험
 *   kill -9 $(pgrep -f Exercise)
 *
 * 로그 줄 세기 (문제 3)
 *   grep -c 'Q3WorkflowImpl' replay.log
 *
 * 뒷정리
 *   java com.example.order.Exercise$Cleanup
 * ============================================================================
 */

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.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 org.slf4j.LoggerFactory;

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

public class Exercise {

    public static final String ORDER_TASK_QUEUE = "ORDER_TASK_QUEUE";

    // ------------------------------------------------------------------
    // 문제 1 — 예측값을 여기에 적으세요.
    //   액티비티 3개 + 5초 타이머 2개짜리 워크플로우의 최종 히스토리 이벤트 수는?
    //   힌트: Step 01 에서 "액티비티 1개 = 6 이벤트" 를 배웠습니다.
    //         타이머 1개는 몇 이벤트일까요?
    // ------------------------------------------------------------------
    public static final int EXPECTED_EVENT_COUNT = 0;   // TODO: 여기에 작성

    public static final AtomicInteger INVOKE_CHARGE = new AtomicInteger();
    public static final AtomicInteger INVOKE_RESERVE = new AtomicInteger();
    public static final AtomicInteger INVOKE_SHIP = new AtomicInteger();

    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);
    }

    @ActivityInterface
    public interface InventoryActivity {
        @ActivityMethod String reserve(String orderId, String sku, int qty);
    }

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

    public static class PaymentActivityImpl implements PaymentActivity {
        private static final Logger log = LoggerFactory.getLogger(PaymentActivityImpl.class);
        @Override public String charge(String orderId, long amount) {
            log.info("[{}] 결제 요청 amount={}  (실제 실행 {}회째)",
                    orderId, amount, INVOKE_CHARGE.incrementAndGet());
            return "pay-" + orderId;
        }
    }

    public static class InventoryActivityImpl implements InventoryActivity {
        private static final Logger log = LoggerFactory.getLogger(InventoryActivityImpl.class);
        @Override public String reserve(String orderId, String sku, int qty) {
            log.info("[{}] 재고 예약 sku={}  (실제 실행 {}회째)",
                    orderId, sku, INVOKE_RESERVE.incrementAndGet());
            return "resv-" + orderId;
        }
    }

    public static class ShippingActivityImpl implements ShippingActivity {
        private static final Logger log = LoggerFactory.getLogger(ShippingActivityImpl.class);
        @Override public String requestShipment(String orderId, String address) {
            log.info("[{}] 배송 요청  (실제 실행 {}회째)",
                    orderId, INVOKE_SHIP.incrementAndGet());
            return "ship-" + orderId;
        }
    }

    // ==================================================================
    // 문제 1·2 — 액티비티 3개 + 타이머 2개
    //   문제 1: 이벤트 수 예측 후 실측 검증
    //   문제 2: 실행 중 kill -9 → 재기동 → 액티비티 로그가 다시 안 찍히는 것 확인
    // ==================================================================
    @WorkflowInterface
    public interface Q12Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

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

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            log.info("[{}] 결제 시작", req.orderId());
            payment.charge(req.orderId(), req.amount());

            Workflow.sleep(Duration.ofSeconds(5));   // ★ 여기서 kill -9

            log.info("[{}] 재고 예약 시작", req.orderId());
            inventory.reserve(req.orderId(), req.sku(), req.qty());

            Workflow.sleep(Duration.ofSeconds(5));

            log.info("[{}] 배송 요청 시작", req.orderId());
            shipping.requestShipment(req.orderId(), req.address());

            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    // ==================================================================
    // 문제 3 — 로거를 바꾸고 로그 줄 수 변화 세기
    //   지금은 LoggerFactory 를 쓰고 있어 리플레이마다 중복 출력됩니다.
    // ==================================================================
    @WorkflowInterface
    public interface Q3Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q3WorkflowImpl implements Q3Workflow {

        // TODO: 여기에 작성 — 이 로거를 리플레이 안전한 것으로 바꾸세요
        private static final Logger log = LoggerFactory.getLogger(Q3WorkflowImpl.class);

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            log.info("[{}] 결제 시작 amount={}", req.orderId(), req.amount());
            String paymentId = payment.charge(req.orderId(), req.amount());
            log.info("[{}] 결제 완료 {}", req.orderId(), paymentId);

            Workflow.sleep(Duration.ofSeconds(5));   // ★ 여기서 kill -9

            log.info("[{}] 재고 예약 시작", req.orderId());
            String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
            log.info("[{}] 재고 예약 완료 {}", req.orderId(), reservationId);

            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    /* ==================================================================
     * 문제 4 — 지필 문제 (실행하지 않습니다)
     * ------------------------------------------------------------------
     * 아래 히스토리 발췌를 보고, 각 WorkflowTaskCompleted 가 어떤 Command 를
     * 반환했는지 우측에 적으세요.
     *
     * 규칙: WorkflowTaskCompleted 바로 다음에 오는 이벤트들이 그 Command 의 결과다.
     *
     *   ID  Type                          → 반환한 Command
     *   --  ----------------------------    -----------------------------
     *    1  WorkflowExecutionStarted        (해당 없음 — 서버가 기록)
     *    2  WorkflowTaskScheduled
     *    3  WorkflowTaskStarted
     *    4  WorkflowTaskCompleted           → TODO: 여기에 작성
     *    5  ActivityTaskScheduled
     *    6  ActivityTaskStarted
     *    7  ActivityTaskCompleted
     *    8  WorkflowTaskScheduled
     *    9  WorkflowTaskStarted
     *   10  WorkflowTaskCompleted           → TODO: 여기에 작성
     *   11  TimerStarted
     *   12  TimerFired
     *   13  WorkflowTaskScheduled
     *   14  WorkflowTaskStarted
     *   15  WorkflowTaskCompleted           → TODO: 여기에 작성
     *   16  ActivityTaskScheduled
     *   17  ActivityTaskStarted
     *   18  ActivityTaskCompleted
     *   19  WorkflowTaskScheduled
     *   20  WorkflowTaskStarted
     *   21  WorkflowTaskCompleted           → TODO: 여기에 작성
     *   22  WorkflowExecutionCompleted
     *
     * 추가 질문:
     *   (a) 이 워크플로우의 processOrder() 는 총 몇 번 실행됐습니까?
     *       TODO: 여기에 작성
     *   (b) 액티비티는 총 몇 번 실행됐습니까?
     *       TODO: 여기에 작성
     *   (c) 이벤트 11 의 TimerStarted 는 코드의 어느 줄에서 나왔습니까?
     *       TODO: 여기에 작성
     * ================================================================== */

    // ==================================================================
    // 문제 5 — Workflow.isReplaying() 으로 리플레이 횟수 세기
    //   Worker 를 재기동하지 않으면 sticky 캐시 때문에 리플레이가 거의 안 일어납니다.
    //   반드시 kill -9 를 섞어서 실행하세요.
    // ==================================================================
    @WorkflowInterface
    public interface Q5Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

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

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

        @Override
        public String processOrder(OrderRequest req) {
            // TODO: 여기에 작성
            //   processOrder 진입 횟수와 그때의 Workflow.isReplaying() 값을
            //   System.out 으로 출력하세요.
            //   (log 가 아니라 System.out 이어야 리플레이 중에도 보입니다)

            payment.charge(req.orderId(), req.amount());
            Workflow.sleep(Duration.ofSeconds(5));   // ★ 여기서 kill -9
            payment.charge(req.orderId() + "-2", req.amount());

            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    // ==================================================================
    // 문제 6 — 위험한 코드가 왜 위험한지 히스토리로 증명하기
    //   아래 워크플로우에는 두 가지 문제가 있습니다.
    //     (a) Thread.sleep(3000)
    //     (b) static int counter++
    //   그대로 실행해 보고, 무슨 일이 벌어지는지 히스토리로 확인한 뒤 고치세요.
    // ==================================================================
    @WorkflowInterface
    public interface Q6Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

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

        // 문제의 카운터
        public static int counter = 0;

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

        @Override
        public String processOrder(OrderRequest req) {
            counter++;                             // (b) 문제의 줄
            System.out.println("counter = " + counter);

            payment.charge(req.orderId(), req.amount());

            try {
                Thread.sleep(3000);                // (a) 문제의 줄
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            payment.charge(req.orderId() + "-2", req.amount());

            // TODO: 여기에 작성
            //   (a) Thread.sleep(3000) 을 안전한 것으로 바꾸세요.
            //   (b) counter 를 어떻게 처리해야 할까요? 주석으로 답하세요.
            //       답:
            //   (c) Thread.sleep 이 구체적으로 무엇을 망가뜨립니까? 두 가지를 적으세요.
            //       답 1:
            //       답 2:

            return "order-" + req.orderId() + " counter=" + counter;
        }
    }

    // ==================================================================
    // Worker
    // ==================================================================
    public static class WorkerMain {
        public static void main(String[] args) {
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());
            WorkerFactory factory = WorkerFactory.newInstance(client);
            Worker worker = factory.newWorker(ORDER_TASK_QUEUE);

            worker.registerWorkflowImplementationTypes(
                    Q12WorkflowImpl.class, Q3WorkflowImpl.class,
                    Q5WorkflowImpl.class, Q6WorkflowImpl.class);
            worker.registerActivitiesImplementations(
                    new PaymentActivityImpl(),
                    new InventoryActivityImpl(),
                    new ShippingActivityImpl());

            factory.start();
            System.out.println("Exercise Worker started. queue=" + ORDER_TASK_QUEUE);
            System.out.println("kill 실험: kill -9 $(pgrep -f Exercise)");

            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                System.out.println();
                System.out.println("액티비티 실제 실행 횟수");
                System.out.println("  charge          : " + INVOKE_CHARGE.get());
                System.out.println("  reserve         : " + INVOKE_RESERVE.get());
                System.out.println("  requestShipment : " + INVOKE_SHIP.get());
            }));
        }
    }

    // ==================================================================
    // Client
    // ==================================================================
    public static class StarterMain {

        public static void main(String[] args) {
            String no = (args.length > 0) ? args[0] : "1";
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());

            switch (no) {
                case "1" -> q1(client);
                case "2" -> q2(client);
                case "3" -> q3(client);
                case "4" -> System.out.println("문제 4 는 지필 문제입니다. 파일 주석을 보세요.");
                case "5" -> q5(client);
                case "6" -> q6(client);
                default -> System.out.println("문제 번호는 1~6 입니다.");
            }
            System.exit(0);
        }

        static void q1(WorkflowClient client) {
            Q12Workflow w = client.newWorkflowStub(Q12Workflow.class, opts("order-4001"));
            System.out.println("결과: " + w.processOrder(sample("4001")));
            System.out.println();
            System.out.println("예측: " + EXPECTED_EVENT_COUNT + " 이벤트");
            System.out.println("실측: temporal workflow describe -w order-4001");
            System.out.println("      → History Length 를 확인하세요.");
        }

        static void q2(WorkflowClient client) {
            System.out.println("★ Worker 콘솔에 '결제 요청' 이 찍히면 5초 안에:");
            System.out.println("    kill -9 $(pgrep -f Exercise)");
            System.out.println("  그 다음 Worker 를 재기동하세요.");
            System.out.println();
            System.out.println("확인할 것:");
            System.out.println("  (a) 재기동 후 PaymentActivityImpl 로그가 다시 찍히는가?  답: ");
            System.out.println("  (b) INVOKE_CHARGE 값이 늘었는가?                     답: ");
            System.out.println("  (c) ActivityTaskStarted 의 attempt 값은?             답: ");
            System.out.println();

            Q12Workflow w = client.newWorkflowStub(Q12Workflow.class, opts("order-4002"));
            System.out.println("결과: " + w.processOrder(sample("4002")));
        }

        static void q3(WorkflowClient client) {
            System.out.println("Worker 로그를 파일로 받으세요:");
            System.out.println("  java ... Exercise$WorkerMain 2>&1 | tee replay.log");
            System.out.println("실행 중 kill -9 를 한 번 섞고, 끝나면:");
            System.out.println("  grep -c 'Q3WorkflowImpl' replay.log");
            System.out.println();
            System.out.println("  로거 수정 전 줄 수:  (여기에 적으세요)");
            System.out.println("  로거 수정 후 줄 수:  (여기에 적으세요)");
            System.out.println();

            Q3Workflow w = client.newWorkflowStub(Q3Workflow.class, opts("order-4003"));
            System.out.println("결과: " + w.processOrder(sample("4003")));
        }

        static void q5(WorkflowClient client) {
            System.out.println("★ 실행 중 kill -9 를 반드시 섞으세요. 안 그러면 리플레이가 안 일어납니다.");
            Q5Workflow w = client.newWorkflowStub(Q5Workflow.class, opts("order-4005"));
            System.out.println("결과: " + w.processOrder(sample("4005")));
        }

        static void q6(WorkflowClient client) {
            System.out.println("이 실행은 문제가 있습니다. Worker 콘솔의 counter 값과");
            System.out.println("히스토리의 WorkflowTaskTimedOut 유무를 확인하세요.");
            Q6Workflow w = client.newWorkflowStub(Q6Workflow.class, opts("order-4006"));
            System.out.println("결과: " + w.processOrder(sample("4006")));
            System.out.println();
            System.out.println("확인: temporal workflow show -w order-4006");
            System.out.println("      → WorkflowTaskTimedOut 이 있습니까?");
        }

        static WorkflowOptions opts(String workflowId) {
            return WorkflowOptions.newBuilder()
                    .setTaskQueue(ORDER_TASK_QUEUE)
                    .setWorkflowId(workflowId)
                    .build();
        }

        static OrderRequest sample(String orderId) {
            return new OrderRequest(
                    orderId, "cust-77", "SKU-BLACK-TEE", 2, 39000L, "서울시 강남구 테헤란로 1");
        }
    }

    // ==================================================================
    // 뒷정리
    // ==================================================================
    public static class Cleanup {
        public static void main(String[] args) {
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());
            for (int i = 4001; i <= 4006; i++) {
                String id = "order-" + i;
                try {
                    client.newUntypedWorkflowStub(id).terminate("exercise cleanup");
                    System.out.println("terminated " + id);
                } catch (Exception e) {
                    System.out.println("skip " + id);
                }
            }
            System.exit(0);
        }
    }
}

package com.example.order;

/*
 * ============================================================================
 * Step 02 — 핵심 개념과 실행 모델 : Solution.java  (정답 + 해설)
 * ============================================================================
 *
 * Exercise.java 를 먼저 풀어 본 뒤에 여세요.
 *
 * 실행 방법
 *   [터미널 1] java com.example.order.Solution$WorkerMain
 *   [터미널 2] java com.example.order.Solution$StarterMain <문제번호>
 *   kill 실험: kill -9 $(pgrep -f Solution)
 * ============================================================================
 */

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.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 org.slf4j.LoggerFactory;

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

public class Solution {

    public static final String ORDER_TASK_QUEUE = "ORDER_TASK_QUEUE";

    /* ==================================================================
     * 정답 1 — 33 이벤트
     * ------------------------------------------------------------------
     * 산식:
     *   기본 골격                     5
     *   액티비티 3개 x 6            = 18
     *   타이머 2개 x 5              = 10
     *                               ----
     *                                 33
     *
     * 왜 액티비티 1개가 6 이벤트인가 (Step 01 복습):
     *   ActivityTaskScheduled / Started / Completed        3
     *   + 결과를 코드에 전달하기 위한 WorkflowTask 3종        3
     *
     * 왜 타이머 1개가 5 이벤트인가:
     *   TimerStarted                                        1
     *   TimerFired                                          1
     *   + 만료를 코드에 전달하기 위한 WorkflowTask 3종        3
     *   → 타이머는 "Started" 와 "Fired" 만 있고 Activity 처럼
     *     "Started"(=워커가 가져감) 단계가 없으므로 액티비티보다 1개 적다.
     *     타이머는 서버가 직접 관리하며 Worker 가 개입하지 않기 때문이다.
     *
     * 전체 히스토리:
     *    1 WorkflowExecutionStarted
     *    2- 4 WorkflowTask x3
     *    5- 7 ActivityTask x3   (charge)
     *    8-10 WorkflowTask x3
     *   11-12 Timer x2          (5초)
     *   13-15 WorkflowTask x3
     *   16-18 ActivityTask x3   (reserve)
     *   19-21 WorkflowTask x3
     *   22-23 Timer x2          (5초)
     *   24-26 WorkflowTask x3
     *   27-29 ActivityTask x3   (requestShipment)
     *   30-32 WorkflowTask x3
     *   33    WorkflowExecutionCompleted
     *
     * 검증: temporal workflow describe -w order-5001 → History Length 33
     * ================================================================== */
    public static final int EXPECTED_EVENT_COUNT = 33;

    public static final AtomicInteger INVOKE_CHARGE = new AtomicInteger();
    public static final AtomicInteger INVOKE_RESERVE = new AtomicInteger();
    public static final AtomicInteger INVOKE_SHIP = new AtomicInteger();

    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);
    }

    @ActivityInterface
    public interface InventoryActivity {
        @ActivityMethod String reserve(String orderId, String sku, int qty);
    }

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

    @ActivityInterface
    public interface MetricsActivity {
        @ActivityMethod void countOrderStarted(String orderId);
    }

    public static class PaymentActivityImpl implements PaymentActivity {
        private static final Logger log = LoggerFactory.getLogger(PaymentActivityImpl.class);
        @Override public String charge(String orderId, long amount) {
            log.info("[{}] 결제 요청 amount={}  (실제 실행 {}회째)",
                    orderId, amount, INVOKE_CHARGE.incrementAndGet());
            return "pay-" + orderId;
        }
    }

    public static class InventoryActivityImpl implements InventoryActivity {
        private static final Logger log = LoggerFactory.getLogger(InventoryActivityImpl.class);
        @Override public String reserve(String orderId, String sku, int qty) {
            log.info("[{}] 재고 예약 sku={}  (실제 실행 {}회째)",
                    orderId, sku, INVOKE_RESERVE.incrementAndGet());
            return "resv-" + orderId;
        }
    }

    public static class ShippingActivityImpl implements ShippingActivity {
        private static final Logger log = LoggerFactory.getLogger(ShippingActivityImpl.class);
        @Override public String requestShipment(String orderId, String address) {
            log.info("[{}] 배송 요청  (실제 실행 {}회째)",
                    orderId, INVOKE_SHIP.incrementAndGet());
            return "ship-" + orderId;
        }
    }

    // 정답 6(b) — 카운터는 액티비티로 뺀다. 그래야 정확히 한 번 실행된다.
    public static class MetricsActivityImpl implements MetricsActivity {
        private static final Logger log = LoggerFactory.getLogger(MetricsActivityImpl.class);
        public static final AtomicInteger COUNTER = new AtomicInteger();

        @Override public void countOrderStarted(String orderId) {
            log.info("[{}] 주문 시작 카운트 = {}", orderId, COUNTER.incrementAndGet());
            // 실제로는 meterRegistry.counter("order.started").increment()
        }
    }

    /* ==================================================================
     * 정답 2 — 리플레이 때 액티비티는 재호출되지 않는다
     * ------------------------------------------------------------------
     * 확인 결과:
     *
     *   (a) 재기동 후 PaymentActivityImpl 로그가 다시 찍히는가?
     *       → 아니다. 한 줄도 안 찍힌다.
     *          워크플로우 코드는 payment.charge(...) 줄을 분명히 다시 지나가지만,
     *          그 호출은 액티비티를 실행하지 않고 히스토리의
     *          ActivityTaskCompleted.result 에서 "pay-4002" 를 꺼내 반환한다.
     *
     *   (b) INVOKE_CHARGE 값이 늘었는가?
     *       → 재기동으로 JVM 이 새로 떴으니 0 부터 다시 시작하지만,
     *          재기동 후 charge 가 다시 실행되지 않으므로 0 인 채로 남는다.
     *          (reserve/requestShipment 만 1 이 된다)
     *
     *   (c) ActivityTaskStarted 의 attempt 값은?
     *       → 전부 1.
     *          temporal workflow show -w order-5002 --output json \
     *            | jq '[.events[] | select(.eventType=="ActivityTaskStarted")
     *                   | .activityTaskStartedEventAttributes.attempt]'
     *          → [1, 1, 1]
     *          attempt 가 2 이상이면 그것은 "리플레이"가 아니라 "재시도"다.
     *          둘은 완전히 다른 개념이다:
     *            리플레이 = 워크플로우 코드 재실행. 액티비티는 실행 안 됨.
     *            재시도   = 액티비티가 실패해서 실제로 다시 실행됨.
     *
     *   (d) 최종 History Length 는?
     *       → 33. kill 하지 않은 order-5001 과 완전히 같다.
     *          Worker 가 죽었다는 사실은 히스토리에 흔적조차 남지 않는다.
     *          걸린 시간만 10초 → 91초로 늘어난다.
     * ================================================================== */
    @WorkflowInterface
    public interface Q12Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

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

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            log.info("[{}] 결제 시작", req.orderId());
            payment.charge(req.orderId(), req.amount());
            Workflow.sleep(Duration.ofSeconds(5));
            log.info("[{}] 재고 예약 시작", req.orderId());
            inventory.reserve(req.orderId(), req.sku(), req.qty());
            Workflow.sleep(Duration.ofSeconds(5));
            log.info("[{}] 배송 요청 시작", req.orderId());
            shipping.requestShipment(req.orderId(), req.address());
            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    /* ==================================================================
     * 정답 3 — Workflow.getLogger 로 바꾸면 8줄 → 4줄
     * ------------------------------------------------------------------
     * 측정 (실행 중 kill -9 한 번 섞은 경우):
     *
     *   grep -c 'Q3WorkflowImpl' replay.log
     *     LoggerFactory 사용      : 8
     *     Workflow.getLogger 사용 : 4
     *
     * 왜 8줄이 되는가:
     *   코드에 log.info 가 4개 있는데, 워크플로우가 3번 실행되면서
     *   이미 지나간 로그가 반복 출력되기 때문이다.
     *     1회차 Workflow Task : "결제 시작"                       (1줄)
     *     2회차 Workflow Task : "결제 시작"(중복) + "결제 완료"     (2줄)
     *     3회차(재기동)       : "결제 시작"(중복) + "결제 완료"(중복)
     *                          + "재고 예약 시작"                  (3줄)
     *     4회차               : ... + "재고 예약 완료"             (2줄)
     *                                                    합계 8줄
     *
     * 내부 동작:
     *   Workflow.getLogger 는 ReplayAwareLogger 라는 래퍼를 돌려준다.
     *   대략 이런 구조다:
     *
     *     public void info(String msg, Object... args) {
     *         if (!Workflow.isReplaying()) {
     *             delegate.info(msg, args);
     *         }
     *     }
     *
     *   즉 "이미 히스토리에 있는 구간을 다시 지나가는 중"이면 출력을 버린다.
     *   그래서 각 사건이 정확히 한 번씩만 기록된다.
     *
     * 주의 — 액티비티에서는 반대다:
     *   액티비티 구현체에서 Workflow.getLogger 를 쓰면 워크플로우 컨텍스트 밖이라
     *   예외가 난다. 액티비티는 평범한 LoggerFactory 를 쓴다.
     *
     * 팀 규칙으로 강제하기 (ArchUnit 예시):
     *
     *   @ArchTest
     *   static final ArchRule 워크플로우는_Workflow_getLogger_를_쓴다 =
     *       noClasses()
     *           .that().haveSimpleNameEndingWith("WorkflowImpl")
     *           .should().callMethod(LoggerFactory.class, "getLogger", Class.class)
     *           .because("워크플로우 로그는 리플레이마다 중복 출력됩니다. "
     *                  + "Workflow.getLogger() 를 사용하세요.");
     *
     * 더 넓은 원칙:
     *   로거만의 문제가 아니다. 워크플로우 코드 안의 모든 관찰 가능성 작업이
     *   리플레이마다 반복된다 — 메트릭 카운터, 슬랙 알림, System.out.
     *   판단 기준은 하나다: "이 줄이 100번 반복 실행돼도 괜찮은가?"
     *   안 괜찮다면 액티비티로 빼라.
     * ================================================================== */
    @WorkflowInterface
    public interface Q3Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q3WorkflowImpl implements Q3Workflow {

        // 정답: Workflow.getLogger
        private static final Logger log = Workflow.getLogger(Q3WorkflowImpl.class);

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            log.info("[{}] 결제 시작 amount={}", req.orderId(), req.amount());
            String paymentId = payment.charge(req.orderId(), req.amount());
            log.info("[{}] 결제 완료 {}", req.orderId(), paymentId);

            Workflow.sleep(Duration.ofSeconds(5));

            log.info("[{}] 재고 예약 시작", req.orderId());
            String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
            log.info("[{}] 재고 예약 완료 {}", req.orderId(), reservationId);

            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    /* ==================================================================
     * 정답 4 — Command 매핑
     * ------------------------------------------------------------------
     *   ID  Type                          → 반환한 Command
     *   --  ----------------------------    -----------------------------
     *    4  WorkflowTaskCompleted           → ScheduleActivityTask(charge)
     *   10  WorkflowTaskCompleted           → StartTimer(5s)
     *   15  WorkflowTaskCompleted           → ScheduleActivityTask(reserve)
     *   21  WorkflowTaskCompleted           → CompleteWorkflowExecution
     *
     * 규칙이 왜 항상 성립하는가:
     *   Worker 는 Workflow Task 를 처리한 뒤 RespondWorkflowTaskCompleted 라는
     *   단 하나의 gRPC 호출로 (a) "처리 완료" 와 (b) "그 결과 만들어진 Command 목록" 을
     *   함께 보낸다. 서버는 이것을 받아
     *     ① WorkflowTaskCompleted 이벤트를 먼저 append
     *     ② 그 다음 각 Command 를 대응하는 Event 로 변환해 순서대로 append
     *   한다. 그래서 WorkflowTaskCompleted 바로 뒤에 오는 이벤트들이
     *   반드시 그 Task 가 반환한 Command 의 결과가 된다.
     *
     * Command → Event 대응표:
     *   ScheduleActivityTask              → ActivityTaskScheduled
     *   StartTimer                        → TimerStarted
     *   CompleteWorkflowExecution         → WorkflowExecutionCompleted
     *   FailWorkflowExecution             → WorkflowExecutionFailed
     *   StartChildWorkflowExecution       → StartChildWorkflowExecutionInitiated
     *   ContinueAsNewWorkflowExecution    → WorkflowExecutionContinuedAsNew
     *   RequestCancelActivityTask         → ActivityTaskCancelRequested
     *
     * 추가 질문 정답:
     *   (a) processOrder() 는 총 몇 번 실행됐나?
     *       → 4번. WorkflowTaskCompleted 가 4개(4, 10, 15, 21)이기 때문이다.
     *          Workflow Task 하나가 곧 processOrder() 한 번 전체 실행이다.
     *
     *   (b) 액티비티는 총 몇 번 실행됐나?
     *       → 2번. ActivityTaskStarted 가 2개(6, 17)다.
     *          코드는 4번 돌았지만 액티비티는 2번만 실행됐다 — 이 비대칭이 핵심이다.
     *
     *   (c) 이벤트 11 의 TimerStarted 는 코드의 어느 줄에서 나왔나?
     *       → Workflow.sleep(Duration.ofSeconds(5)) 줄.
     *          Workflow.sleep 은 실제로 스레드를 재우지 않는다. StartTimer Command 를
     *          만들고 코루틴을 yield 시킬 뿐이다. 5초는 서버가 세고, 만료되면
     *          TimerFired 를 기록하고 새 Workflow Task 를 스케줄한다.
     *          이것이 "워크플로우가 30일을 자도 리소스를 안 먹는" 이유다.
     * ================================================================== */

    /* ==================================================================
     * 정답 5 — Workflow.isReplaying() 으로 리플레이 관찰
     * ------------------------------------------------------------------
     * kill 을 섞어 실행한 출력 예:
     *
     *   >> 진입 #1  isReplaying=false     ← 첫 실행
     *   >> 진입 #2  isReplaying=true      ← charge 결과를 받아 이어감 (앞부분은 리플레이)
     *   --- kill -9 / 재기동 ---
     *   >> 진입 #1  isReplaying=true      ← 새 JVM. 카운터도 0부터. full replay
     *   >> 진입 #2  isReplaying=true
     *
     * 읽는 법:
     *   isReplaying 은 "지금 이 코드 라인이 히스토리에 이미 기록된 구간인가" 를 나타낸다.
     *   같은 processOrder() 실행 안에서도 앞부분은 true, 새로 진행하는 뒷부분은 false 가 된다.
     *   그래서 "진입 시점의 isReplaying" 은 "이번 Workflow Task 가 리플레이로 시작했는가" 를
     *   의미할 뿐, 실행 전체의 성격을 말하지 않는다.
     *
     * 왜 kill 을 섞어야 하는가:
     *   Sticky Execution 캐시 때문이다. Worker 가 워크플로우 인스턴스를 메모리에
     *   들고 있으면 다음 Workflow Task 는 리플레이 없이 "마지막 지점부터" 이어서 실행된다.
     *   즉 정상 경로에서는 리플레이가 거의 일어나지 않는다.
     *   캐시를 날려야(= Worker 재기동) full replay 를 관찰할 수 있다.
     *
     * 주의 — 카운터로 뭔가를 판단하지 말 것:
     *   진입 횟수는 캐시 히트 여부, Worker 재기동 타이밍, 서버 부하에 따라 매번 달라진다.
     *   "몇 번 실행됐는지"에 의존하는 로직은 어떤 형태든 잘못된 설계다.
     * ================================================================== */
    @WorkflowInterface
    public interface Q5Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q5WorkflowImpl implements Q5Workflow {
        private static final AtomicInteger ENTER = new AtomicInteger();

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

        @Override
        public String processOrder(OrderRequest req) {
            // log 가 아니라 System.out 이어야 리플레이 중에도 보인다.
            // (Workflow.getLogger 는 리플레이 중 출력을 억제하므로 관찰 목적에 안 맞는다)
            System.out.printf("  >> 진입 #%d  isReplaying=%s%n",
                    ENTER.incrementAndGet(), Workflow.isReplaying());

            payment.charge(req.orderId(), req.amount());
            Workflow.sleep(Duration.ofSeconds(5));
            payment.charge(req.orderId() + "-2", req.amount());

            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    /* ==================================================================
     * 정답 6 — Thread.sleep 과 static 카운터
     * ------------------------------------------------------------------
     * (a) Thread.sleep(3000) → Workflow.sleep(Duration.ofSeconds(3))
     * (b) counter++          → 액티비티로 이동 (MetricsActivity)
     *
     * (c) Thread.sleep 이 구체적으로 무엇을 망가뜨리는가 — 두 가지:
     *
     *   답 1) 워크플로우 코루틴 스레드를 진짜로 블로킹한다.
     *     Workflow Task 는 workflowTaskTimeout(기본 10초) 안에 응답해야 한다.
     *     3초를 자면 예산의 30%를 그냥 태운다. 액티비티가 여러 개라 리플레이가
     *     길어지면 10초를 넘겨 WorkflowTaskTimedOut 이 나고, 서버가 그 Task 를
     *     재스케줄해 처음부터 다시 시작한다. 그러면 또 3초를 자고... 무한 루프가 된다.
     *
     *     실제 히스토리:
     *       temporal workflow show -w order-4006
     *          ...
     *          14  WorkflowTaskTimedOut       ← 10초 초과
     *          15  WorkflowTaskScheduled      ← 재스케줄
     *          16  WorkflowTaskStarted
     *          17  WorkflowTaskTimedOut       ← 또 초과
     *          ...
     *
     *     또한 Worker 의 워크플로우 스레드는 유한하다(기본 600).
     *     동시 실행 중인 워크플로우가 600개를 넘고 각각 3초씩 자면
     *     "Timeout expired while waiting for a free workflow thread" 가 난다.
     *     즉 한 워크플로우의 Thread.sleep 이 워커 전체를 마비시킨다.
     *
     *   답 2) 리플레이할 때마다 다시 3초를 잔다.
     *     Workflow.sleep 은 히스토리에 TimerStarted/TimerFired 로 남으므로
     *     리플레이 때 "이미 지났음"으로 즉시 통과한다.
     *     Thread.sleep 은 히스토리에 아무 흔적도 남기지 않으므로
     *     리플레이할 때마다 실제로 3초를 다시 잔다.
     *     Workflow Task 가 10번 돌면 30초를 낭비한다. 히스토리가 길어질수록
     *     선형으로 느려지며, 결국 workflowTaskTimeout 을 넘긴다.
     *
     * Workflow.sleep 은 왜 안전한가:
     *   스레드를 재우지 않는다. StartTimer Command 를 만들고 코루틴을 yield 한 뒤
     *   Workflow Task 를 즉시 완료한다. 워크플로우 인스턴스는 캐시에서 축출되고
     *   Worker 는 아무 리소스도 붙들지 않는다. 3초 뒤 서버가 TimerFired 를 기록하고
     *   새 Workflow Task 를 스케줄한다.
     *   이 구조 덕분에 "30일 뒤에 리마인드" 같은 워크플로우가 리소스 0 으로 대기한다.
     *
     * counter 는 왜 액티비티로 빼야 하는가:
     *   static 필드는 리플레이마다 증가하므로 실제 실행 횟수와 무관한 값이 된다.
     *   Worker 를 재기동하면 JVM 이 새로 떠서 0 으로 리셋되기까지 한다.
     *   즉 이 값은 아무것도 의미하지 않는다.
     *   게다가 워크플로우 인스턴스 간에 공유되는 가변 static 상태는
     *   결정성 자체를 깨뜨린다 — 같은 히스토리로 리플레이해도 다른 값이 나온다.
     *   정답: metrics.countOrderStarted(orderId) 로 액티비티에 위임한다.
     *         액티비티는 리플레이되지 않으므로 정확히 한 번 실행된다.
     * ================================================================== */
    @WorkflowInterface
    public interface Q6Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

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

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

        // 정답 (b): 카운터를 액티비티로 위임
        private final MetricsActivity metrics =
                Workflow.newActivityStub(MetricsActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            // static counter++ 대신 액티비티 호출.
            // 리플레이되지 않으므로 정확히 한 번만 증가한다.
            metrics.countOrderStarted(req.orderId());

            payment.charge(req.orderId(), req.amount());

            // 정답 (a): Thread.sleep -> Workflow.sleep
            //   스레드를 블로킹하지 않고, 히스토리에 TimerStarted/TimerFired 로 남아
            //   리플레이 때 즉시 통과한다.
            Workflow.sleep(Duration.ofSeconds(3));

            payment.charge(req.orderId() + "-2", req.amount());

            log.info("[{}] 완료", req.orderId());
            return "order-" + req.orderId() + " COMPLETED";
        }
    }

    // ==================================================================
    // Worker
    // ==================================================================
    public static class WorkerMain {
        public static void main(String[] args) {
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());
            WorkerFactory factory = WorkerFactory.newInstance(client);
            Worker worker = factory.newWorker(ORDER_TASK_QUEUE);

            worker.registerWorkflowImplementationTypes(
                    Q12WorkflowImpl.class, Q3WorkflowImpl.class,
                    Q5WorkflowImpl.class, Q6WorkflowImpl.class);
            worker.registerActivitiesImplementations(
                    new PaymentActivityImpl(),
                    new InventoryActivityImpl(),
                    new ShippingActivityImpl(),
                    new MetricsActivityImpl());

            factory.start();
            System.out.println("Solution Worker started. queue=" + ORDER_TASK_QUEUE);

            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                System.out.println();
                System.out.println("--------------------------------------------");
                System.out.println(" 액티비티 실제 실행 횟수 (리플레이해도 안 늘어남)");
                System.out.println("   charge          : " + INVOKE_CHARGE.get());
                System.out.println("   reserve         : " + INVOKE_RESERVE.get());
                System.out.println("   requestShipment : " + INVOKE_SHIP.get());
                System.out.println("   order.started   : " + MetricsActivityImpl.COUNTER.get());
                System.out.println("--------------------------------------------");
            }));
        }
    }

    // ==================================================================
    // Client
    // ==================================================================
    public static class StarterMain {

        public static void main(String[] args) {
            String no = (args.length > 0) ? args[0] : "1";
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());

            switch (no) {
                case "1" -> q1(client);
                case "2" -> q2(client);
                case "3" -> q3(client);
                case "4" -> System.out.println("정답 4 는 파일 주석의 Command 매핑표를 보세요.");
                case "5" -> q5(client);
                case "6" -> q6(client);
                default -> System.out.println("문제 번호는 1~6 입니다.");
            }
            System.exit(0);
        }

        static void q1(WorkflowClient client) {
            Q12Workflow w = client.newWorkflowStub(Q12Workflow.class, opts("order-5001"));
            System.out.println("결과: " + w.processOrder(sample("5001")));
            System.out.println("정답: " + EXPECTED_EVENT_COUNT + " 이벤트");
            System.out.println("검증: temporal workflow describe -w order-5001");
            System.out.println("      → History Length 33");
        }

        static void q2(WorkflowClient client) {
            System.out.println("★ '결제 요청' 로그가 뜨면 5초 안에: kill -9 $(pgrep -f Solution)");
            Q12Workflow w = client.newWorkflowStub(Q12Workflow.class, opts("order-5002"));
            long t0 = System.currentTimeMillis();
            System.out.println("결과: " + w.processOrder(sample("5002")));
            System.out.println("소요: " + (System.currentTimeMillis() - t0) + "ms");
            System.out.println();
            System.out.println("검증 명령:");
            System.out.println("  temporal workflow describe -w order-5002    → History Length 33");
            System.out.println("  temporal workflow show -w order-5002 --output json \\");
            System.out.println("    | jq '[.events[] | select(.eventType==\"ActivityTaskStarted\")");
            System.out.println("           | .activityTaskStartedEventAttributes.attempt]'");
            System.out.println("                                              → [1,1,1]");
        }

        static void q3(WorkflowClient client) {
            Q3Workflow w = client.newWorkflowStub(Q3Workflow.class, opts("order-5003"));
            System.out.println("결과: " + w.processOrder(sample("5003")));
            System.out.println("grep -c 'Q3WorkflowImpl' replay.log  → 4 (LoggerFactory 였다면 8)");
        }

        static void q5(WorkflowClient client) {
            System.out.println("★ 실행 중 kill -9 를 섞으세요. isReplaying 값 변화를 관찰합니다.");
            Q5Workflow w = client.newWorkflowStub(Q5Workflow.class, opts("order-5005"));
            System.out.println("결과: " + w.processOrder(sample("5005")));
        }

        static void q6(WorkflowClient client) {
            Q6Workflow w = client.newWorkflowStub(Q6Workflow.class, opts("order-5006"));
            System.out.println("결과: " + w.processOrder(sample("5006")));
            System.out.println();
            System.out.println("검증: temporal workflow show -w order-5006");
            System.out.println("  → WorkflowTaskTimedOut 이 없다. Workflow.sleep 은 스레드를 안 잡는다.");
            System.out.println("  → TimerStarted / TimerFired 가 히스토리에 남아 리플레이 때 즉시 통과한다.");
            System.out.println("  → order.started 카운터는 정확히 1 이다 (액티비티로 뺐으므로).");
        }

        static WorkflowOptions opts(String workflowId) {
            return WorkflowOptions.newBuilder()
                    .setTaskQueue(ORDER_TASK_QUEUE)
                    .setWorkflowId(workflowId)
                    .build();
        }

        static OrderRequest sample(String orderId) {
            return new OrderRequest(
                    orderId, "cust-77", "SKU-BLACK-TEE", 2, 39000L, "서울시 강남구 테헤란로 1");
        }
    }

    // ==================================================================
    // 뒷정리
    // ==================================================================
    public static class Cleanup {
        public static void main(String[] args) {
            WorkflowClient client = WorkflowClient.newInstance(
                    WorkflowServiceStubs.newLocalServiceStubs());
            for (int i = 5001; i <= 5006; i++) {
                String id = "order-" + i;
                try {
                    client.newUntypedWorkflowStub(id).terminate("solution cleanup");
                    System.out.println("terminated " + id);
                } catch (Exception e) {
                    System.out.println("skip " + id);
                }
            }
            System.exit(0);
        }
    }
}