[LBP] 윤준석 로또 미션 2-5단계 제출합니다.

src/main/java/config/LottoConstants.java

@@ -0,0 +1,18 @@
+package config;
+
+public enum LottoConstants {
+    MIN_NUMBER(1),
+    MAX_NUMBER(45),
+    LOTTO_SIZE(6),
+    LOTTO_PRICE(1000);
+
+    private final int value;
+
+    LottoConstants(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/config/LottoValidator.java

@@ -0,0 +1,48 @@
+package config;
+
+import java.util.*;
+
+public class LottoValidator {
+    public static void validatePurchaseAmount(int amount) {
+        if (amount <= 0) {
+            throw new IllegalArgumentException("구매 금액은 0보다 커야 합니다.");
+        }
+        if (amount % 1000 != 0) {
+            throw new IllegalArgumentException("구매 금액은 1000원 단위여야 합니다.");
+        }
+    }
+
+    public static void validateManualTicketCount(int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("수동 구매 개수는 0 이상이어야 합니다.");
+        }
+    }
+
+    public static List<Integer> validateAndParseLottoNumbers(String input) {
+        List<Integer> numbers = Arrays.stream(input.split(","))
+                .map(String::trim)
+                .map(Integer::parseInt)
+                .toList();
+
+        if (numbers.size() != 6) {
+            throw new IllegalArgumentException("로또 번호는 6개여야 합니다.");
+        }
+
+        Set<Integer> uniqueNumbers = new HashSet<>(numbers);
+        if (uniqueNumbers.size() != 6) {
+            throw new IllegalArgumentException("로또 번호는 중복될 수 없습니다.");
+        }
+
+        if (numbers.stream().anyMatch(n -> n < 1 || n > 45)) {
+            throw new IllegalArgumentException("로또 번호는 1~45 사이여야 합니다.");
+        }
+
+        return new ArrayList<>(uniqueNumbers);
+    }
+
+    public static void validateBonusNumber(int bonus) {
+        if (bonus < 1 || bonus > 45) {
+            throw new IllegalArgumentException("보너스 번호는 1~45 사이여야 합니다.");
+        }
+    }
+}

src/main/java/config/WinningRank.java

@@ -0,0 +1,39 @@
+package config;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public enum WinningRank {
+    MATCH_3(3, 5000, "3개 일치 (5000원)"),
+    MATCH_4(4, 50000, "4개 일치 (50000원)"),
+    MATCH_5(5, 1500000, "5개 일치 (1500000원)"),
+    MATCH_5_BONUS(5, 30000000, "5개 일치, 보너스 볼 일치(30000000원)"),
+    MATCH_6(6, 2000000000, "6개 일치 (2000000000원)");
+
+    private final int matchCount;
+    private final int prize;
+    private final String description;
+
+    WinningRank(int matchCount, int prize, String description) {
+        this.matchCount = matchCount;
+        this.prize = prize;
+        this.description = description;
+    }
+
+    public int getPrize() {
+        return prize;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public static Optional<WinningRank> findByMatchCount(int matchCount, boolean hasBonus) {
+        if (matchCount == 5 && hasBonus) {
+            return Optional.of(MATCH_5_BONUS);
+        }
+        return Arrays.stream(values())
+                .filter(rank -> rank.matchCount == matchCount)
+                .findFirst();
+    }
+}

src/main/java/controller/LottoMachineController.java

@@ -0,0 +1,94 @@
+package controller;
+
+import model.Lotto;
+import model.LottoMachine;
+import model.LottoResultChecker;
+import config.LottoValidator;
+import view.InputView;
+import view.ResultView;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class LottoMachineController {
+    public void run() {
+        int purchaseAmount;
+
+        while (true) {
+            try {
+                purchaseAmount = InputView.getPurchaseAmount();
+                LottoValidator.validatePurchaseAmount(purchaseAmount);
+                break;
+            } catch (IllegalArgumentException e) {
+                ResultView.printInvalidAmountMessage();
+            }
+        }
+
+        int totalTicketCount = LottoMachine.getTicketCount(purchaseAmount);
+
+        int manualTicketCount;
+        while (true) {
+            try {
+                manualTicketCount = InputView.getManualTicketCount();
+                LottoValidator.validateManualTicketCount(manualTicketCount);
+                if (manualTicketCount > totalTicketCount) {
+                    ResultView.printInvalidManualTicketMessage();
+                    continue;
+                }
+                break;
+            } catch (IllegalArgumentException e) {
+                ResultView.printInvalidManualCountMessage();
+            }
+        }
+
+        int autoTicketCount = totalTicketCount - manualTicketCount;
+
+        List<List<Integer>> manualNumbers;
+        while (true) {
+            try {
+                List<String> inputNumbers = InputView.getManualLottoNumbers(manualTicketCount);
+                manualNumbers = inputNumbers.stream()
+                        .map(LottoValidator::validateAndParseLottoNumbers)
+                        .collect(Collectors.toList());
+                break;
+            } catch (IllegalArgumentException e) {
+                ResultView.printInvalidLottoNumbersMessage();
+            }
+        }
+
+        List<Lotto> tickets = LottoMachine.generateLottos(manualNumbers, purchaseAmount);
+        List<String> formattedTickets = tickets.stream().map(Lotto::toString).collect(Collectors.toList());
+
+        ResultView.printOrderTickets(manualTicketCount, autoTicketCount);
+        ResultView.printTickets(formattedTickets);
+
+        List<Integer> winningNumbers;
+        while (true) {
+            try {
+                String input = InputView.getWinningNumbers();
+                winningNumbers = LottoValidator.validateAndParseLottoNumbers(input);
+                break;
+            } catch (IllegalArgumentException e) {
+                ResultView.printInvalidWinningNumbersMessage();
+            }
+        }
+
+        int bonusNumber;
+        while (true) {
+            try {
+                bonusNumber = InputView.getBonusNumber();
+                LottoValidator.validateBonusNumber(bonusNumber);
+                break;
+            } catch (IllegalArgumentException e) {
+                ResultView.printInvalidBonusNumberMessage();
+            }
+        }
+
+        Map<String, Integer> results = LottoResultChecker.checkWinningResults(tickets, winningNumbers, bonusNumber);
+        int totalPrize = results.get("totalPrize");
+        double profitRate = LottoResultChecker.calculateProfitRate(totalPrize, purchaseAmount);
+
+        ResultView.printWinningStatistics(results, profitRate);
+    }
+}

src/main/java/model/LottoMachine.java

@@ -0,0 +1,46 @@
+package model;
+
+import config.LottoConstants;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class LottoMachine {
+    private static final int LOTTO_PRICE = LottoConstants.LOTTO_PRICE.getValue();
+    private static final List<Integer> LOTTO_NUMBER_POOL =
+            IntStream.rangeClosed(LottoConstants.MIN_NUMBER.getValue(), LottoConstants.MAX_NUMBER.getValue())
+                    .boxed()
+                    .toList();
+
+    public static int getTicketCount(int purchaseAmount) {
+        if (purchaseAmount % LOTTO_PRICE != 0) {
+            throw new IllegalArgumentException("구매 금액은 1000원 단위여야 합니다.");
+        }
+        return purchaseAmount / LOTTO_PRICE;
+    }
+
+    private static Lotto generateAutoLotto() {
+        List<Integer> shuffledNumbers = new ArrayList<>(LOTTO_NUMBER_POOL);
+        Collections.shuffle(shuffledNumbers);
+        return new Lotto(shuffledNumbers.subList(0, LottoConstants.LOTTO_SIZE.getValue()));
+    }
+
+    public static List<Lotto> generateLottos(List<List<Integer>> manualNumbers, int purchaseAmount) {
+        int totalTicketCount = getTicketCount(purchaseAmount);
+        int manualCount = manualNumbers.size();
+        int autoCount = totalTicketCount - manualCount;
+
+        if (manualCount > totalTicketCount) {
+            throw new IllegalArgumentException("구매 가능한 로또 개수를 초과했습니다.");
+        }
+
+        List<Lotto> lottos = new ArrayList<>();
+        manualNumbers.forEach(numbers -> lottos.add(new Lotto(numbers)));
+        for (int i = 0; i < autoCount; i++) {
+            lottos.add(generateAutoLotto());
+        }
+
+        return lottos;
+    }
+}

src/main/java/model/LottoResultChecker.java

@@ -0,0 +1,51 @@
+package model;
+
+import config.WinningRank;
+import java.util.*;
+
+public class LottoResultChecker {
+
+    public static Map<String, Integer> checkWinningResults(List<Lotto> purchasedLottos, List<Integer> winningNumbers, int bonusNumber) {
+        Map<String, Integer> result = initializeResultMap();
+        int totalPrize = 0;
+        Set<Integer> winningSet = new HashSet<>(winningNumbers);
+
+        for (Lotto lotto : purchasedLottos) {
+            totalPrize += updateResults(result, lotto, winningSet, bonusNumber);
+        }
+
+        result.put("totalPrize", totalPrize);
+        return result;
+    }
+
+    private static Map<String, Integer> initializeResultMap() {
+        Map<String, Integer> result = new LinkedHashMap<>();
+        for (WinningRank rank : WinningRank.values()) {
+            result.put(rank.getDescription(), 0);
+        }
+        return result;
+    }
+
+    private static int updateResults(Map<String, Integer> result, Lotto lotto, Set<Integer> winningSet, int bonusNumber) {
+        int matchCount = (int) lotto.getNumbers().stream().filter(winningSet::contains).count();
+        boolean hasBonus = lotto.getNumbers().contains(bonusNumber);
+
+        Optional<WinningRank> rank = WinningRank.findByMatchCount(matchCount, hasBonus);
+        if (rank.isEmpty()) {
+            return 0;
+        }
+
+        WinningRank winningRank = rank.get();
+        String key = winningRank.getDescription();
+        result.put(key, result.getOrDefault(key, 0) + 1);
+
+        return winningRank.getPrize();
+    }
+
+    public static double calculateProfitRate(int totalPrize, int purchaseAmount) {
+        if (purchaseAmount == 0) {
+            return 0.0;
+        }
+        return (double) totalPrize / purchaseAmount;
+    }
+}

src/main/java/view/ResultView.java

@@ -1,4 +1,5 @@
 package view;
+
 import java.util.List;
 
 public class ResultView {