로또 미션 [sjiwon]

docs/README.md

@@ -0,0 +1,90 @@
+## Feature
+
+- [X] User는 `1000원` 단위로 로또 N장을 구매한다
+    - 구매 후 로또 생성기로부터 N장의 로또를 생성한다
+        - `1000원` 단위로 입력하지 않을 경우 `IllegalArgumentException`를 발생시키고 `[Error]`로 시작하는 에러 메시지를 출력 후 `종료`한다
+
+- [X] LottoWinningMachine은 로또 당첨 번호를 생성한다
+    - 총 7개의 중복되지 않는 숫자 (기본 당첨 번호 6개 + 보너스 번호 1개)
+
+- [X] LottoStatistics는 N장의 로또에 대한 당첨 통계를 산출한다
+
+<br>
+<hr>
+
+## Model
+
+### `Lotto`
+
+- 로또 번호 List를 추상화시킨 모델
+    - [X] 로또 번호는 1..45 범위 안에 존재해야 한다
+    - [X] 각 번호들은 중복되지 않아야 한다
+
+### `UserLotto`
+
+- `1000원` 단위의 로또 N장을 구매하는 컴포넌트
+    - `List<Lotto>`
+
+### `LottoWinningMachine`
+
+- 로또 당첨 번호 6개 + 보너스 번호를 생성하는 컴포넌트
+
+### `BonusNumber`
+
+- `보너스 번호`에 대한 컴포넌트
+
+### `WinningRank`
+
+- 당첨과 관련된 순위를 표현하는 컴포넌트
+
+### `LottoStatistics`
+
+- 로또 당첨 내역 및 수익률을 산출하기 위한 통계용 컴포넌트
+
+<br>
+<hr>
+
+## Utils
+
+### `ExceptionConstants`
+
+- 전역 예외 메시지 통합 컴포넌트
+
+### `LottoConstants`
+
+- Lotto 숫자 범위 & 전체 사이즈 관련 상수 전용 컴포넌트
+
+### `LottoRandomGenerator`
+
+- 로또 번호 자동 생성기
+
+### `Validator`
+
+- 사용자 Input에 대한 기본 검증 컴포넌트
+  - `LottoPurchaseAmountValidator` -> 로또 구입금액 검증 컴포넌트
+  - `WinningNumberValidator` -> 로또 당첨번호 검증 컴포넌트
+  - `BonusNumberValidator` -> 보너스 번호 검증 컴포넌트
+
+<br>
+<hr>
+
+## View
+
+### `InputView`
+
+- 사용자 Input을 받기 위한 컴포넌트
+
+### `OutputView`
+
+- 로또 게임 진행과 관련된 출력 컴포넌트
+
+<br>
+<hr>
+
+## Controller
+
+### `GameController`
+
+- 로또 게임 진행과 관련된 컨트롤러
+
+<br>

src/main/java/lotto/Application.java

@@ -1,7 +1,9 @@
 package lotto;
 
+import lotto.controller.GameController;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        new GameController().run();
     }
 }

src/main/java/lotto/controller/GameController.java

@@ -0,0 +1,41 @@
+package lotto.controller;
+
+import lotto.model.LottoStatistics;
+import lotto.model.LottoWinningMachine;
+import lotto.model.UserLotto;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+import java.util.List;
+
+public class GameController {
+    private static UserLotto userLotto;
+    private static LottoWinningMachine lottoWinningMachine;
+
+    public void run() {
+        try {
+            buyLotto();
+            initLottoWinningMachine();
+            displayLottoResult();
+        } catch (IllegalArgumentException e) {
+            OutputView.printErrorMessage(e.getMessage());
+        }
+    }
+
+    private void buyLotto() {
+        final int lottoPurchaseCount = InputView.readLottoPurchaseCount();
+        userLotto = UserLotto.issueLottoByPurchaseCount(lottoPurchaseCount);
+        OutputView.printPurchaseInformation(userLotto.getUserLottos());
+    }
+
+    private void initLottoWinningMachine() {
+        final List<Integer> winingNumbers = InputView.readWiningNumbers();
+        final int bonusNumber = InputView.readBonusNumber();
+        lottoWinningMachine = LottoWinningMachine.drawWinningLottery(winingNumbers, bonusNumber);
+    }
+
+    private void displayLottoResult() {
+        final LottoStatistics lottoStatistics = LottoStatistics.checkLotteryResult(lottoWinningMachine, userLotto);
+        OutputView.printWinningStatistics(lottoStatistics);
+    }
+}

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

