Temporal: Workflow Orchestration

// Workflow definition
@WorkflowInterface
public interface OrderProcessingWorkflow {
    @WorkflowMethod
    OrderResult processOrder(OrderRequest request);
}

// Workflow implementation
@WorkflowImplementation(OrderProcessingWorkflow.class)
public class OrderProcessingWorkflowImpl implements OrderProcessingWorkflow {
    
    private final PaymentActivities paymentActivities = 
        Workflow.newActivityStub(PaymentActivities.class,
            ActivityOptions.newBuilder()
                .setScheduleToCloseTimeout(Duration.ofMinutes(5))
                .setRetryOptions(RetryOptions.newBuilder()
                    .setMaximumAttempts(3)
                    .build())
                .build());
    
    private final InventoryActivities inventoryActivities = 
        Workflow.newActivityStub(InventoryActivities.class);
    
    @Override
    public OrderResult processOrder(OrderRequest request) {
        // Step 1: Validate and reserve inventory
        ReservationResult reservation = inventoryActivities.reserveItems(request.getItems());
        
        // Step 2: Process payment with timeout and retry
        PaymentResult payment = paymentActivities.processPayment(
            request.getPaymentInfo(), reservation.getTotalAmount());
        
        // Step 3: Fulfill order if payment successful
        if (payment.isSuccessful()) {
            FulfillmentResult fulfillment = inventoryActivities.fulfillOrder(reservation);
            return OrderResult.success(fulfillment.getTrackingNumber());
        } else {
            // Compensate: Release reserved inventory
            inventoryActivities.releaseReservation(reservation);
            return OrderResult.failure(payment.getErrorMessage());
        }
    }
}

// Saga workflow for distributed transaction
@WorkflowImplementation(BookingWorkflow.class)
public class BookingWorkflowImpl implements BookingWorkflow {
    
    private final FlightActivities flightActivities = 
        Workflow.newActivityStub(FlightActivities.class);
    private final HotelActivities hotelActivities = 
        Workflow.newActivityStub(HotelActivities.class);
    private final CarActivities carActivities = 
        Workflow.newActivityStub(CarActivities.class);
    private final PaymentActivities paymentActivities = 
        Workflow.newActivityStub(PaymentActivities.class);
    
    @Override
    public BookingResult bookTrip(TripRequest request) {
        List<CompensationAction> compensations = new ArrayList<>();
        
        try {
            // Step 1: Book flight
            FlightBooking flight = flightActivities.bookFlight(
                request.getFlightDetails());
            compensations.add(() -> flightActivities.cancelFlight(flight.getId()));
            
            // Step 2: Book hotel
            HotelBooking hotel = hotelActivities.bookHotel(
                request.getHotelDetails());
            compensations.add(() -> hotelActivities.cancelHotel(hotel.getId()));
            
            // Step 3: Book car rental
            CarBooking car = carActivities.bookCar(request.getCarDetails());
            compensations.add(() -> carActivities.cancelCar(car.getId()));
            
            // Step 4: Process payment
            PaymentResult payment = paymentActivities.processPayment(
                calculateTotal(flight, hotel, car), request.getPaymentMethod());
            
            if (payment.isSuccessful()) {
                // Send confirmation
                sendConfirmation(request.getCustomerEmail(), flight, hotel, car);
                return BookingResult.success(generateItinerary(flight, hotel, car));
            } else {
                throw new PaymentFailedException("Payment failed: " + payment.getErrorMessage());
            }
            
        } catch (Exception e) {
            // Execute compensations in reverse order
            executeCompensations(compensations);
            return BookingResult.failure(e.getMessage());
        }
    }
    
    private void executeCompensations(List<CompensationAction> compensations) {
        // Execute compensations in reverse order (LIFO)
        for (int i = compensations.size() - 1; i >= 0; i--) {
            try {
                compensations.get(i).compensate();
            } catch (Exception e) {
                // Log compensation failure but continue
                Workflow.getLogger(this.getClass()).error("Compensation failed", e);
            }
        }
    }
    
    private interface CompensationAction {
        void compensate() throws Exception;
    }
}

// Enhanced saga with parallel execution and timeouts
@WorkflowImplementation(ParallelSagaWorkflow.class)
public class ParallelSagaWorkflowImpl implements ParallelSagaWorkflow {
    
    @Override
    public OrderResult processOrder(OrderRequest request) {
        // Execute some activities in parallel
        Promise<InventoryResult> inventory = Async.function(
            inventoryActivities::reserveItems, request.getItems());
        Promise<CreditCheckResult> creditCheck = Async.function(
            creditActivities::checkCredit, request.getCustomerId());
        Promise<ShippingQuote> shipping = Async.function(
            shippingActivities::getQuote, request.getShippingAddress());
        
        // Wait for all with timeout
        try {
            Promise.allOf(inventory, creditCheck, shipping)
                .get(Duration.ofMinutes(5));
        } catch (Exception e) {
            // Compensate any completed operations
            if (inventory.isCompleted() && inventory.get().isSuccess()) {
                inventoryActivities.releaseReservation(inventory.get().getReservationId());
            }
            throw new ApplicationFailure("Parallel operations failed", "TIMEOUT");
        }
        
        // Continue with sequential operations
        if (creditCheck.get().isApproved()) {
            PaymentResult payment = paymentActivities.processPayment(
                request.getPayment(), calculateTotal(inventory.get(), shipping.get()));
            
            if (payment.isSuccessful()) {
                return fulfillOrder(inventory.get(), shipping.get());
            } else {
                inventoryActivities.releaseReservation(inventory.get().getReservationId());
                throw new PaymentFailedException();
            }
        }
        
        return OrderResult.rejected("Credit check failed");
    }
}