// ❌ Anti-Pattern: Primitive Obsession — raw primitives for all domain concepts
interface OrderData {
  id: string;           // What kind of ID? Order? Customer? Product? All the same type.
  customerId: string;   // Could accidentally receive a productId here — TypeScript won't care
  status: string;       // 'PENDING', 'SHIPPED', 'xyz', 'null' — any string compiles
  totalAmount: number;  // -500 compiles. 0 compiles. NaN compiles.
  currency: string;     // 'USD', 'MONOPOLY', '' — any string compiles
  items: {
    productId: string;  // Same type as customerId — swappable by accident
    quantity: number;   // 0 compiles. -3 compiles.
    unitPrice: number;  // Negative compiles. NaN compiles.
  }[];
}

// Three months later, in a discount service:
function applyDiscount(order: OrderData, customerId: string): number {
  // Bug: wrong argument passed — customerId used where orderId expected
  // TypeScript sees string → string: compiles and ships to production
  if (order.id === customerId) { /* ... */ }
  return order.totalAmount * 0.9;
}

// src/domain/shared/Entity.ts
export abstract class Entity<TId extends { equals(other: TId): boolean }> {
  protected constructor(public readonly id: TId) {}

  equals(other: Entity<TId>): boolean {
    if (!(other instanceof Entity)) return false;
    if (other.constructor !== this.constructor) return false; // Same class required
    return this.id.equals(other.id);
  }

  // Entities are NOT equal by value — two Orders with different IDs are different orders
  // even if their state (status, items, total) happens to be identical at this moment
}

// 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[] = [];

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

  /** Called by the Use Case after the repository.save() commits */
  pullDomainEvents(): DomainEvent[] {
    const events = [...this._domainEvents];
    this._domainEvents.length = 0; // Clear after pulling
    return events;
  }
}

// src/domain/shared/ValueObject.ts
export abstract class ValueObject<T extends Record<string, unknown>> {
  protected readonly props: Readonly<T>;

  protected constructor(props: T) {
    this.props = Object.freeze({ ...props }); // Immutable — Object.freeze enforces at runtime
  }

  equals(other: ValueObject<T>): boolean {
    if (other === null || other === undefined) return false;
    if (other.constructor !== this.constructor) return false;
    return JSON.stringify(this.props) === JSON.stringify(other.props);
  }
}

// src/domain/shared/brand.ts
declare const __brand: unique symbol;
type Brand<T, B extends string> = T & { readonly [__brand]: B };

// Branded ID types — each is a distinct type, not assignable to each other
export type OrderId   = Brand<string, 'OrderId'>;
export type CustomerId = Brand<string, 'CustomerId'>;
export type ProductId  = Brand<string, 'ProductId'>;
export type SKU        = Brand<string, 'SKU'>;
export type WarehouseId = Brand<string, 'WarehouseId'>;

// Factory functions with validation
export function makeOrderId(raw: string): OrderId {
  if (!raw || raw.trim().length === 0) throw new DomainError('OrderId cannot be empty');
  return raw as OrderId;
}

export function generateOrderId(): OrderId {
  return `ord_${crypto.randomUUID()}` as OrderId;
}

function applyDiscount(order: Order, customerId: CustomerId): Money {
  // ❌ TypeScript Error: Type 'OrderId' is not assignable to type 'CustomerId'
  if (order.id === customerId) { /* ... */ }
  // This line no longer compiles — the bug is caught before it reaches production
}

// src/domain/payment/Money.ts
import { ValueObject } from '../shared/ValueObject';
import { DomainError } from '../shared/DomainError';

export const SupportedCurrencies = ['USD', 'EUR', 'GBP', 'INR', 'JPY'] as const;
export type Currency = typeof SupportedCurrencies[number];

interface MoneyProps {
  amountCents: number; // Store as integer cents — eliminates floating-point errors
  currency: Currency;
}

export class Money extends ValueObject<MoneyProps> {
  private constructor(props: MoneyProps) {
    super(props);
  }

  static of(currency: Currency, amount: number): Money {
    if (!SupportedCurrencies.includes(currency))
      throw new DomainError(`Unsupported currency: ${currency}`);
    if (!Number.isFinite(amount))
      throw new DomainError(`Money amount must be a finite number, got: ${amount}`);
    if (amount < 0)
      throw new DomainError(`Money amount cannot be negative: ${amount}`);

    // Convert to cents — integer arithmetic eliminates floating-point issues
    const amountCents = Math.round(amount * 100);
    return new Money({ amountCents, currency });
  }

  static zero(currency: Currency): Money {
    return new Money({ amountCents: 0, currency });
  }

  // ✅ add() returns a new Money — does not mutate either operand
  add(other: Money): Money {
    this.assertSameCurrency(other);
    return new Money({ amountCents: this.props.amountCents + other.props.amountCents, currency: this.props.currency });
  }

