Design a Vending Machine

public enum Coin {
    PENNY(1), NICKEL(5), DIME(10), QUARTER(25), DOLLAR(100);

    private final int valueInCents;
    Coin(int value) { this.valueInCents = value; }
    public int getValue() { return valueInCents; }
}

public class Product {
    private final String code;
    private final String name;
    private final int priceInCents;

    public Product(String code, String name, int priceInCents) {
        this.code = code;
        this.name = name;
        this.priceInCents = priceInCents;
    }
    // getters omitted for brevity
}

public interface State {
    void insertCoin(VendingMachine machine, Coin coin);
    void selectProduct(VendingMachine machine, String productCode);
    void dispense(VendingMachine machine);
    void cancel(VendingMachine machine);
}

public class VendingMachine {
    private State currentState;
    private final Inventory inventory;
    private final PaymentHandler paymentHandler;
    private int currentBalance;  // cents inserted this transaction
    private String selectedProduct;

    // Pre-created state singletons (Flyweight)
    private final State idleState = new IdleState();
    private final State acceptingMoneyState = new AcceptingMoneyState();
    private final State dispensingState = new DispensingState();

    public VendingMachine(Inventory inventory, PaymentHandler paymentHandler) {
        this.inventory = inventory;
        this.paymentHandler = paymentHandler;
        this.currentState = idleState;
    }

    // Delegates to current state — no conditionals here
    public synchronized void insertCoin(Coin coin) {
        currentState.insertCoin(this, coin);
    }

    public synchronized void selectProduct(String code) {
        currentState.selectProduct(this, code);
    }

    public synchronized void dispense() {
        currentState.dispense(this);
    }

    public synchronized void cancel() {
        currentState.cancel(this);
    }

    // --- State transition helpers (package-private) ---
    void setState(State state) { this.currentState = state; }
    void addBalance(int cents) { this.currentBalance += cents; }
    void resetTransaction() {
        this.currentBalance = 0;
        this.selectedProduct = null;
    }

    // Getters for states and fields
    State getIdleState() { return idleState; }
    State getAcceptingMoneyState() { return acceptingMoneyState; }
    State getDispensingState() { return dispensingState; }
    int getCurrentBalance() { return currentBalance; }
    String getSelectedProduct() { return selectedProduct; }
    void setSelectedProduct(String code) { this.selectedProduct = code; }
    Inventory getInventory() { return inventory; }
    PaymentHandler getPaymentHandler() { return paymentHandler; }
}

// --- Concrete States ---
public class IdleState implements State {
    @Override
    public void insertCoin(VendingMachine machine, Coin coin) {
        machine.addBalance(coin.getValue());
        machine.getPaymentHandler().addCoin(coin);
        machine.setState(machine.getAcceptingMoneyState());
    }

    @Override
    public void selectProduct(VendingMachine machine, String code) {
        throw new IllegalStateException("Insert coins first");
    }

    @Override
    public void dispense(VendingMachine machine) {
        throw new IllegalStateException("No product selected");
    }

    @Override
    public void cancel(VendingMachine machine) { /* no-op, nothing to refund */ }
}

public class AcceptingMoneyState implements State {
    @Override
    public void insertCoin(VendingMachine machine, Coin coin) {
        machine.addBalance(coin.getValue());
        machine.getPaymentHandler().addCoin(coin);
    }

    @Override
    public void selectProduct(VendingMachine machine, String code) {
        Inventory inv = machine.getInventory();
        if (!inv.isAvailable(code)) {
            throw new OutOfStockException("Product " + code + " is out of stock");
        }
        int price = inv.getProduct(code).getPriceInCents();
        if (machine.getCurrentBalance() < price) {
            int needed = price - machine.getCurrentBalance();
            throw new InsufficientFundsException("Insert " + needed + " more cents");
        }
        int change = machine.getCurrentBalance() - price;
        if (change > 0 && !machine.getPaymentHandler().canMakeChange(change)) {
            throw new CannotMakeChangeException("Cannot make change, try exact amount");
        }
        machine.setSelectedProduct(code);
        machine.setState(machine.getDispensingState());
    }

    @Override
    public void dispense(VendingMachine machine) {
        throw new IllegalStateException("Select a product first");
    }

