@Service
@Slf4j
public class QuoteOrchestrationService {
  @Autowired private WebClient customerServiceClient;
  @Autowired private WebClient pricingServiceClient;
  @Autowired private WebClient inventoryServiceClient;
  @Autowired private WebClient productServiceClient;
  @Autowired private KafkaTemplate<String, QuoteEvent> kafkaTemplate;
  @Autowired private CircuitBreakerRegistry circuitBreakerRegistry;

  @Transactional
  @CircuitBreaker(name = "quoteProcessing", fallbackMethod = "fallbackQuote")
  @TimeLimiter(name = "quoteProcessing")
  @Retry(name = "quoteProcessing", fallbackMethod = "fallbackQuote")
  public Mono<QuoteResponse> processQuoteRequest(QuoteRequest request) {
    log.info("Orchestrating quote request for customer: {}", request.getCustomerId());

    // Step 1: Validate customer & get pricing tier
    return customerServiceClient.get()
        .uri("/api/customers/{id}/pricing-tier", request.getCustomerId())
        .retrieve()
        .bodyToMono(CustomerPricingTier.class)
        .doOnError(e -> log.error("Customer service failed", e))
        .retryWhen(Retry.backoff(3, Duration.ofMillis(500)))

        // Step 2: Fetch product details and check inventory
        .flatMap(pricingTier -> {
          List<Mono<ProductDetails>> productMonos = request.getProductIds().stream()
              .map(productId -> productServiceClient.get()
                  .uri("/api/products/{id}", productId)
                  .retrieve()
                  .bodyToMono(ProductDetails.class)
                  .zipWith(inventoryServiceClient.get()
                      .uri("/api/inventory/{id}/availability", productId)
                      .retrieve()
                      .bodyToMono(InventoryStatus.class))
                  .map(tuple -> enrichProductWithInventory(tuple.getT1(), tuple.getT2())))
              .collect(Collectors.toList());

          return Mono.zip(productMonos, products ->
              Arrays.stream(products).map(p -> (ProductDetails) p).collect(Collectors.toList()))
              .map(products -> new Tuple2<>(pricingTier, products));
        })

        // Step 3: Calculate dynamic pricing with business rules
        .flatMap(tuple -> {
          CustomerPricingTier tier = tuple.getT1();
          List<ProductDetails> products = tuple.getT2();

          PricingRequest pricingRequest = PricingRequest.builder()
              .customerId(request.getCustomerId())
              .pricingTier(tier)
              .products(products)
              .requestedQuantities(request.getQuantities())
              .seasonalFactors(getSeasonalFactors())
              .competitorPricing(getCompetitorPricing(products))
              .build();

          return pricingServiceClient.post()
              .uri("/api/pricing/calculate")
              .bodyValue(pricingRequest)
              .retrieve()
              .bodyToMono(PricingResponse.class)
              .map(pricing -> buildQuoteResponse(request, tier, products, pricing));
        })

        // Step 4: Publish quote event for downstream systems
        .doOnSuccess(quote -> {
          QuoteEvent event = new QuoteEvent(quote.getQuoteId(), "QUOTE_GENERATED",
              quote.getTotalAmount(), Instant.now());
          kafkaTemplate.send("quote-events", event);
          log.info("Published quote event: {}", quote.getQuoteId());
        })

        // Step 5: Comprehensive error handling
        .doOnError(e -> {
          log.error("Quote orchestration failed for request: {}", request.getId(), e);
          sendAlertToOps("Quote processing failure", e);
        });
  }

  // I wrote this. I understand every line. I control every outcome.
  // But maintaining this across 23 services? That's the challenge.
}