[로또 미션] 김의천 미션 제출합니다.

src/main/java/LottoApplication.java

@@ -0,0 +1,8 @@
+import controller.LottoGameController;
+
+public class LottoApplication {
+    public static void main(String[] args) {
+        LottoGameController lottoGameController = new LottoGameController();
+        lottoGameController.run();
+    }
+}

src/main/java/controller/LottoGameController.java

@@ -0,0 +1,104 @@
+package controller;
+
+import model.*;
+import view.InputView;
+import view.OutputView;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Collectors;
+
+public class LottoGameController {
+    private final LottoGenerator lottoGenerator = new LottoGenerator();
+    private LottoPurchasePrice lottoPurchasePrice;
+    private int lottoCount;
+    private int manualLottoCount;
+    private LottoList manualLottoList;
+    private LottoList lottoList;
+    private WinningLottoInfo winningLottoInfo;
+
+    public void run() {
+        inputLottoPurchasePrice();
+        inputManualLottoCount();
+        inputManualLottoList();
+        makeLottoList(lottoCount);
+        inputWinningLottoInfo();
+        printLottoPrizeResult();
+    }
+
+    private void inputLottoPurchasePrice() {
+        while (true) {
+            try {
+                lottoPurchasePrice = InputView.inputLottoPurchasePrice();
+                lottoCount = lottoPurchasePrice.getLottoCount();
+                break;
+            } catch (Exception exception) {
+                OutputView.printErrorMessage(exception.getMessage());
+            }
+        }
+    }
+
+    private void inputManualLottoCount() {
+        while (true) {
+            try {
+                int manualLottoCount = InputView.inputManualLottoCount();
+                if (manualLottoCount > lottoPurchasePrice.getLottoCount()) {
+                    throw new IllegalArgumentException("수동 로또의 개수가 전체 구매할 수 있는 로또 수인 "
+                            + lottoPurchasePrice.getLottoCount()
+                            + "개보다 많아서는 안 됩니다. 수동 로또의 개수를 줄여보세요.");
+                }
+                this.manualLottoCount = manualLottoCount;
+                break;
+            } catch (Exception exception) {
+                OutputView.printErrorMessage(exception.getMessage());
+            }
+        }
+    }
+
+    private void inputManualLottoList() {
+        while (true) {
+            try {
+                manualLottoList = InputView.inputManualLottoList(manualLottoCount);
+                break;
+            } catch (Exception exception) {
+                OutputView.printErrorMessage(exception.getMessage());
+            }
+        }
+    }
+
+    private void makeLottoList(int lottoCount) {
+        int autoLottoCount = lottoCount - this.manualLottoList.size();
+        List<Lotto> manualLottoList = this.manualLottoList.getValue();
+        List<Lotto> autoLottoList = IntStream.range(0, autoLottoCount)
+                .mapToObj(i -> lottoGenerator.generate())
+                .collect(Collectors.toList());
+        List<Lotto> concatedLottoList = new ArrayList<>();
+        concatedLottoList.addAll(manualLottoList);
+        concatedLottoList.addAll(autoLottoList);
+
+        lottoList = new LottoList(concatedLottoList);
+        OutputView.printLottoPurchases(lottoList, manualLottoCount, autoLottoCount);
+    }
+
+    private void inputWinningLottoInfo() {
+        while (true) {
+            try {
+                final Lotto winningLotto = InputView.inputWinningLotto();
+                final BonusNumber bonusNumber = InputView.inputBonusNumber();
+                this.winningLottoInfo = new WinningLottoInfo(winningLotto, bonusNumber);
+                break;
+            } catch (Exception exception) {
+                OutputView.printErrorMessage(exception.getMessage());
+            }
+        }
+    }
+
+    private void printLottoPrizeResult() {
+        try {
+            OutputView.printLottoPrizeResult(lottoList.getLottoResultByWinningLottoInfo(winningLottoInfo));
+        } catch (Exception exception) {
+            OutputView.printErrorMessage(exception.getMessage());
+        }
+    }
+}

src/main/java/model/BonusNumber.java