@@ -0,0 +1,28 @@
+package lotto.model;
+
+import static lotto.utils.ExceptionConstants.LottoMachineException.BONUS_NUMBER_IS_NOT_IN_RANGE;
+import static lotto.utils.LottoConstants.MAX_VALUE;
+import static lotto.utils.LottoConstants.MIN_VALUE;
+
+public class BonusNumber {
+    private final int value;
+
+    public BonusNumber(final int value) {
+        validateBonusNumberIsInRange(value);
+        this.value = value;
+    }
+
+    private void validateBonusNumberIsInRange(final int value) {
+        if (isOutOfRange(value)) {
+            throw new IllegalArgumentException(BONUS_NUMBER_IS_NOT_IN_RANGE.message);
+        }
+    }
+
+    private boolean isOutOfRange(final int value) {
+        return value < MIN_VALUE || value > MAX_VALUE;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

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

@@ -0,0 +1,58 @@
+package lotto.model;
+
+import java.util.Collections;
+import java.util.List;
+
+import static java.util.Collections.sort;
+import static lotto.utils.ExceptionConstants.LottoException.*;
+import static lotto.utils.LottoConstants.*;
+
+public class Lotto {
+    private final List<Integer> numbers;
+
+    public Lotto(final List<Integer> numbers) {
+        validateEachLottoElementIsInRange(numbers);
+        validateTotalLottoSize(numbers);
+        validateLottoHasDuplicateElement(numbers);
+        sort(numbers);
+        this.numbers = numbers;
+    }
+
+    private void validateEachLottoElementIsInRange(final List<Integer> numbers) {
+        if (hasOutOfRange(numbers)) {
+            throw new IllegalArgumentException(LOTTO_NUMBER_IS_NOT_IN_RANGE.message);
+        }
+    }
+
+    private boolean hasOutOfRange(final List<Integer> numbers) {
+        return numbers.stream()
+                .anyMatch(number -> number < MIN_VALUE || number > MAX_VALUE);
+    }
+
+    private void validateTotalLottoSize(final List<Integer> numbers) {
+        if (numbers.size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException(LOTTO_SIZE_IS_NOT_FULFILL.message);
+        }
+    }
+
+    private void validateLottoHasDuplicateElement(final List<Integer> numbers) {
+        if (hasDuplicateNumber(numbers)) {
+            throw new IllegalArgumentException(LOTTO_NUMBER_MUST_BE_UNIQUE.message);
+        }
+    }
+
+    private boolean hasDuplicateNumber(final List<Integer> number) {
+        return number.stream()
+                .distinct()
+                .count() != LOTTO_SIZE;
+    }
+
+    public List<Integer> getNumbers() {
+        return Collections.unmodifiableList(numbers);
+    }
+
+    @Override
+    public String toString() {
+        return numbers.toString();
+    }
+}

src/main/java/lotto/model/LottoStatistics.java

@@ -0,0 +1,104 @@
+package lotto.model;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoStatistics {
+    private final LottoWinningMachine lottoWinningMachine;
+    private final UserLotto userLotto;
+    private final Map<WinningRank, Integer> winningResult = new EnumMap<>(WinningRank.class);
+
+    private LottoStatistics(
+            final LottoWinningMachine lottoWinningMachine,
+            final UserLotto userLotto
+    ) {
+        this.lottoWinningMachine = lottoWinningMachine;
+        this.userLotto = userLotto;
+        initWinningResult();
+        calculateLotteryWinningResult();
+    }
+
+    public static LottoStatistics checkLotteryResult(
+            final LottoWinningMachine lottoWinningMachine,
+            final UserLotto userLotto
+    ) {
+        return new LottoStatistics(lottoWinningMachine, userLotto);
+    }
+
+    private void initWinningResult() {
+        for (WinningRank winningRank : WinningRank.values()) {
+            winningResult.put(winningRank, 0);
+        }
+    }
+
+    private void calculateLotteryWinningResult() {
+        List<Integer> winningLotteryNumbers = lottoWinningMachine.getWinningLotteryNumbers();
+        int bonusNumber = lottoWinningMachine.getBonusNumber();
+
+        for (Lotto lotto : userLotto.getUserLottos()) {
+            List<Integer> lottoNumbers = lotto.getNumbers();
+            int matchCount = getLottoMatchCount(lottoNumbers, winningLotteryNumbers);
+            boolean hasBonus = isBonusNumberExists(lottoNumbers, bonusNumber);
+
+            WinningRank winningRank = WinningRank.of(matchCount, hasBonus);
+            updateWinningResult(winningRank);
+        }
+    }
+
+    private int getLottoMatchCount(
+            final List<Integer> lottoNumbers,
+            final List<Integer> winningLotteryNumbers
+    ) {
+        return (int) lottoNumbers.stream()
+                .filter(winningLotteryNumbers::contains)
+                .count();
+    }
+
+    private boolean isBonusNumberExists(
+            final List<Integer> lottoNumbers,
+            final int bonusNumber
+    ) {
+        return lottoNumbers.contains(bonusNumber);
+    }
+
+    private void updateWinningResult(final WinningRank winningRank) {
+        winningResult.put(winningRank, winningResult.get(winningRank) + 1);
+    }
+
+    public Map<WinningRank, Integer> getWinningResult() {
+        return Collections.unmodifiableMap(winningResult);
+    }
+
+    public int getWinningCountByRank(final WinningRank winningRank) {
+        return winningResult.getOrDefault(winningRank, 0);
+    }
+
+    public BigDecimal getEarningRate() {
+        final BigDecimal lottoPurchaseAmount = userLotto.getLottoPurchaseAmount();
+        final BigDecimal totalWinningAmount = calculateTotalWinningAmount();
+
+        return totalWinningAmount
+                .multiply(BigDecimal.valueOf(100)) // 백분율
+                .divide(lottoPurchaseAmount, 1, RoundingMode.HALF_UP);
+    }
+
+    private BigDecimal calculateTotalWinningAmount() {
+        BigDecimal amount = BigDecimal.ZERO;
+        for (WinningRank winningRank : winningResult.keySet()) {
+            final BigDecimal addPrize = getAddPrize(winningRank);
+            amount = amount.add(addPrize);
+        }
+        return amount;
+    }
+
+    private BigDecimal getAddPrize(final WinningRank winningRank) {
+        final int reward = winningRank.getReward();
+        final int count = winningResult.get(winningRank);
+
+        return BigDecimal.valueOf((long) reward * count);
+    }
+}