  subtract(other: Money): Money {
    this.assertSameCurrency(other);
    const result = this.props.amountCents - other.props.amountCents;
    if (result < 0) throw new DomainError('Money subtraction cannot produce a negative result');
    return new Money({ amountCents: result, currency: this.props.currency });
  }

  multiply(factor: number): Money {
    if (!Number.isFinite(factor) || factor < 0)
      throw new DomainError(`Money multiplier must be a non-negative finite number: ${factor}`);
    return new Money({
      amountCents: Math.round(this.props.amountCents * factor),
      currency: this.props.currency,
    });
  }

  greaterThan(other: Money): boolean {
    this.assertSameCurrency(other);
    return this.props.amountCents > other.props.amountCents;
  }

  get currency(): Currency { return this.props.currency; }
  get amountCents(): number { return this.props.amountCents; }
  get amount(): number { return this.props.amountCents / 100; }

  toString(): string { return `${this.props.currency} ${this.amount.toFixed(2)}`; }

  private assertSameCurrency(other: Money): void {
    if (this.props.currency !== other.props.currency)
      throw new DomainError(
        `Currency mismatch: cannot operate on ${this.props.currency} and ${other.props.currency}`
      );
  }
}

// src/domain/customer/Address.ts
interface AddressProps {
  street: string;
  city: string;
  state: string;
  postalCode: string;
  countryCode: string; // ISO 3166-1 alpha-2
}

export class Address extends ValueObject<AddressProps> {
  static create(props: AddressProps): Address {
    if (!props.street.trim()) throw new DomainError('Street is required');
    if (!props.city.trim()) throw new DomainError('City is required');
    if (!/^[A-Z]{2}$/.test(props.countryCode))
      throw new DomainError(`Invalid ISO country code: ${props.countryCode}`);
    return new Address(props);
  }

  get street()      { return this.props.street; }
  get city()        { return this.props.city; }
  get state()       { return this.props.state; }
  get postalCode()  { return this.props.postalCode; }
  get countryCode() { return this.props.countryCode; }
}

// src/domain/customer/EmailAddress.ts
export class EmailAddress extends ValueObject<{ value: string }> {
  private static readonly EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  static create(raw: string): EmailAddress {
    if (!EmailAddress.EMAIL_REGEX.test(raw))
      throw new DomainError(`Invalid email address: ${raw}`);
    return new EmailAddress({ value: raw.toLowerCase().trim() });
  }

  get value(): string { return this.props.value; }
  toString(): string  { return this.props.value; }
}

// src/domain/order/Order.ts
import { AggregateRoot } from '../shared/AggregateRoot';
import { OrderId, generateOrderId } from './OrderId';
import { CustomerId } from '../customer/CustomerId';
import { LineItem } from './LineItem';
import { Money } from '../payment/Money';
import { OrderStatus } from './OrderStatus';
import { DomainError } from '../shared/DomainError';
import { OrderPlaced } from './events/OrderPlaced';
import { OrderCancelled } from './events/OrderCancelled';
import { WarehouseId } from '../fulfillment/WarehouseId';

interface OrderSnapshot {
  id: OrderId;
  customerId: CustomerId;
  status: OrderStatus;
  items: LineItem[];
  shippingAddress: Address | null;
}

export class Order extends AggregateRoot<OrderId> {
  private _customerId: CustomerId;
  private _status: OrderStatus;
  private _items: LineItem[];
  private _shippingAddress: Address | null;

  // ✅ Private constructor — the only way to get an Order is through the factory
  private constructor(snapshot: OrderSnapshot) {
    super(snapshot.id);
    this._customerId = snapshot.customerId;
    this._status = snapshot.status;
    this._items = [...snapshot.items];
    this._shippingAddress = snapshot.shippingAddress;
  }

  // ✅ Static factory — enforces all creation invariants before the object exists in memory
  static create(customerId: CustomerId): Order {
    if (!customerId) throw new DomainError('CustomerId is required to create an Order');
    return new Order({
      id: generateOrderId(),
      customerId,
      status: OrderStatus.PENDING,
      items: [],
      shippingAddress: null,
    });
  }

  // ✅ Reconstitute from storage — used by the Repository adapter (Part 13)
  static reconstitute(snapshot: OrderSnapshot): Order {
    return new Order(snapshot);
  }

  // ──── Command Methods (mutate state) ────

  addItem(item: LineItem): void {
    if (this._status !== OrderStatus.PENDING)
      throw new DomainError(`Cannot add items to Order ${this.id} — status is ${this._status}`);

    const existing = this._items.find(i => i.productId === item.productId);
    if (existing) {
      // Aggregate the quantity rather than creating a duplicate line item
      this.removeItemByProductId(item.productId);
      this._items.push(existing.withAdditionalQuantity(item.quantity));
    } else {
      this._items.push(item);
    }
  }

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

