// ❌ Anti-Pattern: External code holds a direct reference to a child Entity
const order = await orderRepo.findById(orderId);

// The LineItem is an Entity — it has a public setter that bypasses all Order guards
const lineItem = order.items.find(i => i.productId === targetProductId)!;
lineItem.setQuantity(-5);  // ✅ Compiles. The LineItem has no guard against this.
// The Order.total() now returns a negative number.
// The Order never knew this happened. No domain event raised.
await lineItemRepo.save(lineItem); // Saving the child directly — the Order is not involved

// Two separate transactions later:
// Order.total is negative. Payment calculation is wrong.
// Fraud detection triggers. Customer is blocked.

// src/domain/shared/AggregateRoot.ts
import { Entity } from './Entity';
import { DomainEvent } from './DomainEvent';

export abstract class AggregateRoot<TId extends { equals(other: TId): boolean }>
  extends Entity<TId> {

  private readonly _domainEvents: DomainEvent[] = [];
  private _version: number = 0; // Optimistic concurrency guard — Part 11

  protected constructor(id: TId, version = 0) {
    super(id);
    this._version = version;
  }

  protected addDomainEvent(event: DomainEvent): void {
    this._domainEvents.push(event);
  }

  /**
   * Called by the Use Case after repository.save() has committed.
   * Clears the event list — events are dispatched once and forgotten.
   */
  pullDomainEvents(): DomainEvent[] {
    const events = [...this._domainEvents];
    this._domainEvents.length = 0;
    return events;
  }

  get version(): number { return this._version; }
  get hasDomainEvents(): boolean { return this._domainEvents.length > 0; }
}

// src/domain/order/Order.ts (relevant sections)
export class Order extends AggregateRoot<OrderId> {
  // ❌ If items were public:  external code could call order.items.push(rawItem)
  // ✅ With ReadonlyArray:    order.items returns an immutable view
  private _items: LineItem[] = [];

  get items(): ReadonlyArray<LineItem> {
    return this._items; // Typed as ReadonlyArray — push/splice are not available
  }

  // ✅ The only way to add an item is through this guarded method
  addItem(productId: ProductId, quantity: number, unitPrice: Money): void {
    if (this._status !== OrderStatus.PENDING)
      throw new DomainError(`Cannot add items to Order ${this.id} — already placed`);
    if (quantity <= 0)
      throw new DomainError(`Item quantity must be positive, got ${quantity}`);

    const existing = this._items.find(i => i.productId === productId);
    if (existing) {
      // Merge quantities on duplicate product — business rule enforced here
      const idx = this._items.indexOf(existing);
      this._items[idx] = existing.withAdditionalQuantity(quantity);
    } else {
      this._items.push(LineItem.create(productId, quantity, unitPrice));
    }
  }

  updateItemQuantity(productId: ProductId, newQuantity: number): void {
    if (this._status !== OrderStatus.PENDING)
      throw new DomainError(`Cannot update items on Order ${this.id} — already placed`);
    if (newQuantity <= 0)
      throw new DomainError(`New quantity must be positive, got ${newQuantity}`);

    const idx = this._items.findIndex(i => i.productId === productId);
    if (idx === -1)
      throw new DomainError(`ProductId ${productId} not found in Order ${this.id}`);

    this._items[idx] = this._items[idx].withQuantity(newQuantity);
  }

  removeItem(productId: ProductId): void {
    if (this._status !== OrderStatus.PENDING)
      throw new DomainError(`Cannot remove items from Order ${this.id} — already placed`);

    const idx = this._items.findIndex(i => i.productId === productId);
    if (idx === -1)
      throw new DomainError(`ProductId ${productId} not found in Order ${this.id}`);

    this._items.splice(idx, 1);
  }
}

const order = await orderRepo.findById(orderId);

// ❌ TypeScript Error: Property 'push' does not exist on type 'ReadonlyArray<LineItem>'
order.items.push(someItem);

// ❌ TypeScript Error: Index signature in type 'ReadonlyArray<LineItem>' only permits reading
order.items[0] = someOtherItem;

// ✅ Only valid mutation path:
order.addItem(productId, 2, Money.of('USD', 49.99));

// ❌ Anti-Pattern: Order holds a direct reference to the Customer Aggregate
class Order extends AggregateRoot<OrderId> {
  private _customer: Customer; // ← Object reference to another Aggregate

  // Problem: Order.customer is now mutable — Customer state can change after Order is loaded
  // Problem: Loading an Order now requires loading the entire Customer Aggregate tree
  // Problem: A transaction saving Order could accidentally save Customer mutations too
}

// ✅ Correct: Order holds only the CustomerId — a Value Object (branded string)
class Order extends AggregateRoot<OrderId> {
  private _customerId: CustomerId; // ← ID reference only — Customer is a separate Aggregate

  // When the Use Case needs Customer data, it loads it separately via ICustomerRepository
  // The Order and Customer are saved in separate transactions — clear boundary
}

