implementation 'org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j'
    implementation 'io.github.resilience4j:resilience4j-all'
    implementation 'org.springframework.boot:spring-boot-starter-aop'

    /**
     * hotDealService 재고 점유 요청
     */
    @Retry(name = "custom", fallbackMethod = "fallbackForRetryReserveStock")
    @CircuitBreaker(name = "custom", fallbackMethod = "fallBackForCircuitBreakerReserveStock")
    public ProductReservationResponseDto reserveStock(ProductReservationRequestDto requestDto) {
        log.info("===[재고 점유 요청 실행]===");
        return hotDealServiceClient.reserveStock(requestDto);
    }

    // stock Reserve CircuitBreaker Fallback
    private ProductReservationResponseDto fallBackForCircuitBreakerReserveStock(ProductReservationRequestDto requestDto, Throwable throwable) {
        log.error("[CircuitBreaker Fallback] hotDeal-service 호출 실패. orderId={}, error={}", requestDto.getOrderId(), throwable.getMessage());
        if(throwable instanceof OrderException) throw (OrderException) throwable;
        return new ProductReservationResponseDto(true);
    }

    // stock Reserve Retry Fallback
    private ProductReservationResponseDto fallbackForRetryReserveStock(ProductReservationRequestDto requestDto, Throwable throwable) {
        log.error("[RETRY Fallback] hotDeal-service 호출 최종 재시도 실패. orderId={}, error={}", requestDto.getOrderId(), throwable.getMessage());
        if(throwable instanceof OrderException) throw (OrderException) throwable;
        throw new RuntimeException();
    }

@Component
@Slf4j(topic = "FeignErrorDecoder")
public class FeignErrorDecoder implements ErrorDecoder {

    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public Exception decode(String methodKey, Response response) {
        String errorMessage = "null";
        try {
            if (response.body() != null) {
                byte[] bodyBytes = response.body().asInputStream().readAllBytes();
                String responseBody = new String(bodyBytes);
                Map<String, String> errorMap = objectMapper.readValue(responseBody, new TypeReference<>() {
                });
                errorMessage = errorMap.getOrDefault("errorMessage", "Unknown ErrorMessage");
            } else {
                // body가 없는 경우
                errorMessage = String.format("Feign 호출 실패: 응답 body 없음 (methodKey: %s, status: %d)", methodKey, response.status());
            }
        } catch (IOException e) {
            log.info("Feign Client 응답 파싱 실패");
        }

        int status = response.status();
   

        /**
         * hotdealService
         */
        // 재고 점유 요청
        if (methodKey.contains("HotDealServiceClient#reserveStock")){
            if (status == 503) {
                log.error("HotDealServiceClient#reserveStock. 503 응답. StatusCode = {}, ErrorMessage = {}" ,status ,errorMessage);
                return FeignException.errorStatus(methodKey, response);
            }
            else if(status == 400){
                log.error("HotDealServiceClient#reserveStock. 400 응답. ErrorMessage = {}" ,errorMessage);
                throw new OrderException(ErrorCode.ORDER_RESERVE_STOCK_BAD_REQUEST, errorMessage);
            }
            else if(status == 404){
                log.error("HotDealServiceClient#reserveStock. 404 응답. ErrorMessage = {}" ,errorMessage);
                throw new OrderException(ErrorCode.ORDER_RESERVE_STOCK_NOT_FOUND, errorMessage);
            }
        }

//// 이하 생략

@SpringBootTest
public class CircuitBreakerTest {

    @Autowired
    OrderService orderService;

    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;

    @MockitoBean
    HotDealServiceClient hotDealServiceClient;

    private Long userId = 1L;

    // CircuitBreaker 각 테스트 케이스 이전에 초기화
    @BeforeEach
    void resetCircuitBreaker() {
        circuitBreakerRegistry.circuitBreaker("custom").reset();
    }

    // Retry, CircuitBreaker 무시, OrderException 생겨야함, 최종 결과 CLOSED
    @Test
    public void Ignore(){
        //given
        OrderRequestDto orderRequestDto = generateOrderRequest();

        Mockito.when(hotDealServiceClient.reserveStock(any()))
                .thenThrow(new OrderException(ErrorCode.ORDER_HOTDEAL_SERVICE_FAILED, "요청 수량보다 재고가 부족합니다. productIds = [1]"));

        //when, then
        for(int i = 1; i <= 11; i++){
            Assertions.assertThatThrownBy(() -> orderService.createOrder(userId, orderRequestDto)).isInstanceOf(OrderException.class);
        }
        CircuitBreaker cb = circuitBreakerRegistry.circuitBreaker("custom");
        Assertions.assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.CLOSED);
    }


    // Retry, CircuitBreaker 대상, 최종 결과 OPEN 
    @Test
    public void OPEN(){
        //given
        OrderRequestDto orderRequestDto = generateOrderRequest();

        Response response = generateResponse();
        FeignException feignException = FeignException.errorStatus("HotDealServiceClient#reserveStock", response);
        Mockito.when(hotDealServiceClient.reserveStock(any())).thenThrow(feignException);

        //when, then
        for(int i = 1; i <= 11; i++){
            Assertions.assertThatThrownBy(() -> orderService.createOrder(userId, orderRequestDto));
        }
        CircuitBreaker cb = circuitBreakerRegistry.circuitBreaker("custom");
        Assertions.assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.OPEN);
    }

    private OrderRequestDto generateOrderRequest() {
        return new OrderRequestDto("city", "street", "zipCode", List.of(new OrderProductRequest(1L, 1)));
    }

    private Response generateResponse() {
        return Response.builder()
                .status(503)
                .reason("Service Unavailable")
                .request(Request.create(Request.HttpMethod.POST, "/hotdeal/reserve", Map.of(), null, new RequestTemplate()))
                .headers(Map.of())
                .body("Service Down", StandardCharsets.UTF_8)
                .build();
    }
}