// OrderOrchestrator - the conductor
class OrderOrchestrator {
  async fulfillOrder(orderId: string) {
    const order = await this.orderService.get(orderId);

    // Step 1: Charge payment
    const payment = await this.paymentService.charge(order.userId, order.total);
    if (!payment.success) {
      await this.orderService.updateStatus(orderId, 'payment_failed');
      return { success: false, reason: 'payment_failed' };
    }

    // Step 2: Reserve inventory
    try {
      await this.inventoryService.reserve(order.items);
    } catch (err) {
      // Compensate: refund the payment
      await this.paymentService.refund(payment.id);
      await this.orderService.updateStatus(orderId, 'inventory_failed');
      return { success: false, reason: 'out_of_stock' };
    }

    // Step 3: Create shipment
    const shipment = await this.shippingService.createShipment(order);

    // Step 4: Send confirmation
    await this.notificationService.sendOrderConfirmation(order, shipment);

    await this.orderService.updateStatus(orderId, 'fulfilled');
    return { success: true, shipmentId: shipment.id };
  }
}

// Order Service - publishes the initial event
async function createOrder(orderData: OrderInput) {
  const order = await db.insert(orders).values(orderData);
  await eventBus.publish('order.created', {
    orderId: order.id,
    userId: order.userId,
    items: order.items,
    total: order.total,
  });
  return order;
}

// Payment Service - reacts to order.created
eventBus.subscribe('order.created', async (event) => {
  const result = await chargeCustomer(event.userId, event.total);
  if (result.success) {
    await eventBus.publish('payment.completed', {
      orderId: event.orderId,
      paymentId: result.paymentId,
    });
  } else {
    await eventBus.publish('payment.failed', {
      orderId: event.orderId,
      reason: result.error,
    });
  }
});

// Inventory Service - reacts to payment.completed
eventBus.subscribe('payment.completed', async (event) => {
  const reserved = await reserveItems(event.orderId);
  if (reserved) {
    await eventBus.publish('inventory.reserved', {
      orderId: event.orderId,
    });
  } else {
    await eventBus.publish('inventory.failed', {
      orderId: event.orderId,
    });
  }
});

// Shipping Service - reacts to inventory.reserved
eventBus.subscribe('inventory.reserved', async (event) => {
  const shipment = await createShipment(event.orderId);
  await eventBus.publish('shipment.created', {
    orderId: event.orderId,
    trackingNumber: shipment.trackingNumber,
  });
});

// Notification Service - reacts to shipment.created
eventBus.subscribe('shipment.created', async (event) => {
  await sendConfirmationEmail(event.orderId, event.trackingNumber);
});

class OrderSaga {
  private steps: SagaStep[] = [];

  async execute(orderId: string) {
    for (const step of this.steps) {
      try {
        await step.execute(orderId);
      } catch (err) {
        // Something failed - compensate all completed steps in reverse
        await this.compensate(orderId);
        throw err;
      }
    }
  }

  private async compensate(orderId: string) {
    // Walk backwards through completed steps
    for (const step of this.steps.reverse()) {
      if (step.completed) {
        await step.compensate(orderId);
      }
    }
  }
}

// Define the saga steps
const saga = new OrderSaga();
saga.addStep({
  execute: (id) => paymentService.charge(id),
  compensate: (id) => paymentService.refund(id),
});
saga.addStep({
  execute: (id) => inventoryService.reserve(id),
  compensate: (id) => inventoryService.release(id),
});
saga.addStep({
  execute: (id) => shippingService.schedule(id),
  compensate: (id) => shippingService.cancel(id),
});

Happy path:
order.created → payment.completed → inventory.reserved → shipment.created

Failure path (inventory fails):
order.created → payment.completed → inventory.failed → payment.refund.requested → order.cancelled

Order Fulfillment (orchestrated - too important for implicit flow):
  Orchestrator → Payment → Inventory → Shipping

Side effects (choreographed - loosely coupled, non-critical):
  order.fulfilled event →
    ├── Analytics Service: update metrics
    ├── Loyalty Service: award points
    ├── Email Service: send receipt
    └── Recommendation Service: update model