// ❌ Anti-Pattern: Two Aggregates in one transaction — crosses consistency boundary
async execute(command: PlaceOrderCommand): Promise<void> {
  await db.$transaction(async (tx) => {
    await tx.order.update({ where: { id: command.orderId }, data: { status: 'PLACED' } });
    await tx.inventory.update({ where: { productId: command.productId }, data: { reserved: { increment: 1 } } });
    // ❌ This couples Order and Inventory into a single transaction
    // If Inventory fails, Order rollback cascades — tight coupling in disguise
  });
}

// ✅ Correct: Each Aggregate in its own transaction; cross-boundary coordination via Domain Events
async execute(command: PlaceOrderCommand): Promise<void> {
  const order = await this.orderRepo.findById(command.orderId);
  order.place();
  await this.orderRepo.save(order); // Transaction 1: only touches orders + line_items tables

  // Domain Events handle the cross-Aggregate side effects — no distributed transaction needed
  const events = order.pullDomainEvents();
  for (const event of events) await this.eventBus.publish(event);
  // InventoryReservationHandler handles its own Aggregate in its own transaction (Part 5)
}

// src/domain/order/ports/IOrderRepository.ts
import { Order } from '../Order';
import { OrderId } from '../OrderId';
import { CustomerId } from '../../customer/CustomerId';

export interface IOrderRepository {
  /** Load an Order by its ID. Returns null if not found. */
  findById(id: OrderId): Promise<Order | null>;

  /** Load all Orders for a specific customer */
  findByCustomerId(customerId: CustomerId): Promise<Order[]>;

  /**
   * Persist an Order and all its child LineItems atomically.
   * Must handle both INSERT (new Order) and UPDATE (existing Order).
   */
  save(order: Order): Promise<void>;

  /** Generate a new, globally unique OrderId */
  nextId(): OrderId;
}

// src/infrastructure/persistence/InMemoryOrderRepository.ts
import { IOrderRepository } from '../../domain/order/ports/IOrderRepository';
import { Order } from '../../domain/order/Order';
import { OrderId, generateOrderId } from '../../domain/order/OrderId';
import { CustomerId } from '../../domain/customer/CustomerId';

export class InMemoryOrderRepository implements IOrderRepository {
  // Use a Map for O(1) lookup by OrderId
  private readonly store = new Map<string, Order>();

  async findById(id: OrderId): Promise<Order | null> {
    return this.store.get(id) ?? null;
  }

  async findByCustomerId(customerId: CustomerId): Promise<Order[]> {
    return Array.from(this.store.values())
      .filter(order => order.customerId === customerId);
  }

  async save(order: Order): Promise<void> {
    // Deep clone to simulate database round-trip isolation
    // Prevents the in-memory test double from sharing references with the caller
    this.store.set(order.id, this.clone(order));
  }

  nextId(): OrderId {
    return generateOrderId();
  }

  // ── Test helpers (not part of IOrderRepository) ──

  /** Returns all stored Orders — useful in tests to assert persistence side effects */
  findAll(): Order[] {
    return Array.from(this.store.values());
  }

  /** Clear all data — use in beforeEach to ensure test isolation */
  clear(): void {
    this.store.clear();
  }

  get size(): number {
    return this.store.size;
  }

  private clone(order: Order): Order {
    // Reconstitute from snapshot to ensure the stored object is independent of the caller's reference
    return Order.reconstitute({
      id: order.id,
      customerId: order.customerId,
      status: order.status,
      items: [...order.items],
      shippingAddress: order.shippingAddress,
      version: order.version,
    });
  }
}

// tests/unit/domain/order/OrderRepositoryContract.ts
import { IOrderRepository } from '../../../../src/domain/order/ports/IOrderRepository';
import { Order } from '../../../../src/domain/order/Order';
import { CustomerId } from '../../../../src/domain/customer/CustomerId';
import { Money } from '../../../../src/domain/payment/Money';

/**
 * Abstract contract test suite.
 * Both InMemoryOrderRepository and PrismaOrderRepository must pass every test here.
 */
