The method that emptied the customer's cart

import java.util.*;

/**
 * Root cause: one misunderstanding of pass-by-value, expressed twice in
 * opposite directions.
 *
 * BUG 1 — redactForLogging mutated the caller's data.
 *   `items.removeIf(...)` follows the copied reference to the SAME list the
 *   Cart holds, and deletes from it. The method got its own copy of the arrow,
 *   not its own list. So preparing a log line permanently removed the
 *   restricted item from the customer's cart, and they were charged for two
 *   items instead of three.
 *
 *   It only reproduced with debug logging on because that is the only path that
 *   called it — which is why it looked intermittent and customer-specific.
 *
 *   Fix: copy before filtering. The method never touches the caller's list.
 *
 * BUG 2 — emptyCart mutated nothing.
 *   `items = new ArrayList<>()` moves only the METHOD'S copy of the arrow. The
 *   Cart's own field still points at the original list, so the cart was never
 *   cleared. Nothing threw, nothing logged, and the old items reappeared on the
 *   next page load. "Tell them to clear cookies" was treating a symptom.
 *
 *   Fix: follow the arrow — items.clear() — or better, give Cart a method that
 *   owns the operation.
 *
 * The rule both bugs violate: following the reference is visible to the caller,
 * moving it is not. Bug 1 followed it when it should have copied; bug 2 moved
 * it when it should have followed it.
 *
 * What would make this impossible rather than fixed:
 *
 *   1. Do not hand out the live list. Cart.items() now returns an
 *      unmodifiable view, so `removeIf` on it throws instead of silently
 *      corrupting the cart — the failure becomes loud and immediate.
 *   2. Type the parameter by what the method is allowed to do. redactForLogging
 *      takes a Collection it only reads and RETURNS a new list; there is no
 *      path by which it can modify the input.
 *   3. Put mutation behind named methods on the owner (cart.empty()), so
 *      "empty the cart" cannot be attempted by assigning to a parameter.
 *
 * Note what is still not protected: the unmodifiable view guards the LIST, not
 * the Item objects inside it. Item is a record with only immutable components
 * here, so it is safe — but a mutable element type would still be reachable
 * through the view. Immutability has to go all the way down.
 */
public class Solution {

    record Item(String name, int paise, boolean restricted) {}

    static final class Cart {
        private final List<Item> items = new ArrayList<>();

        void add(Item item) {
            items.add(item);
        }

        /** FIX 3: a read-only view. Mutating it throws rather than corrupting. */
        List<Item> items() {
            return Collections.unmodifiableList(items);
        }

        /** Mutation lives here, named, where it cannot be done by accident. */
        void empty() {
            items.clear();
        }

        int totalPaise() {
            return items.stream().mapToInt(Item::paise).sum();
        }
    }

    /**
     * FIX 1: takes a Collection it only reads, returns a new List. The input is
     * never modified, and the signature is what guarantees it.
     */
    static List<Item> redactForLogging(Collection<Item> items) {
        List<Item> safe = new ArrayList<>(items);
        safe.removeIf(Item::restricted);
        return safe;
    }

    public static void main(String[] args) {
        Cart cart = new Cart();
        cart.add(new Item("Keyboard", 250000, false));
        cart.add(new Item("Restricted knife", 180000, true));
        cart.add(new Item("Mouse", 90000, false));

        int itemsOrdered = cart.items().size();
        int expectedTotal = cart.totalPaise();
        System.out.println("customer ordered   = " + itemsOrdered + " items, "
            + expectedTotal + " paise");

        List<Item> forLog = redactForLogging(cart.items());
        System.out.println("log line           = " + forLog.size() + " items (restricted hidden)");

        int itemsCharged = cart.items().size();
        int chargedTotal = cart.totalPaise();
        System.out.println("customer charged   = " + itemsCharged + " items, "
            + chargedTotal + " paise");

        // FIX 2: ask the owner to do it, instead of reassigning a parameter.
        cart.empty();
        int afterCheckout = cart.items().size();
        System.out.println("cart after order   = " + afterCheckout + " items (expected 0)");

        // Proof that the old bug is now loud instead of silent.
        cart.add(new Item("Later item", 1000, true));
        try {
            cart.items().removeIf(Item::restricted);
            System.out.println("view is still mutable — not protected");
        } catch (UnsupportedOperationException e) {
            System.out.println("mutating the view -> " + e.getClass().getSimpleName()
                + " (fails loudly, as it should)");
        }
        cart.empty();

        System.out.println();
        boolean chargedCorrectly = itemsCharged == itemsOrdered && chargedTotal == expectedTotal;
        boolean logRedacted = forLog.stream().noneMatch(Item::restricted);
        boolean cartCleared = afterCheckout == 0;

        System.out.println("charged for everything ordered : " + chargedCorrectly);
        System.out.println("restricted item kept out of log: " + logRedacted);
        System.out.println("cart emptied after order       : " + cartCleared);
        System.out.println(chargedCorrectly && logRedacted && cartCleared ? "PASS" : "FAIL");
    }
}