// ❌ Anti-Pattern: Monolithic switch statement — violates SRP and OCP simultaneously

class PaymentProcessor {
  async processPayment(
    type: string,    // 'STRIPE' | 'PAYPAL' | 'APPLEPAY' | 'CRYPTO' | ...
    amount: number,
    currency: string,
  ): Promise<string> {
    if (type === 'STRIPE') {
      // 15 lines of Stripe-specific logic
      const stripeAmount = Math.round(amount * 100);
      const response = await fetch('https://api.stripe.com/v1/charges', {
        method: 'POST',
        headers: { Authorization: `Bearer ${process.env.STRIPE_KEY}` },
        body: new URLSearchParams({ amount: String(stripeAmount), currency }),
      });
      const data = await response.json();
      return data.id;
    } else if (type === 'PAYPAL') {
      // 20 lines of PayPal OAuth + order creation logic
      // ...
      return 'paypal_order_id';
    } else if (type === 'APPLEPAY') {
      // 12 lines of Apple Pay session handling
      // ...
      return 'applepay_token';
    } else if (type === 'CRYPTO') {
      // 18 lines of wallet address + blockchain confirmation logic
      // ...
      return 'tx_hash';
    }
    throw new Error(`Unsupported payment type: ${type}`);
  }
}

// ✅ Each class has exactly one reason to change

// Owned by: Payments Team — gateway communication only
class StripeGateway implements IPaymentGateway {
  async charge(amount: number, currency: string): Promise<PaymentResult> {
    const stripeAmount = Math.round(amount * 100);
    const response = await fetch('https://api.stripe.com/v1/charges', {
      method: 'POST',
      headers: { Authorization: `Bearer ${process.env.STRIPE_KEY}` },
      body: new URLSearchParams({ amount: String(stripeAmount), currency }),
    });
    const data = await response.json();
    return { status: 'OK', transactionId: data.id };
  }
}

// Owned by: Finance Team — currency conversion rules only
class CurrencyNormalizer {
  normalize(amount: number, fromCurrency: string, toCurrency: string): number {
    if (fromCurrency === toCurrency) return amount;
    const rates: Record<string, number> = { USD: 1, EUR: 0.92, GBP: 0.79 };
    return (amount / rates[fromCurrency]) * rates[toCurrency];
  }
}

// Owned by: Compliance Team — audit format only
class PaymentAuditLogger {
  log(result: PaymentResult, actor: string): void {
    const entry = {
      timestamp: new Date().toISOString(),
      actor,
      transactionId: result.status === 'OK' ? result.transactionId : null,
      outcome: result.status,
    };
    console.log('[AUDIT]', JSON.stringify(entry));
  }
}

// Owned by: Payments Team — orchestration only; delegates everything
class PaymentOrchestrator {
  constructor(
    private readonly gateway: IPaymentGateway,
    private readonly normalizer: CurrencyNormalizer,
    private readonly logger: PaymentAuditLogger,
  ) {}

  async execute(amount: number, currency: string, actor: string): Promise<PaymentResult> {
    const normalized = this.normalizer.normalize(amount, currency, 'USD');
    const result = await this.gateway.charge(normalized, 'USD');
    this.logger.log(result, actor);
    return result;
  }
}

type PaymentResult = { status: 'OK'; transactionId: string } | { status: 'FAILED'; reason: string };
interface IPaymentGateway {
  charge(amount: number, currency: string): Promise<PaymentResult>;
}

// The shared gateway interface — the abstraction that enables OCP
interface IPaymentGateway {
  charge(amount: number, currency: string): Promise<PaymentResult>;
  refund(transactionId: string): Promise<void>;
}

// Strategy registry — satisfies ensures all SupportedGateways are covered
// and literal types are preserved for downstream type inference
type SupportedGateway = 'stripe' | 'paypal' | 'adyen';

const gatewayRegistry = {
  stripe: new StripeGateway(),
  paypal: new PayPalGateway(),
  adyen:  new AdyenGateway(),
} satisfies Record<SupportedGateway, IPaymentGateway>;

// Payment engine — closed for modification, open for extension
class PaymentEngine {
  private readonly registry: Record<SupportedGateway, IPaymentGateway>;

  constructor(registry: Record<SupportedGateway, IPaymentGateway>) {
    this.registry = registry;
  }

  async charge(
    gatewayKey: SupportedGateway,
    amount: number,
    currency: string,
  ): Promise<PaymentResult> {
    const gateway = this.registry[gatewayKey];
    if (!gateway) throw new Error(`Unknown gateway: ${gatewayKey}`);
    return gateway.charge(amount, currency);
  }
}

// 1. Implement the interface
class CryptoGateway implements IPaymentGateway {
  async charge(amount: number, currency: string): Promise<PaymentResult> {
    return { status: 'OK', transactionId: `crypto_${Date.now()}` };
  }
  async refund(transactionId: string): Promise<void> { /* ... */ }
}

