// ❌ Anti-Pattern: Fat IOrderService — every client depends on every method

interface IOrderService {
  createOrder(customerId: string, items: OrderItem[]): Promise<Order>;
  updateOrder(orderId: string, items: OrderItem[]): Promise<Order>;
  cancelOrder(orderId: string, reason: string): Promise<void>;
  refundOrder(orderId: string): Promise<RefundResult>;
  deleteOrder(orderId: string): Promise<void>;
  findOrderById(orderId: string): Promise<Order | null>;
  findOrdersByCustomer(customerId: string): Promise<Order[]>;
  exportOrderReport(from: Date, to: Date): Promise<OrderReport>;
}

// The AuditExporter only needs to read transaction dates
// But it must depend on the ENTIRE IOrderService contract
class AuditExporter {
  constructor(private readonly orderService: IOrderService) {}

  async exportComplianceReport(from: Date, to: Date): Promise<string[]> {
    const report = await this.orderService.exportOrderReport(from, to);
    return report.entries.map(e => `${e.orderId}: ${e.total}`);
  }
  // AuditExporter has no business with createOrder, deleteOrder, refundOrder —
  // but it is forced to depend on all of them through the fat interface.
}

// ✅ Role interfaces — each sized to one consumer's actual needs

interface IOrderReader {
  findOrderById(orderId: string): Promise<Order | null>;
  findOrdersByCustomer(customerId: string): Promise<Order[]>;
}

interface IOrderWriter {
  createOrder(customerId: string, items: OrderItem[]): Promise<Order>;
  updateOrder(orderId: string, items: OrderItem[]): Promise<Order>;
}

interface IOrderCanceller {
  cancelOrder(orderId: string, reason: string): Promise<void>;
}

interface IOrderRefunder {
  refundOrder(orderId: string): Promise<RefundResult>;
}

interface IOrderReporter {
  exportOrderReport(from: Date, to: Date): Promise<OrderReport>;
}

// Now AuditExporter depends only on what it uses
class AuditExporter {
  constructor(private readonly reporter: IOrderReporter) {}

  async exportComplianceReport(from: Date, to: Date): Promise<string[]> {
    const report = await this.reporter.exportOrderReport(from, to);
    return report.entries.map(e => `${e.orderId}: ${e.total}`);
  }
}

// The concrete class implements all role interfaces — that is its responsibility
class OrderService implements IOrderReader, IOrderWriter, IOrderCanceller, IOrderRefunder, IOrderReporter {
  async findOrderById(orderId: string): Promise<Order | null> { return null; }
  async findOrdersByCustomer(customerId: string): Promise<Order[]> { return []; }
  async createOrder(customerId: string, items: OrderItem[]): Promise<Order> { return {} as Order; }
  async updateOrder(orderId: string, items: OrderItem[]): Promise<Order> { return {} as Order; }
  async cancelOrder(orderId: string, reason: string): Promise<void> {}
  async refundOrder(orderId: string): Promise<RefundResult> { return {} as RefundResult; }
  async exportOrderReport(from: Date, to: Date): Promise<OrderReport> { return {} as OrderReport; }
}

// ❌ Violation: Domain imports from infrastructure

// domain/PaymentService.ts
import { StripeClient } from '../infrastructure/stripe/StripeClient'; // ← Direct import

class PaymentService {
  private readonly stripe = new StripeClient(process.env.STRIPE_KEY!);

  async chargeOrder(orderId: string, amount: number): Promise<string> {
    return this.stripe.createCharge({ amount, currency: 'usd' }).then(c => c.id);
  }
}
// If StripeClient changes its API, PaymentService must change.
// PaymentService cannot be unit tested without a live Stripe connection.

// ✅ DIP: Domain defines the abstraction; infrastructure implements it

// domain/ports/IPaymentGateway.ts — OWNED BY the domain layer
interface IPaymentGateway {
  charge(amount: number, currency: string): Promise<PaymentResult>;
  refund(transactionId: string): Promise<void>;
}

// domain/PaymentService.ts — depends ONLY on the interface it owns
class PaymentService {
  constructor(private readonly gateway: IPaymentGateway) {}

  async chargeOrder(orderId: string, amount: number): Promise<string> {
    const result = await this.gateway.charge(amount, 'USD');
    if (result.status === 'FAILED') throw new Error(result.reason);
    return result.transactionId;
  }
}

// infrastructure/stripe/StripeGateway.ts — implements the domain interface
import { StripeClient } from './StripeClient';

class StripeGateway implements IPaymentGateway {
  private readonly client = new StripeClient(process.env.STRIPE_KEY!);

