Strategy Pattern

// Strategy Pattern Example

// Payment Strategy Interface
class PaymentStrategy {
  pay(amount) {
    throw new Error('Pay method must be implemented');
  }
}

// Concrete Payment Strategies
class CreditCardStrategy extends PaymentStrategy {
  constructor(cardNumber, cvv, expiryDate) {
    super();
    this.cardNumber = cardNumber;
    this.cvv = cvv;
    this.expiryDate = expiryDate;
  }
  
  pay(amount) {
    console.log(`Paying $${amount} using Credit Card`);
    console.log(`Card Number: ****${this.cardNumber.slice(-4)}`);
    console.log(`Processing payment...`);
    return { success: true, transactionId: 'CC_' + Date.now() };
  }
}

class PayPalStrategy extends PaymentStrategy {
  constructor(email, password) {
    super();
    this.email = email;
    this.password = password;
  }
  
  pay(amount) {
    console.log(`Paying $${amount} using PayPal`);
    console.log(`PayPal account: ${this.email}`);
    console.log(`Authenticating...`);
    return { success: true, transactionId: 'PP_' + Date.now() };
  }
}

class CryptoStrategy extends PaymentStrategy {
  constructor(walletAddress, privateKey) {
    super();
    this.walletAddress = walletAddress;
    this.privateKey = privateKey;
  }
  
  pay(amount) {
    console.log(`Paying $${amount} using Cryptocurrency`);
    console.log(`Wallet: ${this.walletAddress.slice(0, 10)}...`);
    console.log(`Broadcasting transaction to blockchain...`);
    return { success: true, transactionId: 'CRYPTO_' + Date.now() };
  }
}

class ApplePayStrategy extends PaymentStrategy {
  constructor(deviceId, touchId) {
    super();
    this.deviceId = deviceId;
    this.touchId = touchId;
  }
  
  pay(amount) {
    console.log(`Paying $${amount} using Apple Pay`);
    console.log(`Authenticating with Touch ID...`);
    console.log(`Device verified: ${this.deviceId}`);
    return { success: true, transactionId: 'AP_' + Date.now() };
  }
}

// Context - Shopping Cart
class ShoppingCart {
  constructor() {
    this.items = [];
    this.paymentStrategy = null;
  }
  
  addItem(item) {
    this.items.push(item);
    console.log(`Added ${item.name} to cart`);
  }
  
  setPaymentStrategy(strategy) {
    this.paymentStrategy = strategy;
  }
  
  calculateTotal() {
    return this.items.reduce((total, item) => total + item.price * item.quantity, 0);
  }
  
  checkout() {
    const total = this.calculateTotal();
    console.log(`\nCheckout Summary:`);
    this.items.forEach(item => {
      console.log(`- ${item.name} x${item.quantity}: $${item.price * item.quantity}`);
    });
    console.log(`Total: $${total}\n`);
    
    if (!this.paymentStrategy) {
      console.log('Please select a payment method!');
      return;
    }
    
    const result = this.paymentStrategy.pay(total);
    if (result.success) {
      console.log(`Payment successful! Transaction ID: ${result.transactionId}\n`);
      this.items = []; // Clear cart
    }
  }
}

// Usage
const cart = new ShoppingCart();
cart.addItem({ name: 'Laptop', price: 999, quantity: 1 });
cart.addItem({ name: 'Mouse', price: 49, quantity: 2 });
cart.addItem({ name: 'Keyboard', price: 79, quantity: 1 });

// Pay with Credit Card
console.log('=== Paying with Credit Card ===');
cart.setPaymentStrategy(new CreditCardStrategy('1234567812345678', '123', '12/25'));
cart.checkout();

// Same items, different payment method
cart.addItem({ name: 'Monitor', price: 299, quantity: 1 });

console.log('=== Paying with PayPal ===');
cart.setPaymentStrategy(new PayPalStrategy('user@example.com', 'password123'));
cart.checkout();

// Sorting Strategy Example
class SortStrategy {
  sort(data) {
    throw new Error('Sort method must be implemented');
  }
}

class BubbleSortStrategy extends SortStrategy {
  sort(data) {
    console.log('Using Bubble Sort');
    const arr = [...data];
    for (let i = 0; i < arr.length; i++) {
      for (let j = 0; j < arr.length - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        }
      }
    }
    return arr;
  }
}

class QuickSortStrategy extends SortStrategy {
  sort(data) {
    console.log('Using Quick Sort');
    if (data.length <= 1) return data;
    
    const pivot = data[Math.floor(data.length / 2)];
    const left = data.filter(x => x < pivot);
    const middle = data.filter(x => x === pivot);
    const right = data.filter(x => x > pivot);
    
    return [...this.sort(left), ...middle, ...this.sort(right)];
  }
}

class MergeSortStrategy extends SortStrategy {
  sort(data) {
    console.log('Using Merge Sort');
    if (data.length <= 1) return data;
    
    const mid = Math.floor(data.length / 2);
    const left = data.slice(0, mid);
    const right = data.slice(mid);
    
    return this.merge(this.sort(left), this.sort(right));
  }
  
  merge(left, right) {
    const result = [];
    let i = 0, j = 0;
    
    while (i < left.length && j < right.length) {
      if (left[i] <= right[j]) {
        result.push(left[i++]);
      } else {
        result.push(right[j++]);
      }
    }
    
    return result.concat(left.slice(i)).concat(right.slice(j));
  }
}

class DataProcessor {
  constructor(strategy) {
    this.sortStrategy = strategy;
  }
  
  setSortStrategy(strategy) {
    this.sortStrategy = strategy;
  }
  
  process(data) {
    console.log(`Original data: [${data.join(', ')}]`);
    const sorted = this.sortStrategy.sort(data);
    console.log(`Sorted data: [${sorted.join(', ')}]\n`);
    return sorted;
  }
}

// Usage
console.log('\n=== Sorting Strategy Example ===');
const data = [64, 34, 25, 12, 22, 11, 90];
const processor = new DataProcessor(new BubbleSortStrategy());

processor.process(data);

processor.setSortStrategy(new QuickSortStrategy());
processor.process(data);

processor.setSortStrategy(new MergeSortStrategy());
processor.process(data);

// Compression Strategy Example
class CompressionStrategy {
  compress(file) {
    throw new Error('Compress method must be implemented');
  }
}

class ZipStrategy extends CompressionStrategy {
  compress(file) {
    console.log(`Compressing ${file} using ZIP algorithm`);
    return `${file}.zip`;
  }
}

class RarStrategy extends CompressionStrategy {
  compress(file) {
    console.log(`Compressing ${file} using RAR algorithm`);
    return `${file}.rar`;
  }
}

class TarGzStrategy extends CompressionStrategy {
  compress(file) {
    console.log(`Compressing ${file} using TAR.GZ algorithm`);
    return `${file}.tar.gz`;
  }
}

class FileCompressor {
  constructor() {
    this.strategy = null;
  }
  
  setStrategy(strategy) {
    this.strategy = strategy;
  }
  
  compressFile(filename) {
    if (!this.strategy) {
      throw new Error('Compression strategy not set');
    }
    
    const compressedFile = this.strategy.compress(filename);
    console.log(`File compressed to: ${compressedFile}\n`);
    return compressedFile;
  }
}

// Usage
console.log('\n=== Compression Strategy Example ===');
const compressor = new FileCompressor();

compressor.setStrategy(new ZipStrategy());
compressor.compressFile('document.pdf');

compressor.setStrategy(new RarStrategy());
compressor.compressFile('images-folder');

compressor.setStrategy(new TarGzStrategy());
compressor.compressFile('source-code');