[로또] 손지현 미션 제출합니다.

docs/README.md

@@ -0,0 +1,57 @@
+# 로또 게임 기능 구현 정리
+
+-------
+## Controller
+* GameController 
+  * run : 게임 실행
+--------
+## Service
+* GameService
+  * start : 로또 구매금액을 만큼의 로또를 발급
+  * gameSetting : 당첨 번호와 보너스 번호를 입력 받음
+  * gameInProgress : 
+    * 입력 받은 당첨번호, 보너스 번호가 일치하는지 검증 
+  * result :
+    * 당첨금 확인 및 수익률 확인하여 출력
+--------
+## Domain
+* Game
+  * Game 진행을 위한 금액을 받는다.
+    * 로또 금액 검증
+        * 숫자 값으로만 이루어져 있는지 확인, 아닌 경우 예외 처리
+        * 1000의 배수인지 여부 확인, 아닌 경우 예외 처리
+  * 고객에게 로또 생성 후, 당첨 번호와 보너스 번호를 생성한다.
+    * 당첨 번호 리스트 검증
+        * 총 6개의 숫자 값인지, 1~45 사이의 숫자인, 중복 값이 없는지 확인
+            * 하나라도 맞지 않은 경우 예외 처리
+    * 보너스 번호 검증
+        * 숫자 값인지 1~45 사이의 숫자인지 당첨 번호 리스트와 중복되지 않은 값인지
+            * 하나라도 맞지 않은 경우 예외 처리
+* Lotto
+  * 한 장의 로또로 6개의 번호를 갖고 있다.
+    * 로또 번호가 생성될 때 총 6개의 숫자 값인지 중복 값은 없는지 검증한다.
+  * 당첨 번호와 비교하여 등수 안에 들 경우, 랭크를 저장한다.
+* Player
+  * 구매한 여러장의 로또를 갖고 있다.
+  * 당첨 번호를 받아 비교한다.
+  * 보너스 번호를 받아 비교한다.
+* Rank 
+  * 랭킹 정보를 갖고 있는 열거형 상수 값
+    * rankCount : 당첨된 등수 카운팅을 위한 맵 생성
+    * ranking : 일치하는 로또 번호 카운트에 따른 Rank 리턴을 위한 맵 생성
+
+
+-------
+## View
+* GameInput : 게임에 필요한 입력값
+* GameOutput : 게임에 필요한 출력값
+------
+## Util
+* Calculator : 숫자 관련 계산 기능
+* InputValidator : 입력값에 대한 검증 메서드
+------
+## Constant
+* Exception 메시지 정의
+* LottoGame 상수 정의 
+------
+입력에 대한 예외처리는 IllegalArgumentException 이다.

src/main/java/lotto/Application.java

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

src/main/java/lotto/constant/ExceptionMessage.java

@@ -0,0 +1,18 @@
+package lotto.constant;
+
+public enum ExceptionMessage {
+    AMOUNT_NUMBER_ERROR("[ERROR] 로또 구입 금액은 1000원 단위로 입력하셔야 합니다."),
+    LOTTO_NUMBER_ERROR("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다."),
+    LOTTO_NUMBER_VALID_ERROR("[ERROR] 로또 번호는 6개의 중복되지 않는 숫자를 입력 해주셔야 합니다."),
+    BONUS_NUMBER_ERROR("[ERROR] 보너스 번호는 1부터 45 사이의 중복되지 않는 숫자여야 합니다.");
+
+    ExceptionMessage(String message) {
+        this.message = message;
+    }
+
+    private final String message;
+
+    public String getMessage(){
+        return message;
+    }
+}

src/main/java/lotto/constant/LottoGame.java

@@ -0,0 +1,12 @@
+package lotto.constant;
+
+public class LottoGame {
+    public final static int LOTTO_PRICE = 1000;
+    public static final String REGEX = "[0-9]+";
+    public final static int LOTTO_NUMBER_COUNT = 6;
+    public final static int LOTTO_MIN_NUMBER = 1;
+    public final static int LOTTO_MAX_NUMBER = 45;
+
+    public final static int WIN_MIN_COUNT = 3;
+    public final static String DECIMAL_FORMAT = "%.1f";
+}

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

@@ -0,0 +1,19 @@
+package lotto.controller;
+
+import lotto.service.GameService;
+import lotto.view.GameOutput;
+
+public class GameController {
+    private static GameService gameService = new GameService();
+
+    public void run() {
+        gameService.start();
+        GameOutput.printBlankLine();
+        gameService.gameSetting();
+        GameOutput.printBlankLine();
+        gameService.gameInProgress();
+        GameOutput.printBlankLine();
+        gameService.result();
+
+    }
+}

src/main/java/lotto/domain/Game.java

