// ============================================================
// Domain Events — 型安全なイベント定義
// ============================================================
 
// 基底イベント型
interface DomainEvent {
  readonly eventId: string;
  readonly aggregateId: string;
  readonly aggregateType: string;
  readonly eventType: string;
  readonly data: Readonly<Record<string, unknown>>;
  readonly metadata: Readonly<{
    timestamp: Date;
    version: number;
    userId?: string;          // 誰がこの変更を行ったか
    correlationId?: string;   // 関連する操作のID（分散トレーシング）
    causationId?: string;     // このイベントの原因となったイベントID
  }>;
}
 
// 注文ドメインのイベント（Discriminated Union で型安全に）
type OrderEvent =
  | OrderCreated
  | ItemAdded
  | ItemRemoved
  | DiscountApplied
  | PaymentReceived
  | OrderShipped
  | OrderCancelled;
 
interface OrderCreated extends DomainEvent {
  readonly eventType: "OrderCreated";
  readonly data: {
    readonly customerId: string;
    readonly items: ReadonlyArray<{
      productId: string;
      quantity: number;
      unitPrice: number;
    }>;
    readonly shippingAddress: {
      street: string;
      city: string;
      postalCode: string;
    };
  };
}
 
interface ItemAdded extends DomainEvent {
  readonly eventType: "ItemAdded";
  readonly data: {
    readonly productId: string;
    readonly productName: string;
    readonly quantity: number;
    readonly unitPrice: number;
  };
}
 
interface ItemRemoved extends DomainEvent {
  readonly eventType: "ItemRemoved";
  readonly data: {
    readonly productId: string;
    readonly quantity: number;
    readonly reason: string;
  };
}
 
interface DiscountApplied extends DomainEvent {
  readonly eventType: "DiscountApplied";
  readonly data: {
    readonly discountType: "percentage" | "fixed";
    readonly value: number;
    readonly couponCode?: string;
    readonly reason: string;
  };
}
 
interface PaymentReceived extends DomainEvent {
  readonly eventType: "PaymentReceived";
  readonly data: {
    readonly amount: number;
    readonly paymentMethod: "credit_card" | "bank_transfer" | "wallet";
    readonly transactionId: string;
  };
}
 
interface OrderShipped extends DomainEvent {
  readonly eventType: "OrderShipped";
  readonly data: {
    readonly carrier: string;
    readonly trackingNumber: string;
    readonly estimatedDelivery: string;
  };
}
 
interface OrderCancelled extends DomainEvent {
  readonly eventType: "OrderCancelled";
  readonly data: {
    readonly reason: string;
    readonly cancelledBy: string;
    readonly refundAmount: number;
  };
}

// ============================================================
// Order Aggregate — イベントソーシング対応
// ============================================================
 
interface OrderItem {
  productId: string;
  productName: string;
  quantity: number;
  unitPrice: number;
}
 
type OrderStatus = "created" | "paid" | "shipped" | "delivered" | "cancelled";
 
class Order {
  private _id: string = "";
  private _customerId: string = "";
  private _status: OrderStatus = "created";
  private _items: OrderItem[] = [];
  private _totalAmount: number = 0;
  private _discountAmount: number = 0;
  private _version: number = 0;
  private _uncommittedEvents: OrderEvent[] = [];
 
  // ============================================
  // クエリ（読み取り）
  // ============================================
  get id(): string { return this._id; }
  get status(): OrderStatus { return this._status; }
  get items(): ReadonlyArray<OrderItem> { return this._items; }
  get totalAmount(): number { return this._totalAmount; }
  get netAmount(): number { return this._totalAmount - this._discountAmount; }
  get version(): number { return this._version; }
 
  // ============================================
  // ファクトリ: イベントから状態を復元
  // ============================================
  static fromEvents(events: OrderEvent[]): Order {
    const order = new Order();
    for (const event of events) {
      order.applyEvent(event, false);  // 既存イベントは uncommitted に追加しない
    }
    return order;
  }
 
  static fromSnapshot(snapshot: OrderSnapshot, newEvents: OrderEvent[]): Order {
    const order = new Order();
    order._id = snapshot.id;
    order._customerId = snapshot.customerId;
    order._status = snapshot.status;
    order._items = [...snapshot.items];
    order._totalAmount = snapshot.totalAmount;
    order._discountAmount = snapshot.discountAmount;
    order._version = snapshot.version;
 
    // スナップショット以降のイベントを再生
    for (const event of newEvents) {
      order.applyEvent(event, false);
    }
    return order;
  }
 
