Vending Machine

import java.util.*;

enum Coin {
    FIVE(5), TEN(10), TWENTY(20), FIFTY(50);
    final int value;
    Coin(int v) { this.value = v; }
    static Coin[] descending() {
        Coin[] c = values().clone();
        Arrays.sort(c, Comparator.comparingInt((Coin x) -> x.value).reversed());
        return c;
    }
}

record Product(String name, int price) {}          // price in whole rupees — never a double

class Slot {
    private final String code;
    private final Product product;
    private int count;
    Slot(String code, Product product, int count) { this.code = code; this.product = product; this.count = count; }
    String code()      { return code; }
    Product product()  { return product; }
    boolean inStock()  { return count > 0; }
    void take()        { if (count <= 0) throw new IllegalStateException("empty slot " + code); count--; }
    void restock(int n){ count += n; }
}

class Inventory {
    private final Map<String, Slot> slots = new LinkedHashMap<>();
    void add(Slot s)          { slots.put(s.code(), s); }
    Optional<Slot> find(String code) { return Optional.ofNullable(slots.get(code)); }
}

class CoinBank {
    private final Map<Coin, Integer> held = new EnumMap<>(Coin.class);
    CoinBank() { for (Coin c : Coin.values()) held.put(c, 0); }

    void deposit(Coin c) { held.merge(c, 1, Integer::sum); }

    /** Greedy — correct for canonical currency systems like ₹/$/€. */
    Optional<Map<Coin, Integer>> plan(int amount) {
        Map<Coin, Integer> give = new EnumMap<>(Coin.class);
        int left = amount;
        for (Coin c : Coin.descending()) {
            int n = Math.min(left / c.value, held.get(c));
            if (n > 0) { give.put(c, n); left -= n * c.value; }
        }
        return left == 0 ? Optional.of(give) : Optional.empty();   // empty == cannot make exact change
    }

    void withdraw(Map<Coin, Integer> plan) {
        plan.forEach((c, n) -> held.merge(c, -n, Integer::sum));
    }
}

// ---------- states: each method RETURNS the next state ----------
interface State {
    default State insertCoin(VendingMachine m, Coin c) { return this; }   // ignored unless overridden
    default State select(VendingMachine m, String code) { return this; }
    default State refund(VendingMachine m)              { return this; }
    String name();
}

class Idle implements State {
    public String name() { return "IDLE"; }
    public State insertCoin(VendingMachine m, Coin c) {
        m.acceptCoin(c);
        return new HasMoney();
    }
    // select() and refund() deliberately NOT overridden — those cells are "do nothing"
}

class HasMoney implements State {
    public String name() { return "HAS_MONEY"; }

    public State insertCoin(VendingMachine m, Coin c) {
        m.acceptCoin(c);
        return this;                                       // stay here, credit grows
    }

    public State select(VendingMachine m, String code) {
        Slot slot = m.inventory().find(code).orElse(null);
        if (slot == null)        { m.display("INVALID CODE");  return this; }
        if (!slot.inStock())     { m.display("SOLD OUT");      return this; }

        int price = slot.product().price();
        if (m.credit() < price)  { m.display("NEED ₹" + (price - m.credit()) + " MORE"); return this; }

        int due = m.credit() - price;
        // ---- every check that can fail happens BEFORE the first irreversible step ----
        Optional<Map<Coin, Integer>> plan = due == 0 ? Optional.of(Map.of()) : m.bank().plan(due);
        if (plan.isEmpty())      { m.display("EXACT CHANGE ONLY"); return this; }

        slot.take();                                       // irreversible from here on
        m.deductCredit(price);
        m.dispense(slot.product());
        m.bank().withdraw(plan.get());
        m.returnCoins(plan.get());
        m.clearCredit();
        return new Idle();
    }

    public State refund(VendingMachine m) {
        m.bank().plan(m.credit()).ifPresent(p -> { m.bank().withdraw(p); m.returnCoins(p); });
        m.clearCredit();
        return new Idle();
    }
}

class VendingMachine {
    private final Inventory inventory = new Inventory();
    private final CoinBank bank = new CoinBank();
    private State state = new Idle();
    private int credit = 0;

    Inventory inventory() { return inventory; }
    CoinBank bank()       { return bank; }
    int credit()          { return credit; }
    String state()        { return state.name(); }

    void acceptCoin(Coin c)  { credit += c.value; bank.deposit(c); }
    void deductCredit(int n)  { credit -= n; }
    void clearCredit()        { credit = 0; }
    void display(String msg)  { System.out.println("   [display] " + msg); }
    void dispense(Product p)  { System.out.println("   [tray] " + p.name()); }
    void returnCoins(Map<Coin, Integer> coins) {
        if (!coins.isEmpty()) System.out.println("   [tray] change " + coins);
    }

    // the only three inputs — each just forwards to the current state
    void insertCoin(Coin c)   { state = state.insertCoin(this, c); }
    void select(String code)  { state = state.select(this, code); }
    void refund()             { state = state.refund(this); }
}

public class Main {
    public static void main(String[] args) {
        VendingMachine m = new VendingMachine();
        m.inventory().add(new Slot("A1", new Product("Cola", 25), 2));
        m.inventory().add(new Slot("A3", new Product("Candy", 15), 1));
        m.inventory().add(new Slot("B3", new Product("Gum", 5), 0));

        System.out.println("select before paying, state=" + m.state());
        m.select("A1");                                    // ignored — no arrow out of IDLE
        System.out.println("still " + m.state());

        m.insertCoin(Coin.TWENTY);
        m.insertCoin(Coin.TEN);
        System.out.println("credit ₹" + m.credit() + ", state=" + m.state());
        m.select("A1");                                    // cola + ₹5 change
        System.out.println("after sale, state=" + m.state() + ", credit ₹" + m.credit());

        m.insertCoin(Coin.FIFTY);
        m.select("A3");                                    // ₹35 change — bank may not have it
        m.refund();
        System.out.println("final state=" + m.state());
    }
}