Final

docs/README.md

@@ -0,0 +1,20 @@
+기능 구현 목록
+
+## 기능 구현 목록
+
+기능 목록
+
+- 로또를 구매 한다
+    - 구입 금액을 입력
+        - 음수, 0, 또는 1,000으로 나누어 떨어지지 않는 값을 입력하면 예외 발생
+    - 구매한 로또를 출력함
+- 당첨 번호를 입력한다.
+    - 당첨 번호는 6자리를, 보너스 번호는 1자리를 입력
+        - 당첨 번호가 서로 중복될 경우 예외 발생
+        - 보너스 번호가 당첨 번호와 중복될 경우 예외 발생
+        - 로또 숫자들이 정해진 범위 (1 ~ 45)를 벗어나면 예외 발생
+- 결과를 출력한다.
+    - 당첨 통계
+        - n개 일치 (%d원) - %d개
+    - 수익률
+        - 총 수익률은 %f원 입니다.

src/main/java/lotto/Application.java

@@ -2,6 +2,7 @@
 
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        LottoController lottoController = new LottoController();
+        lottoController.run();
     }
 }

src/main/java/lotto/LottoController.java

@@ -0,0 +1,84 @@
+package lotto;
+
+import java.math.BigDecimal;
+import java.util.List;
+import lotto.domain.lotto.LottoService;
+import lotto.domain.lotto.entity.Lotto;
+import lotto.domain.lotto.entity.LottoAnswer;
+import lotto.domain.lotto.entity.LottoResultCount;
+import lotto.domain.lotto.entity.Lottos;
+import lotto.domain.lotto.generator.RandomLottoGenerator;
+import lotto.domain.lotto.money.Money;
+import lotto.exception.RetryExceptionHandler;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+public class LottoController {
+    public static final BigDecimal PERCENT_DECIMAL = new BigDecimal(100);
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+    private final RetryExceptionHandler handler = new RetryExceptionHandler();
+    private final LottoService lottoService = new LottoService(new RandomLottoGenerator());
+
+    void run() {
+        //로또 구입
+        Money purchaseMoney = getPurchaseMoney();
+        Lottos lottos = purchaseLotto(purchaseMoney);
+        printPurchasedLotto(lottos);
+
+        //정답 생성
+        LottoAnswer answer = getLottoAnswer();
+
+        //결과 출력
+        LottoResultCount results = lottos.getResults(answer);
+        printResult(results);
+        printRevenu(purchaseMoney, results);
+    }
+
+    private void printRevenu(Money purchaseMoney, LottoResultCount results) {
+        BigDecimal initMoney = purchaseMoney.toBigDecimal();
+        BigDecimal totalPrize = results.getTotalPrize();
+        outputView.printRevenue(totalPrize.divide(initMoney).multiply(PERCENT_DECIMAL));
+    }
+
+    private void printResult(LottoResultCount results) {
+        outputView.printResults(results);
+    }
+
+    private Money getPurchaseMoney() {
+        return handler.get(() -> {
+            int purchaseMoney = inputView.getPurchaseMoney();
+            return Money.nonZeroMoney(purchaseMoney);
+        });
+
+    }
+
+    private Lottos purchaseLotto(Money purchaseMoney) {
+        return lottoService.purchaseLottos(purchaseMoney);
+    }
+
+    private LottoAnswer getLottoAnswer() {
+        Lotto lotto = getLottoUsingInput();
+        return generateLottoAnswer(lotto);
+    }
+
+    private LottoAnswer generateLottoAnswer(Lotto lotto) {
+        return handler.get(() -> {
+                    int bonusNumber = inputView.getBonusNumber();
+                    return new LottoAnswer(lotto, bonusNumber);
+                }
+        );
+    }
+
+    private Lotto getLottoUsingInput() {
+        return handler.get(() -> {
+                    List<Integer> lottoNumbers = inputView.getLottoNumbers();
+                    return new Lotto(lottoNumbers);
+                }
+        );
+    }
+
+    private void printPurchasedLotto(Lottos lottos) {
+        outputView.printPurchasedLotto(lottos);
+    }
+}