@@ -0,0 +1,21 @@
+package model;
+
+public class BonusNumber {
+    public final int bonusNumber;
+
+    public BonusNumber(int bonusNumber) {
+        validateBonusNumber(bonusNumber);
+        this.bonusNumber = bonusNumber;
+    }
+
+    private void validateBonusNumber(int bonusNumber) {
+        if (bonusNumber < LottoConstants.MIN_NUMBER.getValue() || bonusNumber > LottoConstants.MAX_NUMBER.getValue()) {
+            throw new Error("보너스 넘버는 " + LottoConstants.MIN_NUMBER.getValue()
+                    + " 이상 " + LottoConstants.MAX_NUMBER.getValue() + " 이하여야 합니다.");
+        }
+    }
+
+    public int getValue() {
+        return bonusNumber;
+    }
+}

src/main/java/model/Lotto.java

@@ -0,0 +1,47 @@
+package model;
+
+import java.util.*;
+
+public class Lotto {
+    private final List<Integer> lotto;
+
+    public Lotto(List<Integer> lotto) {
+        validateLotto(lotto);
+        this.lotto = getSortedLotto(lotto);
+    }
+
+    private void validateLotto(List<Integer> lotto) {
+        if (lotto.size() != LottoConstants.NUMBER_COUNT.getValue()) {
+            throw new IllegalArgumentException("로또 번호는 6개의 수로 이루어져야 합니다.");
+        }
+
+        lotto.forEach(lottoNumber -> {
+            if (lottoNumber < LottoConstants.MIN_NUMBER.getValue() || lottoNumber > LottoConstants.MAX_NUMBER.getValue()) {
+                throw new IllegalArgumentException("로또 번호는 " + LottoConstants.MIN_NUMBER.getValue() +
+                        " 이상 " + LottoConstants.MAX_NUMBER.getValue() + " 이하여야 합니다.");
+            }
+        });
+
+        Set<Integer> uniqueLottoNumbers = new HashSet<>(lotto);
+
+        if (uniqueLottoNumbers.size() != LottoConstants.NUMBER_COUNT.getValue()) {
+            throw new IllegalArgumentException("로또 번호는 중복되어서는 안 됩니다.");
+        }
+    }
+
+    private List<Integer> getSortedLotto(List<Integer> lotto) {
+        List<Integer> sortedLotto = new ArrayList<>(lotto);
+        sortedLotto.sort(null);
+
+        return sortedLotto;
+    }
+
+    public List<Integer> getValue() {
+        return Collections.unmodifiableList(lotto);
+    }
+
+    @Override
+    public String toString() {
+        return lotto.toString();
+    }
+}

src/main/java/model/LottoConstants.java