// 2. Extend the union type
type SupportedGateway = 'stripe' | 'paypal' | 'adyen' | 'crypto';

// 3. Add to the registry — satisfies enforces that all four are present
const gatewayRegistry = {
  stripe: new StripeGateway(),
  paypal: new PayPalGateway(),
  adyen:  new AdyenGateway(),
  crypto: new CryptoGateway(), // ← Added here only
} satisfies Record<SupportedGateway, IPaymentGateway>;
// If 'crypto' is absent: "Property 'crypto' is missing in type..."

// ❌ Train wreck — violates Law of Demeter
class OrderConfirmationService {
  async notifyCustomer(order: Order): Promise<void> {
    // Traverses order → customer → wallet → ledger → notificationPrefs
    const email = order.getCustomer().getWallet().getLedger().getOwner().email;
    await this.emailService.send(email, 'Your order is confirmed');
  }
}

// ✅ Tell, don't ask — the Order exposes what the service needs
class Order {
  getCustomerEmail(): string {
    return this.customer.contactEmail; // Internal traversal hidden inside the aggregate
  }
}

class OrderConfirmationService {
  async notifyCustomer(order: Order): Promise<void> {
    const email = order.getCustomerEmail(); // Only one level deep
    await this.emailService.send(email, 'Your order is confirmed');
  }
}

// ❌ LSP Violation: Square extends Rectangle — breaks behavioral contract

class Rectangle {
  protected width: number;
  protected height: number;

  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }

  setWidth(w: number): void { this.width = w; }
  setHeight(h: number): void { this.height = h; }

  area(): number { return this.width * this.height; }
}

class Square extends Rectangle {
  constructor(side: number) {
    super(side, side);
  }

  // ❌ Strengthens the invariant: width and height must always be equal
  // This BREAKS any code written against Rectangle's contract
  override setWidth(w: number): void {
    this.width = w;
    this.height = w; // Side effect: changes height too
  }

  override setHeight(h: number): void {
    this.height = h;
    this.width = h; // Side effect: changes width too
  }
}

// Code written against Rectangle — correct behavior expected:
function testRectangle(rect: Rectangle): void {
  rect.setWidth(5);
  rect.setHeight(3);
  console.assert(rect.area() === 15, 'Area must be 5 × 3 = 15');
}

testRectangle(new Rectangle(1, 1)); // ✅ Passes: area = 15
testRectangle(new Square(1));       // ❌ Fails: area = 9 (width setHeight also set to 3)
// Square is not substitutable for Rectangle — LSP violated

// Under --strictFunctionTypes:
// Parameter types must be CONTRAVARIANT (accept wider or equal types)
// Return types must be COVARIANT (return narrower or equal types)

type ProcessPayment = (event: PaymentEvent) => void;

// ✅ Contravariant parameter: accepts a wider type (BaseEvent is wider than PaymentEvent)
const contravariantHandler: ProcessPayment = (event: BaseEvent) => {
  console.log(event.eventId); // OK — BaseEvent has eventId
};

// ❌ Covariant parameter (TypeScript error under --strictFunctionTypes):
const covariantHandler: ProcessPayment = (event: StripePaymentEvent) => {
  // StripePaymentEvent is narrower — accessing .stripeCustomerId may not exist on PaymentEvent
  console.log(event.stripeCustomerId); // TS Error: Argument of type 'StripePaymentEvent' is not assignable
};

interface IDiscountCalculator {
  // Precondition: amount > 0, discountRate ∈ [0, 1]
  calculate(amount: number, discountRate: number): number;
}

class StandardDiscount implements IDiscountCalculator {
  calculate(amount: number, discountRate: number): number {
    // Checks base preconditions
    if (amount <= 0) throw new RangeError('Amount must be positive');
    if (discountRate < 0 || discountRate > 1) throw new RangeError('Rate must be 0–1');
    return amount * (1 - discountRate);
  }
}

// ❌ Subtype strengthens precondition: rejects amount < 100
class BulkDiscount extends StandardDiscount {
  override calculate(amount: number, discountRate: number): number {
    // WRONG: requires amount >= 100 — caller written against IDiscountCalculator cannot know this
    if (amount < 100) throw new RangeError('BulkDiscount requires amount >= 100');
    return super.calculate(amount, discountRate);
  }
}

// Caller uses IDiscountCalculator — cannot distinguish BulkDiscount:
const calculator: IDiscountCalculator = new BulkDiscount();
calculator.calculate(50, 0.1); // ❌ Throws — but caller had no way to know

interface IPaymentResult {
  // Postcondition: always returns a non-empty transactionId on success
  processPayment(amount: number): { transactionId: string; status: 'OK' };
}

// ❌ Subtype weakens postcondition: may return empty transactionId
class DeferredProcessor implements IPaymentResult {
  processPayment(amount: number): { transactionId: string; status: 'OK' } {
    return { transactionId: '', status: 'OK' }; // Empty string violates postcondition
  }
}