  setShippingAddress(address: Address): void {
    if (this._status !== OrderStatus.PENDING)
      throw new DomainError(`Cannot set shipping address on Order ${this.id} — already placed`);
    this._shippingAddress = address;
  }

  place(): void {
    if (this._status !== OrderStatus.PENDING)
      throw new DomainError(`Order ${this.id} cannot be placed — status is ${this._status}`);
    if (this._items.length === 0)
      throw new DomainError(`Order ${this.id} cannot be placed with no line items`);
    if (!this._shippingAddress)
      throw new DomainError(`Order ${this.id} cannot be placed without a shipping address`);

    this._status = OrderStatus.PLACED;
    this.addDomainEvent(new OrderPlaced(this.id, this._customerId, this.total));
  }

  cancel(reason: string): void {
    if (![OrderStatus.PENDING, OrderStatus.PLACED].includes(this._status))
      throw new DomainError(
        `Order ${this.id} cannot be cancelled — status is ${this._status}. Only PENDING or PLACED orders can be cancelled.`
      );
    this._status = OrderStatus.CANCELLED;
    this.addDomainEvent(new OrderCancelled(this.id, reason));
  }

  ship(warehouseId: WarehouseId): void {
    if (this._status !== OrderStatus.PAID)
      throw new DomainError(
        `Order ${this.id} cannot be shipped — status is ${this._status}, expected PAID`
      );
    this._status = OrderStatus.SHIPPED;
    this.addDomainEvent(new OrderShipped(this.id, warehouseId));
  }

  // ──── Query Methods (read state) ────

  get customerId(): CustomerId     { return this._customerId; }
  get status(): OrderStatus        { return this._status; }
  get items(): ReadonlyArray<LineItem> { return this._items; }
  get shippingAddress(): Address | null { return this._shippingAddress; }

  get total(): Money {
    return this._items.reduce(
      (sum, item) => sum.add(item.subtotal),
      Money.zero('USD'), // Default — will be overridden by real currency in Part 3
    );
  }

  private removeItemByProductId(productId: ProductId): void {
    const idx = this._items.findIndex(i => i.productId === productId);
    if (idx === -1) throw new DomainError(`Item with productId ${productId} not found in Order ${this.id}`);
    this._items.splice(idx, 1);
  }
}

// src/domain/order/LineItem.ts
import { Entity } from '../shared/Entity';
import { LineItemId, generateLineItemId } from './LineItemId';
import { ProductId } from '../product/ProductId';
import { Money } from '../payment/Money';
import { DomainError } from '../shared/DomainError';

interface LineItemSnapshot {
  id: LineItemId;
  productId: ProductId;
  quantity: number;
  unitPrice: Money;
}

export class LineItem extends Entity<LineItemId> {
  private _productId: ProductId;
  private _quantity: number;
  private _unitPrice: Money;

  private constructor(snapshot: LineItemSnapshot) {
    super(snapshot.id);
    this._productId = snapshot.productId;
    this._quantity = snapshot.quantity;
    this._unitPrice = snapshot.unitPrice;
  }

  static create(productId: ProductId, quantity: number, unitPrice: Money): LineItem {
    if (quantity <= 0 || !Number.isInteger(quantity))
      throw new DomainError(`LineItem quantity must be a positive integer, got: ${quantity}`);
    if (unitPrice.amountCents <= 0)
      throw new DomainError(`LineItem unit price must be positive, got: ${unitPrice}`);
    return new LineItem({ id: generateLineItemId(), productId, quantity, unitPrice });
  }

  withAdditionalQuantity(additionalQty: number): LineItem {
    return LineItem.create(this._productId, this._quantity + additionalQty, this._unitPrice);
  }

  get productId():   ProductId { return this._productId; }
  get quantity():    number    { return this._quantity; }
  get unitPrice():   Money     { return this._unitPrice; }
  get subtotal():    Money     { return this._unitPrice.multiply(this._quantity); }
}

// ❌ Bug: Comparing Entities by value (should compare by ID)
const orderA = Order.create(customerId);
const orderB = Order.reconstitute({ id: orderA.id, /* same state */ });
console.log(orderA === orderB);          // false — different object references
console.log(orderA.equals(orderB));      // true — same OrderId ✅

// ❌ Bug: Comparing Value Objects by reference (should compare structurally)
const priceA = Money.of('USD', 99.99);
const priceB = Money.of('USD', 99.99);
console.log(priceA === priceB);          // false — different object references ❌
console.log(priceA.equals(priceB));      // true — same amount and currency ✅

// ✅ Using the correct equality methods in a discount eligibility check:
const hasDiscountAmount = order.total.greaterThan(Money.of('USD', 100));
const isPreferredCustomer = order.customerId.equals(preferredCustomer.id);