[LBP] 현정빈 로또 미션 2-5 단계 제출합니다.

src/main/java/Application.java

@@ -0,0 +1,9 @@
+import controller.LottoController;
+
+public class Application {
+
+    public static void main(String[] args) {
+        LottoController lottoController = new LottoController();
+        lottoController.run();
+    }
+}

src/main/java/controller/LottoController.java

@@ -0,0 +1,78 @@
+package controller;
+
+import model.*;
+import view.ErrorView;
+import view.InputView;
+import view.ResultView;
+
+import java.util.List;
+
+public class LottoController {
+
+    public void run() {
+        try {
+            Money money = getPurchaseAmount();
+            int manualCount = getManualCount(money);
+            LottoTickets lottoTickets = generateLottoTickets(money, manualCount);
+
+            ResultView.printOrderTickets(manualCount, money.getTicketCount() - manualCount);
+            ResultView.printPurchasedLottoTickets(lottoTickets);
+
+            processWinningResults(lottoTickets, money);
+
+            InputView.closeScanner();
+
+        } catch (IllegalArgumentException e) {
+            ErrorView.printErrorMessage(e.getMessage());
+        }
+    }
+
+    private Money getPurchaseAmount() {
+        Money money = new Money(InputView.getPurchaseAmount());
+        validatePurchaseAmount(money);
+        return money;
+    }
+
+    private int getManualCount(Money money) {
+        int manualCount = InputView.getManualTicketCount();
+        validateManualCount(manualCount, money);
+        return manualCount;
+    }
+
+    private LottoTickets generateLottoTickets(Money money, int manualCount) {
+        List<List<Integer>> manualNumbers = InputView.getManualNumbers(manualCount);
+        int autoCount = money.getTicketCount() - manualCount;
+        return new LottoTickets(manualNumbers, autoCount);
+    }
+
+    public void validateManualCount(int manualCount, Money money) {
+        if (manualCount > money.getTicketCount()) {
+            throw new IllegalArgumentException("수동 구매 개수가 구매 가능한 개수를 초과할 수 없습니다.");
+        }
+    }
+
+    public void validatePurchaseAmount(Money money) {
+        int purchaseAmount = money.getAmount();
+
+        if (purchaseAmount < 1000) {
+            throw new IllegalArgumentException("구매 금액은 1000원 이상이어야 합니다.");
+        }
+        if (purchaseAmount % 1000 != 0) {
+            throw new IllegalArgumentException("구매 금액은 1000원 단위여야 합니다.");
+        }
+    }
+
+    private void processWinningResults(LottoTickets lottoTickets, Money money) {
+        ResultView.printWinningStatistics(createLottoResult(lottoTickets, getWinningNumbers()), money.getAmount());
+    }
+
+    private WinningNumbers getWinningNumbers() {
+        List<Integer> winningNumbers = InputView.getWinningNumbers();
+        int bonusNumber = InputView.getBonusNumber();
+        return new WinningNumbers(winningNumbers, bonusNumber);
+    }
+
+    private LottoResult createLottoResult(LottoTickets lottoTickets, WinningNumbers winningNumbers) {
+        return new LottoResult(lottoTickets.getTickets(), winningNumbers);
+    }
+}

src/main/java/model/Lotto.java

@@ -0,0 +1,20 @@
+package model;
+
+import java.util.*;
+
+public class Lotto {
+
+    private final LottoNumbers lottoNumbers;
+
+    public Lotto() {
+        this.lottoNumbers = new LottoNumbers();
+    }
+
+    public Lotto(List<Integer> numbers) {
+        this.lottoNumbers = new LottoNumbers(numbers);
+    }
+
+    public List<Integer> getSortedNumbers() {
+        return lottoNumbers.getSortedNumbers();
+    }
+}

src/main/java/model/LottoNumbers.java