src/main/java/lotto/domain/lotto/LottoService.java

@@ -0,0 +1,33 @@
+package lotto.domain.lotto;
+
+import java.util.ArrayList;
+import java.util.List;
+import lotto.domain.lotto.entity.Lotto;
+import lotto.domain.lotto.entity.Lottos;
+import lotto.domain.lotto.generator.LottoGenerator;
+import lotto.domain.lotto.money.Cash;
+import lotto.domain.lotto.money.Money;
+
+public class LottoService {
+
+    public static final int LOTTO_PRICE = 1000;
+    private final LottoGenerator lottoGenerator;
+
+    public LottoService(LottoGenerator lottoGenerator) {
+        this.lottoGenerator = lottoGenerator;
+    }
+
+    public Lottos purchaseLottos(Money money) {
+        List<Lotto> lottos = new ArrayList<>();
+        Cash cash = money.toCash();
+        while (cash.canPurchase(LOTTO_PRICE)) {
+            lottos.add(generateLotto());
+            cash.spend(LOTTO_PRICE);
+        }
+        return new Lottos(lottos);
+    }
+
+    public Lotto generateLotto() {
+        return lottoGenerator.generate();
+    }
+}

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

@@ -0,0 +1,62 @@
+package lotto.domain.lotto.entity;
+
+import java.util.List;
+import lotto.exception.LottoException;
+
+public class Lotto {
+    private final List<LottoNumber> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        this.numbers = numbers.stream()
+                .map(LottoNumber::new)
+                .sorted()
+                .toList();
+    }
+
+    private void validate(List<Integer> numbers) {
+        validateSize(numbers);
+        validateDuplication(numbers);
+    }
+
+    private void validateDuplication(List<Integer> numbers) {
+        int distinctSize = (int) numbers.stream()
+                .distinct()
+                .count();
+        if (distinctSize != numbers.size()) {
+            throw LottoException.LOTTO_SIZE_EXCEPTION.makeException();
+        }
+    }
+
+    private static void validateSize(List<Integer> numbers) {
+        if (numbers.size() != 6) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    // TODO: 추가 기능 구현
+    public int getSameNumberCount(Lotto lotto) {
+        return (int) this.numbers.stream()
+                .filter(lotto.numbers::contains)
+                .count();
+    }
+
+    public boolean hasNumber(LottoNumber number) {
+        return this.numbers.contains(number);
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers.stream()
+                .map(LottoNumber::getNumber)
+                .toList();
+    }
+
+
+    @Override
+    public String toString() {
+        return numbers.stream()
+                .map(LottoNumber::getNumber)
+                .toList()
+                .toString();
+    }
+}

src/main/java/lotto/domain/lotto/entity/LottoAnswer.java

@@ -0,0 +1,28 @@
+package lotto.domain.lotto.entity;
+
+import lotto.exception.LottoException;
+
+public class LottoAnswer {
+    private final Lotto lotto;
+    private final LottoNumber bonusNumber;
+
+    public LottoAnswer(Lotto lotto, int bonusNumber) {
+        this.lotto = lotto;
+        this.bonusNumber = new LottoNumber(bonusNumber);
+        validate();
+    }
+
+    private void validate() {
+        if (this.lotto.hasNumber(this.bonusNumber)) {
+            throw LottoException.LOTTO_DUPLICATED_BONUS_NUMBER.makeException();
+        }
+    }
+
+    public int getSameNumberCount(Lotto lotto) {
+        return lotto.getSameNumberCount(this.lotto);
+    }
+
+    public boolean matchesBonusNumber(Lotto lotto) {
+        return lotto.hasNumber(this.bonusNumber);
+    }
+}

src/main/java/lotto/domain/lotto/entity/LottoNumber.java

