// ❌ Anti-Pattern: Boolean flag state — transitions are implicit and unverifiable

class Order {
  isCreated: boolean = false;
  isPaid: boolean = false;
  isShipped: boolean = false;
  isCancelled: boolean = false;
  isRefunded: boolean = false;

  ship(): void {
    // The guard condition must check ALL possible invalid states manually
    if (!this.isCreated || !this.isPaid || this.isCancelled || this.isShipped) {
      throw new Error('Cannot ship in current state');
    }
    this.isShipped = true;
  }
}

// What states are valid? The caller must manually reconstruct the logic.
// What transitions are allowed from SHIPPED? Unknowable without reading all methods.
// Can an order be both isPaid and isCancelled? The type system has no opinion.

// Each state is a distinct type — cannot mix-and-match fields
type OrderState =
  | { status: 'DRAFT';     createdAt: Date }
  | { status: 'CONFIRMED'; confirmedAt: Date; totalAmountCents: number }
  | { status: 'PAID';      paidAt: Date; transactionId: string }
  | { status: 'SHIPPED';   shippedAt: Date; trackingCode: string }
  | { status: 'CANCELLED'; cancelledAt: Date; reason: string }
  | { status: 'REFUNDED';  refundedAt: Date; refundAmountCents: number };

// Allowed transitions — encoded as a type-level map
type Transitions = {
  DRAFT:     'confirm';
  CONFIRMED: 'pay' | 'cancel';
  PAID:      'ship' | 'refund';
  SHIPPED:   never;       // Terminal — no further transitions
  CANCELLED: never;       // Terminal
  REFUNDED:  never;       // Terminal
};

// Transition guards — only legal transitions compile
class OrderStateMachine {
  #state: OrderState;

  constructor() {
    this.#state = { status: 'DRAFT', createdAt: new Date() };
  }

  get state(): Readonly<OrderState> { return this.#state; }

  confirm(totalAmountCents: number): void {
    this.#assertStatus('DRAFT');
    this.#state = { status: 'CONFIRMED', confirmedAt: new Date(), totalAmountCents };
  }

  pay(transactionId: string): void {
    this.#assertStatus('CONFIRMED');
    this.#state = { status: 'PAID', paidAt: new Date(), transactionId };
  }

  ship(trackingCode: string): void {
    this.#assertStatus('PAID');
    this.#state = { status: 'SHIPPED', shippedAt: new Date(), trackingCode };
  }

  cancel(reason: string): void {
    const state = this.#state;
    if (state.status !== 'DRAFT' && state.status !== 'CONFIRMED') {
      throw new Error(`Cannot cancel from ${state.status}`);
    }
    this.#state = { status: 'CANCELLED', cancelledAt: new Date(), reason };
  }

  refund(refundAmountCents: number): void {
    this.#assertStatus('PAID');
    this.#state = { status: 'REFUNDED', refundedAt: new Date(), refundAmountCents };
  }

  #assertStatus<S extends OrderState['status']>(expected: S): asserts this is { '#state': Extract<OrderState, { status: S }> } {
    if (this.#state.status !== expected) {
      throw new Error(`Expected state ${expected}, got ${this.#state.status}`);
    }
  }
}

// Exhaustive state handler — compiler guarantees all states are covered
function describeOrderState(state: OrderState): string {
  switch (state.status) {
    case 'DRAFT':     return `Draft order created at ${state.createdAt.toISOString()}`;
    case 'CONFIRMED': return `Confirmed: $${state.totalAmountCents / 100}`;
    case 'PAID':      return `Paid: transaction ${state.transactionId}`;
    case 'SHIPPED':   return `Shipped: tracking ${state.trackingCode}`;
    case 'CANCELLED': return `Cancelled: ${state.reason}`;
    case 'REFUNDED':  return `Refunded: $${state.refundAmountCents / 100}`;
    // TypeScript ensures this is unreachable if all states are handled
  }
}

// Handler interface
interface IPaymentMiddleware {
  setNext(handler: IPaymentMiddleware): IPaymentMiddleware;
  handle(request: PaymentRequest): Promise<PaymentRequest>;
}

type PaymentRequest = {
  orderId: string;
  amountCents: number;
  currency: string;
  customerId: string;
  metadata: Record<string, string>;
  // Enriched by handlers:
  normalizedAmount?: number;
  fraudScore?: number;
};