@@ -0,0 +1,53 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LottoNumbers {
+    private static final int LOTTO_MIN_NUMBER = 1;
+    private static final int LOTTO_MAX_NUMBER = 45;
+    private static final int LOTTO_CREATE_SIZE = 6;
+    private static final List<Integer> LOTTO_NUMBER_POOL =
+            IntStream.rangeClosed(LOTTO_MIN_NUMBER, LOTTO_MAX_NUMBER)
+                    .boxed()
+                    .collect(Collectors.toList());
+
+    private List<Integer> numbers;
+
+    public LottoNumbers() {
+        this.numbers = createLottoNumbers();
+    }
+
+    public LottoNumbers(List<Integer> numbers) {
+        validate(numbers);
+        this.numbers = List.copyOf(numbers);
+    }
+
+    private void validate(List<Integer> numbers) {
+        if (numbers.size() != LOTTO_CREATE_SIZE) {
+            throw new IllegalArgumentException("로또 번호는 6개여야 합니다.");
+        }
+        if (numbers.stream().distinct().count() != LOTTO_CREATE_SIZE) {
+            throw new IllegalArgumentException("중복된 숫자가 있습니다.");
+        }
+        if (numbers.stream().anyMatch(n -> n < LOTTO_MIN_NUMBER || n > LOTTO_MAX_NUMBER)) {
+            throw new IllegalArgumentException("로또 번호는 1~45 사이여야 합니다.");
+        }
+    }
+
+    private List<Integer> createLottoNumbers() {
+        List<Integer> shuffledNumbers = new ArrayList<>(LOTTO_NUMBER_POOL);
+        Collections.shuffle(shuffledNumbers);
+
+        return shuffledNumbers.subList(0, LOTTO_CREATE_SIZE);
+    }
+
+    public List<Integer> getSortedNumbers() {
+        return numbers.stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+}

src/main/java/model/LottoResult.java

@@ -0,0 +1,42 @@
+package model;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoResult {
+    private final Map<Rank, Integer> matchCountMap = new EnumMap<>(Rank.class);
+
+    public LottoResult(List<Lotto> tickets, WinningNumbers winningNumbers) {
+        for (Lotto ticket : tickets) {
+            Rank rank = determineRank(ticket, winningNumbers);
+            matchCountMap.put(rank, matchCountMap.getOrDefault(rank, 0) + 1);
+        }
+    }
+
+    private Rank determineRank(Lotto ticket, WinningNumbers winningNumbers) {
+        List<Integer> ticketNumbers = ticket.getSortedNumbers();
+        int matchCount = (int) ticketNumbers.stream()
+                .filter(winningNumbers.getNumbers()::contains)
+                .count();
+        boolean hasBonus = ticketNumbers.contains(winningNumbers.getBonusNumber());
+
+        if (matchCount == 6) return Rank.FIRST;
+        if (matchCount == 5 && hasBonus) return Rank.SECOND;
+        if (matchCount == 5) return Rank.THIRD;
+        if (matchCount == 4) return Rank.FOURTH;
+        if (matchCount == 3) return Rank.FIFTH;
+        return Rank.NONE;
+    }
+
+    public Map<Rank, Integer> getMatchCountMap() {
+        return matchCountMap;
+    }
+
+    public double calculateProfitRate(int totalCost) {
+        int totalPrize = matchCountMap.entrySet().stream()
+                .mapToInt(entry -> entry.getKey().getPrizeMoney() * entry.getValue())
+                .sum();
+        return (double) totalPrize / totalCost;
+    }
+}

src/main/java/model/LottoTickets.java

@@ -0,0 +1,31 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LottoTickets {
+
+    private final List<Lotto> tickets;
+
+    public LottoTickets(List<List<Integer>> manualNumbers, int autoTicketCount) {
+        this.tickets = new ArrayList<>();
+        addManualTickets(manualNumbers);
+        addAutoTickets(autoTicketCount);
+    }
+
+    private void addManualTickets(List<List<Integer>> manualNumbers) {
+        for (List<Integer> numbers : manualNumbers) {
+            tickets.add(new Lotto(numbers));
+        }
+    }
+
+    private void addAutoTickets(int autoTicketCount) {
+        for (int i = 0; i < autoTicketCount; i++) {
+            tickets.add(new Lotto());
+        }
+    }
+
+    public List<Lotto> getTickets() {
+        return new ArrayList<>(tickets);
+    }
+}

src/main/java/model/Money.java

@@ -0,0 +1,18 @@
+package model;
+
+public class Money {
+    private static final int LOTTO_PRICE = 1000;
+    private final int amount;
+
+    public Money(int amount) {
+        this.amount = amount;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    public int getTicketCount() {
+        return amount / LOTTO_PRICE;
+    }
+}

src/main/java/model/Rank.java

@@ -0,0 +1,32 @@
+package model;
+
+public enum Rank {
+    FIFTH(3, false, 5_000),
+    FOURTH(4, false, 50_000),
+    THIRD(5, false, 1_500_000),
+    SECOND(5, true, 30_000_000), // 5개 일치 + 보너스 볼 일치
+    FIRST(6, false, 2_000_000_000),
+    NONE(0, false, 0); // NONE은 출력에서 제외됨
+
+    private final int matchCount;
+    private final boolean bonusMatch;
+    private final int prizeMoney;
+
+    Rank(int matchCount, boolean bonusMatch, int prizeMoney) {
+        this.matchCount = matchCount;
+        this.bonusMatch = bonusMatch;
+        this.prizeMoney = prizeMoney;
+    }
+
+    public int getMatchCount() {
+        return matchCount;
+    }
+
+    public int getPrizeMoney() {
+        return prizeMoney;
+    }
+
+    public boolean isBonusMatch() {
+        return bonusMatch;
+    }
+}

src/main/java/model/WinningNumbers.java

@@ -0,0 +1,43 @@
+package model;
+
+import java.util.List;
+
+public class WinningNumbers {
+    private static final int SIZE = 6;
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 45;
+    private final List<Integer> numbers;
+    private final int bonusNumber;
+
+    public WinningNumbers(List<Integer> numbers, int bonusNumber) {
+        validate(numbers, bonusNumber);
+        this.numbers = List.copyOf(numbers);
+        this.bonusNumber = bonusNumber;
+    }
+
+    private void validate(List<Integer> numbers, int bonusNumber) {
+        if (numbers.size() != SIZE) {
+            throw new IllegalArgumentException("당첨 번호는 6개의 숫자로 입력해야 합니다.");
+        }
+        if (numbers.stream().distinct().count() != SIZE) {
+            throw new IllegalArgumentException("중복된 숫자가 있습니다.");
+        }
+        if (numbers.stream().anyMatch(n -> n < MIN_NUMBER || n > MAX_NUMBER)) {
+            throw new IllegalArgumentException("당첨 번호는 1부터 45 사이여야 합니다.");
+        }
+        if (bonusNumber < MIN_NUMBER || bonusNumber > MAX_NUMBER) {
+            throw new IllegalArgumentException("보너스 볼은 1부터 45 사이여야 합니다.");
+        }
+        if (numbers.contains(bonusNumber)) {
+            throw new IllegalArgumentException("보너스 볼은 당첨 번호와 중복될 수 없습니다.");
+        }
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+    public int getBonusNumber() {
+        return bonusNumber;
+    }
+}

src/main/java/view/ErrorView.java

@@ -0,0 +1,7 @@
+package view;
+
+public class ErrorView {
+    public static void printErrorMessage(String message) {
+        System.out.println(message);
+    }
+}