// src/application/order/ports/IPlaceOrderPort.ts
// (Often just the Use Case class itself serves as the port — this is explicit naming)
import { PlaceOrderCommand } from '../commands/PlaceOrderCommand';
import { OrderId } from '../../../domain/order/OrderId';

export interface IPlaceOrderPort {
  execute(command: PlaceOrderCommand): Promise<OrderId>;
}

// src/domain/order/ports/IOrderRepository.ts — already defined in Part 4
export interface IOrderRepository {
  findById(id: OrderId): Promise<Order | null>;
  findByCustomerId(customerId: CustomerId): Promise<Order[]>;
  save(order: Order): Promise<void>;
  nextId(): OrderId;
}

// src/domain/payment/ports/IPaymentProcessor.ts
export interface IPaymentProcessor {
  charge(amount: Money, orderId: OrderId): Promise<PaymentReceipt>;
  refund(receiptId: ReceiptId, amount: Money): Promise<RefundConfirmation>;
}

// src/domain/shared/ports/IEmailPort.ts
export interface IEmailPort {
  send(options: {
    to: string;
    subject: string;
    template: string;
    variables: Record<string, string | number>;
  }): Promise<void>;
}

// src/infrastructure/payment/StripePaymentProcessor.ts
import Stripe from 'stripe';                               // External library
import { IPaymentProcessor } from '../../domain/payment/ports/IPaymentProcessor';
import { Money } from '../../domain/payment/Money';
import { OrderId } from '../../domain/order/OrderId';
import { PaymentReceipt } from '../../domain/payment/PaymentReceipt';
import { DomainError } from '../../domain/shared/DomainError';

export class StripePaymentProcessor implements IPaymentProcessor {
  constructor(private readonly stripe: Stripe) {}

  async charge(amount: Money, orderId: OrderId): Promise<PaymentReceipt> {
    try {
      const intent = await this.stripe.paymentIntents.create({
        amount: amount.amountCents,
        currency: amount.currency.toLowerCase(),
        metadata: { orderId },
        confirm: true,
        payment_method: 'pm_card_visa', // In production: supplied by client
      });

      if (intent.status !== 'succeeded') {
        throw new DomainError(`Payment failed with status: ${intent.status}`);
      }

      return PaymentReceipt.create({
        receiptId: intent.id as any,
        orderId,
        amount,
        providerReference: intent.id,
        capturedAt: new Date(),
      });
    } catch (err) {
      if (err instanceof Stripe.errors.StripeCardError) {
        throw new DomainError(`Card declined: ${err.message}`);
      }
      throw err; // Re-throw unexpected Stripe errors
    }
  }

  async refund(receiptId: ReceiptId, amount: Money): Promise<RefundConfirmation> {
    const refund = await this.stripe.refunds.create({
      payment_intent: receiptId,
      amount: amount.amountCents,
    });
    return RefundConfirmation.create({ refundId: refund.id as any, amount, processedAt: new Date() });
  }
}

// src/infrastructure/payment/PayPalPaymentProcessor.ts — a second driven adapter
import { PayPalClient } from '@paypal/checkout-server-sdk';
import { IPaymentProcessor } from '../../domain/payment/ports/IPaymentProcessor';
// ... same interface, different implementation

// src/interface/http/OrderController.ts
import { Request, Response } from 'express';
import { PlaceOrderUseCase } from '../../application/order/PlaceOrderUseCase';
import { PlaceOrderCommand } from '../../application/order/commands/PlaceOrderCommand';
import { Money } from '../../domain/payment/Money';

export class OrderController {
  constructor(private readonly placeOrder: PlaceOrderUseCase) {}

  async create(req: Request, res: Response): Promise<void> {
    const command: PlaceOrderCommand = {
      customerId: req.body.customerId,
      items: req.body.items.map((i: any) => ({
        productId: i.productId,
        quantity: i.quantity,
        unitPrice: Money.of(i.currency, i.unitPrice),
      })),
      shippingAddress: req.body.shippingAddress,
    };

    try {
      const orderId = await this.placeOrder.execute(command);
      res.status(201).json({ orderId });
    } catch (error) {
      this.handleError(error, res);
    }
  }
}

// src/interface/kafka/OrderCommandConsumer.ts
import { Consumer, EachMessagePayload } from 'kafkajs';
import { PlaceOrderUseCase } from '../../application/order/PlaceOrderUseCase';
import { PlaceOrderCommand } from '../../application/order/commands/PlaceOrderCommand';
import { Money } from '../../domain/payment/Money';

export class OrderCommandConsumer {
  constructor(
    private readonly consumer: Consumer,
    private readonly placeOrder: PlaceOrderUseCase,
  ) {}

  async start(): Promise<void> {
    await this.consumer.subscribe({ topic: 'order.commands', fromBeginning: false });
    await this.consumer.run({
      eachMessage: async ({ message }: EachMessagePayload) => {
        const payload = JSON.parse(message.value!.toString());
        const command: PlaceOrderCommand = {
          customerId: payload.customerId,
          items: payload.items.map((i: any) => ({
            productId: i.productId,
            quantity: i.quantity,
            unitPrice: Money.of(i.currency, i.unitPrice),
          })),
          shippingAddress: payload.shippingAddress,
        };
        // Same use case — same PlaceOrderCommand — zero application code changes
        await this.placeOrder.execute(command);
      },
    });
  }
}

// src/interface/cli/PlaceOrderCommand.ts
import { program } from 'commander';
import { PlaceOrderUseCase } from '../../application/order/PlaceOrderUseCase';
import { Money } from '../../domain/payment/Money';

export function registerPlaceOrderCommand(placeOrder: PlaceOrderUseCase): void {
  program
    .command('place-order')
    .requiredOption('--customer <id>')
    .requiredOption('--product <id>')
    .requiredOption('--quantity <n>', '', parseInt)
    .requiredOption('--price <amount>', '', parseFloat)
    .action(async (opts) => {
      const command = {
        customerId: opts.customer,
        items: [{ productId: opts.product, quantity: opts.quantity, unitPrice: Money.of('USD', opts.price) }],
        shippingAddress: { street: '1 CLI St', city: 'Test', state: 'TS', postalCode: '00000', countryCode: 'US' },
      };
      const orderId = await placeOrder.execute(command);
      console.log(`Order placed: ${orderId}`);
    });
}

# Check for any domain files importing from infrastructure
grep -r "from.*infrastructure" src/domain/
# Must return: (empty)

grep -r "from.*infrastructure" src/application/
# Must return: (empty)

grep -r "from.*prisma" src/domain/
# Must return: (empty)

grep -r "from.*stripe" src/application/
# Must return: (empty)