export function orderRepositoryContract(
  getRepo: () => IOrderRepository,
  beforeEachHook?: () => Promise<void>,
): void {
  describe('IOrderRepository contract', () => {
    let repo: IOrderRepository;

    beforeEach(async () => {
      if (beforeEachHook) await beforeEachHook();
      repo = getRepo();
    });

    it('should return null for a non-existent OrderId', async () => {
      const result = await repo.findById('ord_nonexistent' as any);
      expect(result).toBeNull();
    });

    it('should persist a new Order and retrieve it by ID', async () => {
      const customerId = 'cust_001' as CustomerId;
      const order = Order.create(customerId);
      order.addItem('prod_001' as any, 2, Money.of('USD', 49.99));
      order.setShippingAddress(testAddress());

      await repo.save(order);

      const retrieved = await repo.findById(order.id);
      expect(retrieved).not.toBeNull();
      expect(retrieved!.id).toBe(order.id);
      expect(retrieved!.items).toHaveLength(1);
      expect(retrieved!.items[0].quantity).toBe(2);
    });

    it('should update an existing Order on save', async () => {
      const order = Order.create('cust_001' as CustomerId);
      await repo.save(order);

      order.addItem('prod_002' as any, 1, Money.of('USD', 29.99));
      await repo.save(order);

      const retrieved = await repo.findById(order.id);
      expect(retrieved!.items).toHaveLength(1);
      expect(retrieved!.items[0].unitPrice.amount).toBeCloseTo(29.99);
    });

    it('should retrieve all Orders for a CustomerId', async () => {
      const customerId = 'cust_multi' as CustomerId;
      const order1 = Order.create(customerId);
      const order2 = Order.create(customerId);
      const orderOther = Order.create('cust_other' as CustomerId);

      await repo.save(order1);
      await repo.save(order2);
      await repo.save(orderOther);

      const customerOrders = await repo.findByCustomerId(customerId);
      expect(customerOrders).toHaveLength(2);
      expect(customerOrders.every(o => o.customerId === customerId)).toBe(true);
    });

    it('should generate unique OrderIds', () => {
      const ids = new Set(Array.from({ length: 100 }, () => repo.nextId()));
      expect(ids.size).toBe(100); // All 100 must be unique
    });
  });
}

// tests/unit/infrastructure/InMemoryOrderRepository.test.ts
import { InMemoryOrderRepository } from '../../../src/infrastructure/persistence/InMemoryOrderRepository';
import { orderRepositoryContract } from '../../unit/domain/order/OrderRepositoryContract';

describe('InMemoryOrderRepository', () => {
  let repo: InMemoryOrderRepository;

  orderRepositoryContract(
    () => repo,
    async () => { repo = new InMemoryOrderRepository(); repo.clear(); }
  );
});

// tests/integration/PrismaOrderRepository.test.ts
import { PrismaClient } from '@prisma/client';
import { PrismaOrderRepository } from '../../../src/infrastructure/persistence/PrismaOrderRepository';
import { orderRepositoryContract } from '../../unit/domain/order/OrderRepositoryContract';

describe('PrismaOrderRepository (integration)', () => {
  const prisma = new PrismaClient();
  let repo: PrismaOrderRepository;

  orderRepositoryContract(
    () => repo,
    async () => {
      repo = new PrismaOrderRepository(prisma);
      await prisma.orderItem.deleteMany();
      await prisma.order.deleteMany();
    }
  );

  afterAll(() => prisma.$disconnect());
});

// src/domain/shared/DomainEvent.ts
export abstract class DomainEvent {
  public readonly eventId: string;
  public readonly occurredAt: Date;
  public readonly aggregateId: string;
  public readonly eventVersion: number;

  protected constructor(aggregateId: string, eventVersion: number = 1) {
    this.eventId = crypto.randomUUID();
    this.occurredAt = new Date();
    this.aggregateId = aggregateId;
    this.eventVersion = eventVersion;
  }

  /** Discriminator for runtime event type routing in handlers */
  abstract get eventType(): string;
}

// src/domain/order/events/OrderPlaced.ts
import { DomainEvent } from '../../shared/DomainEvent';
import { OrderId } from '../OrderId';
import { CustomerId } from '../../customer/CustomerId';
import { Money } from '../../payment/Money';

export class OrderPlaced extends DomainEvent {
  constructor(
    public readonly orderId: OrderId,
    public readonly customerId: CustomerId,
    public readonly total: Money,
  ) {
    super(orderId);
  }

  get eventType(): string { return 'order.placed'; }
}

// src/domain/order/Order.ts
export interface OrderSnapshot {
  id: OrderId;
  customerId: CustomerId;
  status: OrderStatus;
  items: LineItem[];
  shippingAddress: Address | null;
  version: number;
}

export class Order extends AggregateRoot<OrderId> {
  // ── Creation factory — enforces all creation invariants ──
  static create(customerId: CustomerId): Order {
    if (!customerId) throw new DomainError('CustomerId is required');
    return new Order({
      id: generateOrderId(),
      customerId,
      status: OrderStatus.PENDING,
      items: [],
      shippingAddress: null,
      version: 0,
    });
  }

  // ── Reconstitution factory — bypasses creation invariants, trusts the database ──
  static reconstitute(snapshot: OrderSnapshot): Order {
    return new Order(snapshot);
    // No invariant checks here — we trust the data was valid when it was saved
    // A SHIPPED order with no items is valid stored state (items were shipped)
  }

  private constructor(private readonly snapshot: OrderSnapshot) {
    super(snapshot.id, snapshot.version);
    this._customerId = snapshot.customerId;
    this._status = snapshot.status;
    this._items = [...snapshot.items];
    this._shippingAddress = snapshot.shippingAddress;
  }
}