The event bus nobody could call

import java.util.*;
import java.util.function.Consumer;

/**
 * Solution: the event bus nobody could call.
 *
 * Two separate mistakes, and the interesting part is that the first one was
 * a real problem — the reviewer was right that the API was too strict.
 *
 *   The original  <T extends Event> subscribe(Class<T>, Handler<T>)
 *   rejected the audit handler, because generics are invariant and a
 *   Handler<Event> is not a Handler<OrderPlaced>.
 *
 *   The raw-type "fix" solved that by switching off the relationship
 *   entirely, so any handler could be filed under any key.
 *
 * The right answer is the wildcard, and which one falls straight out of
 * PECS. A Handler CONSUMES its type — handle(T) takes a T and returns
 * nothing — so it is `? super T`:
 *
 *     <T extends Event> void subscribe(Class<T> type, Handler<? super T> h)
 *
 * That accepts the Handler<Event> for OrderPlaced, because Event is a
 * supertype of OrderPlaced. And it REJECTS filing a Handler<OrderPlaced>
 * under Event.class, because OrderPlaced is not a supertype of Event — which
 * is the six-week-old bug, now a compile error.
 *
 * The one remaining cast is Class.cast(), which is checked rather than
 * unchecked: the key proves the type, and if it were ever wrong it would
 * throw at the boundary naming both types instead of deep inside a handler.
 */
public class Solution {

    interface Event {}

    record OrderPlaced(String orderId) implements Event {}

    record PaymentFailed(String reason) implements Event {}

    interface Handler<T extends Event> {
        void handle(T event);
    }

    static final class EventBus {
        /**
         * Handlers are stored already adapted to Consumer<Event>, so nothing
         * raw and nothing unchecked survives past subscribe().
         */
        private final Map<Class<?>, List<Consumer<Event>>> handlers = new HashMap<>();

        /**
         * FIX: `? super T` — a Handler consumes its type, so it may be a
         * handler of T or of anything above T.
         */
        <T extends Event> void subscribe(Class<T> type, Handler<? super T> handler) {
            handlers.computeIfAbsent(type, k -> new ArrayList<>())
                    .add(event -> handler.handle(type.cast(event)));
        }

        void publish(Event event) {
            for (Class<?> key : List.of(event.getClass(), Event.class)) {
                for (Consumer<Event> handler : handlers.getOrDefault(key, List.of())) {
                    handler.accept(event);
                }
            }
        }
    }

    public static void main(String[] args) {
        List<String> delivered = new ArrayList<>();
        boolean noMisdelivery = true;

        EventBus bus = new EventBus();

        Handler<Event> audit = e -> delivered.add("audit <- " + e);
        bus.subscribe(Event.class, audit);

        Handler<OrderPlaced> orders = e -> delivered.add("orders <- " + e.orderId());
        bus.subscribe(OrderPlaced.class, orders);

        // The API is no longer too strict: the audit handler registers for a
        // SPECIFIC type too, which the original signature refused.
        bus.subscribe(OrderPlaced.class, audit);

        // And the six-week-old bug no longer compiles:
        //
        //   bus.subscribe(Event.class, orders);
        //
        //   error: method subscribe in class EventBus cannot be applied to
        //          given types;
        //     required: Class<T>,Handler<? super T>
        //     found:    Class<Event>,Handler<OrderPlaced>
        //     reason: inference variable T has incompatible bounds
        //
        // which is the whole point — the wildcard did not just permit what
        // was wanted, it forbade what was wrong.

        System.out.println("── publishing two events ──");
        try {
            bus.publish(new OrderPlaced("ORD-1"));
            bus.publish(new PaymentFailed("card declined"));
        } catch (ClassCastException e) {
            noMisdelivery = false;
            System.out.println("  ClassCastException during delivery:");
            System.out.println("    " + e.getMessage());
        }

        System.out.println();
        for (String line : delivered) {
            System.out.println("  " + line);
        }

        System.out.println();
        long auditLines = delivered.stream().filter(s -> s.startsWith("audit")).count();
        long orderLines = delivered.stream().filter(s -> s.startsWith("orders")).count();

        // audit is registered twice for OrderPlaced (catch-all + specific),
        // so it sees that event twice and PaymentFailed once.
        boolean auditSawAll = auditLines == 3;
        boolean ordersSawOnlyOrders = orderLines == 1;

        System.out.println("every event reached its handlers : " + noMisdelivery);
        System.out.println("audit saw every delivery         : " + auditSawAll);
        System.out.println("orders handler saw only orders   : " + ordersSawOnlyOrders);
        System.out.println(noMisdelivery && auditSawAll && ordersSawOnlyOrders ? "PASS" : "FAIL");
    }
}