[로또] 김연진 미션 제출합니다.

docs/README.md

@@ -0,0 +1,48 @@
+## 3주차 미션 로또 기능 정의
+
+### 로또 게임 진행 (LottoController)
+- [X] 게임 시작
+- [x] 게임 진행
+
+### 로또 개수 계산 (LottoCounter)
+- [x] 금액에 맞는 로또 개수 계산
+
+### 랜덤 로또 생성 (RandomLottoGenerator)
+- [x] 랜덤 번호 6개로 로또 생성
+
+### 사용자 생성 로또 (PlayerLotto)
+- [x] 원하는 개수만큼 로또 생성
+
+### 당첨 로또 (WinningLotto)
+- [x] 입력받은 당첨 로또 관리
+- [x] 보너스 숫자 관리
+- [x] 예외) 당첨 로또 숫자와 보너스 숫자가 겹칠 경우
+
+### 로또 당첨 계산 (LottoResult)
+- [x] 로또 당첨 여부 판별
+- [x] 수익률 계산
+
+### 로또 번호 관리(Lotto)
+- [x] 예외) 중복된 수를 입력한 경우
+- [x] 예외) 번호가 6개가 아닌 경우
+- [x] 예외) 범위 이외의 수인 경우
+
+### 입력 (InputFactory)
+- [x] 로또 구입 금액 입력 기능
+- [x] 당첨 번호 입력 기능
+- [x] 보너스 번호 입력 기능
+
+### 로또 구매 안내 출력 (OutputView)
+- [x] 구매 개수 안내
+- [x] 생성된 로또 번호 안내
+- [x] 당첨 통계 안내
+- [x] 수익률 안내
+
+### 예외 처리(InputValidator)
+- [x] 보너스 번호를 입력할 때 숫자가 아닌 입력한 경우
+- [x] 범위 이외의 숫자를 보너스 숫자로 입력한 경우
+- [x] 구입 금액이 1000원 단위가 아닌 경우
+- [x] 구입 금액 입력이 숫자가 아닌 경우
+- [x] 잘못된 형식으로 당첨 번호를 입력한 경우 (쉼표가 없는 경우 등)
+
+

src/main/java/lotto/Application.java

@@ -1,7 +1,12 @@
 package lotto;
 
+import lotto.controller.LottoController;
+import lotto.view.InputFactory;
+import lotto.view.OutputView;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        LottoController lottoController = new LottoController(new OutputView(), new InputFactory());
+        lottoController.start();
     }
 }

src/main/java/lotto/controller/LottoController.java

@@ -0,0 +1,45 @@
+package lotto.controller;
+
+import lotto.model.*;
+import lotto.view.InputFactory;
+import lotto.view.OutputView;
+
+public class LottoController {
+
+    private final OutputView outputView;
+    private final InputFactory inputFactory;
+
+    public LottoController(OutputView outputView, InputFactory inputFactory) {
+        this.outputView = outputView;
+        this.inputFactory = inputFactory;
+    }
+
+    public void start() {
+        try {
+            PlayerLottoes playerLottoes = buyLotto();
+            WinningLotto winningLotto = createWinningLotto();
+            calculateResult(playerLottoes, winningLotto);
+        } catch (IllegalArgumentException error) {
+            outputView.printErrorMessage(error.getMessage());
+        }
+    }
+
+    private PlayerLottoes buyLotto() {
+        LottoCounter lottoCounter = new LottoCounter(inputFactory.readPurchaseAmount());
+        PlayerLottoes playerLottoes = new PlayerLottoes(lottoCounter.getLotteryTicket());
+        outputView.printPurchaseCount(lottoCounter.getLotteryTicket());
+        outputView.printPlayerLottoes(playerLottoes);
+        return playerLottoes;
+    }
+
+    private WinningLotto createWinningLotto() {
+        return new WinningLotto(inputFactory.readWinningNumber(), inputFactory.readBonusNumber());
+    }
+
+    private void calculateResult(PlayerLottoes playerLottoes, WinningLotto winningLotto) {
+        LottoResultCalculator lottoResultCalculator = new LottoResultCalculator(winningLotto, playerLottoes);
+        ProfitCalculator profitCalculator = new ProfitCalculator(lottoResultCalculator.getRankingsResult());
+        outputView.printLottoResult(lottoResultCalculator.getRankingsResult());
+        outputView.printProfit(profitCalculator.getProfit());
+    }
+}

