// ✅ Contrato que todos devem seguir
interface PaymentMethod {
  process(amount: number): Promise<PaymentResult>;
  calculateFee(amount: number): number;
  validate(): boolean;
  getMethodName(): string;
}

// Tipos auxiliares
interface PaymentResult {
  success: boolean;
  transactionId?: string;
  errorMessage?: string;
}

// Classe base opcional com funcionalidades comuns
abstract class BasePaymentMethod implements PaymentMethod {
  abstract process(amount: number): Promise<PaymentResult>;
  abstract calculateFee(amount: number): number;
  abstract validate(): boolean;
  abstract getMethodName(): string;
  
  // Método comum para logging
  protected log(action: string, amount: number, success: boolean): void {
    const status = success ? 'SUCCESS' : 'FAILED';
    console.log(`[${this.getMethodName()}] ${action} R$ ${amount}: ${status}`);
  }
  
  // Método comum para formatação
  protected formatAmount(amount: number): string {
    return new Intl.NumberFormat('pt-BR', {
      style: 'currency',
      currency: 'BRL'
    }).format(amount);
  }
}

// ✅ Cartão de Crédito
class CreditCardPayment extends BasePaymentMethod {
  constructor(
    private cardNumber: string,
    private cvv: string,
    private expiryDate: string,
    private holderName: string
  ) {
    super();
  }
  
  async process(amount: number): Promise<PaymentResult> {
    if (!this.validate()) {
      return { success: false, errorMessage: 'Dados do cartão inválidos' };
    }
    
    try {
      // Simulação de processamento
      await this.processWithGateway(amount);
      const transactionId = this.generateTransactionId();
      
      this.log('Payment processed', amount, true);
      return { success: true, transactionId };
    } catch (error) {
      this.log('Payment failed', amount, false);
      return { success: false, errorMessage: 'Erro no processamento' };
    }
  }
  
  calculateFee(amount: number): number {
    return amount * 0.035; // 3.5%
  }
  
  validate(): boolean {
    return this.cardNumber.length === 16 &&
           this.cvv.length === 3 &&
           this.expiryDate.match(/^d{2}/d{2}$/) !== null &&
           this.holderName.length > 0;
  }
  
  getMethodName(): string {
    return 'CREDIT_CARD';
  }
  
  private async processWithGateway(amount: number): Promise<void> {
    // Integração com gateway de pagamento
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
  
  private generateTransactionId(): string {
    return 'CC_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
  }
}

// ✅ PIX
class PixPayment extends BasePaymentMethod {
  constructor(private pixKey: string) {
    super();
  }
  
  async process(amount: number): Promise<PaymentResult> {
    if (!this.validate()) {
      return { success: false, errorMessage: 'Chave PIX inválida' };
    }
    
    try {
      const qrCode = await this.generateQRCode(amount);
      const transactionId = this.generateTransactionId();
      
      this.log('PIX QR Code generated', amount, true);
      return { success: true, transactionId };
    } catch (error) {
      this.log('PIX generation failed', amount, false);
      return { success: false, errorMessage: 'Erro na geração do PIX' };
    }
  }
  
  calculateFee(amount: number): number {
    return 0; // PIX é gratuito
  }
  
  validate(): boolean {
    // Validação simplificada de chave PIX
    return this.pixKey.length > 0 &&
           (this.pixKey.includes('@') || // Email
            this.pixKey.match(/^d{11}$/) || // CPF
            this.pixKey.match(/^d{14}$/) || // CNPJ
            this.pixKey.match(/^+d{13}$/)); // Telefone
  }
  
  getMethodName(): string {
    return 'PIX';
  }
  
  private async generateQRCode(amount: number): Promise<string> {
    // Simulação de geração de QR Code
    await new Promise(resolve => setTimeout(resolve, 500));
    return `PIX_QR_${amount}_${this.pixKey}`;
  }
  
  private generateTransactionId(): string {
    return 'PIX_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
  }
}

// ✅ Boleto
class BoletoPayment extends BasePaymentMethod {
  constructor(
    private dueDate: Date,
    private payerDocument: string,
    private payerName: string
  ) {
    super();
  }
  
  async process(amount: number): Promise<PaymentResult> {
    if (!this.validate()) {
      return { success: false, errorMessage: 'Dados do boleto inválidos' };
    }
    
    try {
      const boletoCode = await this.generateBoleto(amount);
      const transactionId = this.generateTransactionId();
      
      this.log('Boleto generated', amount, true);
      return { success: true, transactionId };
    } catch (error) {
      this.log('Boleto generation failed', amount, false);
      return { success: false, errorMessage: 'Erro na geração do boleto' };
    }
  }
  
  calculateFee(amount: number): number {
    return 2.50; // Taxa fixa
  }
  
  validate(): boolean {
    const now = new Date();
    return this.dueDate > now &&
           this.payerDocument.length >= 11 &&
           this.payerName.length > 0;
  }
  
  getMethodName(): string {
    return 'BOLETO';
  }
  
  private async generateBoleto(amount: number): Promise<string> {
    // Simulação de geração de boleto
    await new Promise(resolve => setTimeout(resolve, 800));
    return `BOLETO_${amount}_${this.dueDate.getTime()}`;
  }
  
  private generateTransactionId(): string {
    return 'BOL_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
  }
}

// ✅ Processador que usa polimorfismo
class PaymentProcessor {
  // ZERO if/else ou switch/case!
  async processPayment(method: PaymentMethod, amount: number): Promise<PaymentResult> {
    console.log(`Iniciando pagamento de ${method.formatAmount ? method.formatAmount(amount) : amount} via ${method.getMethodName()}`);
    
    // Calcula taxa
    const fee = method.calculateFee(amount);
    const totalAmount = amount + fee;
    
    console.log(`Taxa: R$ ${fee} | Total: R$ ${totalAmount}`);
    
    // Processa pagamento - POLIMORFISMO EM AÇÃO!
    const result = await method.process(totalAmount);
    
    if (result.success) {
      console.log(`✅ Pagamento aprovado! ID: ${result.transactionId}`);
    } else {
      console.log(`❌ Pagamento rejeitado: ${result.errorMessage}`);
    }
    
    return result;
  }
  
  // Processa múltiplos pagamentos
  async processMultiplePayments(payments: Array<{method: PaymentMethod, amount: number}>): Promise<PaymentResult[]> {
    const results = await Promise.all(
      payments.map(({method, amount}) => this.processPayment(method, amount))
    );
    
    const successful = results.filter(r => r.success).length;
    console.log(`
📊 Resumo: ${successful}/${results.length} pagamentos aprovados`);
    
    return results;
  }
  
  // Calcula total de taxas
  calculateTotalFees(payments: Array<{method: PaymentMethod, amount: number}>): number {
    return payments.reduce((total, {method, amount}) => {
      return total + method.calculateFee(amount);
    }, 0);
  }
}

// ✅ Uso limpo e extensível
const processor = new PaymentProcessor();

// Criando métodos de pagamento
const creditCard = new CreditCardPayment(
  '1234567890123456',
  '123',
  '12/25',
  'João Silva'
);

const pix = new PixPayment('joao@email.com');

const boleto = new BoletoPayment(
  new Date('2025-02-15'),
  '12345678901',
  'João Silva'
);

// Processando pagamentos - MESMO CÓDIGO para todos os tipos!
await processor.processPayment(creditCard, 100);
await processor.processPayment(pix, 50);
await processor.processPayment(boleto, 200);

// Processamento em lote
await processor.processMultiplePayments([
  { method: creditCard, amount: 100 },
  { method: pix, amount: 50 },
  { method: boleto, amount: 200 }
]);