프리코스 3주차

public class Car {
    private int position;

    // 자동차 이동 여부를 결정하는 비즈니스 로직
    public void move(int randomValue) {
        ...
    }

    // UI 로직
    private void print(int position) {
        StringBuilder sb = new StringBuilder();
        ...
    }
}

public class PossessionCoin {
    private static final int DEFAULT_QUANTITY = 0;
    private static final String TO_STRING_FORMAT = "%d원 - %d개";

    private final Coin coin;
    private final int quantity;

    public PossessionCoin(Coin coin, int quantity) {
        this.coin = coin;
        this.quantity = quantity;
    }

    public Coin getCoin() {
        return coin;
    }

    public boolean isExistQuantity() {
        return quantity > DEFAULT_QUANTITY;
    }

    public int calculatePossibleQuantity(InvestmentMoney investmentMoney) {
        return investmentMoney.trade(coin.getAmount(), quantity);
    }

    @Override
    public String toString() {
        return String.format(TO_STRING_FORMAT, coin.getAmount(), quantity);
    }
}

public class PossessionCoins {
    List<PossessionCoin> possessionCoins;

    public PossessionCoins(List<PossessionCoin> possessionCoins) {
        this.possessionCoins = possessionCoins;
    }

    public List<PossessionCoin> getPossessionCoins() {
        return Collections.unmodifiableList(possessionCoins);
    }

    public List<Change> takeChange(InvestmentMoney investmentMoney) {
        List<Change> changes = new ArrayList<>();

        for (PossessionCoin possessionCoin : possessionCoins) {
            Coin coin = possessionCoin.getCoin();
            if (possessionCoin.isExistQuantity() && investmentMoney.isPossibleChange(coin)) {
                int coinQuantity = possessionCoin.calculate(investmentMoney);
                changes.add(new Change(coin, coinQuantity));
            }
        }

        return changes;
    }
}

public class PossessionCoins {
    List<PossessionCoin> possessionCoins;

    public PossessionCoins(List<PossessionCoin> possessionCoins) {
        this.possessionCoins = possessionCoins;
    }

    public List<PossessionCoin> getPossessionCoins() {
        return Collections.unmodifiableList(possessionCoins);
    }

    public List<Change> takeChange(InvestmentMoney investmentMoney) {
        return possessionCoins.stream()
            .filter(PossessionCoin::isExistQuantity)
            .filter(investmentMoney::isPossibleChange)
            .map(possessionCoin -> getChange(investmentMoney, possessionCoin))
            .collect(toList());
    }

    private Change getChange(InvestmentMoney investmentMoney, PossessionCoin possessionCoin) {
        int coinQuantity = possessionCoin.calculatePossibleQuantity(investmentMoney);
        return new Change(possessionCoin.getCoin(), coinQuantity);
    }
}

public enum Coin {
    COIN_500(500),
    COIN_100(100),
    COIN_50(50),
    COIN_10(10);

    private final int amount;

    Coin(final int amount) {
        this.amount = amount;
    }

    public int getAmount() {
        return amount;
    }
}

for (Coin coin : Coin.values()) {
    System.out.println(coin);
}

public enum Coin {
    COIN_500(500),
    COIN_100(100),
    COIN_50(50),
    COIN_10(10);

    public static final ArrayList<Coin> COINS = new ArrayList<>(Arrays.asList(Coin.values()));
    public static final String PREFIX = "COIN_";

    private final int amount;

    Coin(final int amount) {
        this.amount = amount;
    }

    public static List<Integer> getCoinAmounts() {
        return COINS.stream()
            .map(coin -> coin.amount)
            .collect(toList());
    }

    public static Coin parseCoin(int amount) {
        return Coin.valueOf(PREFIX + amount);
    }

    public int getAmount() {
        return amount;
    }
}

public class PossessionCoin {
    private static final int DEFAULT_QUANTITY = 0;
    private static final String TO_STRING_FORMAT = "%d원 - %d개";

    private final Coin coin;
    private final int quantity;

