// ❌ Naive multi-service transaction — no rollback if any step fails
async function placeOrder(cmd: PlaceOrderCommand): Promise<void> {
  // Step 1: Reserve inventory (Inventory Service)
  await inventoryClient.reserve(cmd.productId, cmd.quantity)
  // If crash here: inventory reserved, payment not charged, no order record

  // Step 2: Charge payment (Payment Service)
  const charge = await paymentClient.charge(cmd.userId, cmd.totalCents)
  // If crash here: inventory reserved, payment charged, no order record

  // Step 3: Create order record (Order Service)
  await orderRepository.save({ ...cmd, chargeId: charge.id, status: 'confirmed' })
  // If crash here: inventory reserved, payment charged, no order record in DB
}
// There is no global rollback mechanism across these three services
// Each failure scenario leaves the system in a different inconsistent state

// ✅ Choreography compensation — each service handles its own rollback
// When PaymentFailed is published, Inventory Service must release the reserved stock

class InventoryService {
  async onPaymentFailed(event: PaymentFailedEvent): Promise<void> {
    // Find the reservation created for this order
    const reservation = await this.reservationRepository.findByOrderId(event.orderId)
    if (!reservation) return // idempotent — already released or never reserved

    await this.reservationRepository.release(reservation.id)
    await eventBus.publish('StockReservationReleased', {
      orderId: event.orderId,
      productId: reservation.productId,
      quantity: reservation.quantity,
      releasedAt: new Date().toISOString(),
    })
  }
}

// ✅ Orchestration SAGA — explicit state machine with compensating transactions
type OrderSagaState =
  | 'RESERVING_INVENTORY'
  | 'CHARGING_PAYMENT'
  | 'CREATING_FULFILLMENT'
  | 'COMPENSATING_PAYMENT'
  | 'COMPENSATING_INVENTORY'
  | 'SAGA_COMPLETE'
  | 'SAGA_FAILED'

interface OrderSagaInstance {
  sagaId: string
  orderId: string
  userId: string
  state: OrderSagaState
  reservationId?: string
  chargeId?: string
  retryCount: number
  updatedAt: Date
}

class OrderSagaOrchestrator {
  async handleEvent(saga: OrderSagaInstance, event: SagaEvent): Promise<OrderSagaInstance> {
    switch (saga.state) {
      case 'RESERVING_INVENTORY':
        if (event.type === 'StockReserved') {
          await inventoryClient.reserve(saga.orderId, event.reservationId)
          await commandBus.send('ChargeCard', { orderId: saga.orderId, userId: saga.userId })
          return { ...saga, state: 'CHARGING_PAYMENT', reservationId: event.reservationId }
        }
        if (event.type === 'StockReservationFailed') {
          return { ...saga, state: 'SAGA_FAILED' } // nothing to compensate
        }
        break

      case 'CHARGING_PAYMENT':
        if (event.type === 'PaymentCharged') {
          await commandBus.send('CreateFulfillment', { orderId: saga.orderId })
          return { ...saga, state: 'CREATING_FULFILLMENT', chargeId: event.chargeId }
        }
        if (event.type === 'PaymentFailed') {
          // Begin compensation — release the inventory reservation
          await commandBus.send('ReleaseStock', { orderId: saga.orderId, reservationId: saga.reservationId! })
          return { ...saga, state: 'COMPENSATING_INVENTORY' }
        }
        break

      case 'COMPENSATING_INVENTORY':
        if (event.type === 'StockReleased') {
          return { ...saga, state: 'SAGA_FAILED' }
        }
        // StockRelease failed — must retry until success (cannot leave inventory reserved)
        if (event.type === 'StockReleaseFailed') {
          await commandBus.send('ReleaseStock', { orderId: saga.orderId, reservationId: saga.reservationId! })
          return { ...saga, state: 'COMPENSATING_INVENTORY', retryCount: saga.retryCount + 1 }
        }
        break

      // ... additional states
    }
    return saga
  }
}

// ✅ Temporal.io SAGA workflow — durable execution, automatic retry, crash-safe
import { proxyActivities, sleep } from '@temporalio/workflow'

const activities = proxyActivities<typeof orderActivities>({
  scheduleToCloseTimeout: '5 minutes',
  retry: { maximumAttempts: 5, initialInterval: '1s', backoffCoefficient: 2 }
})

export async function orderSagaWorkflow(input: OrderSagaInput): Promise<OrderSagaResult> {
  let inventoryReserved = false
  let paymentCharged = false

  try {
    // Step 1: Reserve inventory
    const reservation = await activities.reserveInventory(input.orderId, input.items)
    inventoryReserved = true

    // Step 2: Charge payment
    const charge = await activities.chargePayment(input.userId, input.totalCents, input.orderId)
    paymentCharged = true

    // Step 3: Create fulfillment
    await activities.createFulfillment(input.orderId, reservation.id, charge.id)

    return { status: 'success', orderId: input.orderId }
  } catch (err) {
    // Compensation — run in reverse order of successful steps
    if (paymentCharged) await activities.refundPayment(input.orderId)
    if (inventoryReserved) await activities.releaseInventory(input.orderId)

    return { status: 'failed', orderId: input.orderId, reason: err.message }
  }
  // If this process crashes mid-workflow: Temporal replays from the last durable checkpoint
  // Activities already completed are not re-executed — their results are replayed from history
}

// ❌ SAGA isolation hazard — two concurrent order sagas for the same product
// Saga A: reserves last 3 units (inventory = 0)
// Saga B: also reads inventory = 3 and attempts reservation — succeeds momentarily
// Saga A payment fails → compensates → releases 3 units
// Saga B payment succeeds → fulfillment tries to ship inventory that was double-reserved

// ✅ Mitigation: pessimistic lock on the inventory reservation step for the same SKU
// Or: idempotent reservation with version-checked inventory decrement
await db.transaction(async (trx) => {
  const result = await trx.raw(`
    UPDATE inventory SET reserved = reserved + $1
    WHERE sku = $2 AND (quantity_on_hand - reserved) >= $1
    RETURNING sku, quantity_on_hand, reserved
  `, [quantity, sku])

  if (result.rowCount === 0) throw new InsufficientStockError(sku)
})
// Atomic check-and-reserve prevents double-reservation at the inventory level