Notification service
Every system sends them. Few send them well.

NotificationService
  send(NotificationRequest): NotificationResult

NotificationRequest
  String requestId
  String userId
  String templateId
  Map params
  Set<Channel> channels
  Priority priority

ChannelSender (interface)
  channel(): Channel
  send(Recipient, RenderedMessage): DeliveryResult

SmsSender

EmailSender

PushSender

Provider (interface)
  deliver(...)

TemplateEngine
  render(templateId, Channel, params): RenderedMessage

PreferenceFilter (interface)
  allowed(userId, Channel, Priority): bool

RetryPolicy
  execute(Supplier)

How they connect:
  SmsSender implements ChannelSender
  EmailSender implements ChannelSender
  PushSender implements ChannelSender
  SmsSender uses Provider (primary + fallback)
  NotificationService uses ChannelSender
  NotificationService uses TemplateEngine
  NotificationService uses PreferenceFilter

enum Channel { SMS, EMAIL, PUSH, WHATSAPP }
enum Priority { CRITICAL, TRANSACTIONAL, PROMOTIONAL }
enum DeliveryStatus { SENT, FAILED, SKIPPED }

record NotificationRequest(String requestId, String userId, String templateId,
                           Map<String, String> params, Set<Channel> channels, Priority priority) {}
record RenderedMessage(String subject, String body) {}
record DeliveryResult(Channel channel, DeliveryStatus status, String detail) {}

interface Provider { void deliver(String address, RenderedMessage msg) throws ProviderException; String name(); }

interface ChannelSender {
    Channel channel();
    DeliveryResult send(User user, RenderedMessage msg);
}

/** Wraps providers in priority order and tries each with retries: Decorator/fallback. */
class FailoverChannelSender implements ChannelSender {
    private final Channel channel; private final List<Provider> providers; private final RetryPolicy retry;
    private final Function<User, String> addressOf;               // user → phone / email / device token

    FailoverChannelSender(Channel channel, List<Provider> providers, RetryPolicy retry, Function<User, String> addressOf) {
        this.channel = channel; this.providers = providers; this.retry = retry; this.addressOf = addressOf;
    }
    public Channel channel() { return channel; }
    public DeliveryResult send(User user, RenderedMessage msg) {
        String address = addressOf.apply(user);
        if (address == null) return new DeliveryResult(channel, DeliveryStatus.SKIPPED, "no address");
        for (Provider p : providers) {
            try {
                retry.run(() -> p.deliver(address, msg));
                return new DeliveryResult(channel, DeliveryStatus.SENT, p.name());
            } catch (ProviderException e) { /* log, try the next provider */ }
        }
        return new DeliveryResult(channel, DeliveryStatus.FAILED, "all providers failed");
    }
}

class RetryPolicy {
    private final int maxAttempts; private final Duration baseDelay;
    RetryPolicy(int maxAttempts, Duration baseDelay) { this.maxAttempts = maxAttempts; this.baseDelay = baseDelay; }

    void run(ThrowingRunnable action) throws ProviderException {
        for (int attempt = 1; ; attempt++) {
            try { action.run(); return; }
            catch (ProviderException e) {
                if (!e.isRetryable() || attempt == maxAttempts) throw e;
                long backoff = baseDelay.toMillis() * (1L << (attempt - 1));
                sleep(ThreadLocalRandom.current().nextLong(backoff / 2, backoff + 1));   // exponential backoff + jitter
            }
        }
    }
    private void sleep(long ms) { try { Thread.sleep(ms); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); } }
}
interface ThrowingRunnable { void run() throws ProviderException; }

interface PreferenceFilter { boolean allowed(User user, Channel channel, Priority priority); }

class OptOutFilter implements PreferenceFilter {
    public boolean allowed(User u, Channel c, Priority p) {
        return p == Priority.CRITICAL || !u.optedOut(c, p);        // critical (OTP, security) always goes out
    }
}
class QuietHoursFilter implements PreferenceFilter {
    private final Clock clock;
    QuietHoursFilter(Clock clock) { this.clock = clock; }
    public boolean allowed(User u, Channel c, Priority p) {
        if (p != Priority.PROMOTIONAL) return true;
        LocalTime t = LocalTime.now(clock.withZone(u.zone()));
        return !(t.isAfter(LocalTime.of(22, 0)) || t.isBefore(LocalTime.of(8, 0)));
    }
}

class NotificationService {
    private final Map<Channel, ChannelSender> senders;
    private final List<PreferenceFilter> filters;
    private final TemplateEngine templates; private final UserRepository users;
    private final Map<String, List<DeliveryResult>> processed = new ConcurrentHashMap<>();   // a DB table in prod

    NotificationService(List<ChannelSender> senders, List<PreferenceFilter> filters,
                        TemplateEngine templates, UserRepository users) {
        this.senders = senders.stream().collect(Collectors.toMap(ChannelSender::channel, s -> s));
        this.filters = filters; this.templates = templates; this.users = users;
    }

    public List<DeliveryResult> send(NotificationRequest req) {
        // computeIfAbsent: atomic per requestId, so a duplicate concurrent call returns the first result
        return processed.computeIfAbsent(req.requestId(), id -> doSend(req));
    }

    private List<DeliveryResult> doSend(NotificationRequest req) {
        User user = users.get(req.userId());
        List<DeliveryResult> results = new ArrayList<>();
        for (Channel ch : req.channels()) {
            if (!filters.stream().allMatch(f -> f.allowed(user, ch, req.priority()))) {
                results.add(new DeliveryResult(ch, DeliveryStatus.SKIPPED, "preference/quiet hours"));
                continue;
            }
            RenderedMessage msg = templates.render(req.templateId(), ch, req.params());
            results.add(senders.get(ch).send(user, msg));
        }
        return results;
    }
}