// 事件基类
public abstract class DomainEvent {
    private final String aggregateId;
    private final Instant timestamp;
    private final long version;

    protected DomainEvent(String aggregateId, long version) {
        this.aggregateId = aggregateId;
        this.timestamp = Instant.now();
        this.version = version;
    }
}

// 具体事件
public class OrderCreated extends DomainEvent {
    private final String userId;
    private final List<OrderItem> items;

    public OrderCreated(String orderId, long version, String userId,
                        List<OrderItem> items) {
        super(orderId, version);
        this.userId = userId;
        this.items = items;
    }
}

public class OrderPaid extends DomainEvent {
    private final BigDecimal amount;
    private final String paymentId;

    public OrderPaid(String orderId, long version, BigDecimal amount,
                     String paymentId) {
        super(orderId, version);
        this.amount = amount;
        this.paymentId = paymentId;
    }
}

// 聚合根——通过回放事件构建状态
public class OrderAggregate {
    private String orderId;
    private OrderStatus status;
    private List<OrderItem> items;
    private BigDecimal totalAmount;

    // 从事件流重建状态
    public static OrderAggregate fromEvents(List<DomainEvent> events) {
        OrderAggregate order = new OrderAggregate();
        for (DomainEvent event : events) {
            order.apply(event);
        }
        return order;
    }

    private void apply(DomainEvent event) {
        if (event instanceof OrderCreated e) {
            this.orderId = e.getAggregateId();
            this.items = e.getItems();
            this.status = OrderStatus.CREATED;
            this.totalAmount = calculateTotal(e.getItems());
        } else if (event instanceof OrderPaid e) {
            this.status = OrderStatus.PAID;
        }
    }
}

// Command 端：处理下单命令
@Service
public class OrderCommandHandler {
    @Autowired private EventStore eventStore;

    @Transactional
    public void handle(CreateOrderCommand cmd) {
        OrderAggregate order = OrderAggregate.create(cmd);
        List<DomainEvent> events = order.getUncommittedEvents();

        // 持久化事件
        eventStore.saveEvents(cmd.getOrderId(), events, cmd.getExpectedVersion());
    }
}

// Projection：消费事件更新读模型
@Component
public class OrderProjection {
    @Autowired private JdbcTemplate jdbc;

    @KafkaListener(topics = "order-events")
    public void onEvent(ConsumerRecord<String, DomainEvent> record) {
        DomainEvent event = record.value();

        if (event instanceof OrderCreated e) {
            jdbc.update(
                "INSERT INTO order_view (order_id, user_id, status, total, created_at) "
                + "VALUES (?, ?, 'CREATED', ?, ?)",
                e.getAggregateId(), e.getUserId(),
                e.getTotalAmount(), e.getTimestamp()
            );
        } else if (event instanceof OrderPaid e) {
            jdbc.update(
                "UPDATE order_view SET status = 'PAID' WHERE order_id = ?",
                e.getAggregateId()
            );
        }
    }
}

// Query 端：直接查读模型，毫秒级响应
@RestController
public class OrderQueryController {
    @GetMapping("/orders/{id}")
    public OrderView getOrder(@PathVariable String id) {
        return orderReadRepository.findById(id)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }
}

// Saga 协调器
@Service
public class CreateOrderSaga {
    @Autowired private OrderService orderService;
    @Autowired private InventoryService inventoryService;
    @Autowired private PaymentService paymentService;

    public void execute(CreateOrderRequest request) {
        String orderId = UUID.randomUUID().toString();

        try {
            // Step 1: 创建订单
            orderService.createOrder(orderId, request);

            // Step 2: 扣减库存
            inventoryService.reserve(orderId, request.getItems());

            // Step 3: 发起支付
            paymentService.charge(orderId, request.getAmount());

        } catch (InventoryException e) {
            // 补偿：取消订单
            orderService.cancelOrder(orderId);
            throw new OrderFailedException("库存不足", e);

        } catch (PaymentException e) {
            // 补偿：释放库存 + 取消订单
            inventoryService.release(orderId);
            orderService.cancelOrder(orderId);
            throw new OrderFailedException("支付失败", e);
        }
    }
}

// 状态机驱动的 Saga
public class OrderSagaState {
    private OrderStatus current;

    public void transition(OrderStatusEvent event) {
        this.current = switch (this.current) {
            case CREATED -> {
                if (event == OrderStatusEvent.STOCK_RESERVED)
                    yield OrderStatus.STOCK_RESERVED;
                throw new IllegalStateException("无效的状态转换");
            }
            case STOCK_RESERVED -> {
                if (event == OrderStatusEvent.PAYMENT_SUCCESS)
                    yield OrderStatus.COMPLETED;
                yield OrderStatus.COMPENSATING;
            }
            case COMPENSATING -> {
                compensate();
                yield OrderStatus.CANCELLED;
            }
            default -> this.current;
        };
    }
}