  // ============================================
  // コマンド（書き込み） — ビジネスルールの検証 + イベント発行
  // ============================================
  static create(
    orderId: string,
    customerId: string,
    items: OrderItem[],
    shippingAddress: { street: string; city: string; postalCode: string },
    userId: string
  ): Order {
    // ビジネスルールの検証
    if (items.length === 0) {
      throw new DomainError("注文には1つ以上の商品が必要です");
    }
    if (items.some((i) => i.quantity <= 0)) {
      throw new DomainError("商品数量は正の整数でなければなりません");
    }
 
    const order = new Order();
    order.raiseEvent({
      eventType: "OrderCreated",
      aggregateId: orderId,
      data: {
        customerId,
        items: items.map((i) => ({
          productId: i.productId,
          quantity: i.quantity,
          unitPrice: i.unitPrice,
        })),
        shippingAddress,
      },
    }, userId);
    return order;
  }
 
  addItem(item: OrderItem, userId: string): void {
    // ビジネスルール: 支払い済みの注文には商品を追加できない
    if (this._status !== "created") {
      throw new DomainError(
        `状態 "${this._status}" の注文に商品を追加できません`
      );
    }
    if (item.quantity <= 0) {
      throw new DomainError("商品数量は正の整数でなければなりません");
    }
 
    this.raiseEvent({
      eventType: "ItemAdded",
      aggregateId: this._id,
      data: {
        productId: item.productId,
        productName: item.productName,
        quantity: item.quantity,
        unitPrice: item.unitPrice,
      },
    }, userId);
  }
 
  removeItem(productId: string, quantity: number, reason: string, userId: string): void {
    if (this._status !== "created") {
      throw new DomainError("支払い済みの注文から商品を削除できません");
    }
    const existingItem = this._items.find((i) => i.productId === productId);
    if (!existingItem) {
      throw new DomainError(`商品 ${productId} は注文に含まれていません`);
    }
    if (existingItem.quantity < quantity) {
      throw new DomainError("削除数量が注文数量を超えています");
    }
 
    this.raiseEvent({
      eventType: "ItemRemoved",
      aggregateId: this._id,
      data: { productId, quantity, reason },
    }, userId);
  }
 
  applyDiscount(type: "percentage" | "fixed", value: number, reason: string, couponCode?: string, userId?: string): void {
    if (this._status !== "created") {
      throw new DomainError("支払い済みの注文に割引を適用できません");
    }
    if (type === "percentage" && (value < 0 || value > 100)) {
      throw new DomainError("割引率は 0-100% の範囲でなければなりません");
    }
 
    this.raiseEvent({
      eventType: "DiscountApplied",
      aggregateId: this._id,
      data: { discountType: type, value, couponCode, reason },
    }, userId ?? "system");
  }
 
  receivePayment(amount: number, method: PaymentReceived["data"]["paymentMethod"], txId: string, userId: string): void {
    if (this._status !== "created") {
      throw new DomainError("この注文はすでに支払い済みです");
    }
    if (amount < this.netAmount) {
      throw new DomainError(
        `支払い金額 ${amount} が不足しています（必要額: ${this.netAmount}）`
      );
    }
 
    this.raiseEvent({
      eventType: "PaymentReceived",
      aggregateId: this._id,
      data: { amount, paymentMethod: method, transactionId: txId },
    }, userId);
  }
 
  ship(carrier: string, trackingNumber: string, estimatedDelivery: string, userId: string): void {
    if (this._status !== "paid") {
      throw new DomainError("支払い済みの注文のみ発送できます");
    }
 
    this.raiseEvent({
      eventType: "OrderShipped",
      aggregateId: this._id,
      data: { carrier, trackingNumber, estimatedDelivery },
    }, userId);
  }
 
  cancel(reason: string, userId: string): void {
    if (this._status === "shipped" || this._status === "delivered") {
      throw new DomainError("発送済みの注文はキャンセルできません");
    }
    if (this._status === "cancelled") {
      throw new DomainError("既にキャンセル済みです");
    }
 
    const refundAmount = this._status === "paid" ? this.netAmount : 0;
    this.raiseEvent({
      eventType: "OrderCancelled",
      aggregateId: this._id,
      data: { reason, cancelledBy: userId, refundAmount },
    }, userId);
  }
 
