dependencies {
  // 1. CircuitBreaker : 장애 전파 방지 기능 제공
  implementation("io.github.resilience4j:resilience4j-circuitbreaker:${resilience4jVersion}")
  // 2. Retry : 요청 실패 시 재시도 처리 기능 제공
  implementation("io.github.resilience4j:resilience4j-retry:${resilience4jVersion}")
  // 3. RateLimiter : 제한치를 넘어서 요청을 거부하거나 Queue 생성하여 처리하는 기능 제공
  implementation("io.github.resilience4j:resilience4j-ratelimiter:${resilience4jVersion}")
  // 4. TimeLimiter : 실행 시간제한 설정 기능 제공
  implementation("io.github.resilience4j:resilience4j-timelimiter:${resilience4jVersion}")
  // 5. Bulkhead : 동시 실행 횟수 제한 기능 제공
  implementation("io.github.resilience4j:resilience4j-bulkhead:${resilience4jVersion}")
  // 6. Cache : 결과 캐싱 기능 제공
  implementation("io.github.resilience4j:resilience4j-cache:${resilience4jVersion}")
}

public class CircuitBreakerConfigurationProperties extends
    io.github.resilience4j.common.circuitbreaker.configuration.CircuitBreakerConfigurationProperties {
    private int circuitBreakerAspectOrder = Ordered.LOWEST_PRECEDENCE - 3;
}

public class RetryConfigurationProperties extends
    io.github.resilience4j.common.retry.configuration.RetryConfigurationProperties {
    private int retryAspectOrder = Ordered.LOWEST_PRECEDENCE - 4;
}

@Aspect
public class CircuitBreakerAspect implements Ordered {
   @Override
    public int getOrder() {
        return circuitBreakerProperties.getCircuitBreakerAspectOrder();
    }
}

implementation("org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j:2.1.6")
implementation("org.springframework.boot:spring-boot-starter-actuator")

resilience4j:
  circuitbreaker:
    failure-rate-threshold: 10   # 실패 10% 이상 시 서킷 오픈
    slow-call-duration-threshold: 500   # 500ms 이상 소요 시 실패로 간주
    slow-call-rate-threshold: 10   # slowCallDurationThreshold 초과 비율이 10% 이상 시 서킷 오픈
    wait-duration-in-open-state: 30000   # OPEN -> HALF-OPEN 전환 전 기다리는 시간
    minimum-number-of-calls: 50   # 집계에 필요한 최소 호출 수
    sliding-window-size: 100   # 서킷 CLOSE 상태에서 N회 호출 도달 시 failureRateThreshold 실패 비율 계산
    permitted-number-of-calls-in-half-open-state: 30   # HALFOPEN -> CLOSE or OPEN 으로 판단하기 위해 호출 횟수
  retry:
    wait-duration: 100   # 재시도 사이 간격
    max-attempts: 2   # 재시도 횟수(최초 호출 포함)

@Configuration
@ConfigurationProperties(prefix = "resilience4j.circuitbreaker")
class CircuitBreakerProperty {
   var failureRateThreshold: Float = Float.MIN_VALUE
   var slowCallDurationThreshold: Long = Long.MIN_VALUE
   var slowCallRateThreshold: Float = Float.MIN_VALUE
   var waitDurationInOpenState: Long = Long.MIN_VALUE
   var minimumNumberOfCalls: Int = Int.MIN_VALUE
   var slidingWindowSize: Int = Int.MIN_VALUE
   var permittedNumberOfCallsInHalfOpenState: Int = Int.MIN_VALUE
}

@Configuration
class CircuitBreakerProvider(
    val circuitBreakerProperty: CircuitBreakerProperty
) {
    companion object {
        const val CIRCUIT_REDIS: String = "CB_REDIS"
    }

    @Bean
    fun circuitBreakerRegistry(): CircuitBreakerRegistry {
        return CircuitBreakerRegistry.ofDefaults()
    }

    @Bean
    fun redisCircuitBreaker(circuitBreakerRegistry: CircuitBreakerRegistry): CircuitBreaker {
        return circuitBreakerRegistry.circuitBreaker(
            CIRCUIT_REDIS, CircuitBreakerConfig.custom()
                .failureRateThreshold(circuitBreakerProperty.failureRateThreshold)
                .slowCallDurationThreshold(Duration.ofMillis(circuitBreakerProperty.slowCallDurationThreshold))
                .slowCallRateThreshold(circuitBreakerProperty.slowCallRateThreshold)
                .waitDurationInOpenState(Duration.ofMillis(circuitBreakerProperty.waitDurationInOpenState))
                .minimumNumberOfCalls(circuitBreakerProperty.minimumNumberOfCalls)
                .slidingWindowSize(circuitBreakerProperty.slidingWindowSize)
                .ignoreExceptions(StockManageException::class.java)   // 화이트리스트로 서킷 오픈 기준 관리
                .permittedNumberOfCallsInHalfOpenState(circuitBreakerProperty.permittedNumberOfCallsInHalfOpenState)
                .build()
        )
    }
}