  async charge(amount: number, currency: string): Promise<PaymentResult> {
    const charge = await this.client.createCharge({ amount, currency });
    return { status: 'OK', transactionId: charge.id };
  }

  async refund(transactionId: string): Promise<void> {
    await this.client.createRefund({ charge: transactionId });
  }
}

// src/main.ts — the composition root

import { PaymentService } from './domain/PaymentService';
import { OrderService } from './domain/OrderService';
import { StripeGateway } from './infrastructure/stripe/StripeGateway';
import { PostgresOrderRepository } from './infrastructure/db/PostgresOrderRepository';
import { PaymentController } from './api/PaymentController';

// All construction and wiring happens here — ONCE, at startup
const gateway = new StripeGateway(process.env.STRIPE_KEY!);
const orderRepo = new PostgresOrderRepository(process.env.DATABASE_URL!);
const paymentService = new PaymentService(gateway);
const orderService = new OrderService(orderRepo, paymentService);
const paymentController = new PaymentController(orderService);

// Express routing — only receives already-wired controllers
app.post('/orders/:id/pay', (req, res) => paymentController.pay(req, res));

// ❌ Service Locator — hidden dependencies, invisible from the outside

const container = new Map<string, unknown>();
container.set('paymentGateway', new StripeGateway());
container.set('orderRepo', new PostgresOrderRepository());

class PaymentService {
  async chargeOrder(orderId: string, amount: number): Promise<string> {
    // Fetching a dependency at call time — hidden from constructor signature
    const gateway = container.get('paymentGateway') as IPaymentGateway;
    return (await gateway.charge(amount, 'USD')).transactionId;
  }
}

// Test cannot inject a mock — the dependency is fetched from a global container
// The test must manipulate the global container to replace the gateway
// This makes test setup order-dependent and globally coupled

// ✅ Constructor DI — explicit, replaceable, no global state
const mockGateway: IPaymentGateway = {
  charge: async () => ({ status: 'OK', transactionId: 'test_txn' }),
  refund: async () => {},
};
const service = new PaymentService(mockGateway);
const txnId = await service.chargeOrder('ord_001', 100);

// tsconfig: "experimentalDecorators": true, "emitDecoratorMetadata": true
import 'reflect-metadata';
import { injectable, inject, Container } from 'inversify';

@injectable()
class PaymentService {
  constructor(
    @inject('IPaymentGateway') private readonly gateway: IPaymentGateway,
  ) {}
}

const container = new Container();
container.bind<IPaymentGateway>('IPaymentGateway').to(StripeGateway);
container.bind<PaymentService>(PaymentService).toSelf();

const service = container.get<PaymentService>(PaymentService);

// tsconfig: "experimentalDecorators": false (default)
// No reflect-metadata needed

// Stage 3 decorator — a function receiving the decorated value and context
function log(target: Function, context: ClassMethodDecoratorContext) {
  const methodName = String(context.name);
  return function (this: unknown, ...args: unknown[]) {
    console.log(`[LOG] ${methodName} called with:`, args);
    const result = (target as Function).apply(this, args);
    console.log(`[LOG] ${methodName} returned:`, result);
    return result;
  };
}

class PaymentService {
  @log
  async chargeOrder(orderId: string, amount: number): Promise<string> {
    return `txn_${amount}`;
  }
}

// Using Symbol.metadata for a lightweight service registry
const INJECTABLE = Symbol('injectable');

function injectable(target: Function, context: ClassDecoratorContext) {
  context.metadata[INJECTABLE] = true;
}

@injectable
class StripeGateway implements IPaymentGateway {
  async charge(amount: number, currency: string): Promise<PaymentResult> {
    return { status: 'OK', transactionId: `stripe_${Date.now()}` };
  }
  async refund(transactionId: string): Promise<void> {}
}

// Read at composition root:
const isInjectable = (StripeGateway as any)[Symbol.metadata]?.[INJECTABLE]; // true

// ✅ Lifecycle reference — shown here in pseudo-code for any IoC container

// SINGLETON — one instance for the entire process lifetime
// Use for: stateless services, connection pools, configuration
container.bind(PaymentService).toSelf().inSingletonScope();

// TRANSIENT — new instance per resolution
// Use for: stateful request handlers, aggregate factories
container.bind(OrderFactory).toSelf().inTransientScope();

// REQUEST — one instance per HTTP request (scoped lifetime)
// Use for: per-request context (user identity, trace ID)
container.bind(RequestContext).toSelf().inRequestScope();