Design a Notification Service

public enum ChannelType { EMAIL, SMS, PUSH }
public enum Priority { CRITICAL, HIGH, MEDIUM, LOW }
public enum NotificationType { ORDER_UPDATE, PROMOTION, SECURITY_ALERT, SOCIAL }

public class Notification {
    private final String id;
    private final String userId;
    private final NotificationType type;
    private final Priority priority;
    private final Template template;
    private final Map<String, String> variables;

    private Notification(Builder builder) {
        this.id = UUID.randomUUID().toString();
        this.userId = builder.userId;
        this.type = builder.type;
        this.priority = builder.priority;
        this.template = builder.template;
        this.variables = Map.copyOf(builder.variables);
    }

    public String renderMessage() { return template.render(variables); }

    public static class Builder {
        private String userId;
        private NotificationType type;
        private Priority priority = Priority.MEDIUM;
        private Template template;
        private Map<String, String> variables = new HashMap<>();

        public Builder userId(String id) { this.userId = id; return this; }
        public Builder type(NotificationType t) { this.type = t; return this; }
        public Builder priority(Priority p) { this.priority = p; return this; }
        public Builder template(Template t) { this.template = t; return this; }
        public Builder variable(String key, String val) { variables.put(key, val); return this; }
        public Notification build() { return new Notification(this); }
    }
}

public class Template {
    private final String templateId;
    private final String body; // "Hello {{name}}, your order {{orderId}} is {{status}}"

    public String render(Map<String, String> variables) {
        String result = body;
        for (var entry : variables.entrySet()) {
            result = result.replace("{{" + entry.getKey() + "}}", entry.getValue());
        }
        return result;
    }
}

public interface Channel {
    boolean send(String userId, String renderedMessage);
    ChannelType getType();
}

public class EmailChannel implements Channel {
    private final EmailClient emailClient;

    @Override
    public boolean send(String userId, String message) {
        String email = lookupEmail(userId);
        return emailClient.send(email, "Notification", message);
    }

    @Override
    public ChannelType getType() { return ChannelType.EMAIL; }
}

public class NotificationService {
    private final Map<ChannelType, Channel> channels;
    private final UserPreferenceStore preferenceStore;
    private final RateLimiter rateLimiter;

    public void send(Notification notification) {
        String userId = notification.getUserId();
        Set<ChannelType> userChannels = preferenceStore
            .getPreference(userId)
            .getChannels(notification.getType());

        String message = notification.renderMessage();

        for (ChannelType channelType : userChannels) {
            // Skip if rate limited (unless CRITICAL)
            if (notification.getPriority() != Priority.CRITICAL
                    && !rateLimiter.allowRequest(userId, channelType)) {
                continue;
            }

            Channel channel = channels.get(channelType);
            if (channel != null) {
                // Fire-and-forget per channel — one failure doesn't block others
                CompletableFuture.runAsync(() -> channel.send(userId, message));
            }
        }
    }
}

public class RateLimiter {
    private final Map<String, TokenBucket> buckets = new ConcurrentHashMap<>();
    private final int maxTokens;
    private final Duration refillInterval;

    public RateLimiter(int maxTokens, Duration refillInterval) {
        this.maxTokens = maxTokens;
        this.refillInterval = refillInterval;
    }

    public boolean allowRequest(String userId, ChannelType channel) {
        String key = userId + ":" + channel.name();
        TokenBucket bucket = buckets.computeIfAbsent(key,
            k -> new TokenBucket(maxTokens, refillInterval));
        return bucket.tryConsume();
    }
}

public class TokenBucket {
    private final int maxTokens;
    private final Duration refillInterval;
    private int tokens;
    private Instant lastRefill;

    public TokenBucket(int maxTokens, Duration refillInterval) {
        this.maxTokens = maxTokens;
        this.refillInterval = refillInterval;
        this.tokens = maxTokens;
        this.lastRefill = Instant.now();
    }

    public synchronized boolean tryConsume() {
        refill();
        if (tokens > 0) { tokens--; return true; }
        return false;
    }

    private void refill() {
        Instant now = Instant.now();
        long elapsed = Duration.between(lastRefill, now).toMillis();
        long intervalsElapsed = elapsed / refillInterval.toMillis();
        if (intervalsElapsed > 0) {
            tokens = (int) Math.min(maxTokens, tokens + intervalsElapsed);
            lastRefill = now;
        }
    }
}