[자판기] 전하영 리팩토링합니다.

docs/README.md

@@ -0,0 +1,58 @@
+# 자판기
+
+## 기능 목록
+
+
+- 자판기가 보유하고 있는 금액 입력 받기
+    - 입력값 검증
+        - 숫자인지
+        - 10의 배수인지
+
+
+- 자판기가 보유하고 있는 금액으로 동전을 무작위로 생성
+
+
+- 자판기가 보유하고 있는 동전 출력
+
+
+- 상품명, 가격, 수량 입력 받기
+    - 입력값 검증
+        - 숫자인지
+        - 100원 이상인지
+        - 10원으로 나누어 떨어지는지
+
+
+- 투입 금액 입력 받기
+    - 입력값 검증
+        - 숫자인지
+        - 양수인지
+
+
+- 구매할 상품 입력 받기
+
+
+- 입력 받은 상품 구매 가능 여부 확인
+    - 상품의 품절 여부
+    - 잔액이 충분한지
+    - 판매하는 상품인지
+
+
+- 상품 구매
+    - 남은 투입금액 계산
+    - 남은 상품 수량 계산
+
+
+- 잔돈 반환 여부 확인
+    - 잔돈 반환
+        - 남은 금액이 남은 상품의 최저 가격보다 적은 경우
+        - 모든 상품이 소진된 경우
+    - 잔돈 반환 X
+        - 상품 추가 구매
+
+
+- 잔돈 계산
+    - 잔돈 전체 반환 가능 여부 확인
+        - 잔돈이 자판기 보유금액보다 금액이 작은 경우 > 전체 반환
+        - 잔돈이 자판기 보유금액보다 금액이 큰 경우 > 잔돈으로 반환할 수 있는 금액(보유금액)만 반환
+
+- 잔돈 출력

src/main/java/vendingmachine/Application.java

@@ -1,7 +1,12 @@
 package vendingmachine;
 
+import vendingmachine.controller.VendingMachineController;
+
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        VendingMachineController vendingMachineController=new VendingMachineController();
+        vendingMachineController.setVendingMachine();
+        vendingMachineController.runVendingMachine();
     }
 }

src/main/java/vendingmachine/Coin.java

@@ -12,5 +12,17 @@ public enum Coin {
         this.amount = amount;
     }
 
-    // 추가 기능 구현
+    public int get() {
+        return amount;
+    }
+
+    public static Coin getEqualCoin(int amount) {
+        for (Coin coin : Coin.values()) {
+            if (coin.amount == amount) {
+                return coin;
+            }
+        }
+        return null;
+    }
+
 }

src/main/java/vendingmachine/controller/VendingMachineController.java

@@ -0,0 +1,80 @@
+package vendingmachine.controller;
+
+import vendingmachine.model.Balance;
+import vendingmachine.model.Product;
+import vendingmachine.model.Validator;
+import vendingmachine.view.InputView;
+import vendingmachine.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static vendingmachine.model.Validator.validateProduct;
+
+public class VendingMachineController {
+
+    private static Balance balance;
+    private static Map<String, Product> products;
+    private static int amountOfInput;
+
+    public void setVendingMachine() {
+        balance = new Balance(InputView.readBalance());
+        OutputView.printBalanceCoin(balance.createCoin());
+        saveProducts();
+        amountOfInput = InputView.readAmountOfInput();
+        OutputView.printAmountOfInput(amountOfInput);
+    }
+
+    public void runVendingMachine() {
+        while (canBuy()) {
+            buy();
+            OutputView.printAmountOfInput(amountOfInput);
+        }
+        OutputView.printChange(balance.calculateChangeCoin(amountOfInput));
+    }
+
+    private boolean canBuy() {
+        List<Integer> leftProductsPrice = new ArrayList<Integer>();
+        for (Map.Entry<String, Product> entry : products.entrySet()) {
+            if (entry.getValue().stockIsLeft()) {
+                leftProductsPrice.add(entry.getValue().getPrice());
+            }
+        }
+        if (leftProductsPrice.isEmpty()) {
+            return false;
+        }
+        return amountOfInput >= leftProductsPrice.stream().mapToInt(Integer::intValue).min().getAsInt();
+    }
+
+
+    public void saveProducts() throws IllegalArgumentException {
+        products = new HashMap<>();
+        try {
+            String[] str = InputView.readProductInfo().split(";");
+            for (String s : str) {
+                String[] productInfo = s.substring(1, s.length() - 1).split(",");
+                validateProduct(productInfo, products);
+                products.put(productInfo[0], new Product(productInfo[1], productInfo[2]));
+            }
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            saveProducts();
+        }
+    }
+
+
+    private void buy() {
+        try {
+            String buyingProduct = InputView.readBuyingProduct();
+            Validator.validateBuyingProduct(buyingProduct, products, amountOfInput);
+            amountOfInput -= products.get(buyingProduct).getPrice();
+            products.get(buyingProduct).reduceAmount();
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            buy();
+        }
+    }
+}
+