src/main/java/lotto/model/BonusNumber.java

@@ -0,0 +1,26 @@
+package lotto.model;
+
+import lotto.view.ExceptionMessage;
+
+public class BonusNumber {
+
+    private final int bonusNumber;
+    private static final int MAX_NUMBER = 45;
+    private static final int MIN_NUMBER = 1;
+
+    public BonusNumber(int bonusNumber) {
+        validateCorrectRange(bonusNumber);
+        this.bonusNumber = bonusNumber;
+    }
+
+    public int getBonus() {
+        return bonusNumber;
+    }
+
+    private void validateCorrectRange(int bonusNumber) {
+        if (!(MIN_NUMBER <= bonusNumber && bonusNumber <= MAX_NUMBER)) {
+            ExceptionMessage exceptionMessage = ExceptionMessage.INCORRECT_RANGE;
+            throw new IllegalArgumentException(exceptionMessage.toString());
+        }
+    }
+}

src/main/java/lotto/model/Constant.java

@@ -0,0 +1,19 @@
+package lotto.model;
+
+public enum Constant {
+
+    MAX_NUMBER(45),
+    MIN_NUMBER(1),
+    LOTTO_SIZE(6),
+    LOTTO_PRICE(1000);
+
+    private final Integer constant;
+
+    Constant(Integer constant) {
+        this.constant = constant;
+    }
+
+    public Integer getConstant() {
+        return this.constant;
+    }
+}

src/main/java/lotto/model/Lotto.java

@@ -0,0 +1,52 @@
+package lotto.model;
+
+import lotto.view.ExceptionMessage;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Lotto {
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validateLottoSize(numbers);
+        validateDuplicateNumber(numbers);
+        validateRange(numbers);
+        this.numbers = numbers;
+    }
+
+    private void validateLottoSize(List<Integer> numbers) {
+        if (numbers.size() != Constant.LOTTO_SIZE.getConstant()) {
+            ExceptionMessage message = ExceptionMessage.INCORRECT_LOTTO_SIZE;
+            throw new IllegalArgumentException(message.toString());
+        }
+    }
+
+    private void validateDuplicateNumber(List<Integer> numbers) {
+        Set<Integer> numberToSet = new HashSet<>(numbers);
+        if (numberToSet.size() != Constant.LOTTO_SIZE.getConstant()) {
+            ExceptionMessage message = ExceptionMessage.DUPLICATE_NUMBER;
+            throw new IllegalArgumentException(message.toString());
+        }
+    }
+
+    private void validateRange(List<Integer> numbers) {
+        numbers.forEach(this::isCorrectRange);
+    }
+    private void isCorrectRange(int number) {
+        int maxNumber = Constant.MAX_NUMBER.getConstant();
+        int minNumber = Constant.MIN_NUMBER.getConstant();
+        if (!(minNumber <= number && number <= maxNumber)) {
+            ExceptionMessage exceptionMessage = ExceptionMessage.INCORRECT_RANGE;
+            throw new IllegalArgumentException(exceptionMessage.toString());
+        }
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+    public boolean hasNumber(int number) {
+        return numbers.contains(number);
+    }
+}

src/main/java/lotto/model/LottoCounter.java

@@ -0,0 +1,28 @@
+package lotto.model;
+
+import lotto.view.ExceptionMessage;
+
+public class LottoCounter {
+
+    private final int lotteryTicket;
+
+    public LottoCounter(int payment) {
+        validateThousandUnits(payment);
+        this.lotteryTicket = calculateLotteryTicket(payment);
+    }
+
+    public int calculateLotteryTicket(int payment) {
+        return payment / Constant.LOTTO_PRICE.getConstant();
+    }
+
+    public int getLotteryTicket() {
+        return lotteryTicket;
+    }
+
+    private void validateThousandUnits(Integer amount) {
+        if((amount % Constant.LOTTO_PRICE.getConstant()) != 0) {
+            ExceptionMessage exceptionMessage = ExceptionMessage.INCORRECT_AMOUNT;
+            throw new IllegalArgumentException(exceptionMessage.toString());
+        }
+    }
+}

src/main/java/lotto/model/LottoResult.java

