Vending Machine

export {};
 
enum Denomination {
  Coin1 = 1,
  Coin2 = 2,
  Coin5 = 5,
  Coin10 = 10,
  Note20 = 20,
  Note50 = 50,
}
 
const DENOMINATIONS_DESC: readonly Denomination[] = [
  Denomination.Note50,
  Denomination.Note20,
  Denomination.Coin10,
  Denomination.Coin5,
  Denomination.Coin2,
  Denomination.Coin1,
];
 
class Product {
  public constructor(
    public readonly id: string,
    public readonly name: string,
  ) {
    if (id.trim().length === 0 || name.trim().length === 0) {
      throw new Error("product id and name are required");
    }
  }
}
 
interface SlotQuote {
  readonly product: Product;
  readonly priceInRupees: number;
  readonly count: number;
}
 
class Slot {
  private count: number;
 
  public constructor(
    public readonly code: string,
    private readonly product: Product,
    private readonly priceInRupees: number,
    initialCount: number,
  ) {
    if (code.trim().length === 0) {
      throw new Error("slot code is required");
    }
 
    if (!Number.isInteger(priceInRupees) || priceInRupees <= 0) {
      throw new Error("price must be a positive integer number of rupees");
    }
 
    if (!Number.isInteger(initialCount) || initialCount < 0) {
      throw new Error("slot count must be a non-negative integer");
    }
 
    this.count = initialCount;
  }
 
  public quote(): SlotQuote {
    return {
      product: this.product,
      priceInRupees: this.priceInRupees,
      count: this.count,
    };
  }
 
  public dispense(): Product {
    if (this.count === 0) {
      throw new Error(`slot ${this.code} is sold out`);
    }
 
    this.count -= 1;
    return this.product;
  }
}
 
class Inventory {
  private readonly slots = new Map<string, Slot>();
 
  public constructor(slots: readonly Slot[]) {
    for (const slot of slots) {
      if (this.slots.has(slot.code)) {
        throw new Error(`duplicate slot code ${slot.code}`);
      }
      this.slots.set(slot.code, slot);
    }
  }
 
  public quote(code: string): SlotQuote {
    const slot = this.slots.get(code);
    if (slot === undefined) {
      throw new Error(`unknown slot ${code}`);
    }
    return slot.quote();
  }
 
  public dispense(code: string): Product {
    const slot = this.slots.get(code);
    if (slot === undefined) {
      throw new Error(`unknown slot ${code}`);
    }
    return slot.dispense();
  }
 
  public hasAnyStock(): boolean {
    return [...this.slots.values()].some(
      (slot) => slot.quote().count > 0,
    );
  }
}
 
class CashBox {
  private readonly reserve = new Map<Denomination, number>();
  private tender: Denomination[] = [];
 
  public constructor(
    initialReserve: ReadonlyMap<Denomination, number>,
  ) {
    for (const denomination of DENOMINATIONS_DESC) {
      const count = initialReserve.get(denomination) ?? 0;
      if (!Number.isInteger(count) || count < 0) {
        throw new Error("cash reserve counts must be non-negative integers");
      }
      this.reserve.set(denomination, count);
    }
  }
 
  public get balance(): number {
    return this.tender.reduce((sum, value) => sum + value, 0);
  }
 
  public accept(value: Denomination): void {
    if (!DENOMINATIONS_DESC.includes(value)) {
      throw new Error(`unsupported denomination ${value}`);
    }
    this.tender.push(value);
  }
 
  public refund(): readonly Denomination[] {
    const refund = [...this.tender];
    this.tender = [];
    return refund;
  }
 
  public canSettle(priceInRupees: number): boolean {
    if (this.balance < priceInRupees) return false;
 
    const changeDue = this.balance - priceInRupees;
    return this.planChange(
      changeDue,
      this.availableAfterTender(),
    ) !== null;
  }
 