@@ -0,0 +1,79 @@
+package lotto.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import lotto.constant.ExceptionMessage;
+import lotto.constant.LottoGame;
+import lotto.util.Calculator;
+import lotto.util.InputValidator;
+
+public class Game {
+    public static int receiveAmount;
+    private List<Integer> winningNumbers;
+    private int bonusNumber;
+
+    public Game(String receiveAmount) {
+        validateAmount(receiveAmount);
+        this.receiveAmount = Integer.parseInt(receiveAmount);
+    }
+
+    public Game setWinningNumbers(String enterNumbers) {
+        List<String> numbers = List.of(enterNumbers.split(","));
+        validWinningNubmers(numbers);
+
+        winningNumbers = numbers.stream()
+                .map(Integer::valueOf)
+                .sorted()
+                .collect(Collectors.toList());
+
+        return this;
+    }
+
+    public List<Integer> getWinningNumbers() {
+        return winningNumbers;
+    }
+
+    public Game setBonusNumber(String enterNumber){
+        validBonusNubmer(enterNumber);
+        bonusNumber = Integer.parseInt(enterNumber);
+        return this;
+    }
+
+    public int getBonusNumber() {
+        return bonusNumber;
+    }
+
+
+    public int lottoPurchaseCount(){
+        return Calculator.divide(receiveAmount, LottoGame.LOTTO_PRICE);
+    }
+
+    private void validateAmount(String amount) {
+        if(!InputValidator.isNumber(amount) || !Calculator.isMultiple(Integer.parseInt(amount), LottoGame.LOTTO_PRICE)){
+            throw new IllegalArgumentException(ExceptionMessage.AMOUNT_NUMBER_ERROR.getMessage());
+        }
+    }
+
+    private static void validWinningNubmers(List<String> enterWinningNumbers) {
+        if(!InputValidator.isCorrectCount(enterWinningNumbers.size()) || InputValidator.isDuplicateNumberForString(enterWinningNumbers)) {
+            throw new IllegalArgumentException(ExceptionMessage.LOTTO_NUMBER_VALID_ERROR.getMessage());
+        }
+
+        validWinningNubmer(enterWinningNumbers);
+    }
+
+    private static void validWinningNubmer(List<String> winningNumbers) {
+        for (var winningNumber : winningNumbers) {
+            if (!InputValidator.isNumber(winningNumber) || !InputValidator.isCorrectNumber(Integer.parseInt(winningNumber))) {
+                throw new IllegalArgumentException(ExceptionMessage.LOTTO_NUMBER_ERROR.getMessage());
+            }
+        }
+    }
+
+    private void validBonusNubmer(String bonusNumber) {
+        if(!InputValidator.isNumber(bonusNumber)
+                || !InputValidator.isCorrectNumber(Integer.parseInt(bonusNumber)) || winningNumbers.contains(bonusNumber)){
+            throw new IllegalArgumentException(ExceptionMessage.BONUS_NUMBER_ERROR.getMessage());
+        }
+    }
+}

src/main/java/lotto/domain/Lotto.java

@@ -0,0 +1,47 @@
+package lotto.domain;
+
+import java.util.List;
+import lotto.constant.ExceptionMessage;
+import lotto.constant.LottoGame;
+import lotto.util.InputValidator;
+
+public class Lotto {
+    private final List<Integer> numbers;
+    private Rank rank;
+
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        this.numbers = numbers;
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+    private void validate(List<Integer> numbers) {
+        if (!InputValidator.isCorrectCount(numbers.size()) || InputValidator.isDuplicateNumber(numbers)) {
+            throw new IllegalArgumentException(ExceptionMessage.LOTTO_NUMBER_ERROR.getMessage());
+        }
+    }
+
+    public void setRank(int count) {
+        if(count >= LottoGame.WIN_MIN_COUNT) {
+            rank = Rank.getRank(count);
+            Rank.addRankCount(rank);
+        }
+    }
+
+    public Rank getRank() {
+        return rank;
+    }
+
+
+    public void matchBonusNumber(int bonusNumber) {
+        if(rank == Rank.THIRD && numbers.contains(bonusNumber)) {
+            Rank.minusThirdRankCount();
+            rank = Rank.SECOND;
+            Rank.addRankCount(rank);
+        }
+    }
+}

src/main/java/lotto/domain/Player.java

@@ -0,0 +1,59 @@
+package lotto.domain;
+
+
+import camp.nextstep.edu.missionutils.Randoms;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import lotto.constant.LottoGame;
+import lotto.util.Calculator;
+
+public class Player {
+    public final List<Lotto> lottos;
+
+    public Player(int purchaseCount) {
+        this.lottos = receiveLotto(purchaseCount);
+    }
+
+    private List<Lotto> receiveLotto(int purchaseCount) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < purchaseCount; i++) {
+            lottos.add(new Lotto(makeNumbers()));
+        }
+        return lottos;
+    }
+
+    private List<Integer> makeNumbers() {
+        return Randoms.pickUniqueNumbersInRange(LottoGame.LOTTO_MIN_NUMBER, LottoGame.LOTTO_MAX_NUMBER,
+                        LottoGame.LOTTO_NUMBER_COUNT)
+                .stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+
+    public List<Lotto> checkMatchWinningNumber(List<Integer> winningNumbers) {
+        List<Integer> matchList;
+        for (var lotto : lottos) {
+            matchList = lotto.getNumbers().stream()
+                    .filter(number -> winningNumbers.stream()
+                            .anyMatch(Predicate.isEqual(number)))
+                    .collect(Collectors.toList());
+
+            lotto.setRank(matchList.size());
+            matchList.clear();
+        }
+        return lottos;
+    }
+
+    public void checkMatchBonusNumber(int bonusNumber) {
+        for (var lotto : lottos) {
+            lotto.matchBonusNumber(bonusNumber);
+        }
+    }
+
+    public String getEarningRate(double amount) {
+        double rate = Calculator.percentage(Rank.getTotalEarning(), amount);
+        return Calculator.rounds(rate);
+    }
+}