Aberto para extensão, fechado para modificação Open-Closed Principle

// ✅ Interface que define o contrato
interface NotificationChannel {
  send(message: string, recipient: string): Promise<boolean>;
  validateRecipient(recipient: string): boolean;
  getChannelName(): string;
}

// ✅ Classe base com funcionalidades comuns
abstract class BaseNotification implements NotificationChannel {
  constructor(protected config: any) {}
  
  abstract send(message: string, recipient: string): Promise<boolean>;
  abstract validateRecipient(recipient: string): boolean;
  abstract getChannelName(): string;
  
  // Método comum para logging
  protected log(action: string, recipient: string, success: boolean): void {
    console.log(`[${this.getChannelName()}] ${action} to ${recipient}: ${success ? 'SUCCESS' : 'FAILED'}`);
  }
}

// ✅ Email
class EmailNotification extends BaseNotification {
  async send(message: string, recipient: string): Promise<boolean> {
    if (!this.validateRecipient(recipient)) return false;
    
    try {
      // Simulação de envio de email
      await this.sendEmail(message, recipient);
      this.log('Email sent', recipient, true);
      return true;
    } catch (error) {
      this.log('Email failed', recipient, false);
      return false;
    }
  }
  
  validateRecipient(email: string): boolean {
    return /^[^s@]+@[^s@]+.[^s@]+$/.test(email);
  }
  
  getChannelName(): string { return 'EMAIL'; }
  
  private async sendEmail(message: string, email: string): Promise<void> {
    // Integração com serviço de email
    console.log(`Sending email to ${email}: ${message}`);
  }
}

// ✅ SMS
class SMSNotification extends BaseNotification {
  async send(message: string, recipient: string): Promise<boolean> {
    if (!this.validateRecipient(recipient)) return false;
    
    try {
      await this.sendSMS(message, recipient);
      this.log('SMS sent', recipient, true);
      return true;
    } catch (error) {
      this.log('SMS failed', recipient, false);
      return false;
    }
  }
  
  validateRecipient(phone: string): boolean {
    return /^+?[1-9]d{1,14}$/.test(phone);
  }
  
  getChannelName(): string { return 'SMS'; }
  
  private async sendSMS(message: string, phone: string): Promise<void> {
    console.log(`Sending SMS to ${phone}: ${message}`);
  }
}

// ✅ Push Notification
class PushNotification extends BaseNotification {
  async send(message: string, recipient: string): Promise<boolean> {
    if (!this.validateRecipient(recipient)) return false;
    
    try {
      await this.sendPush(message, recipient);
      this.log('Push sent', recipient, true);
      return true;
    } catch (error) {
      this.log('Push failed', recipient, false);
      return false;
    }
  }
  
  validateRecipient(deviceToken: string): boolean {
    return deviceToken.length >= 64; // Token mínimo
  }
  
  getChannelName(): string { return 'PUSH'; }
  
  private async sendPush(message: string, token: string): Promise<void> {
    console.log(`Sending push to ${token}: ${message}`);
  }
}

// ✅ Gerenciador que usa polimorfismo
class NotificationManager {
  private channels: Map<string, NotificationChannel> = new Map();
  
  registerChannel(name: string, channel: NotificationChannel): void {
    this.channels.set(name, channel);
  }
  
  async sendNotification(
    channelName: string, 
    message: string, 
    recipient: string
  ): Promise<boolean> {
    const channel = this.channels.get(channelName);
    if (!channel) {
      console.log(`Channel ${channelName} not found`);
      return false;
    }
    
    return await channel.send(message, recipient);
  }
  
  async broadcast(message: string, recipients: Record<string, string>): Promise<void> {
    const promises = Object.entries(recipients).map(([channel, recipient]) => 
      this.sendNotification(channel, message, recipient)
    );
    
    await Promise.all(promises);
  }
  
  getAvailableChannels(): string[] {
    return Array.from(this.channels.keys());
  }
}

// ✅ Uso do sistema
const notificationManager = new NotificationManager();

// Registrando canais
notificationManager.registerChannel('email', new EmailNotification({}));
notificationManager.registerChannel('sms', new SMSNotification({}));
notificationManager.registerChannel('push', new PushNotification({}));

// Enviando notificações
await notificationManager.broadcast('Seu pedido foi aprovado!', {
  email: 'user@example.com',
  sms: '+5511999999999',
  push: 'device_token_here'
});