  // ============================================
  // イベント適用（状態変更ロジック）— 純粋関数
  // ============================================
  private applyEvent(event: OrderEvent, isNew: boolean = true): void {
    switch (event.eventType) {
      case "OrderCreated":
        this._id = event.aggregateId;
        this._customerId = event.data.customerId;
        this._status = "created";
        this._items = event.data.items.map((i) => ({
          productId: i.productId,
          productName: "",
          quantity: i.quantity,
          unitPrice: i.unitPrice,
        }));
        this._totalAmount = this._items.reduce(
          (sum, i) => sum + i.unitPrice * i.quantity, 0
        );
        break;
 
      case "ItemAdded":
        this._items.push({
          productId: event.data.productId,
          productName: event.data.productName,
          quantity: event.data.quantity,
          unitPrice: event.data.unitPrice,
        });
        this._totalAmount += event.data.unitPrice * event.data.quantity;
        break;
 
      case "ItemRemoved": {
        const idx = this._items.findIndex(
          (i) => i.productId === event.data.productId
        );
        if (idx >= 0) {
          this._totalAmount -= this._items[idx].unitPrice * event.data.quantity;
          this._items[idx].quantity -= event.data.quantity;
          if (this._items[idx].quantity <= 0) {
            this._items.splice(idx, 1);
          }
        }
        break;
      }
 
      case "DiscountApplied":
        if (event.data.discountType === "percentage") {
          this._discountAmount = this._totalAmount * (event.data.value / 100);
        } else {
          this._discountAmount = event.data.value;
        }
        break;
 
      case "PaymentReceived":
        this._status = "paid";
        break;
 
      case "OrderShipped":
        this._status = "shipped";
        break;
 
      case "OrderCancelled":
        this._status = "cancelled";
        break;
    }
 
    this._version++;
    if (isNew) {
      this._uncommittedEvents.push(event as OrderEvent);
    }
  }
 
  // ============================================
  // イベント発行ヘルパー
  // ============================================
  private raiseEvent(
    eventData: Pick<OrderEvent, "eventType" | "aggregateId" | "data">,
    userId: string
  ): void {
    const event = {
      ...eventData,
      eventId: crypto.randomUUID(),
      aggregateType: "Order",
      metadata: {
        timestamp: new Date(),
        version: this._version + 1,
        userId,
      },
    } as OrderEvent;
    this.applyEvent(event, true);
  }
 
  getUncommittedEvents(): ReadonlyArray<OrderEvent> {
    return [...this._uncommittedEvents];
  }
 
  clearUncommittedEvents(): void {
    this._uncommittedEvents = [];
  }
 
  toSnapshot(): OrderSnapshot {
    return {
      id: this._id,
      customerId: this._customerId,
      status: this._status,
      items: [...this._items],
      totalAmount: this._totalAmount,
      discountAmount: this._discountAmount,
      version: this._version,
    };
  }
}
 
interface OrderSnapshot {
  id: string;
  customerId: string;
  status: OrderStatus;
  items: OrderItem[];
  totalAmount: number;
  discountAmount: number;
  version: number;
}
 
class DomainError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "DomainError";
  }
}

// ============================================================
// Event Store Interface（ドメイン層）
// ============================================================
interface EventStore {
  append(
    aggregateId: string,
    events: DomainEvent[],
    expectedVersion: number
  ): Promise<void>;
  getEvents(aggregateId: string): Promise<DomainEvent[]>;
  getEventsAfterVersion(
    aggregateId: string,
    version: number
  ): Promise<DomainEvent[]>;
  getAllEvents(options?: {
    eventTypes?: string[];
    since?: Date;
    limit?: number;
  }): AsyncIterable<DomainEvent>;
}
 
// ============================================================
// PostgreSQL 実装
// ============================================================
class PostgresEventStore implements EventStore {
  constructor(private pool: Pool) {}
 
