// Command-based (queue as task distributor)
// Producer knows about consumers and tells them what to do
await queue.publish('inventory.reserve', {
  orderId: 'ORD-123',
  items: [{ productId: 'PROD-A', quantity: 2 }]
});

await queue.publish('email.send', {
  to: '[email protected]',
  template: 'order-confirmation',
  data: { orderId: 'ORD-123' }
});

// The producer must know about every downstream system
// Adding a new consumer means changing the producer

// Event-based (queue as event bus)
// Producer emits a fact. It does not know or care who listens.
await eventBus.emit('order.placed', {
  orderId: 'ORD-123',
  userId: 'USER-456',
  items: [{ productId: 'PROD-A', quantity: 2 }],
  total: 49.99,
  placedAt: '2025-03-15T14:30:00Z'
});

// Consumers subscribe independently
// Adding a new consumer requires ZERO changes to the producer

// Event-driven order system built on queue infrastructure

// 1. Order service emits events (does not know about downstream)
class OrderService {
  async placeOrder(orderData) {
    const order = await db.orders.create(orderData);

    // Emit event: "this happened"
    await eventBus.emit('order.placed', {
      orderId: order.id,
      items: order.items,
      total: order.total,
      userId: order.userId
    });

    return order;
  }

  async cancelOrder(orderId) {
    await db.orders.update(orderId, { status: 'cancelled' });

    await eventBus.emit('order.cancelled', {
      orderId,
      cancelledAt: new Date().toISOString()
    });
  }
}

// 2. Independent services react to events they care about
class InventoryService {
  constructor(eventBus) {
    eventBus.on('order.placed', (event) => this.reserve(event));
    eventBus.on('order.cancelled', (event) => this.release(event));
  }

  async reserve(event) {
    for (const item of event.items) {
      await db.inventory.decrement(item.productId, item.quantity);
    }
  }

  async release(event) {
    const order = await db.orders.findById(event.orderId);
    for (const item of order.items) {
      await db.inventory.increment(item.productId, item.quantity);
    }
  }
}

class AnalyticsService {
  constructor(eventBus) {
    eventBus.on('order.placed', (event) => this.trackOrder(event));
    // Does not care about order.cancelled
  }

  async trackOrder(event) {
    await analytics.record('revenue', event.total);
    await analytics.record('items_sold', event.items.length);
  }
}

// 3. Adding a new service requires ZERO changes to OrderService
class FraudDetectionService {
  constructor(eventBus) {
    eventBus.on('order.placed', (event) => this.checkFraud(event));
  }

  async checkFraud(event) {
    const riskScore = await calculateRisk(event);
    if (riskScore > 0.8) {
      await eventBus.emit('order.flagged', {
        orderId: event.orderId,
        riskScore
      });
    }
  }
}

// Traditional: store current state (mutable)
// orders table: { id: 'ORD-1', status: 'shipped', total: 49.99 }
// When you update, the old state is gone

// Event sourcing: store events (immutable)
const orderEvents = [
  { type: 'OrderPlaced',    data: { total: 49.99 }, timestamp: '10:00' },
  { type: 'PaymentReceived', data: { method: 'card' }, timestamp: '10:01' },
  { type: 'OrderPacked',     data: { warehouse: 'W2' }, timestamp: '11:30' },
  { type: 'OrderShipped',    data: { carrier: 'DHL', tracking: 'XYZ' }, timestamp: '14:00' }
];

// Current state is derived by replaying events
function getCurrentState(events) {
  return events.reduce((state, event) => {
    switch (event.type) {
      case 'OrderPlaced':
        return { ...state, status: 'placed', total: event.data.total };
      case 'PaymentReceived':
        return { ...state, status: 'paid', paymentMethod: event.data.method };
      case 'OrderPacked':
        return { ...state, status: 'packed', warehouse: event.data.warehouse };
      case 'OrderShipped':
        return {
          ...state,
          status: 'shipped',
          carrier: event.data.carrier,
          tracking: event.data.tracking
        };
      default:
        return state;
    }
  }, {});
}

const currentState = getCurrentState(orderEvents);
// { status: 'shipped', total: 49.99, paymentMethod: 'card',
//   warehouse: 'W2', carrier: 'DHL', tracking: 'XYZ' }

// Without CQRS: same model for reads and writes
// The orders table serves both the checkout flow and the admin dashboard
// Compromise: not optimal for either

// With CQRS: separate models
// Write side: optimized for transactional integrity
class OrderWriteModel {
  async placeOrder(orderData) {
    await db.orders.create(orderData);                 // Normalized schema
    await eventBus.emit('order.placed', orderData);    // Publish event
  }
}

// Read side: optimized for query performance
class OrderReadModel {
  constructor(eventBus) {
    // Build a denormalized view from events
    eventBus.on('order.placed', async (event) => {
      await readDb.orderSummaries.upsert({
        orderId: event.orderId,
        customerName: await lookupCustomerName(event.userId),
        itemCount: event.items.length,
        total: event.total,
        status: 'placed'
      });
    });

    eventBus.on('order.shipped', async (event) => {
      await readDb.orderSummaries.update(event.orderId, {
        status: 'shipped',
        shippedAt: event.shippedAt
      });
    });
  }

  // Fast queries on denormalized data (no JOINs needed)
  async getOrderDashboard(filters) {
    return readDb.orderSummaries.find(filters);
  }
}