  public settle(priceInRupees: number): readonly Denomination[] {
    if (!Number.isInteger(priceInRupees) || priceInRupees <= 0) {
      throw new Error("sale price must be a positive integer");
    }
 
    if (this.balance < priceInRupees) {
      throw new Error("insufficient funds");
    }
 
    const available = this.availableAfterTender();
    const change = this.planChange(
      this.balance - priceInRupees,
      available,
    );
 
    if (change === null) {
      throw new Error("exact change is unavailable");
    }
 
    for (const value of change) {
      available.set(value, (available.get(value) ?? 0) - 1);
    }
 
    for (const denomination of DENOMINATIONS_DESC) {
      this.reserve.set(
        denomination,
        available.get(denomination) ?? 0,
      );
    }
 
    this.tender = [];
    return change;
  }
 
  private availableAfterTender(): Map<Denomination, number> {
    const available = new Map(this.reserve);
 
    for (const value of this.tender) {
      available.set(value, (available.get(value) ?? 0) + 1);
    }
 
    return available;
  }
 
  private planChange(
    amount: number,
    available: ReadonlyMap<Denomination, number>,
  ): Denomination[] | null {
    const search = (
      index: number,
      remaining: number,
    ): Denomination[] | null => {
      if (remaining === 0) return [];
      if (index === DENOMINATIONS_DESC.length) return null;
 
      const denomination = DENOMINATIONS_DESC[index];
      const maxCount = Math.min(
        Math.floor(remaining / denomination),
        available.get(denomination) ?? 0,
      );
 
      for (let count = maxCount; count >= 0; count -= 1) {
        const rest = search(
          index + 1,
          remaining - count * denomination,
        );
 
        if (rest !== null) {
          return [
            ...Array.from({ length: count }, () => denomination),
            ...rest,
          ];
        }
      }
 
      return null;
    };
 
    return search(0, amount);
  }
}
 
interface Selection {
  readonly slotCode: string;
  readonly priceInRupees: number;
}
 
interface PurchaseResult {
  readonly product: Product;
  readonly change: readonly Denomination[];
}
 
interface VendingState {
  readonly name: string;
  insertCoin(
    machine: VendingMachine,
    value: Denomination,
  ): void;
  selectProduct(machine: VendingMachine, code: string): void;
  dispense(machine: VendingMachine): PurchaseResult;
  cancel(machine: VendingMachine): readonly Denomination[];
}
 
class VendingMachine {
  private state: VendingState;
  private selection: Selection | null = null;
 
  public constructor(
    private readonly inventory: Inventory,
    private readonly cashBox: CashBox,
  ) {
    this.state = inventory.hasAnyStock()
      ? new IdleState()
      : new SoldOutState();
  }
 
  public get balance(): number {
    return this.cashBox.balance;
  }
 
  public get stateName(): string {
    return this.state.name;
  }
 
  public setState(state: VendingState): void {
    this.state = state;
  }
 
  public insertCoin(value: Denomination): void {
    this.state.insertCoin(this, value);
  }
 
  public selectProduct(code: string): void {
    this.state.selectProduct(this, code);
  }
 
  public dispense(): PurchaseResult {
    return this.state.dispense(this);
  }
 
  public cancel(): readonly Denomination[] {
    return this.state.cancel(this);
  }
 
  public acceptMoney(value: Denomination): void {
    this.cashBox.accept(value);
  }
 
  public quote(code: string): SlotQuote {
    return this.inventory.quote(code);
  }
 
  public rememberSelection(
    slotCode: string,
    priceInRupees: number,
  ): void {
    this.selection = { slotCode, priceInRupees };
  }
 
  public selectedSale(): Selection {
    if (this.selection === null) {
      throw new Error("no product is selected");
    }
    return this.selection;
  }
 
  public releaseSelectedProduct(): Product {
    return this.inventory.dispense(this.selectedSale().slotCode);
  }
 
  public canMakeChange(priceInRupees: number): boolean {
    return this.cashBox.canSettle(priceInRupees);
  }
 
  public settle(priceInRupees: number): readonly Denomination[] {
    return this.cashBox.settle(priceInRupees);
  }
 
  public clearSelection(): void {
    this.selection = null;
  }
 
  public refundMoney(): readonly Denomination[] {
    this.clearSelection();
    return this.cashBox.refund();
  }
 
  public hasStock(): boolean {
    return this.inventory.hasAnyStock();
  }
}
 