@@ -0,0 +1,18 @@
+package model;
+
+public enum LottoConstants {
+    MIN_NUMBER(1),
+    MAX_NUMBER(45),
+    NUMBER_COUNT(6),
+    PRICE(1_000);
+
+    private final int value;
+
+    LottoConstants(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/model/LottoGenerator.java

@@ -0,0 +1,24 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class LottoGenerator {
+    final Random random = new Random();
+
+    public Lotto generate() {
+        final List<Integer> lottoNumbers = new ArrayList<>();
+
+        while (lottoNumbers.size() < LottoConstants.NUMBER_COUNT.getValue()) {
+            final int candidateLottoNumber = random.nextInt(LottoConstants.MIN_NUMBER.getValue(),
+                    LottoConstants.MAX_NUMBER.getValue());
+
+            if (!lottoNumbers.contains(candidateLottoNumber)) {
+                lottoNumbers.add(candidateLottoNumber);
+            }
+        }
+
+        return new Lotto(lottoNumbers);
+    }
+}

src/main/java/model/LottoList.java

@@ -0,0 +1,36 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class LottoList {
+    private final List<Lotto> lottoList;
+
+    public LottoList(List<Lotto> lottoList) {
+        this.lottoList = new ArrayList<>(lottoList);
+    }
+
+    public List<Lotto> getValue() {
+        return lottoList;
+    }
+
+    public int size() {
+        return lottoList.size();
+    }
+
+    public LottoPrizeResult getLottoResultByWinningLottoInfo(WinningLottoInfo winningLottoInfo) {
+        LottoPrizeResult lottoPrizeResult = new LottoPrizeResult();
+
+        lottoList.forEach(lotto -> {
+            Set<Integer> lottoNumbers = new HashSet<>(lotto.getValue());
+            int matchNumberCount = (int) winningLottoInfo.getLottoValue().stream().filter(lottoNumbers::contains).count();
+            boolean hasBonusNumber = lottoNumbers.contains(winningLottoInfo.getBonusNumberValue());
+
+            lottoPrizeResult.addPrize(matchNumberCount, hasBonusNumber);
+        });
+
+        return lottoPrizeResult;
+    }
+}

src/main/java/model/LottoPrize.java

@@ -0,0 +1,43 @@
+package model;
+
+public enum LottoPrize {
+    FIFTH(5_000, 3, false),
+    FOURTH(50_000, 4, false),
+    THIRD(1_500_000, 5, false),
+    SECOND(30_000_000, 5, true),
+    FIRST(2_000_000_000, 6, false);
+
+    private final int money;
+    private final int matchNumberCount;
+    private final boolean hasBonusNumber;
+
+    LottoPrize(int money, int matchNumberCount, boolean hasBonusNumber) {
+        this.money = money;
+        this.matchNumberCount = matchNumberCount;
+        this.hasBonusNumber = hasBonusNumber;
+    }
+
+    public static LottoPrize getPrizeByMatchResult(int matchNumberCount, boolean hasBonusNumber) {
+        for (LottoPrize lottoPrize: values()) {
+            if (matchNumberCount != lottoPrize.matchNumberCount) {
+                continue;
+            }
+
+            if (matchNumberCount == 5 && hasBonusNumber != lottoPrize.hasBonusNumber) {
+                continue;
+            }
+
+            return lottoPrize;
+        }
+
+        return null;
+    }
+
+    public int getMoney() {
+        return money;
+    }
+
+    public int getMatchNumberCount() {
+        return matchNumberCount;
+    }
+}

src/main/java/model/LottoPrizeResult.java

@@ -0,0 +1,46 @@
+package model;
+
+import java.util.*;
+
+public class LottoPrizeResult {
+    private final Map<LottoPrize, Integer> prizeResult;
+    int lottoCount;
+
+    public LottoPrizeResult() {
+        this.prizeResult = new EnumMap<LottoPrize, Integer>(LottoPrize.class);
+        this.lottoCount = 0;
+
+        for (LottoPrize lottoPrize : LottoPrize.values()) {
+            prizeResult.put(lottoPrize, 0);
+        }
+    }
+
+    public Map<LottoPrize, Integer> getValue() {
+        return Collections.unmodifiableMap(prizeResult);
+    }
+
+    public void addPrize(int matchNumberCount, boolean hasBonusNumber) {
+        LottoPrize currentLottoPrize = LottoPrize.getPrizeByMatchResult(matchNumberCount, hasBonusNumber);
+
+        if (currentLottoPrize != null) {
+            prizeResult.put(currentLottoPrize, prizeResult.get(currentLottoPrize) + 1);
+        }
+
+        lottoCount += 1;
+    }
+
+    public double getProfitRate() {
+        int purchasePrice = lottoCount * LottoConstants.PRICE.getValue();
+
+        if (purchasePrice == 0) {
+            return 0;
+        }
+
+        int totalPrizeMoney =
+                prizeResult.entrySet().stream()
+                        .mapToInt(entry -> entry.getKey().getMoney() * entry.getValue())
+                        .sum();
+
+        return (double) totalPrizeMoney / purchasePrice;
+    }
+}

src/main/java/model/LottoPurchasePrice.java

@@ -0,0 +1,29 @@
+package model;
+
+public class LottoPurchasePrice {
+    private final int lottoPurchasePrice;
+
+    public LottoPurchasePrice(int lottoPrice) {
+        validateLottoPrice(lottoPrice);
+        this.lottoPurchasePrice = lottoPrice;
+    }
+
+    private void validateLottoPrice(int lottoPurchasePrice) {
+        if (lottoPurchasePrice < 0) {
+            throw new IllegalArgumentException("로또 총 구입금액은 음수가 될 수 없습니다.");
+        }
+
+        if (lottoPurchasePrice % LottoConstants.PRICE.getValue() != 0) {
+            throw new IllegalArgumentException("로또 총 구입금액은 " + LottoConstants.PRICE.getValue() +
+                    "로 나누어 떨어져야 합니다.");
+        }
+    }
+
+    public int getValue() {
+        return lottoPurchasePrice;
+    }
+
+    public int getLottoCount() {
+        return lottoPurchasePrice / LottoConstants.PRICE.getValue();
+    }
+}