src/main/java/vendingmachine/model/Balance.java

@@ -0,0 +1,52 @@
+package vendingmachine.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import vendingmachine.Coin;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class Balance {
+    private final int balance;
+    List<Integer> numbers = new ArrayList<>();
+    private final Map<Coin, Integer> coins = new EnumMap<>(Coin.class);
+    private final Map<Coin, Integer> changeCoins = new EnumMap<>(Coin.class);
+
+    public Balance(int balance) {
+        this.balance = balance;
+        for (Coin coin : Coin.values()) {
+            numbers.add(coin.get());
+            coins.put(coin, 0);
+        }
+    }
+
+    public Map<Coin, Integer> createCoin() {
+        int tmp = balance;
+
+        while (tmp > 0) {
+            int randomCoinAmount = Randoms.pickNumberInList(numbers);
+            if (tmp >= randomCoinAmount) {
+                Coin key = Coin.getEqualCoin(randomCoinAmount);
+                coins.put(key, coins.get(key) + 1);
+                tmp = tmp - randomCoinAmount;
+            }
+        }
+        return coins;
+    }
+
+    public Map<Coin, Integer> calculateChangeCoin(int change) {
+        if (change > balance) {
+            return coins;
+        }
+        for (Coin coin : Coin.values()) {
+            int numberOfBalanceCoin = coins.get(coin);
+            int neededCoins = change / coin.get();
+            int inputCoins = Math.min(neededCoins, numberOfBalanceCoin);
+            changeCoins.put(coin, inputCoins);
+            change -= coin.get() * inputCoins;
+        }
+        return changeCoins;
+    }
+}

src/main/java/vendingmachine/model/Price.java

@@ -0,0 +1,16 @@
+package vendingmachine.model;
+
+import static vendingmachine.model.Validator.validateNum;
+import static vendingmachine.model.Validator.validatePrice;
+
+public class Price {
+    private final int price;
+    Price(String price) {
+        this.price = validateNum(price);
+        validatePrice(this.price);
+    }
+
+    public int get() {
+        return price;
+    }
+}

src/main/java/vendingmachine/model/Product.java

@@ -0,0 +1,27 @@
+package vendingmachine.model;
+
+import static vendingmachine.model.Validator.validateNegative;
+import static vendingmachine.model.Validator.validateNum;
+
+public class Product {
+    private final Price price;
+    private int amount;
+
+    public Product(String price, String amount) throws IllegalArgumentException {
+        this.price = new Price(price);
+        this.amount = validateNum(amount);
+        validateNegative(this.amount);
+    }
+
+    public boolean stockIsLeft() {
+        return amount > 0;
+    }
+
+    public void reduceAmount() {
+        amount--;
+    }
+
+    public int getPrice() {
+        return price.get();
+    }
+}

src/main/java/vendingmachine/model/Validator.java