class IdleState implements VendingState {
  public readonly name = "idle";
 
  public insertCoin(
    machine: VendingMachine,
    value: Denomination,
  ): void {
    machine.acceptMoney(value);
    machine.setState(new HasMoneyState());
  }
 
  public selectProduct(
    _machine: VendingMachine,
    _code: string,
  ): void {
    throw new Error("insert money before selecting a product");
  }
 
  public dispense(_machine: VendingMachine): PurchaseResult {
    throw new Error("nothing is ready to dispense");
  }
 
  public cancel(_machine: VendingMachine): readonly Denomination[] {
    return [];
  }
}
 
class HasMoneyState implements VendingState {
  public readonly name = "has-money";
 
  public insertCoin(
    machine: VendingMachine,
    value: Denomination,
  ): void {
    machine.acceptMoney(value);
  }
 
  public selectProduct(machine: VendingMachine, code: string): void {
    const quote = machine.quote(code);
 
    if (quote.count === 0) {
      throw new Error(`${quote.product.name} is sold out`);
    }
 
    if (machine.balance < quote.priceInRupees) {
      const shortfall = quote.priceInRupees - machine.balance;
      throw new Error(`insert ₹${shortfall} more`);
    }
 
    if (!machine.canMakeChange(quote.priceInRupees)) {
      throw new Error("exact change is unavailable; add exact money or cancel");
    }
 
    machine.rememberSelection(code, quote.priceInRupees);
    machine.setState(new DispensingState());
  }
 
  public dispense(_machine: VendingMachine): PurchaseResult {
    throw new Error("select a product before dispensing");
  }
 
  public cancel(machine: VendingMachine): readonly Denomination[] {
    const refund = machine.refundMoney();
    machine.setState(
      machine.hasStock() ? new IdleState() : new SoldOutState(),
    );
    return refund;
  }
}
 
class DispensingState implements VendingState {
  public readonly name = "dispensing";
 
  public insertCoin(
    _machine: VendingMachine,
    _value: Denomination,
  ): void {
    throw new Error("wait for the current product");
  }
 
  public selectProduct(
    _machine: VendingMachine,
    _code: string,
  ): void {
    throw new Error("a product is already selected");
  }
 
  public dispense(machine: VendingMachine): PurchaseResult {
    const sale = machine.selectedSale();
    const product = machine.releaseSelectedProduct();
    const change = machine.settle(sale.priceInRupees);
 
    machine.clearSelection();
    machine.setState(
      machine.hasStock() ? new IdleState() : new SoldOutState(),
    );
 
    return { product, change };
  }
 
  public cancel(_machine: VendingMachine): readonly Denomination[] {
    throw new Error("the approved product is already dispensing");
  }
}
 
class SoldOutState implements VendingState {
  public readonly name = "sold-out";
 
  public insertCoin(
    _machine: VendingMachine,
    _value: Denomination,
  ): void {
    throw new Error("machine is sold out");
  }
 
  public selectProduct(
    _machine: VendingMachine,
    _code: string,
  ): void {
    throw new Error("machine is sold out");
  }
 
  public dispense(_machine: VendingMachine): PurchaseResult {
    throw new Error("machine is sold out");
  }
 
  public cancel(machine: VendingMachine): readonly Denomination[] {
    return machine.refundMoney();
  }
}
 
const water = new Product("P-WATER", "Water");
const inventory = new Inventory([
  new Slot("A1", water, 15, 2),
]);
 
const reserve = new Map<Denomination, number>([
  [Denomination.Coin5, 2],
  [Denomination.Coin2, 5],
  [Denomination.Coin1, 5],
]);
 
const machine = new VendingMachine(
  inventory,
  new CashBox(reserve),
);
 
machine.insertCoin(Denomination.Note20);
machine.selectProduct("A1");
const purchase = machine.dispense();
 
console.log(`Dispensed: ${purchase.product.name}`);
console.log(`Change: ${purchase.change.map((value) => `₹${value}`).join(", ")}`);
console.log(`A1 remaining: ${inventory.quote("A1").count}`);
console.log(`State: ${machine.stateName}`);