@@ -0,0 +1,68 @@
+package lotto.model;
+
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Set;
+
+public class LottoResult {
+
+    private final Map<Ranking, Integer> result;
+
+    public LottoResult() {
+        this.result = new EnumMap<>(Ranking.class);
+        Arrays.stream(Ranking.values())
+                .forEach(ranking -> result.put(ranking, 0));
+    }
+
+    public void putResult(Ranking ranking) {
+        result.put(ranking, result.get(ranking) + 1);
+    }
+
+    public Set<Ranking> keySet() {
+        return result.keySet();
+    }
+
+    public Integer get(Ranking ranking) {
+        return result.get(ranking);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder stringBuilder = new StringBuilder();
+        Arrays.stream(Ranking.values())
+                .filter(ranking -> ranking != Ranking.NONE)
+                .forEach(ranking -> {
+                    appendMatchNumberMessage(ranking, stringBuilder);
+                    appendBonusMessage(ranking, stringBuilder);
+                    appendPrizeAmountMessage(ranking, stringBuilder);
+                    appendWinningNumberMessage(ranking, stringBuilder);
+                    stringBuilder.append(ResultMessage.NEW_LINE);
+                });
+        return stringBuilder.toString();
+    }
+
+    private void appendMatchNumberMessage(Ranking ranking, StringBuilder stringBuilder) {
+        ResultMessage resultMessage = ResultMessage.MATCH_NUMBER_MESSAGE;
+        int matchNumber = ranking.getMatchNumber();
+        stringBuilder.append(String.format(resultMessage.toString(), matchNumber));
+    }
+
+    private void appendPrizeAmountMessage(Ranking ranking, StringBuilder stringBuilder) {
+        ResultMessage resultMessage = ResultMessage.AMOUNT_MESSAGE;
+        int prize = ranking.getPrize();
+        stringBuilder.append(String.format(resultMessage.toString(), prize));
+    }
+
+    private void appendBonusMessage(Ranking ranking, StringBuilder stringBuilder) {
+        if (ranking == Ranking.SECOND) {
+            stringBuilder.append(ResultMessage.BONUS_MESSAGE);
+        }
+    }
+
+    private void appendWinningNumberMessage(Ranking ranking, StringBuilder stringBuilder) {
+        ResultMessage resultMessage = ResultMessage.WINNING_NUMBER_MESSAGE;
+        int winningNumber = result.get(ranking);
+        stringBuilder.append(String.format(resultMessage.toString(), winningNumber));
+    }
+}

src/main/java/lotto/model/LottoResultCalculator.java

@@ -0,0 +1,56 @@
+package lotto.model;
+
+import java.util.Arrays;
+
+public class LottoResultCalculator {
+
+    private final WinningLotto winningLotto;
+    private final PlayerLottoes playerLottoes;
+    private final LottoResult lottoResult;
+    private static final int THIRD_RANKING_NUMBER = 5;
+
+    public LottoResultCalculator(WinningLotto winningLotto, PlayerLottoes playerLottoes) {
+        this.winningLotto = winningLotto;
+        this.playerLottoes = playerLottoes;
+        this.lottoResult = calculateWinningRank();
+    }
+
+    private LottoResult calculateWinningRank() {
+        LottoResult result = new LottoResult();
+        for (Lotto lotto : playerLottoes.getLottoes()) {
+            int matchNumber = calculateMatchNumber(lotto);
+            boolean matchBonusNumber = hasBonusNumber(matchNumber, lotto);
+            Ranking ranking = calculateRanking(matchNumber, matchBonusNumber);
+            result.putResult(ranking);
+        }
+        return result;
+    }
+
+    private static Ranking calculateRanking(int matchNumber, boolean isMatchBonus) {
+        return Arrays.stream(Ranking.values())
+                .filter(ranking -> ranking.getMatchNumber() == matchNumber)
+                .filter(ranking -> ranking.getBonusMatch() == isMatchBonus)
+                .findAny()
+                .orElse(Ranking.NONE);
+    }
+
+    private Integer calculateMatchNumber(Lotto lotto) {
+        Lotto winningLottoNumbers = winningLotto.getLotto();
+        return (int) winningLottoNumbers.getNumbers()
+                .stream()
+                .filter(lotto::hasNumber)
+                .count();
+    }
+
+    private boolean hasBonusNumber(int matchNumber, Lotto lotto) {
+        if (matchNumber != THIRD_RANKING_NUMBER) {
+            return false;
+        }
+        BonusNumber bonusNumber = winningLotto.getBonusNumber();
+        return lotto.hasNumber(bonusNumber.getBonus());
+    }
+
+    public LottoResult getRankingsResult() {
+        return lottoResult;
+    }
+}