    public PossessionCoin(Coin coin, int quantity) {
        this.coin = coin;
        this.quantity = quantity;
    }
    ...
}

private boolean isMaxPosition(Car car) {
    return car.getPosition() == maxDistance;
}

car.isMaxPosition(maxDistance);

public class Product {
    ...

    private final Name name;
    private final Price price;
    private final Quantity quantity;

    public Product(String inputProduct) {
        ...
        this.name = new Name(splitInputProduct[NAME_INDEX]);
        this.price = new Price(splitInputProduct[PRICE_INDEX]);
        this.quantity = new Quantity(splitInputProduct[QUANTITY_INDEX]);
    }

    ...

    public String getName() {
        return name.getName();
    }

    public int getPrice() {
        return price.getPrice();
    }

    public boolean isSameName(String productPurchaseName) {
        return this.name.isSame(productPurchaseName);
    }

    public void receive() {
        if (!quantity.isExistQuantity()) {
            throw new IllegalArgumentException(VALID_PRODUCT_QUANTITY);
        }
        quantity.decreaseQuantity();
    }

    public boolean isExistQuantity() {
        return quantity.isExistQuantity();
    }
}

public class InvestmentMoney {
    ...
    private int investmentMoney;

    public InvestmentMoney(String inputInvestmentMoney) {
        ...
        int investmentMoney = Integer.parseInt(inputInvestmentMoney);
        ...
        this.investmentMoney = investmentMoney;
    }
    ...
    
    public void calculate(int price) {
        if (investmentMoney < price) {
            throw new IllegalArgumentException(VALID_PRODUCT_PRICE);
        }
        investmentMoney -= price;
    }

    public boolean isPay(Product product) {
        return investmentMoney >= product.getPrice();
    }
    ...
}

public class ProductPurchase {
    private static final String VALID_EMPTY = "[ERROR] 상품명이 비어있습니다.";
    private static final String VALID_BLANK = "[ERROR] 상품명은 공백이 될 수 없습니다.";

    private final String name;

    public ProductPurchase(String name) {
        validateEmpty(name);
        validateBlank(name);
        this.name = name;
    }

    private void validateEmpty(String name) {
        if (name.isEmpty()) {
            throw new IllegalArgumentException(VALID_EMPTY);
        }
    }

    private void validateBlank(String name) {
        if (name.trim().isEmpty()) {
            throw new IllegalArgumentException(VALID_BLANK);
        }
    }

    public String getName() {
        return name;
    }
}

public class Product {
    ...
    private final String name;
    private final int price;
    private int quantity;

    public Product(String inputProduct) {
        validateStartWithAndEndWith(inputProduct);
        inputProduct = inputProduct.replace(INPUT_PRODUCT_PREFIX, EMPTY);
        inputProduct = inputProduct.replace(INPUT_PRODUCT_SUFFIX, EMPTY);

        String[] splitInputProduct = inputProduct.split(INPUT_PRODUCT_SPLIT_REGEX, INPUT_PRODUCT_SPLIT_LIMIT);
        validateSplitInputProduct(splitInputProduct);

        this.name = splitInputProduct[NAME_INDEX];
        this.price = Integer.parseInt(splitInputProduct[PRICE_INDEX]);
        this.quantity = Integer.parseInt(splitInputProduct[QUANTITY_INDEX]);
    }

    private void validateStartWithAndEndWith(String inputProduct) {
        if (!(inputProduct.startsWith(INPUT_PRODUCT_PREFIX) && inputProduct.endsWith(INPUT_PRODUCT_SUFFIX))) {
            throw new IllegalArgumentException();
        }
    }

    private void validateSplitInputProduct(String[] splitInputProduct) {
        validateName(splitInputProduct[NAME_INDEX]);
        validatePrice(splitInputProduct[PRICE_INDEX]);
        validateQuantity(splitInputProduct[QUANTITY_INDEX]);
    }

    private void validateName(String name) {
        validateEmpty(name);
        validateBlank(name);
    }

