// S - Single Responsibility Principle (SRP)
// O - Open/Closed Principle (OCP)
// L - Liskov Substitution Principle (LSP)
// I - Interface Segregation Principle (ISP)
// D - Dependency Inversion Principle (DIP)

// 1. Lean Abstraction Interface (ISP & DIP)
export interface PaymentGateway {
    processPayment(amount: number, currency: string): Promise<string>;
}

// 2. Open for Extension without modifying caller (OCP & LSP)
export class StripePaymentGateway implements PaymentGateway {
    async processPayment(amount: number, currency: string): Promise<string> {
        return `STRIPE_CHARGE_${Math.random().toString(36).substring(7)}`;
    }
}

// 3. High-Level Domain depends on abstraction, not concrete class (DIP & SRP)
export class CheckoutService {
    constructor(private readonly gateway: PaymentGateway) {}

    async completeOrder(amount: number, currency: string): Promise<string> {
        if (amount <= 0) throw new Error("Order amount must be positive");
        return await this.gateway.processPayment(amount, currency);
    }
}

// Fluent Builder Pattern for Complex Immutable Configuration Objects
export class DatabaseConnectionConfig {
    readonly host: string;
    readonly port: number;
    readonly poolSize: number;
    readonly sslEnabled: boolean;

    private constructor(builder: ConfigBuilder) {
        this.host = builder.host;
        this.port = builder.port;
        this.poolSize = builder.poolSize;
        this.sslEnabled = builder.sslEnabled;
    }

    static get Builder() {
        return new ConfigBuilder();
    }
}

class ConfigBuilder {
    host: string = 'localhost';
    port: number = 5432;
    poolSize: number = 20;
    sslEnabled: boolean = true;

    setHost(host: string) { this.host = host; return this; }
    setPort(port: number) { this.port = port; return this; }
    setPoolSize(size: number) { this.poolSize = size; return this; }
    build() { return new (DatabaseConnectionConfig as any)(this); }
}

// Strategy Pattern: Dynamic Algorithm Selection at Runtime
interface CompressionStrategy {
    compress(data: Uint8Array): Uint8Array;
}

class GzipCompression implements CompressionStrategy {
    compress(data: Uint8Array): Uint8Array { return data; /* Gzip logic */ }
}

class ZstdCompression implements CompressionStrategy {
    compress(data: Uint8Array): Uint8Array { return data; /* Zstandard high-speed */ }
}

class Archiver {
    constructor(private strategy: CompressionStrategy) {}
    setStrategy(strategy: CompressionStrategy) { this.strategy = strategy; }
    archive(payload: Uint8Array) { return this.strategy.compress(payload); }
}