    @Override
    public void cancel(VendingMachine machine) {
        List<Coin> refund = machine.getPaymentHandler().refund(machine.getCurrentBalance());
        machine.resetTransaction();
        machine.setState(machine.getIdleState());
        // return refund coins to user
    }
}

public class DispensingState implements State {
    @Override
    public void insertCoin(VendingMachine machine, Coin coin) {
        throw new IllegalStateException("Dispensing in progress");
    }

    @Override
    public void selectProduct(VendingMachine machine, String code) {
        throw new IllegalStateException("Dispensing in progress");
    }

    @Override
    public void dispense(VendingMachine machine) {
        Inventory inv = machine.getInventory();
        Product product = inv.getProduct(machine.getSelectedProduct());
        int change = machine.getCurrentBalance() - product.getPriceInCents();

        inv.reduceStock(machine.getSelectedProduct());
        List<Coin> changeCoins = machine.getPaymentHandler().calculateChange(change);

        // Physical: dispense product + change coins
        machine.resetTransaction();
        machine.setState(machine.getIdleState());
    }

    @Override
    public void cancel(VendingMachine machine) {
        throw new IllegalStateException("Cannot cancel during dispensing");
    }
}

public class ProductSlot {
    private final Product product;
    private int quantity;

    public ProductSlot(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }

    public boolean isAvailable() { return quantity > 0; }
    public void reduceStock() {
        if (quantity <= 0) throw new OutOfStockException("Slot empty");
        quantity--;
    }
    public void refill(int amount) { this.quantity += amount; }
    public Product getProduct() { return product; }
    public int getQuantity() { return quantity; }
}

public class Inventory {
    private final Map<String, ProductSlot> slots = new LinkedHashMap<>();

    public void addSlot(String code, Product product, int quantity) {
        slots.put(code, new ProductSlot(product, quantity));
    }

    public boolean isAvailable(String code) {
        ProductSlot slot = slots.get(code);
        return slot != null && slot.isAvailable();
    }

    public Product getProduct(String code) {
        ProductSlot slot = slots.get(code);
        if (slot == null) throw new IllegalArgumentException("Invalid code: " + code);
        return slot.getProduct();
    }

    public void reduceStock(String code) {
        slots.get(code).reduceStock();
    }

    public void refill(String code, int amount) {
        slots.get(code).refill(amount);
    }

    public Map<String, Integer> getStockLevels() {
        return slots.entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().getQuantity()));
    }
}

public class PaymentHandler {
    private final Map<Coin, Integer> coinStock = new EnumMap<>(Coin.class);

    public PaymentHandler() {
        for (Coin c : Coin.values()) coinStock.put(c, 0);
    }

    public void addCoin(Coin coin) {
        coinStock.merge(coin, 1, Integer::sum);
    }

    /** Greedy change calculation — works for standard US denominations */
    public List<Coin> calculateChange(int amount) {
        List<Coin> change = new ArrayList<>();
        // Process coins from largest to smallest
        Coin[] denominations = {Coin.DOLLAR, Coin.QUARTER, Coin.DIME, Coin.NICKEL, Coin.PENNY};

        Map<Coin, Integer> tempStock = new EnumMap<>(coinStock);
        for (Coin coin : denominations) {
            while (amount >= coin.getValue() && tempStock.get(coin) > 0) {
                amount -= coin.getValue();
                tempStock.merge(coin, -1, Integer::sum);
                change.add(coin);
            }
        }
        if (amount > 0) throw new CannotMakeChangeException("Insufficient coins for change");

        // Commit: deduct from actual stock
        for (Coin coin : change) {
            coinStock.merge(coin, -1, Integer::sum);
        }
        return change;
    }

    public boolean canMakeChange(int amount) {
        Coin[] denominations = {Coin.DOLLAR, Coin.QUARTER, Coin.DIME, Coin.NICKEL, Coin.PENNY};
        Map<Coin, Integer> tempStock = new EnumMap<>(coinStock);
        for (Coin coin : denominations) {
            while (amount >= coin.getValue() && tempStock.get(coin) > 0) {
                amount -= coin.getValue();
                tempStock.merge(coin, -1, Integer::sum);
            }
        }
        return amount == 0;
    }

    public List<Coin> refund(int amount) {
        return calculateChange(amount);
    }

    public void loadCoins(Coin coin, int count) {
        coinStock.merge(coin, count, Integer::sum);
    }
}