# ─── Python — DIP via ABC + constructor injection ─────────────────────
from abc import ABC, abstractmethod
from dataclasses import dataclass
 
# ── Abstraction (the interface both sides depend on) ───
class MessageSender(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str) -> bool: ...
 
    @abstractmethod
    def provider_name(self) -> str: ...
 
# ── Low-level modules (details) ────────────────────────
class EmailSender(MessageSender):
    def send(self, recipient: str, message: str) -> bool:
        print(f"[Email] To: {recipient} | {message}")
        return True
    def provider_name(self) -> str: return "SMTP Email"
 
class SMSSender(MessageSender):
    def send(self, recipient: str, message: str) -> bool:
        print(f"[SMS] To: {recipient} | {message[:160]}")
        return True
    def provider_name(self) -> str: return "Twilio SMS"
 
class PushSender(MessageSender):
    def send(self, recipient: str, message: str) -> bool:
        print(f"[Push] Token: {recipient[:12]}... | {message}")
        return True
    def provider_name(self) -> str: return "Firebase Push"
 
# ── High-level module (business logic) ────────────────
@dataclass
class NotificationService:
    """High-level module — depends ONLY on MessageSender abstraction."""
    _sender: MessageSender
 
    def notify(self, recipient: str, message: str) -> None:
        success = self._sender.send(recipient, message)
        status = "✅" if success else "❌"
        print(f"  {status} Sent via {self._sender.provider_name()}")
 
    def notify_bulk(self, recipients: list[str], message: str) -> None:
        print(f"Broadcasting to {len(recipients)} recipients...")
        for r in recipients:
            self.notify(r, message)
 
# ── Dependency injection — high-level + low-level ──────
# Swap backends without changing NotificationService at all
email_notifier = NotificationService(EmailSender())
sms_notifier   = NotificationService(SMSSender())
push_notifier  = NotificationService(PushSender())
 
email_notifier.notify("alice@example.com", "Your order shipped!")
sms_notifier.notify("+1-555-0100", "Verification code: 1234")
push_notifier.notify("device_token_abc123xyz", "New message!")
 
# ── Test with a mock — DIP makes testing trivial! ─────
class MockSender(MessageSender):
    def __init__(self): self.sent: list[tuple[str, str]] = []
    def send(self, r, m) -> bool:
        self.sent.append((r, m)); return True
    def provider_name(self) -> str: return "MockSender"
 
mock = MockSender()
svc = NotificationService(mock)
svc.notify("test@example.com", "Test message")
assert len(mock.sent) == 1                            # ✅ verified
assert mock.sent[0] == ("test@example.com", "Test message")
print("All mock assertions passed!")

// ─── Java — DIP via interface + constructor injection ─────────────────
interface MessageSender {
    boolean send(String recipient, String message);
    String getProviderName();
}
 
class EmailSender implements MessageSender {
    public boolean send(String r, String m) { System.out.println("[Email] " + r + ": " + m); return true; }
    public String getProviderName() { return "SMTP Email"; }
}
 
class SMSSender implements MessageSender {
    public boolean send(String r, String m) { System.out.println("[SMS] " + r + ": " + m); return true; }
    public String getProviderName() { return "Twilio SMS"; }
}
 
// High-level module — depends on interface, not concrete class
class NotificationService {
    private final MessageSender sender;  // inject abstraction
 
    NotificationService(MessageSender sender) { this.sender = sender; }
 
    void notify(String recipient, String message) {
        boolean ok = sender.send(recipient, message);
        System.out.println("  " + (ok ? "✅" : "❌") + " via " + sender.getProviderName());
    }
}
 
// Mock for testing
class MockSender implements MessageSender {
    int callCount = 0;
    public boolean send(String r, String m) { callCount++; return true; }
    public String getProviderName() { return "Mock"; }
}
 
class DIPDemo {
    public static void main(String[] args) {
        new NotificationService(new EmailSender()).notify("alice@ex.com", "Shipped!");
        new NotificationService(new SMSSender()).notify("+1-555-0100", "Code: 1234");
 
        // Test with mock
        MockSender mock = new MockSender();
        NotificationService svc = new NotificationService(mock);
        svc.notify("test@ex.com", "Test");
        assert mock.callCount == 1 : "Expected 1 call";
        System.out.println("Mock test passed!");
    }
}

// ─── JavaScript — DIP via constructor injection ───────────────────────
class EmailSender {
    send(recipient, message) { console.log(`[Email] ${recipient}: ${message}`); return true; }
    get providerName() { return "SMTP Email"; }
}
 
class SMSSender {
    send(recipient, message) { console.log(`[SMS] ${recipient}: ${message}`); return true; }
    get providerName() { return "Twilio SMS"; }
}
 
// High-level module — injected with ANY sender (duck typing)
class NotificationService {
    constructor(sender) { this.sender = sender; }
 
    notify(recipient, message) {
        const ok = this.sender.send(recipient, message);
        console.log(`  ${ok ? "✅" : "❌"} via ${this.sender.providerName}`);
    }
}
 
// Swap backends freely
new NotificationService(new EmailSender()).notify("alice@ex.com", "Order shipped!");
new NotificationService(new SMSSender()).notify("+1-555-0100", "Code: 1234");
 
// Mock for testing
const mockSender = { calls: [], send(r, m) { this.calls.push({r, m}); return true; }, providerName: "Mock" };
const svc = new NotificationService(mockSender);
svc.notify("test@ex.com", "Test");
console.assert(mockSender.calls.length === 1, "Expected 1 call");
console.log("Mock test passed!");