// Strategy Interface
interface PaymentStrategy {
  pay(amount: number, currency: string): Promise<PaymentResult>;
  getDisplayName(): string;
  supports(currency: string): boolean;
}

interface PaymentResult {
  success: boolean;
  transactionId: string;
  fee: number;
}

// Concrete Strategies
class CreditCardStrategy implements PaymentStrategy {
  constructor(
    private readonly cardNumber: string,
    private readonly expiryDate: string,
    private readonly cvv: string
  ) {}

  async pay(amount: number, currency: string): Promise<PaymentResult> {
    console.log(`Credit card: ${amount} ${currency} with card ending ${this.cardNumber.slice(-4)}`);
    return {
      success: true,
      transactionId: `cc_${Date.now()}`,
      fee: amount * 0.029, // 2.9% processing fee
    };
  }

  getDisplayName(): string {
    return `Visa/MC ****${this.cardNumber.slice(-4)}`;
  }

  supports(currency: string): boolean {
    return ['USD', 'EUR', 'ILS', 'GBP'].includes(currency);
  }
}

class PayPalStrategy implements PaymentStrategy {
  constructor(private readonly email: string) {}

  async pay(amount: number, currency: string): Promise<PaymentResult> {
    console.log(`PayPal: ${amount} ${currency} for ${this.email}`);
    return {
      success: true,
      transactionId: `pp_${Date.now()}`,
      fee: amount * 0.034, // 3.4% PayPal fee
    };
  }

  getDisplayName(): string {
    return `PayPal (${this.email})`;
  }

  supports(currency: string): boolean {
    return ['USD', 'EUR', 'GBP', 'CAD', 'AUD'].includes(currency);
  }
}

class BitcoinStrategy implements PaymentStrategy {
  constructor(private readonly walletAddress: string) {}

  async pay(amount: number, currency: string): Promise<PaymentResult> {
    // Convert to BTC
    const btcRate = await fetchBtcRate(currency);
    const btcAmount = amount / btcRate;
    console.log(`Bitcoin: ${btcAmount} BTC to ${this.walletAddress}`);
    return {
      success: true,
      transactionId: `btc_${Date.now()}`,
      fee: 0.001, // flat fee
    };
  }

  getDisplayName(): string {
    return `Bitcoin (${this.walletAddress.slice(0, 8)}...)`;
  }

  supports(currency: string): boolean {
    return true; // Bitcoin supports any currency via conversion
  }
}

async function fetchBtcRate(currency: string): Promise<number> {
  return currency === 'USD' ? 45000 : 50000;
}

// Context — משתמש ב-Strategy
class PaymentProcessor {
  private strategy: PaymentStrategy;

  constructor(strategy: PaymentStrategy) {
    this.strategy = strategy;
  }

  // מאפשר החלפה בזמן ריצה
  setStrategy(strategy: PaymentStrategy): void {
    this.strategy = strategy;
  }

  async processPayment(amount: number, currency: string): Promise<PaymentResult> {
    if (!this.strategy.supports(currency)) {
      throw new Error(
        `${this.strategy.getDisplayName()} does not support ${currency}`
      );
    }

    console.log(`Processing via ${this.strategy.getDisplayName()}`);
    return this.strategy.pay(amount, currency);
  }

  getActiveStrategy(): string {
    return this.strategy.getDisplayName();
  }
}

// שימוש — בחירת Strategy לפי Context
const userPreference = 'paypal';

const strategy: PaymentStrategy =
  userPreference === 'credit_card'
    ? new CreditCardStrategy('4111111111111234', '12/26', '123')
    : userPreference === 'paypal'
    ? new PayPalStrategy('user@example.com')
    : new BitcoinStrategy('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq');

const processor = new PaymentProcessor(strategy);

const result = await processor.processPayment(99.99, 'USD');
console.log(`Paid! Transaction: ${result.transactionId}, Fee: ${result.fee.toFixed(2)}`);

// החלפת Strategy בזמן ריצה
processor.setStrategy(new CreditCardStrategy('4111222233334444', '01/28', '456'));
const result2 = await processor.processPayment(49.99, 'EUR');
Strategy Pattern — החלפת אלגוריתמים

Strategy Pattern — החלפת אלגוריתמים

Strategy Pattern — החלפת אלגוריתמים