  async append(
    aggregateId: string,
    events: DomainEvent[],
    expectedVersion: number
  ): Promise<void> {
    const client = await this.pool.connect();
    try {
      await client.query("BEGIN");
 
      // 楽観的ロック: 現在のバージョンを確認
      const { rows } = await client.query(
        `SELECT COALESCE(MAX(version), 0) as current_version
         FROM events WHERE aggregate_id = $1
         FOR UPDATE`,  // SELECT FOR UPDATE で排他ロック
        [aggregateId]
      );
      const currentVersion = rows[0].current_version;
 
      if (currentVersion !== expectedVersion) {
        throw new ConcurrencyError(
          `Expected version ${expectedVersion}, but found ${currentVersion}. ` +
          `Another process may have modified this aggregate.`
        );
      }
 
      // イベントを追記（バッチ INSERT）
      const values: unknown[] = [];
      const placeholders: string[] = [];
      let paramIndex = 1;
 
      for (const event of events) {
        placeholders.push(
          `($${paramIndex}, $${paramIndex + 1}, $${paramIndex + 2}, ` +
          `$${paramIndex + 3}, $${paramIndex + 4}, $${paramIndex + 5}, $${paramIndex + 6})`
        );
        values.push(
          event.eventId,
          event.aggregateId,
          event.aggregateType,
          event.eventType,
          JSON.stringify(event.data),
          JSON.stringify(event.metadata),
          event.metadata.version
        );
        paramIndex += 7;
      }
 
      await client.query(
        `INSERT INTO events
         (event_id, aggregate_id, aggregate_type, event_type, data, metadata, version)
         VALUES ${placeholders.join(", ")}`,
        values
      );
 
      await client.query("COMMIT");
    } catch (error) {
      await client.query("ROLLBACK");
      throw error;
    } finally {
      client.release();
    }
  }
 
  async getEvents(aggregateId: string): Promise<DomainEvent[]> {
    const { rows } = await this.pool.query(
      "SELECT * FROM events WHERE aggregate_id = $1 ORDER BY version ASC",
      [aggregateId]
    );
    return rows.map(this.toDomainEvent);
  }
 
  async getEventsAfterVersion(
    aggregateId: string,
    version: number
  ): Promise<DomainEvent[]> {
    const { rows } = await this.pool.query(
      `SELECT * FROM events
       WHERE aggregate_id = $1 AND version > $2
       ORDER BY version ASC`,
      [aggregateId, version]
    );
    return rows.map(this.toDomainEvent);
  }
 
  async *getAllEvents(options?: {
    eventTypes?: string[];
    since?: Date;
    limit?: number;
  }): AsyncIterable<DomainEvent> {
    let query = "SELECT * FROM events WHERE 1=1";
    const params: unknown[] = [];
    let paramIndex = 1;
 
    if (options?.eventTypes?.length) {
      query += ` AND event_type = ANY($${paramIndex})`;
      params.push(options.eventTypes);
      paramIndex++;
    }
    if (options?.since) {
      query += ` AND (metadata->>'timestamp')::timestamptz >= $${paramIndex}`;
      params.push(options.since);
      paramIndex++;
    }
    query += " ORDER BY (metadata->>'timestamp')::timestamptz ASC";
    if (options?.limit) {
      query += ` LIMIT $${paramIndex}`;
      params.push(options.limit);
    }
 
    const { rows } = await this.pool.query(query, params);
    for (const row of rows) {
      yield this.toDomainEvent(row);
    }
  }
 
  private toDomainEvent(row: any): DomainEvent {
    return {
      eventId: row.event_id,
      aggregateId: row.aggregate_id,
      aggregateType: row.aggregate_type,
      eventType: row.event_type,
      data: row.data,
      metadata: {
        ...row.metadata,
        timestamp: new Date(row.metadata.timestamp),
      },
    };
  }
}
 
class ConcurrencyError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "ConcurrencyError";
  }
}

-- ============================================================
-- PostgreSQL: Event Store テーブル定義
-- ============================================================
 
CREATE TABLE events (
    -- 主キー
    id              BIGSERIAL PRIMARY KEY,
 
    -- イベント識別
    event_id        UUID NOT NULL UNIQUE,
    aggregate_id    UUID NOT NULL,
    aggregate_type  VARCHAR(100) NOT NULL,
    event_type      VARCHAR(100) NOT NULL,
 
    -- イベントデータ
    data            JSONB NOT NULL,
    metadata        JSONB NOT NULL,
 
    -- バージョニング（楽観的ロック用）
    version         INTEGER NOT NULL,
 
    -- タイムスタンプ
    created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
 
    -- 集約ごとのバージョンはユニーク
    CONSTRAINT unique_aggregate_version
        UNIQUE (aggregate_id, version)
);
 
-- インデックス
CREATE INDEX idx_events_aggregate_id ON events (aggregate_id, version);
CREATE INDEX idx_events_event_type ON events (event_type);
CREATE INDEX idx_events_created_at ON events (created_at);
 
