The payment type that shipped half-handled

import java.util.*;

/**
 * Incident reproduction: the payment type that shipped half-handled.
 *
 * Netbanking was added two sprints ago. The PR touched every switch the
 * author could find by grepping for "Upi". It found three of five.
 *
 * The two it missed do not throw at the point of the mistake — they fall
 * into a default branch that was written to be safe and is not:
 *
 *   1. Finance reports that netbanking orders settle with zero platform fee.
 *      Four weeks of them. Nobody noticed, because zero is a plausible
 *      number and no exception was ever thrown.
 *
 *   2. The SLA dashboard shows netbanking as a non-instant method, so those
 *      orders are queued on the slow path and customers see a delay that the
 *      product team did not design.
 *
 * There is nothing wrong with the new record. The defect is that this design
 * cannot tell anyone a case is missing.
 *
 * TASKS
 *   1. Run it and find the two wrong answers.
 *   2. Fix them — and then do the part that matters: change the design so
 *      the SIXTH payment type cannot repeat this. Seal the hierarchy and
 *      delete every default branch.
 *   3. Deleting a default will sometimes compile straight away. When it does,
 *      you have just proved that switch was already exhaustive. Note which
 *      ones those were.
 *   4. In a comment: adding a permitted subtype now breaks compilation for
 *      every consumer. Is that a cost or the feature? Answer for a library
 *      and for an internal service separately.
 */
public class Starter {

    /* The hierarchy is open, so no switch below can be checked. */
    interface Payment {}

    record Card(String network, long amountPaise) implements Payment {}

    record Upi(String handle, long amountPaise) implements Payment {}

    record Cash(long amountPaise) implements Payment {}

    /** Added two sprints ago. */
    record Netbanking(String bank, long amountPaise) implements Payment {}

    /** Site 1 — MISSED. A silent zero is worse than a loud failure. */
    static long feePaise(Payment payment) {
        return switch (payment) {
            case Card c -> Math.round(c.amountPaise() * 0.02);
            case Upi u -> 0L;
            case Cash c -> 0L;
            default -> 0L;
        };
    }

    /** Site 2 — MISSED. Wrong SLA path, no error anywhere. */
    static boolean isInstant(Payment payment) {
        return switch (payment) {
            case Card c -> true;
            case Upi u -> true;
            case Cash c -> false;
            default -> false;
        };
    }

    /** Site 3 — updated correctly in the original PR. */
    static String label(Payment payment) {
        return switch (payment) {
            case Card c -> c.network() + " card";
            case Upi u -> "UPI " + u.handle();
            case Cash c -> "cash";
            case Netbanking n -> n.bank() + " netbanking";
            default -> "unknown";
        };
    }

    /** Site 4 — updated correctly in the original PR. */
    static String settlementAccount(Payment payment) {
        return switch (payment) {
            case Card c -> "acct-card";
            case Upi u -> "acct-upi";
            case Cash c -> "acct-cash";
            case Netbanking n -> "acct-netbanking";
            default -> throw new IllegalStateException("unhandled payment: " + payment);
        };
    }

    public static void main(String[] args) {
        List<Payment> payments = List.of(
                new Card("visa", 500_00L),
                new Upi("ravi@okhdfc", 500_00L),
                new Cash(500_00L),
                new Netbanking("hdfc", 500_00L));

        for (Payment payment : payments) {
            System.out.printf("%-22s fee=%-6d instant=%-6s -> %s%n",
                    label(payment), feePaise(payment), isInstant(payment),
                    settlementAccount(payment));
        }

        // The published rate card: netbanking carries a flat 500 paise fee,
        // and it settles instantly.
        Payment netbanking = new Netbanking("hdfc", 500_00L);
        boolean feeCorrect = feePaise(netbanking) == 500L;
        boolean slaCorrect = isInstant(netbanking);

        System.out.println();
        System.out.println("netbanking fee charged correctly : " + feeCorrect);
        System.out.println("netbanking on the instant path   : " + slaCorrect);
        System.out.println(feeCorrect && slaCorrect ? "PASS" : "FAIL");
    }
}