#include <iostream>
using namespace std;
 
#include <iostream>
 
// Tightly coupled to specific implementations
class Notification {
public:
    void sendEmail(const std::string& message) {
        std::cout << "Sending Email: " << message << "\n";
    }
 
    void sendSMS(const std::string& message) {
        std::cout << "Sending SMS: " << message << "\n";
    }
};
 
//It is not follwing dependency inversion principles because 
//The Notification class is directly tied to the sendEmail and sendSMS methods.
//Adding a new notification method (e.g., PushNotification) would require modifying the Notification class.
 
//Lets make this follow DIP
 
// Abstract base class (Abstraction)
class Notifier {
public:
    virtual void sendNotification(const std::string& message) const = 0;
    virtual ~Notifier() = default;
};
 
// Concrete implementation: Email Notifier
class EmailNotifier : public Notifier {
public:
    void sendNotification(const std::string& message) const override {
        std::cout << "Sending Email: " << message << "\n";
    }
};
 
// Concrete implementation: SMS Notifier
class SMSNotifier : public Notifier {
public:
    void sendNotification(const std::string& message) const override {
        std::cout << "Sending SMS: " << message << "\n";
    }
};
 
// High-level module depends on abstraction (Notifier)
class Notification {
private:
    Notifier& notifier; // Dependency is injected via reference
public:
    Notification(Notifier& n) : notifier(n) {}
 
    void alert(const std::string& message) {
        notifier.sendNotification(message);
    }
};
 

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