@Configuration
class Resilience4jOrderConfig(
    val circuitBreakerConfigurationProperties: CircuitBreakerConfigurationProperties,
    val retryConfigurationProperties: RetryConfigurationProperties
) {
    companion object {
        const val PRIORITY_1 = -3
        const val PRIORITY_2 = -4
    }

    @PostConstruct
    fun setOrder() {
        circuitBreakerConfigurationProperties.circuitBreakerAspectOrder = PRIORITY_2
        retryConfigurationProperties.retryAspectOrder = PRIORITY_1
    }
}

@Repository
class StockRepository(
    val redisManager: RedisManager<Stock, Key>, // Redis
    val integratedStockRepository: IntegratedStockRepository // RDB
) {
    /** Service layer 에서 사용할 조회 메소드 */
    @Retry(name = RetryProvider.RETRY_REDIS)
    @CircuitBreaker(name = CircuitBreakerProvider.CIRCUIT_REDIS, fallbackMethod = "fallbackOnFind")
    fun find(storeId: String, productId: String): Stock {
       return redisManager.findByKey(StockKey(storeId, productId))   // REDIS 조회
    }

    /** StockManageException(Redis Miss) 에 대한 fallback */
    private fun fallbackOnFind(storeId: String, productId: String, e: StockManageException): Stock {
       return integratedStockRepository.find(storeId = storeId, productId = productId).also {
          redisManager.saveByKey(StockKey(storeId, productId), it)   // REDIS 조회 후 저장
       }
    }

    /** Circuit이 Open 상태일 때 fallback */
    private fun fallbackOnFind(storeId: String, productId: String, e: CallNotPermittedException): Stock {
       log.warn("circuit opened!")
       return integratedStockRepository.find(storeId = storeId, productId = productId)  // RDB 조회
    }

    /** 그외 Exception 에 대한 fallback */
    private fun fallbackOnFind(storeId: String, productId: String, e: Throwable): Stock {
       return integratedStockRepository.find(storeId = storeId, productId = productId)  // RDB 조회
    }
}

    @MockBean
    lateinit var redisManager: RedisManager

    @MockBean
    lateinit var integratedStockRepository: IntegratedStockRepository

    @BeforeEach
    fun setup() {
        circuitBreakerService.closeCircuit(CIRCUIT_REDIS)
    }

    @Test
    fun fallbackTest() {
        val requestDto: IntegratedStocksRequestDto<IntegratedStockRequestDto.Find> =
            IntegratedStocksRequestDto(listOf(IntegratedStockRequestDto.Find("sid", "pid")))

        `when`(
            redisManager.findByKey(StockKey("sid", "pid"))
        ).thenThrow(StockManageException(CustomResponseCodes.StockCustomCodes(StockResponseCodes.MISSED)))

        integratedStockController.findAll(requestDto)

        verify(
            integratedStockRepository,
            atLeast(1)
        ).find("sid", "pid")
    }

    @Test
    fun circuitOpenTest() {
        val requestDto: IntegratedStocksRequestDto<IntegratedStockRequestDto.Find> =
            IntegratedStocksRequestDto(listOf(IntegratedStockRequestDto.Find("sid", "pid")))

        `when`(
            redisManager.findByKey(StockKey("sid", "pid"))
        ).thenReturn(
            Stock.of("sid","pid")
        )

        circuitBreakerService.openCircuit(CIRCUIT_REDIS)    // circuit state changed to OPEN
        integratedStockController.findAll(requestDto)

        verify(
            stockManageService,
            never()
        ).findByKey(StockKey("sid", "pid"))
    }

    @Test
    fun circuitCloseTest() {
        val requestDto: IntegratedStocksRequestDto<IntegratedStockRequestDto.Find> =
            IntegratedStocksRequestDto(listOf(IntegratedStockRequestDto.Find("sid", "pid")))

        `when`(
            redisManager.findByKey(StockKey("sid", "pid"))
        ).thenReturn(
            Stock.of("sid","pid")
        )

        integratedStockController.findAll(requestDto)

        verify(
            stockManageService,
            atLeast(1)
        ).findByKey(StockKey("sid", "pid"))
    }

management.endpoints.web.base-path=/api/actuator
management.endpoint.health.show-details=always
management.health.circuitbreakers.enabled= true
management.health.retry.enabled= true
resilience4j.circuitbreaker.configs.default.registerHealthIndicator= true

"circuitBreakers": {
    "status": "UP",
    "details": {
      "CB_REDIS": {
        "status": "UP",
        "details": {
          "failureRate": "-1.0%",
          "failureRateThreshold": "10.0%",
          "slowCallRate": "-1.0%",
          "slowCallRateThreshold": "100.0%",
          "bufferedCalls": 0,
          "slowCalls": 0,
          "slowFailedCalls": 0,
          "failedCalls": 0,
          "notPermittedCalls": 0,
          "state": "CLOSED"
        }
      }
    }
  }