// OrderService.ts
async function getOrderWithUser(orderId: string) {
  // Fetch from own DB
  const order = await db.orders.findById(orderId);
  
  // Fetch from UserService via API
  const user = await userServiceClient.getUser(order.userId);
  
  // Compose in application layer
  return {
    ...order,
    customer: {
      name: user.name,
      email: user.email,
    }
  };
}

// OrderService stores a snapshot of user data it needs
interface Order {
  id: string;
  userId: string;
  // Denormalized from UserService at order creation time
  customerName: string;     // ← copied from user
  customerEmail: string;    // ← copied from user
  lineItems: LineItem[];
  total: number;
  createdAt: Date;
}

// When user updates their name, publish an event
// OrderService listens and updates its own snapshot
async function handleUserUpdated(event: UserUpdatedEvent) {
  await db.orders.updateMany({
    where: { userId: event.userId },
    data: {
      customerName: event.newName,
      customerEmail: event.newEmail,
    }
  });
}

// Choreography-based Saga (event-driven)
// Order placement spans 3 services

// 1. OrderService: create order in PENDING state
async function placeOrder(orderData: OrderData) {
  const order = await db.orders.create({
    ...orderData,
    status: 'PENDING'
  });
  
  await eventBus.publish('order.created', {
    orderId: order.id,
    userId: order.userId,
    items: order.lineItems,
    total: order.total,
  });
  
  return order;
}

// 2. InventoryService: listens to order.created
async function handleOrderCreated(event: OrderCreatedEvent) {
  try {
    await db.inventory.reserve(event.items);
    await eventBus.publish('inventory.reserved', { orderId: event.orderId });
  } catch (error) {
    // Reservation failed — publish failure event
    await eventBus.publish('inventory.reservation.failed', {
      orderId: event.orderId,
      reason: error.message,
    });
  }
}

// 3. PaymentService: listens to inventory.reserved
async function handleInventoryReserved(event: InventoryReservedEvent) {
  try {
    const charge = await paymentGateway.charge(event.orderId);
    await eventBus.publish('payment.captured', { orderId: event.orderId });
  } catch (error) {
    await eventBus.publish('payment.failed', {
      orderId: event.orderId,
      reason: error.message,
    });
  }
}

// OrderService: listens to payment.captured
async function handlePaymentCaptured(event: PaymentCapturedEvent) {
  await db.orders.update({
    where: { id: event.orderId },
    data: { status: 'CONFIRMED' }
  });
}

// Compensating transaction: if payment fails, release inventory
async function handlePaymentFailed(event: PaymentFailedEvent) {
  await db.inventory.release(event.orderId); // Compensate
  await db.orders.update({
    where: { id: event.orderId },
    data: { status: 'FAILED', failureReason: event.reason }
  });
}

// Transactional Outbox Pattern
async function placeOrder(orderData: OrderData) {
  // Both the order AND the event go in the same transaction
  await db.$transaction(async (tx) => {
    const order = await tx.orders.create({
      ...orderData,
      status: 'PENDING'
    });
    
    // Event stored in outbox table, not published yet
    await tx.outbox.create({
      eventType: 'order.created',
      aggregateId: order.id,
      payload: JSON.stringify({
        orderId: order.id,
        userId: order.userId,
        items: order.lineItems,
        total: order.total,
      }),
      processedAt: null,
    });
    
    return order;
  });
  
  // Separate process (Debezium CDC or polling) publishes outbox events
  // If this service crashes, the outbox row still exists and will be published on restart
}

// Write side: optimized for consistency
class OrderCommandHandler {
  async placeOrder(command: PlaceOrderCommand): Promise<string> {
    // Validate, apply business rules, save to write DB
    const order = new Order(command);
    order.validate();
    
    await this.writeDb.orders.save(order);
    await this.eventBus.publish('order.placed', order.toEvent());
    
    return order.id;
  }
}

// Read side: denormalized, optimized for query patterns
class OrderQueryHandler {
  // This table is materialized from events — no joins needed
  async getOrderDashboard(userId: string): Promise<OrderDashboard> {
    return this.readDb.orderViews.findMany({
      where: { userId },
      orderBy: { createdAt: 'desc' },
    });
  }
}

// Event handler that updates the read model
class OrderReadModelUpdater {
  async handleOrderPlaced(event: OrderPlacedEvent) {
    await this.readDb.orderViews.create({
      orderId: event.orderId,
      userId: event.userId,
      customerName: event.customerName,  // denormalized
      status: 'pending',
      itemCount: event.items.length,
      total: event.total,
      productNames: event.items.map(i => i.name).join(', '),  // denormalized for display
      createdAt: event.timestamp,
    });
  }
}