Coffee Machine

import java.util.*;
import java.util.concurrent.*;

enum Ingredient { WATER, MILK, BEANS, SUGAR }

/** A recipe is DATA — adding a drink is a new entry, not a new class. */
record Recipe(String name, Map<Ingredient, Integer> needs) {
    Recipe {
        needs = Map.copyOf(needs);
        if (needs.isEmpty()) throw new IllegalArgumentException("a recipe needs ingredients");
    }
    /** Small / large without new recipes. */
    Recipe scaled(String newName, double factor) {
        Map<Ingredient, Integer> out = new EnumMap<>(Ingredient.class);
        needs.forEach((k, v) -> out.put(k, (int) Math.ceil(v * factor)));
        return new Recipe(newName, out);
    }
}

class RecipeBook {
    private final Map<String, Recipe> byName = new LinkedHashMap<>();
    void add(Recipe r) { byName.put(r.name(), r); }
    Recipe find(String name) {
        Recipe r = byName.get(name);
        if (r == null) throw new IllegalArgumentException("unknown drink: " + name);
        return r;
    }
    static RecipeBook standard() {
        RecipeBook book = new RecipeBook();
        book.add(new Recipe("espresso", Map.of(Ingredient.WATER, 50, Ingredient.BEANS, 20)));
        book.add(new Recipe("latte",    Map.of(Ingredient.WATER, 60, Ingredient.MILK, 80, Ingredient.BEANS, 20)));
        book.add(new Recipe("tea",      Map.of(Ingredient.WATER, 120, Ingredient.MILK, 30, Ingredient.SUGAR, 20)));
        return book;
    }
}

class NotEnoughIngredientException extends RuntimeException {
    final Ingredient ingredient;
    NotEnoughIngredientException(Ingredient i) {
        super("not enough " + i);          // names WHICH one — actionable for whoever refills
        this.ingredient = i;
    }
}

/** THE shared resource. Every outlet points at the same instance. */
class Inventory {
    private final Map<Ingredient, Integer> levels = new EnumMap<>(Ingredient.class);
    private final Map<Ingredient, Integer> capacity = new EnumMap<>(Ingredient.class);
    private final List<Runnable> lowStockListeners = new CopyOnWriteArrayList<>();

    Inventory(Map<Ingredient, Integer> initial) {
        levels.putAll(initial);
        capacity.putAll(initial);
    }

    /**
     * Check EVERY ingredient, then take EVERY ingredient — with nothing in between.
     * Two loops, so a failure leaves the tanks completely untouched.
     */
    synchronized void consume(Recipe recipe) {
        for (var e : recipe.needs().entrySet())                       // pass 1: check all
            if (levels.getOrDefault(e.getKey(), 0) < e.getValue())
                throw new NotEnoughIngredientException(e.getKey());

        for (var e : recipe.needs().entrySet())                       // pass 2: take all
            levels.merge(e.getKey(), -e.getValue(), Integer::sum);

        checkLowStock();
    }

    /** Refilling must take the SAME lock — easy to forget. */
    synchronized void refill(Ingredient ingredient, int quantity) {
        levels.merge(ingredient, quantity, Integer::sum);
        capacity.merge(ingredient, 0, (a, b) -> Math.max(a, levels.get(ingredient)));
    }

    synchronized Map<Ingredient, Integer> snapshot() { return new EnumMap<>(levels); }

    void onLowStock(Runnable listener) { lowStockListeners.add(listener); }

    private void checkLowStock() {
        levels.forEach((ing, level) -> {
            if (level < capacity.get(ing) * 0.2) lowStockListeners.forEach(Runnable::run);
        });
    }
}

class Outlet {
    private final int id;
    private final Inventory inventory;      // shared — NOT a copy
    private final RecipeBook recipes;

    Outlet(int id, Inventory inventory, RecipeBook recipes) {
        this.id = id; this.inventory = inventory; this.recipes = recipes;
    }

    String brew(String drink) {
        Recipe recipe = recipes.find(drink);
        inventory.consume(recipe);          // <- the only synchronized part: microseconds
        pour(recipe);                       // <- the slow part, OUTSIDE the lock
        return "outlet " + id + " served " + recipe.name();
    }

    private void pour(Recipe recipe) {
        try { Thread.sleep(30); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }
}

class CoffeeMachine {
    private final Inventory inventory;
    private final List<Outlet> outlets = new ArrayList<>();
    private final RecipeBook recipes;

    CoffeeMachine(int outletCount, Map<Ingredient, Integer> initial, RecipeBook recipes) {
        this.inventory = new Inventory(initial);
        this.recipes = recipes;
        for (int i = 1; i <= outletCount; i++) outlets.add(new Outlet(i, inventory, recipes));
    }

    Outlet outlet(int i)   { return outlets.get(i - 1); }
    Inventory inventory()  { return inventory; }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Map<Ingredient, Integer> initial = new EnumMap<>(Ingredient.class);
        initial.put(Ingredient.WATER, 500);
        initial.put(Ingredient.MILK, 200);      // only enough milk for TWO lattes
        initial.put(Ingredient.BEANS, 100);
        initial.put(Ingredient.SUGAR, 60);

        CoffeeMachine machine = new CoffeeMachine(3, initial, RecipeBook.standard());
        machine.inventory().onLowStock(() -> { /* a display would light up here */ });

        System.out.println("before: " + machine.inventory().snapshot());

        // three outlets, three lattes, at the same time — 240ml of milk wanted, 200 available
        ExecutorService pool = Executors.newFixedThreadPool(3);
        List<Future<String>> results = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            final int id = i;
            results.add(pool.submit(() -> machine.outlet(id).brew("latte")));
        }

        for (Future<String> f : results) {
            try { System.out.println("  " + f.get()); }
            catch (ExecutionException e) { System.out.println("  refused: " + e.getCause().getMessage()); }
        }
        pool.shutdown();

        System.out.println("after:  " + machine.inventory().snapshot());
        System.out.println("milk never went below zero because consume() is atomic");
    }
}