# Stuck - direct file system access
def load_config():
    with open('/etc/myapp/config.json') as f:
        return json.load(f)

# Define a port (interface)
class ConfigSource(Protocol):
    def read(self) -> dict: ...

# Production adapter
class FileConfigSource:
    def __init__(self, path):
        self.path = path
    def read(self):
        with open(self.path) as f:
            return json.load(f)

# Test adapter
class FakeConfigSource:
    def __init__(self, config):
        self.config = config
    def read(self):
        return self.config

# Use the port:
def load_config(source: ConfigSource):
    return source.read()

// Stuck - direct Stripe SDK call
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_KEY);

async function charge(amount) {
  return await stripe.paymentIntents.create({ amount, currency: 'usd' });
}

interface PaymentGateway {
  charge(amount: number): Promise<{ id: string }>;
}

class StripeGateway implements PaymentGateway {
  constructor(private stripe: Stripe) {}
  async charge(amount: number) {
    const intent = await this.stripe.paymentIntents.create({ amount, currency: 'usd' });
    return { id: intent.id };
  }
}

class FakePaymentGateway implements PaymentGateway {
  async charge(amount: number) {
    return { id: 'fake-charge-' + amount };
  }
}

// Stuck - depends on a global database client
function processOrder(orderId) {
  const order = Database.getInstance().findOrder(orderId);   // singleton
  // ...
}

function processOrder(orderId, db) {
  const order = db.findOrder(orderId);
  // ...
}

// Test:
test('processOrder fetches the order', () => {
  const fakeDb = { findOrder: () => ({ id: 1 }) };
  processOrder(1, fakeDb);
});

// Stuck - constructor side-effects
class OrderService {
  constructor() {
    this.config = await fetch('/config').then(r => r.json());   // 😱
  }
}

class OrderService {
  constructor(config) {
    this.config = config;
  }
}

// Composition root:
const config = await fetch('/config').then(r => r.json());
const orderService = new OrderService(config);

// Test:
const orderService = new OrderService({ /* fake config */ });

// Stuck - uses Date.now() and Math.random() directly
function generateInvoice(items) {
  return {
    id: `INV-${Date.now()}-${Math.random()}`,
    items,
  };
}

function generateInvoice(items, { now, rand }) {
  return {
    id: `INV-${now()}-${rand()}`,
    items,
  };
}

// Production:
generateInvoice(items, { now: Date.now, rand: Math.random });

// Test:
generateInvoice([item], { now: () => 1000, rand: () => 0.5 });
// Asserts: id === 'INV-1000-0.5'

// Stuck - chain of constructions
function processOrder(orderId: string) {
  const repo = new OrderRepo(new DbConnection(new ConfigLoader(new FileReader('/etc/...'))));
  return new OrderService(repo).process(orderId);
}

// Composition root (one place per app)
function buildAppContainer() {
  const reader = new FileReader('/etc/...');
  const config = new ConfigLoader(reader);
  const conn = new DbConnection(config);
  const repo = new OrderRepo(conn);
  const service = new OrderService(repo);
  return { service, /* others */ };
}

// Production:
const { service } = buildAppContainer();
await service.process(orderId);

// Test (just the service, with fakes):
const service = new OrderService(new FakeOrderRepo());
await service.process(orderId);

// Stuck - wants to test a private helper
class OrderProcessor {
    fun process(order: Order) { /* ... */ }
    private fun calculateTotal(items: List<Item>): Double { /* ... */ }
}

class TotalCalculator {
    fun calculate(items: List<Item>): Double { /* ... */ }
}

class OrderProcessor(private val totalCalculator: TotalCalculator) {
    fun process(order: Order) {
        val total = totalCalculator.calculate(order.items)
        // ...
    }
}

// Stuck - sequential async operations
async function checkout(cart) {
  const tax = await taxService.calculate(cart);
  const charge = await stripe.charge(cart.total + tax);
  await orderRepo.save({ cart, tax, charge });
  await emailService.sendConfirmation(cart.userId);
  return charge;
}

async function checkout(cart, deps) {
  const { taxService, stripe, orderRepo, emailService } = deps;
  const tax = await taxService.calculate(cart);
  const charge = await stripe.charge(cart.total + tax);
  await orderRepo.save({ cart, tax, charge });
  await emailService.sendConfirmation(cart.userId);
  return charge;
}