// Abstract base handler — manages chain linkage
abstract class PaymentMiddleware implements IPaymentMiddleware {
  #next: IPaymentMiddleware | null = null;

  setNext(handler: IPaymentMiddleware): IPaymentMiddleware {
    this.#next = handler;
    return handler; // Enables chaining: a.setNext(b).setNext(c)
  }

  protected async passToNext(request: PaymentRequest): Promise<PaymentRequest> {
    if (this.#next) return this.#next.handle(request);
    return request; // End of chain — return as-is
  }

  abstract handle(request: PaymentRequest): Promise<PaymentRequest>;
}

// Concrete handlers
class AmountValidationMiddleware extends PaymentMiddleware {
  async handle(request: PaymentRequest): Promise<PaymentRequest> {
    if (request.amountCents <= 0) throw new Error('Amount must be positive');
    if (request.amountCents > 10_000_00) throw new Error('Amount exceeds maximum of $10,000');
    return this.passToNext(request); // Valid — pass to next handler
  }
}

class CurrencyNormalizationMiddleware extends PaymentMiddleware {
  async handle(request: PaymentRequest): Promise<PaymentRequest> {
    const rates: Record<string, number> = { USD: 1, EUR: 1.08, GBP: 1.27 };
    const rate = rates[request.currency];
    if (!rate) throw new Error(`Unsupported currency: ${request.currency}`);
    // Enrich the request before passing it on
    return this.passToNext({
      ...request,
      normalizedAmount: Math.round(request.amountCents * rate),
    });
  }
}

class FraudScoringMiddleware extends PaymentMiddleware {
  async handle(request: PaymentRequest): Promise<PaymentRequest> {
    const fraudScore = await this.computeFraudScore(request.customerId, request.amountCents);
    if (fraudScore > 80) throw new Error(`Payment blocked: fraud score ${fraudScore}`);
    return this.passToNext({ ...request, fraudScore });
  }

  private async computeFraudScore(customerId: string, amount: number): Promise<number> {
    // Simplified: high-value orders from new customers score higher
    return amount > 500_00 ? 40 : 10; // In reality: ML model call
  }
}

// Build the chain at the composition root
const chain = new AmountValidationMiddleware();
chain
  .setNext(new CurrencyNormalizationMiddleware())
  .setNext(new FraudScoringMiddleware());

// Process a request through the chain
const result = await chain.handle({
  orderId: 'ord_001',
  amountCents: 10_00, // $10.00
  currency: 'EUR',
  customerId: 'cus_abc',
  metadata: {},
});
// result.normalizedAmount = 1080 (€10 × 1.08)
// result.fraudScore = 10 (not high risk)

// Mediator interface
interface IFulfillmentMediator {
  onOrderConfirmed(orderId: string, totalCents: number, customerId: string): Promise<void>;
  onPaymentCompleted(orderId: string, transactionId: string): Promise<void>;
  onShipmentCreated(orderId: string, trackingCode: string): Promise<void>;
}

// Concrete Mediator — coordinates all the aggregates
class OrderFulfillmentMediator implements IFulfillmentMediator {
  constructor(
    private readonly paymentGateway: IPaymentGateway,
    private readonly inventoryService: IInventoryService,
    private readonly notificationService: INotificationService,
  ) {}

  async onOrderConfirmed(orderId: string, totalCents: number, customerId: string): Promise<void> {
    // Coordinates payment + inventory reservation without either knowing about the other
    const result = await this.paymentGateway.charge(totalCents, 'USD', { orderId });
    if (result.status === 'FAILED') throw new Error(result.reason);

    await this.onPaymentCompleted(orderId, result.transactionId);
    await this.notificationService.send(customerId, `Order ${orderId} confirmed`);
  }

  async onPaymentCompleted(orderId: string, transactionId: string): Promise<void> {
    await this.inventoryService.commitReservation(orderId);
    console.log(`[Mediator] Payment ${transactionId} committed inventory for ${orderId}`);
  }

  async onShipmentCreated(orderId: string, trackingCode: string): Promise<void> {
    await this.notificationService.send('customer', `Your order ${orderId} shipped: ${trackingCode}`);
  }
}

interface IInventoryService {
  commitReservation(orderId: string): Promise<void>;
}
interface INotificationService {
  send(customerId: string, message: string): Promise<void>;
}