@Service
public class PaymentService {
    private final Retry retry = Retry.of("paymentRetry", RetryConfig.custom()
        .maxAttempts(3)
        .waitDuration(Duration.ofMillis(500))
        .retryExceptions(RuntimeException.class)
        .build()
    );

    public String processPayment() {
        Callable<String> decorated = Retry.decorateCallable(retry, this::callPaymentGateway);
        try {
            return decorated.call();
        } catch (Exception ex) {
            return "❌ All retries failed!";
        }
    }

    private String callPaymentGateway() {
        if (Math.random() < 0.8) throw new RuntimeException("Gateway timeout");
        return "✅ Payment processed";
    }
}

@Service
public class ExternalApiService {
    private final CircuitBreaker circuitBreaker = CircuitBreaker.of("externalApiCB", CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .waitDurationInOpenState(Duration.ofSeconds(5))
        .slidingWindowSize(10)
        .build()
    );

    public String fetchData() {
        Callable<String> decorated = CircuitBreaker.decorateCallable(circuitBreaker, this::callExternalApi);
        try {
            return decorated.call();
        } catch (CallNotPermittedException ex) {
            return "⛔ Circuit is open. Using fallback!";
        } catch (Exception ex) {
            return "❌ API call failed!";
        }
    }

    private String callExternalApi() {
        if (Math.random() < 0.7) throw new RuntimeException("External service error");
        return "✅ Data from external API";
    }
}

@Service
public class ReportService {
    private final Bulkhead bulkhead = Bulkhead.of("generateReportBulkhead", BulkheadConfig.custom()
        .maxConcurrentCalls(2)
        .maxWaitDuration(Duration.ofMillis(500))
        .build()
    );

    public String generateReport() {
        Callable<String> decorated = Bulkhead.decorateCallable(bulkhead, () -> {
            simulateHeavyComputation();
            return "✅ Report generated!";
        });
        try {
            return decorated.call();
        } catch (BulkheadFullException ex) {
            return "🚫 System busy. Try again later.";
        } catch (Exception e) {
            return "❌ Unexpected error.";
        }
    }

    private void simulateHeavyComputation() throws InterruptedException {
        Thread.sleep(2000);
    }
}