ATM

import java.util.*;

// ---------- money as whole paise; never a double ----------
record Money(long paise) {
    static Money rupees(long r) { return new Money(r * 100); }
    Money plus(Money o)  { return new Money(paise + o.paise); }
    Money minus(Money o) { return new Money(paise - o.paise); }
    boolean gt(Money o)  { return paise > o.paise; }
    long rupees()        { return paise / 100; }
    public String toString() { return "₹" + rupees(); }
}

class Account {
    private final String id;
    private Money balance;
    private Money withdrawnToday = new Money(0);

    Account(String id, Money opening) { this.id = id; this.balance = opening; }

    String id()        { return id; }
    Money balance()    { return balance; }
    Money usedToday()  { return withdrawnToday; }

    boolean hasFunds(Money amount) { return !amount.gt(balance); }

    void debit(Money amount) {
        if (!hasFunds(amount)) throw new IllegalStateException("overdraw");
        balance = balance.minus(amount);
        withdrawnToday = withdrawnToday.plus(amount);
    }
    /** The compensating action. Not "undo" — a real, recorded credit. */
    void credit(Money amount) {
        balance = balance.plus(amount);
        withdrawnToday = withdrawnToday.minus(amount);
    }
}

// ---------- the bank is behind an interface so failure is demoable ----------
interface BankService {
    Account authenticate(Card card, String pin);
    void debit(Account a, Money amount);
    void credit(Account a, Money amount);
}

record Card(String number, String pin) {}

class FakeBank implements BankService {
    private final Map<String, Account> accounts = new HashMap<>();
    void register(Card c, Account a) { accounts.put(c.number(), a); }

    public Account authenticate(Card card, String pin) {
        if (!card.pin().equals(pin)) throw new WrongPinException();
        return accounts.get(card.number());
    }
    public void debit(Account a, Money amount)  { a.debit(amount); }
    public void credit(Account a, Money amount) { a.credit(amount); }
}

class WrongPinException extends RuntimeException {}
class InsufficientFundsException extends RuntimeException {}
class DailyLimitExceededException extends RuntimeException {}
class CannotDispenseAmountException extends RuntimeException {}
class DispenserFaultException extends RuntimeException {}
class TransactionReversedException extends RuntimeException {
    TransactionReversedException(Throwable cause) { super("dispenser fault — debit reversed", cause); }
}

// ---------- the physical half ----------
class Cassette {
    final int denomination;      // in rupees
    int count;
    Cassette(int denomination, int count) { this.denomination = denomination; this.count = count; }
}

class CashDispenser {
    private final List<Cassette> cassettes;   // highest denomination first
    private boolean faulty = false;

    CashDispenser(List<Cassette> cassettes) {
        this.cassettes = new ArrayList<>(cassettes);
        this.cassettes.sort(Comparator.comparingInt((Cassette c) -> c.denomination).reversed());
    }
    void setFaulty(boolean f) { this.faulty = f; }

    /** Greedy over what is physically held. Empty == this machine cannot pay that number. */
    Optional<Map<Integer, Integer>> planFor(Money amount) {
        Map<Integer, Integer> plan = new LinkedHashMap<>();
        long left = amount.rupees();
        for (Cassette c : cassettes) {
            int n = (int) Math.min(left / c.denomination, c.count);
            if (n > 0) { plan.put(c.denomination, n); left -= (long) n * c.denomination; }
        }
        return left == 0 ? Optional.of(plan) : Optional.empty();
    }

    void dispense(Map<Integer, Integer> plan) {
        if (faulty) throw new DispenserFaultException();          // the jam
        for (Cassette c : cassettes) {
            Integer n = plan.get(c.denomination);
            if (n != null) c.count -= n;
        }
        System.out.println("   [tray] " + plan);
    }
}

/** Everything that must die when the card comes out. */
class Session {
    final Card card;
    final Account account;
    Session(Card card, Account account) { this.card = card; this.account = account; }
}

class ATM {
    private static final int MAX_PIN_ATTEMPTS = 3;
    private static final Money DAILY_LIMIT = Money.rupees(20_000);

    private final BankService bank;
    private final CashDispenser dispenser;
    private Session session;              // null == NO_CARD. The state, modelled.
    private Card insertedCard;
    private int pinAttempts;

    ATM(BankService bank, CashDispenser dispenser) { this.bank = bank; this.dispenser = dispenser; }

    void insertCard(Card card) { this.insertedCard = card; this.pinAttempts = 0; }

    void enterPin(String pin) {
        try {
            session = new Session(insertedCard, bank.authenticate(insertedCard, pin));
        } catch (WrongPinException e) {
            if (++pinAttempts >= MAX_PIN_ATTEMPTS) { retainCard(); throw new IllegalStateException("card retained"); }
            throw e;
        }
    }

    Money balance() { return requireSession().account.balance(); }

    Money withdraw(Money amount) {
        Account account = requireSession().account;

        // ---- three checks, cheapest first, before ANY write ----
        if (!account.hasFunds(amount))                                throw new InsufficientFundsException();
        if (account.usedToday().plus(amount).gt(DAILY_LIMIT))          throw new DailyLimitExceededException();
        Map<Integer, Integer> plan = dispenser.planFor(amount)
                .orElseThrow(CannotDispenseAmountException::new);

        // ---- two writes; only the first can be taken back ----
        bank.debit(account, amount);
        try {
            dispenser.dispense(plan);
        } catch (DispenserFaultException e) {
            bank.credit(account, amount);                             // compensate
            throw new TransactionReversedException(e);
        }
        return amount;
    }

    void deposit(Money amount) { bank.credit(requireSession().account, amount); }

    void ejectCard() { session = null; insertedCard = null; pinAttempts = 0; }   // the wipe
    private void retainCard() { session = null; insertedCard = null; }

    private Session requireSession() {
        if (session == null) throw new IllegalStateException("no authenticated session");
        return session;
    }
}

public class Main {
    public static void main(String[] args) {
        Card card = new Card("4821", "1234");
        Account account = new Account("A-1", Money.rupees(12_000));
        FakeBank bank = new FakeBank();
        bank.register(card, account);

        CashDispenser dispenser = new CashDispenser(List.of(
                new Cassette(2000, 2), new Cassette(500, 6), new Cassette(200, 3), new Cassette(100, 5)));
        ATM atm = new ATM(bank, dispenser);

        atm.insertCard(card);
        try { atm.enterPin("9999"); } catch (WrongPinException e) { System.out.println("wrong pin 1/3"); }
        atm.enterPin("1234");
        System.out.println("balance " + atm.balance());

        try { atm.withdraw(Money.rupees(99_000)); }
        catch (InsufficientFundsException e) { System.out.println("declined: insufficient funds"); }

        try { atm.withdraw(Money.rupees(150)); }
        catch (CannotDispenseAmountException e) { System.out.println("declined: no note combination makes ₹150"); }

        // ---- the one that matters ----
        dispenser.setFaulty(true);
        try { atm.withdraw(Money.rupees(5_000)); }
        catch (TransactionReversedException e) {
            System.out.println("dispenser jammed → balance restored to " + atm.balance());
        }

        dispenser.setFaulty(false);
        atm.withdraw(Money.rupees(5_000));
        System.out.println("after clean withdrawal: " + atm.balance());

        atm.ejectCard();
        System.out.println("card out — session cleared");
    }
}