spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=1
            - name: CircuitBreaker
              args:
                name: userService
                fallbackUri: forward:/fallback/user
        
        - id: order-service
          uri: lb://ORDER-SERVICE
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=1
            - AddRequestHeader=X-Request-Id, ${spring.cloud.sleuth.traceId}

# Eureka Server Configuration
server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

# Client Configuration
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 30
    lease-expiration-duration-in-seconds: 90

@Configuration
public class ResilienceConfig {
    
    @Bean
    public CircuitBreakerConfig circuitBreakerConfig() {
        return CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofMillis(1000))
            .slidingWindowSize(10)
            .permittedNumberOfCallsInHalfOpenState(3)
            .recordExceptions(IOException.class, 
                            TimeoutException.class)
            .build();
    }
    
    @Bean
    public CircuitBreakerRegistry circuitBreakerRegistry() {
        return CircuitBreakerRegistry.of(circuitBreakerConfig());
    }
}

@Service
public class ExternalService {
    
    @CircuitBreaker(name = "externalService", 
                   fallbackMethod = "fallback")
    public String callExternalService() {
        // Call external service
        return restTemplate.getForObject(url, String.class);
    }
    
    public String fallback(Exception ex) {
        return "Fallback response due to: " + ex.getMessage();
    }
}

// Order Service Main Application
@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
@EnableFeignClients
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

// Order Entity
@Entity
@Table(name = "orders")
@Data
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private String id;
    
    private String userId;
    private List<OrderItem> items;
    private BigDecimal totalAmount;
    private OrderStatus status;
    private LocalDateTime createdAt;
}

// Order Service Implementation
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    
    private final OrderRepository orderRepository;
    private final ProductServiceClient productService;
    private final PaymentServiceClient paymentService;
    private final CircuitBreakerFactory circuitBreakerFactory;
    
    @Override
    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        // Validate products
        List<Product> products = circuitBreakerFactory.create("productService")
            .run(() -> productService.validateProducts(request.getItems()),
                 throwable -> {
                     log.error("Product service unavailable", throwable);
                     throw new ServiceUnavailableException("Product service unavailable");
                 });
        
        // Calculate total
        BigDecimal total = calculateTotal(products, request.getItems());
        
        // Create order
        Order order = Order.builder()
            .userId(request.getUserId())
            .items(request.getItems())
            .totalAmount(total)
            .status(OrderStatus.PENDING)
            .createdAt(LocalDateTime.now())
            .build();
        
        order = orderRepository.save(order);
        
        // Process payment asynchronously
        processPaymentAsync(order);
        
        return order;
    }
    
    @Async
    public void processPaymentAsync(Order order) {
        try {
            PaymentResponse payment = paymentService.processPayment(
                new PaymentRequest(order.getId(), order.getTotalAmount())
            );
            
            if (payment.isSuccess()) {
                order.setStatus(OrderStatus.CONFIRMED);
                // Publish order confirmed event
                eventPublisher.publishEvent(new OrderConfirmedEvent(order));
            } else {
                order.setStatus(OrderStatus.FAILED);
            }
            
            orderRepository.save(order);
            
        } catch (Exception e) {
            log.error("Payment processing failed", e);
            order.setStatus(OrderStatus.FAILED);
            orderRepository.save(order);
        }
    }
}

// Feign Client for Product Service
@FeignClient(name = "product-service", 
             configuration = FeignConfig.class,
             fallback = ProductServiceFallback.class)
public interface ProductServiceClient {
    
    @PostMapping("/api/products/validate")
    List<Product> validateProducts(@RequestBody List<OrderItem> items);
    
    @GetMapping("/api/products/{id}")
    Product getProduct(@PathVariable String id);
}

// Circuit Breaker Configuration
@Configuration
public class CircuitBreakerConfig {
    
    @Bean
    public Customizer<Resilience4JCircuitBreakerFactory> defaultCustomizer() {
        return factory -> factory.configureDefault(id -> 
            Resilience4JConfigBuilder.of(id)
                .circuitBreakerConfig(CircuitBreakerConfig.custom()
                    .failureRateThreshold(50)
                    .slowCallRateThreshold(100)
                    .waitDurationInOpenState(Duration.ofSeconds(5))
                    .slidingWindowSize(10)
                    .minimumNumberOfCalls(5)
                    .build())
                .timeLimiterConfig(TimeLimiterConfig.custom()
                    .timeoutDuration(Duration.ofSeconds(3))
                    .build())
                .build()
        );
    }
}

// API Gateway Routes Configuration
spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=1
            - name: CircuitBreaker
              args:
                name: orderService
                fallbackUri: forward:/fallback/order
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
            - AddRequestHeader=X-User-Id, ${user.id}

// Trip Service publishes event
tripService.completeTrip(tripId) {
    // Update trip status
    trip.status = COMPLETED;
    tripRepository.save(trip);
    
    // Publish event
    eventBus.publish("trip.completed", {
        tripId: trip.id,
        driverId: trip.driverId,
        riderId: trip.riderId,
        amount: trip.amount,
        completedAt: new Date()
    });
}

// Billing Service subscribes
billingService.subscribe("trip.completed", (event) => {
    // Create invoice
    const invoice = createInvoice(event);
    billingRepository.save(invoice);
    
    // Send to payment service
    paymentService.processPayment(invoice);
});

// Notification Service subscribes
notificationService.subscribe("trip.completed", (event) => {
    // Send receipt to rider
    emailService.sendReceipt(event.riderId, event);
    
    // Notify driver
    pushService.notifyDriver(event.driverId, "Trip completed");
});