@@ -0,0 +1,48 @@
+package lotto.domain.lotto.entity;
+
+import java.util.Objects;
+import lotto.exception.LottoException;
+
+public class LottoNumber implements Comparable<LottoNumber> {
+
+    public static final int LOTTO_RANGE_MAX = 45;
+    public static final int LOTTO_RANGE_MIN = 1;
+    private final int number;
+
+    public LottoNumber(int number) {
+        validateNumberRange(number);
+        this.number = number;
+    }
+
+    private void validateNumberRange(int number) {
+        if (number < LOTTO_RANGE_MIN || number > LOTTO_RANGE_MAX) {
+            throw LottoException.LOTTO_NUMBER_OUT_RANGE.makeException();
+        }
+    }
+
+    @Override
+    public int compareTo(LottoNumber o) {
+        return this.number - o.number;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        LottoNumber that = (LottoNumber) o;
+        return number == that.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(number);
+    }
+}

src/main/java/lotto/domain/lotto/entity/LottoResult.java

@@ -0,0 +1,71 @@
+package lotto.domain.lotto.entity;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.function.BiPredicate;
+
+public enum LottoResult {
+    LOSE(new BigDecimal(0), 0, MatchBonusNumber.IGNORE),
+    FIFTH(new BigDecimal(5_000), 3, MatchBonusNumber.IGNORE),
+    FOURTH(new BigDecimal(50_000), 4, MatchBonusNumber.IGNORE),
+    THIRD(new BigDecimal(1_500_000), 5, MatchBonusNumber.NOT_MATCH),
+    SECOND(new BigDecimal(30_000_000), 5, MatchBonusNumber.MATCH),
+    FIRST(new BigDecimal(2_000_000_000), 6, MatchBonusNumber.IGNORE),
+    ;
+
+    private enum MatchBonusNumber {
+        MATCH(LottoAnswer::matchesBonusNumber),
+        NOT_MATCH(((lottoAnswer, lotto) -> !lottoAnswer.matchesBonusNumber(lotto))),
+        IGNORE((lottoAnswer, lotto) -> true),
+        ;
+
+        private final BiPredicate<LottoAnswer, Lotto> matchBonusNumber;
+
+        MatchBonusNumber(BiPredicate<LottoAnswer, Lotto> matchBonusNumber) {
+            this.matchBonusNumber = matchBonusNumber;
+        }
+
+        public boolean checkBonusNumber(LottoAnswer lottoAnswer, Lotto lotto) {
+            return this.matchBonusNumber.test(lottoAnswer, lotto);
+        }
+    }
+
+    private final BigDecimal prize;
+    private final int sameCount;
+    private final MatchBonusNumber matchBonusNumber;
+
+    LottoResult(BigDecimal prize, int sameCount, MatchBonusNumber matchBonusNumber) {
+        this.prize = prize;
+        this.sameCount = sameCount;
+        this.matchBonusNumber = matchBonusNumber;
+    }
+
+    public static LottoResult getResult(LottoAnswer lottoAnswer, Lotto lotto) {
+        return Arrays.stream(LottoResult.values())
+                .filter(result -> result.matchesSameNumberCount(lottoAnswer, lotto))
+                .filter(result -> result.checkBonusNumber(lottoAnswer, lotto))
+                .findFirst()
+                .orElse(LOSE);
+    }
+
+    private boolean matchesSameNumberCount(LottoAnswer lottoAnswer, Lotto lotto) {
+        int sameNumberCount = lottoAnswer.getSameNumberCount(lotto);
+        return this.sameCount == sameNumberCount;
+    }
+
+    private boolean checkBonusNumber(LottoAnswer lottoAnswer, Lotto lotto) {
+        return this.matchBonusNumber.checkBonusNumber(lottoAnswer, lotto);
+    }
+
+    public BigDecimal getPrize() {
+        return prize;
+    }
+
+    public BigDecimal getTotalPrize(int count) {
+        return this.prize.multiply(new BigDecimal(count));
+    }
+
+    public int getSameCount() {
+        return sameCount;
+    }
+}