    private void validateEmpty(String name) {
        if (name.isEmpty()) {
            throw new IllegalArgumentException();
        }
    }

    private void validateBlank(String name) {
        if (name.trim().isEmpty()) {
            throw new IllegalArgumentException();
        }
    }

    private void validatePrice(String inputPrice) {
        validateNumberFormat(inputPrice);
        int price = Integer.parseInt(inputPrice);

        validateNumberSize(price);
        validateDivide(price);
    }

    private void validateNumberSize(int price) {
        if (price < DEFAULT_PRICE) {
            throw new IllegalArgumentException();
        }
    }

    private void validateDivide(int price) {
        if (price % PRICE_QUOTIENT != REMAINDER) {
            throw new IllegalArgumentException();
        }
    }

    private void validateQuantity(String inputQuantity) {
        validateNumberFormat(inputQuantity);
        int quantity = Integer.parseInt(inputQuantity);
        validateNegativeNumber(quantity);
    }

    private void validateNumberFormat(String input) {
        try {
            Integer.parseInt(input);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException();
        }
    }

    private void validateNegativeNumber(int quantity) {
        if (quantity < DEFAULT_QUANTITY) {
            throw new IllegalArgumentException();
        }
    }
    ...
}

public class Name {
    private static final String VALID_EMPTY = "[ERROR] 상품 이름이 비어있습니다.";
    private static final String VALID_BLANK = "[ERROR] 상품 이름이 공백입니다.";

    private final String name;

    public Name(String name) {
        validateEmpty(name);
        validateBlank(name);
        this.name = name;
    }

    private void validateEmpty(String name) {
        if (name.isEmpty()) {
            throw new IllegalArgumentException(VALID_EMPTY);
        }
    }

    private void validateBlank(String name) {
        if (name.trim().isEmpty()) {
            throw new IllegalArgumentException(VALID_BLANK);
        }
    }

    public String getName() {
        return name;
    }

    public boolean isSame(String name) {
        if (this.name.equals(name)) {
            return true;
        }
        return false;
    }
}

public class Product {
    ...
    private final Name name;
    private final Price price;
    private final Quantity quantity;

    public Product(String inputProduct) {
        validateStartWithAndEndWith(inputProduct);
        inputProduct = inputProduct.replace(INPUT_PRODUCT_PREFIX, EMPTY);
        inputProduct = inputProduct.replace(INPUT_PRODUCT_SUFFIX, EMPTY);

        String[] splitInputProduct = inputProduct.split(INPUT_PRODUCT_SPLIT_REGEX, INPUT_PRODUCT_SPLIT_LIMIT);
        validateArrayLength(splitInputProduct.length);

        this.name = new Name(splitInputProduct[NAME_INDEX]);
        this.price = new Price(splitInputProduct[PRICE_INDEX]);
        this.quantity = new Quantity(splitInputProduct[QUANTITY_INDEX]);
    }

    private void validateStartWithAndEndWith(String inputProduct) {
        if (!(inputProduct.startsWith(INPUT_PRODUCT_PREFIX) && inputProduct.endsWith(INPUT_PRODUCT_SUFFIX))) {
            throw new IllegalArgumentException(VALID_START_END_WITH);
        }
    }

    private void validateArrayLength(int length) {
        if (length != DEFAULT_STRING_SPLIT_LENGTH) {
            throw new IllegalArgumentException(VALID_STRING_SPLIT_LENGTH);
        }
    }

    public String getName() {
        return name.getName();
    }

    public int getPrice() {
        return price.getPrice();
    }

    public boolean isSameName(String productPurchaseName) {
        if (this.name.isSame(productPurchaseName)) {
            return true;
        }
        return false;
    }

    public void receive() {
        if (!quantity.isExistQuantity()) {
            throw new IllegalArgumentException(VALID_PRODUCT_QUANTITY);
        }
        quantity.decreaseQuantity();
    }

    public boolean isExistQuantity() {
        if (quantity.isExistQuantity()) {
            return true;
        }
        return false;
    }
}