@@ -0,0 +1,81 @@
+package vendingmachine.model;
+
+import java.util.Map;
+
+import static vendingmachine.util.NumberConsts.MIN_PRICE;
+import static vendingmachine.util.NumberConsts.MIN_UNIT;
+import static vendingmachine.util.NumberConsts.NUMBER_OF_ELEMENTS;
+import static vendingmachine.util.message.ErrorMessage.INVALID_FORMAT;
+import static vendingmachine.util.message.ErrorMessage.INVALID_PRICE;
+import static vendingmachine.util.message.ErrorMessage.INVALID_UNIT;
+import static vendingmachine.util.message.ErrorMessage.IS_NEGATIVE;
+import static vendingmachine.util.message.ErrorMessage.NOT_NUMBER;
+import static vendingmachine.util.message.ProductErrorMessage.INSUFFICIENT_BALANCE;
+import static vendingmachine.util.message.ProductErrorMessage.INVALID_NAME;
+import static vendingmachine.util.message.ProductErrorMessage.NOT_FOR_SALE;
+import static vendingmachine.util.message.ProductErrorMessage.OUT_OF_STOCK;
+
+public class Validator {
+
+    public static int validateBalance(String input) throws IllegalArgumentException {
+        int balance = validateNum(input);
+        validateNegative(balance);
+        validateInvalidUnit(balance);
+        return balance;
+    }
+
+    public static int validateAmountOfInput(String input) throws IllegalArgumentException {
+        int amountOfInput = validateNum(input);
+        validateNegative(amountOfInput);
+        return amountOfInput;
+    }
+
+    public static void validatePrice(int price) {
+        if (price < MIN_PRICE) {
+            throw new IllegalArgumentException(INVALID_PRICE.fullMessage());
+        }
+        validateInvalidUnit(price);
+    }
+
+    public static void validateProduct(String[] productInfo, Map<String, Product> products) throws IllegalArgumentException {
+        if (productInfo.length != NUMBER_OF_ELEMENTS) {
+            throw new IllegalArgumentException(INVALID_FORMAT.fullMessage());
+        }
+        if (products.containsKey(productInfo[0])) {
+            throw new IllegalArgumentException(INVALID_NAME.fullMessage());
+        }
+    }
+
+    public static void validateBuyingProduct(String buyingProduct, Map<String, Product> products,
+                                             int amountOfInput) throws IllegalArgumentException {
+        if (!products.containsKey(buyingProduct)) {
+            throw new IllegalArgumentException(NOT_FOR_SALE.fullMessage());
+        }
+        if (products.get(buyingProduct).getPrice() > amountOfInput) {
+            throw new IllegalArgumentException(INSUFFICIENT_BALANCE.fullMessage());
+        }
+        if (!products.get(buyingProduct).stockIsLeft()) {
+            throw new IllegalArgumentException(OUT_OF_STOCK.fullMessage());
+        }
+    }
+
+    public static int validateNum(String input) throws IllegalArgumentException {
+        try {
+            return Integer.parseInt(input);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(NOT_NUMBER.fullMessage());
+        }
+    }
+
+    public static void validateNegative(int num) throws IllegalArgumentException {
+        if (num < 0) {
+            throw new IllegalArgumentException(IS_NEGATIVE.fullMessage());
+        }
+    }
+
+    public static void validateInvalidUnit(int num) throws IllegalArgumentException {
+        if (num % MIN_UNIT != 0) {
+            throw new IllegalArgumentException(INVALID_UNIT.fullMessage());
+        }
+    }
+}

src/main/java/vendingmachine/util/NumberConsts.java

@@ -0,0 +1,7 @@
+package vendingmachine.util;
+
+public class NumberConsts {
+    public static final int MIN_PRICE = 100;
+    public static final int MIN_UNIT = 10;
+    public static final int NUMBER_OF_ELEMENTS = 3;
+}

src/main/java/vendingmachine/util/message/ErrorMessage.java

@@ -0,0 +1,23 @@
+package vendingmachine.util.message;
+
+import static vendingmachine.util.NumberConsts.MIN_PRICE;
+import static vendingmachine.util.NumberConsts.MIN_UNIT;
+
+public enum ErrorMessage {
+    ERROR_MESSAGE("[ERROR] "),
+    INVALID_PRICE(String.format("%d원 이상이어야 합니다.", MIN_PRICE)),
+    INVALID_UNIT(String.format("%d원으로 나누어떨어져야 합니다.", MIN_UNIT)),
+    INVALID_FORMAT("형식에 맞지 않습니다."),
+    NOT_NUMBER("형식에 맞지 않습니다."),
+    IS_NEGATIVE("음수를 입력할 수 없습니다.");
+
+    private final String message;
+
+    ErrorMessage(String message) {
+        this.message = message;
+    }
+
+    public String fullMessage() {
+        return ERROR_MESSAGE.message + message;
+    }
+}