-- スナップショットテーブル
CREATE TABLE snapshots (
    aggregate_id    UUID PRIMARY KEY,
    aggregate_type  VARCHAR(100) NOT NULL,
    version         INTEGER NOT NULL,
    state           JSONB NOT NULL,
    created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

// ============================================================
// Command Side（書き込み）
// ============================================================
 
// Command 定義
type OrderCommand =
  | CreateOrderCommand
  | AddItemCommand
  | ApplyDiscountCommand
  | ReceivePaymentCommand
  | ShipOrderCommand
  | CancelOrderCommand;
 
interface CreateOrderCommand {
  type: "CreateOrder";
  orderId: string;
  customerId: string;
  items: Array<{ productId: string; quantity: number; unitPrice: number }>;
  shippingAddress: { street: string; city: string; postalCode: string };
  userId: string;
}
 
interface ShipOrderCommand {
  type: "ShipOrder";
  orderId: string;
  carrier: string;
  trackingNumber: string;
  estimatedDelivery: string;
  userId: string;
}
 
// Command Handler
class OrderCommandHandler {
  constructor(
    private eventStore: EventStore,
    private snapshotRepo: SnapshotRepository,
    private eventBus: EventBus,
  ) {}
 
  async handle(command: OrderCommand): Promise<void> {
    switch (command.type) {
      case "CreateOrder":
        return this.handleCreateOrder(command);
      case "ShipOrder":
        return this.handleShipOrder(command);
      // ... 他のコマンド
    }
  }
 
  private async handleCreateOrder(cmd: CreateOrderCommand): Promise<void> {
    // 新しい集約を作成
    const order = Order.create(
      cmd.orderId,
      cmd.customerId,
      cmd.items.map((i) => ({
        productId: i.productId,
        productName: "",
        quantity: i.quantity,
        unitPrice: i.unitPrice,
      })),
      cmd.shippingAddress,
      cmd.userId
    );
 
    // イベントを永続化
    const events = order.getUncommittedEvents();
    await this.eventStore.append(cmd.orderId, [...events], 0);
    order.clearUncommittedEvents();
 
    // イベントを発行（プロジェクション更新のため）
    for (const event of events) {
      await this.eventBus.publish(event);
    }
  }
 
  private async handleShipOrder(cmd: ShipOrderCommand): Promise<void> {
    // 集約を復元
    const order = await this.loadOrder(cmd.orderId);
 
    // コマンド実行（ビジネスルール検証 + イベント発行）
    order.ship(
      cmd.carrier,
      cmd.trackingNumber,
      cmd.estimatedDelivery,
      cmd.userId
    );
 
    // イベントを永続化
    const newEvents = order.getUncommittedEvents();
    await this.eventStore.append(
      cmd.orderId,
      [...newEvents],
      order.version - newEvents.length
    );
    order.clearUncommittedEvents();
 
    // イベントを発行
    for (const event of newEvents) {
      await this.eventBus.publish(event);
    }
  }
 
  private async loadOrder(orderId: string): Promise<Order> {
    // スナップショットがあれば使用
    const snapshot = await this.snapshotRepo.load(orderId);
    if (snapshot) {
      const newEvents = await this.eventStore.getEventsAfterVersion(
        orderId,
        snapshot.version
      );
      return Order.fromSnapshot(snapshot.state as OrderSnapshot, newEvents as OrderEvent[]);
    }
 
    // なければ全イベントから復元
    const events = await this.eventStore.getEvents(orderId);
    if (events.length === 0) {
      throw new Error(`Order ${orderId} not found`);
    }
    return Order.fromEvents(events as OrderEvent[]);
  }
}

// ============================================================
// Query Side（読み取り）
// ============================================================
 
// Read Model (Projection) — 表示に最適化されたデータ構造
interface OrderSummaryView {
  orderId: string;
  customerName: string;
  customerEmail: string;
  status: string;
  statusLabel: string;  // 表示用ラベル（「発送済み」等）
  itemCount: number;
  totalAmount: number;
  discountAmount: number;
  netAmount: number;
  lastUpdated: Date;
  trackingUrl?: string;
}
 
interface OrderDetailView extends OrderSummaryView {
  items: Array<{
    productName: string;
    quantity: number;
    unitPrice: number;
    subtotal: number;
  }>;
  shippingAddress: {
    street: string;
    city: string;
    postalCode: string;
  };
  timeline: Array<{
    event: string;
    timestamp: Date;
    description: string;
  }>;
}
 
// Projector: イベントから Read Model を構築
class OrderProjector {
  constructor(
    private readDb: ReadDatabase,
    private customerService: CustomerService,
  ) {}
 
  async handle(event: DomainEvent): Promise<void> {
    switch (event.eventType) {
      case "OrderCreated":
        await this.onOrderCreated(event as OrderCreated);
        break;
      case "ItemAdded":
        await this.onItemAdded(event as ItemAdded);
        break;
      case "PaymentReceived":
        await this.onPaymentReceived(event as PaymentReceived);
        break;
      case "OrderShipped":
        await this.onOrderShipped(event as OrderShipped);
        break;
      case "OrderCancelled":
        await this.onOrderCancelled(event as OrderCancelled);
        break;
    }
  }
 
  private async onOrderCreated(event: OrderCreated): Promise<void> {
    // 顧客情報を取得（Read Model は非正規化してOK）
    const customer = await this.customerService.getById(event.data.customerId);
    const items = event.data.items;
    const totalAmount = items.reduce(
      (sum, i) => sum + i.unitPrice * i.quantity, 0
    );
 
    await this.readDb.upsert("order_summaries", event.aggregateId, {
      orderId: event.aggregateId,
      customerName: customer.name,
      customerEmail: customer.email,
      status: "created",
      statusLabel: "注文受付",
      itemCount: items.length,
      totalAmount,
      discountAmount: 0,
      netAmount: totalAmount,
      lastUpdated: event.metadata.timestamp,
    });
  }
 
  private async onItemAdded(event: ItemAdded): Promise<void> {
    const current = await this.readDb.findOne(
      "order_summaries",
      event.aggregateId
    );
    if (!current) return;
 
    const addedAmount = event.data.unitPrice * event.data.quantity;
    await this.readDb.update("order_summaries", event.aggregateId, {
      itemCount: current.itemCount + 1,
      totalAmount: current.totalAmount + addedAmount,
      netAmount: current.netAmount + addedAmount,
      lastUpdated: event.metadata.timestamp,
    });
  }
 
  private async onPaymentReceived(event: PaymentReceived): Promise<void> {
    await this.readDb.update("order_summaries", event.aggregateId, {
      status: "paid",
      statusLabel: "支払い完了",
      lastUpdated: event.metadata.timestamp,
    });
  }
 
  private async onOrderShipped(event: OrderShipped): Promise<void> {
    await this.readDb.update("order_summaries", event.aggregateId, {
      status: "shipped",
      statusLabel: "発送済み",
      trackingUrl: `https://tracking.example.com/${event.data.trackingNumber}`,
      lastUpdated: event.metadata.timestamp,
    });
  }
 
  private async onOrderCancelled(event: OrderCancelled): Promise<void> {
    await this.readDb.update("order_summaries", event.aggregateId, {
      status: "cancelled",
      statusLabel: "キャンセル",
      lastUpdated: event.metadata.timestamp,
    });
  }
}
 
// Query Handler — Read Model に対する検索
class OrderQueryHandler {
  constructor(private readDb: ReadDatabase) {}
 
  async getOrderSummary(orderId: string): Promise<OrderSummaryView | null> {
    return this.readDb.findOne("order_summaries", orderId);
  }
 
  async getOrdersByCustomer(
    customerId: string,
    page: number = 1,
    perPage: number = 20
  ): Promise<{ data: OrderSummaryView[]; total: number }> {
    return this.readDb.findPaginated("order_summaries", {
      where: { customerId },
      orderBy: { lastUpdated: "desc" },
      page,
      perPage,
    });
  }
 
  async getRecentOrders(limit: number = 50): Promise<OrderSummaryView[]> {
    return this.readDb.find("order_summaries", {
      orderBy: { lastUpdated: "desc" },
      limit,
    });
  }
 
  async getOrderStats(): Promise<{
    totalOrders: number;
    pendingOrders: number;
    shippedToday: number;
    totalRevenue: number;
  }> {
    return this.readDb.aggregate("order_summaries", {
      totalOrders: { count: "*" },
      pendingOrders: { count: { where: { status: "created" } } },
      shippedToday: {
        count: {
          where: { status: "shipped", lastUpdated: { gte: today() } },
        },
      },
      totalRevenue: { sum: "netAmount", where: { status: { ne: "cancelled" } } },
    });
  }
}

// ============================================================
// Snapshot Repository
// ============================================================
interface Snapshot {
  aggregateId: string;
  version: number;
  state: Record<string, unknown>;
  createdAt: Date;
}
 
interface SnapshotRepository {
  save(snapshot: Snapshot): Promise<void>;
  load(aggregateId: string): Promise<Snapshot | null>;
}
 
class PostgresSnapshotRepository implements SnapshotRepository {
  constructor(private pool: Pool) {}
 
  async save(snapshot: Snapshot): Promise<void> {
    await this.pool.query(
      `INSERT INTO snapshots (aggregate_id, aggregate_type, version, state, created_at)
       VALUES ($1, $2, $3, $4, $5)
       ON CONFLICT (aggregate_id) DO UPDATE
       SET version = $3, state = $4, created_at = $5`,
      ["Order", snapshot.aggregateId, snapshot.version,
       JSON.stringify(snapshot.state), snapshot.createdAt]
    );
  }
 
  async load(aggregateId: string): Promise<Snapshot | null> {
    const { rows } = await this.pool.query(
      "SELECT * FROM snapshots WHERE aggregate_id = $1",
      [aggregateId]
    );
    if (rows.length === 0) return null;
    return {
      aggregateId: rows[0].aggregate_id,
      version: rows[0].version,
      state: rows[0].state,
      createdAt: rows[0].created_at,
    };
  }
}
 
// ============================================================
// スナップショット対応の Order Repository
// ============================================================
class EventSourcedOrderRepository {
  constructor(
    private eventStore: EventStore,
    private snapshotRepo: SnapshotRepository,
    private snapshotInterval: number = 100,
  ) {}
 
  async load(orderId: string): Promise<Order> {
    const snapshot = await this.snapshotRepo.load(orderId);
 
    if (snapshot) {
      const newEvents = await this.eventStore.getEventsAfterVersion(
        orderId,
        snapshot.version
      );
      return Order.fromSnapshot(
        snapshot.state as OrderSnapshot,
        newEvents as OrderEvent[]
      );
    }
 
    const events = await this.eventStore.getEvents(orderId);
    if (events.length === 0) throw new Error(`Order ${orderId} not found`);
    return Order.fromEvents(events as OrderEvent[]);
  }
 
  async save(order: Order): Promise<void> {
    const events = order.getUncommittedEvents();
    const baseVersion = order.version - events.length;
 
    await this.eventStore.append(order.id, [...events], baseVersion);
    order.clearUncommittedEvents();
 
    // スナップショット保存判定
    if (order.version % this.snapshotInterval === 0) {
      await this.snapshotRepo.save({
        aggregateId: order.id,
        version: order.version,
        state: order.toSnapshot(),
        createdAt: new Date(),
      });
    }
  }
}

// ============================================================
// イベントバージョニングと Upcaster
// ============================================================
 
// v1: 初期バージョン
interface OrderCreatedV1 {
  eventType: "OrderCreated";
  schemaVersion: 1;
  data: {
    customerId: string;
    items: Array<{ productId: string; quantity: number; price: number }>;
  };
}
 
// v2: 通貨フィールドを追加
interface OrderCreatedV2 {
  eventType: "OrderCreated";
  schemaVersion: 2;
  data: {
    customerId: string;
    items: Array<{
      productId: string;
      quantity: number;
      price: number;
      currency: string;  // 新規追加
    }>;
    currency: string;  // 新規追加
  };
}
 
// v3: 配送先を追加
interface OrderCreatedV3 {
  eventType: "OrderCreated";
  schemaVersion: 3;
  data: {
    customerId: string;
    items: Array<{
      productId: string;
      quantity: number;
      price: number;
      currency: string;
    }>;
    currency: string;
    shippingAddress: {  // 新規追加
      street: string;
      city: string;
      postalCode: string;
      country: string;
    };
  };
}
 
// Upcaster Chain
class EventUpcaster {
  private upcasters: Map<string, Map<number, (event: any) => any>> = new Map();
 
  register(eventType: string, fromVersion: number, transform: (event: any) => any): void {
    if (!this.upcasters.has(eventType)) {
      this.upcasters.set(eventType, new Map());
    }
    this.upcasters.get(eventType)!.set(fromVersion, transform);
  }
 
  upcast(event: DomainEvent): DomainEvent {
    const version = (event as any).schemaVersion ?? 1;
    const eventUpcasters = this.upcasters.get(event.eventType);
    if (!eventUpcasters) return event;
 
    let current = event;
    let currentVersion = version;
 
    while (eventUpcasters.has(currentVersion)) {
      current = eventUpcasters.get(currentVersion)!(current);
      currentVersion++;
    }
 
    return current;
  }
}
 
// Upcaster の登録
const upcaster = new EventUpcaster();
 
// v1 → v2: currency フィールドを追加
upcaster.register("OrderCreated", 1, (event: OrderCreatedV1): OrderCreatedV2 => ({
  ...event,
  schemaVersion: 2,
  data: {
    ...event.data,
    currency: "JPY",  // デフォルト値
    items: event.data.items.map((i) => ({
      ...i,
      currency: "JPY",
    })),
  },
}));
 
// v2 → v3: shippingAddress を追加
upcaster.register("OrderCreated", 2, (event: OrderCreatedV2): OrderCreatedV3 => ({
  ...event,
  schemaVersion: 3,
  data: {
    ...event.data,
    shippingAddress: {
      street: "不明",
      city: "不明",
      postalCode: "000-0000",
      country: "JP",
    },
  },
}));

// NG: 既存イベントの構造を直接変更
// v1 のデータ: { amount: 1000 }
// v2 のデータ: { amount: 1000, currency: "JPY" }
// → 既存の v1 イベントを読み込むとクラッシュ
 
// OK: Upcaster でバージョン移行
function upcastOrderCreatedV1toV2(event: OrderCreatedV1): OrderCreatedV2 {
  return {
    ...event,
    schemaVersion: 2,
    data: {
      ...event.data,
      currency: "JPY",  // デフォルト値を付与
    },
  };
}

// NG: CRUD 風の汎用イベント
interface OrderUpdated {
  eventType: "OrderUpdated";
  data: {
    fields: Record<string, unknown>;  // 何が変わったか分からない
  };
}
 
// OK: ドメインの意図を表現するイベント
interface DiscountApplied {
  eventType: "DiscountApplied";
  data: {
    discountType: "percentage" | "fixed";
    value: number;
    reason: "loyalty_program" | "coupon" | "manual";
    couponCode?: string;
  };
}
// 「なぜ金額が変わったか」が明確

// NG: Projector 内で外部 API を呼ぶ
class OrderProjector {
  async handle(event: OrderShipped) {
    // Read Model の更新
    await this.readDb.update(/* ... */);
 
    // 副作用（NG！）
    await this.emailService.sendShipmentNotification(event);
    await this.smsService.sendTrackingLink(event);
    // → プロジェクションを再構築（Rebuild）するたびに
    //   メールとSMSが再送信されてしまう！
  }
}
 
// OK: 副作用は別のイベントハンドラで
class OrderProjector {
  async handle(event: OrderShipped) {
    // Read Model の更新のみ
    await this.readDb.update(/* ... */);
  }
}
 
// 通知は専用のハンドラで（べき等性を保証）
class ShipmentNotificationHandler {
  async handle(event: OrderShipped) {
    // べき等性チェック
    const alreadySent = await this.notificationLog.exists(event.eventId);
    if (alreadySent) return;
 
    await this.emailService.sendShipmentNotification(event);
    await this.notificationLog.record(event.eventId);
  }
}

// 楽観的 UI の例（React）
async function submitOrder(orderData: CreateOrderInput) {
  // 1. コマンド送信
  await api.post("/commands/create-order", orderData);
 
  // 2. UI をローカルで即座に更新（Read Model 更新を待たない）
  setOrders((prev) => [
    { ...orderData, status: "processing", id: tempId },
    ...prev,
  ]);
 
  // 3. バックグラウンドで Read Model の反映を確認
  const confirmed = await pollUntil(
    () => api.get(`/orders/${orderData.id}`),
    (res) => res.status !== 404,
    { maxAttempts: 10, interval: 500 }
  );
 
  if (confirmed) {
    // 楽観的更新を確定データで置換
    setOrders((prev) =>
      prev.map((o) => (o.id === tempId ? confirmed : o))
    );
  }
}

describe("Order Aggregate", () => {
  test("支払い済み注文に商品を追加するとエラー", () => {
    // Given: 支払い済みの注文
    const events: OrderEvent[] = [
      orderCreatedEvent({ items: [item1] }),
      paymentReceivedEvent({ amount: 5000 }),
    ];
    const order = Order.fromEvents(events);
 
    // When + Then: 商品追加するとエラー
    expect(() => {
      order.addItem(item2, "user-1");
    }).toThrow('状態 "paid" の注文に商品を追加できません');
  });
 
  test("注文作成で OrderCreated イベントが発行される", () => {
    // When: 注文を作成
    const order = Order.create("order-1", "customer-1", [item1], address, "user-1");
 
    // Then: 発行されたイベントを検証
    const events = order.getUncommittedEvents();
    expect(events).toHaveLength(1);
    expect(events[0].eventType).toBe("OrderCreated");
    expect(events[0].data.customerId).toBe("customer-1");
  });
});