[로또 main2] 박찬호 제출합니다.

src/main/java/lotto/Application.java

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

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

@@ -0,0 +1,31 @@
+package lotto.controller;
+
+import lotto.domain.*;
+
+import java.util.List;
+
+import static lotto.view.Input.*;
+import static lotto.view.Output.*;
+
+public class LottoController {
+
+    private final LottoMachine lottoMachine;
+
+    public LottoController(LottoMachine lottoMachine) {
+        this.lottoMachine = lottoMachine;
+    }
+
+    public void start() {
+        try {
+            LottoMoney money = new LottoMoney(insertLottoMoney());
+            Lottos lottos = lottoMachine.createLottos(money, insertManualLottoCount());
+            printLottos(lottos);
+            List<WinningNumber> winningNumbers = lottoMachine.createWinningNumbers(insertNormalWinningNumbers(), insertBonusWinningNumber());
+            LottoResult lottoResult = lottoMachine.computeLottoResult(lottos, winningNumbers);
+            printLottoResult(lottoResult, money);
+        } catch (IllegalArgumentException error) {
+            printErrorMessage(error.getMessage());
+        }
+    }
+
+}

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

@@ -0,0 +1,35 @@
+package lotto.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Lotto {
+    private final int MINIMUM_LOTTO_NUMBER = 1;
+    private final int MAXIMUM_LOTTO_NUMBER = 45;
+    private final int LOTTO_TOTAL_COUNT = 6;
+
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        this.numbers = numbers.stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+
+    public Lotto() {
+        this.numbers = Randoms.pickUniqueNumbersInRange(MINIMUM_LOTTO_NUMBER, MAXIMUM_LOTTO_NUMBER, LOTTO_TOTAL_COUNT)
+                .stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+
+    public List<Integer> getNumbers() {
+        return this.numbers;
+    }
+
+    public boolean checkContainWinningNumber(Integer winningNumber) {
+        return numbers.contains(winningNumber);
+    }
+}

src/main/java/lotto/domain/LottoFactory.java

@@ -0,0 +1,14 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class LottoFactory {
+
+    public Lotto createManualLotto(List<Integer> numbers) {
+        return new Lotto(numbers);
+    }
+
+    public Lotto createAutoLotto() {
+        return new Lotto();
+    }
+}

src/main/java/lotto/domain/LottoMachine.java

@@ -0,0 +1,123 @@
+package lotto.domain;
+
+import lotto.domain.enumeration.NumberType;
+import lotto.domain.enumeration.Ranking;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static lotto.domain.enumeration.Ranking.*;
+import static lotto.view.Input.insertLottoNumbers;
+import static lotto.view.Output.printInsertManualLottoNumbersRequest;
+
+public class LottoMachine {
+    private final LottoFactory lottoFactory;
+
+    public LottoMachine(LottoFactory lottoFactory) {
+        this.lottoFactory = lottoFactory;
+    }
+
+    public Lottos createLottos(LottoMoney money, int manualLottoCount) {
+        List<Lotto> manualLottos = createManualLottos(manualLottoCount);
+        List<Lotto> autoLottos = createAutoLottos(money.getTotalLottoCount() - manualLottos.size());
+
+        return new Lottos(manualLottos, autoLottos);
+    }
+
+    private List<Lotto> createManualLottos(int manualLottoCount) {
+        List<Lotto> manualLottos = new ArrayList<>();
+        printInsertManualLottoNumbersRequest();
+        for (int i = 0; i < manualLottoCount; i++) {
+            List<Integer> numbers = insertLottoNumbers();
+            Lotto manualLotto = lottoFactory.createManualLotto(numbers);
+            manualLottos.add(manualLotto);
+        }
+
+        return manualLottos;
+    }
+
+    private List<Lotto> createAutoLottos(int autoLottoCount) {
+        List<Lotto> autoLottos = new ArrayList<>();
+        for (int i = 0; i < autoLottoCount; i++) {
+            Lotto autoLotto = lottoFactory.createAutoLotto();
+            autoLottos.add(autoLotto);
+        }
+
+        return autoLottos;
+    }
+
+    public List<WinningNumber> createWinningNumbers(List<Integer> normalNumbers, Integer bonusNumber) {
+        List<WinningNumber> totalWinningNumbers = new ArrayList<>();
+        List<WinningNumber> normalWinningNumbers = createNormalWinningNumbers(normalNumbers);
+        WinningNumber bonusWinningNumber = createBonusNumber(bonusNumber);
+
+        totalWinningNumbers.addAll(normalWinningNumbers);
+        totalWinningNumbers.add(bonusWinningNumber);
+
+        return totalWinningNumbers;
+    }
+
+    private List<WinningNumber> createNormalWinningNumbers(List<Integer> normalNumbers) {
+        List<WinningNumber> result = new ArrayList<>();
+        for (Integer number : normalNumbers) {
+            WinningNumber normalNumber = new WinningNumber(number, NumberType.NORMAL);
+            result.add(normalNumber);
+        }
+        return result;
+    }
+
+    private WinningNumber createBonusNumber(Integer bonusNumber) {
+        return new WinningNumber(bonusNumber, NumberType.BOUNS);
+    }
+
+    public LottoResult computeLottoResult(Lottos lottos, List<WinningNumber> winningNumbers) {
+        Map<Ranking, Integer> winningInfo = new HashMap<>();
+
+        for (Lotto lotto : lottos.getLottos()) {
+            Ranking ranking = determineRanking(lotto, winningNumbers);
+            winningInfo.put(ranking, winningInfo.getOrDefault(ranking, 0) + 1);
+        }
+        return new LottoResult(winningInfo);
+    }
+
+    private Ranking determineRanking(Lotto lotto, List<WinningNumber> winningNumbers) {
+        int equalNormalNumberCount = getEqualCount(lotto, winningNumbers);
+        boolean isBonusEqual = checkBonusEqual(lotto, winningNumbers);
+
+        return Ranking.create(equalNormalNumberCount, isBonusEqual);
+    }
+
+    private int getEqualCount(Lotto lotto, List<WinningNumber> winningNumbers) {
+        return (int) winningNumbers.stream()
+                .map(WinningNumber::getNumber)
+                .filter(lotto::checkContainWinningNumber)
+                .count();
+    }
+
+    private boolean checkBonusEqual(Lotto lotto, List<WinningNumber> winningNumbers) {
+        return lotto.getNumbers()
+                .contains(
+                        winningNumbers.stream()
+                                .filter(WinningNumber::isBonus)
+                                .map(WinningNumber::getNumber)
+                                .findFirst().get()
+                );
+    }
+
+    public static Double calculateProfit(LottoResult lottoResult, LottoMoney money) {
+        Map<Ranking, Integer> winningInfo = lottoResult.getWinningInfo();
+        Long value = sum(winningInfo);
+
+        return (double) value / (double) money.getPrice();
+    }
+
+    private static Long sum(Map<Ranking, Integer> winningInfo) {
+        return winningInfo.getOrDefault(FIFTH,0) * FIFTH.getPrizeMoney()
+                + winningInfo.getOrDefault(FORTH, 0) * FORTH.getPrizeMoney()
+                + winningInfo.getOrDefault(THIRD, 0) * THIRD.getPrizeMoney()
+                + winningInfo.getOrDefault(SECOND, 0) * SECOND.getPrizeMoney()
+                + winningInfo.getOrDefault(FIRST, 0) * FIRST.getPrizeMoney();
+    }
+}

src/main/java/lotto/domain/LottoMoney.java

@@ -0,0 +1,30 @@
+package lotto.domain;
+
+public class LottoMoney {
+    private final String MONEY_MUST_OVER_1000 = "구매 금액은 1000원 이상을 입력해주세요.";
+    private final String MONEY_UNIT_IS_1000 = "구매 금액은 1000원 단위로 입력해주세요.";
+    private final int LOTTO_PRICE_UNIT = 1000;
+    private final int price;
+
+    public LottoMoney(int price) {
+        validatePrice(price);
+        this.price = price;
+    }
+
+    private void validatePrice(int price) {
+        if (price < LOTTO_PRICE_UNIT) {
+            throw new IllegalArgumentException(MONEY_MUST_OVER_1000);
+        }
+        if (price % LOTTO_PRICE_UNIT != 0) {
+            throw new IllegalArgumentException(MONEY_UNIT_IS_1000);
+        }
+    }
+
+    public int getPrice() {
+        return price;
+    }
+
+    public int getTotalLottoCount() {
+        return price / LOTTO_PRICE_UNIT;
+    }
+}

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

@@ -0,0 +1,17 @@
+package lotto.domain;
+
+import lotto.domain.enumeration.Ranking;
+
+import java.util.Map;
+
+public class LottoResult {
+    private final Map<Ranking, Integer> winningInfo;
+
+    public LottoResult(Map<Ranking, Integer> winningInfo) {
+        this.winningInfo = winningInfo;
+    }
+
+    public Map<Ranking, Integer> getWinningInfo() {
+        return this.winningInfo;
+    }
+}

src/main/java/lotto/domain/Lottos.java

@@ -0,0 +1,32 @@
+package lotto.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lottos {
+    private List<Lotto> lottos;
+    private Integer manualLottoCount;
+    private Integer autoLottoCount;
+
+    public Lottos(List<Lotto> manualLottos, List<Lotto> autoLottos) {
+        List<Lotto> lottos = new ArrayList<>();
+        lottos.addAll(manualLottos);
+        lottos.addAll(autoLottos);
+
+        this.lottos = lottos;
+        this.manualLottoCount = manualLottos.size();
+        this.autoLottoCount = autoLottos.size();
+    }
+
+    public int getManualLottoCount() {
+        return manualLottoCount;
+    }
+
+    public int getAutoLottoCount() {
+        return autoLottoCount;
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+}

src/main/java/lotto/domain/WinningNumber.java

@@ -0,0 +1,22 @@
+package lotto.domain;
+
+import lotto.domain.enumeration.NumberType;
+
+public class WinningNumber {
+    private final Integer number;
+    private final NumberType type;
+
+    public WinningNumber(Integer number, NumberType type) {
+        this.number = number;
+        this.type = type;
+    }
+
+    public Integer getNumber() {
+        return number;
+    }
+
+    public boolean isBonus() {
+        return type == NumberType.BOUNS;
+    }
+
+}

src/main/java/lotto/domain/enumeration/NumberType.java

@@ -0,0 +1,6 @@
+package lotto.domain.enumeration;
+
+public enum NumberType {
+    BOUNS,
+    NORMAL
+}

src/main/java/lotto/domain/enumeration/Ranking.java

@@ -0,0 +1,46 @@
+package lotto.domain.enumeration;
+
+import java.util.Arrays;
+
+public enum Ranking {
+
+    FIRST(2_000_000_000L,6,false),
+    SECOND(30_000_000L, 5, true),
+    THIRD(1_500_000L, 5, false),
+    FORTH(50_000L, 4, false),
+    FIFTH(5_000L, 3, false),
+    NON_WINNER(0L, 0, false);
+
+    private final Long prizeMoney;
+    private final int equalCount;
+    private final boolean containBonus;
+    private static final int CHECK_SECOND_OR_THIRD_CONDITION = 5;
+
+    Ranking(Long prizeMoney, int equalCount, boolean containBonus) {
+        this.equalCount = equalCount;
+        this.prizeMoney = prizeMoney;
+        this.containBonus = containBonus;
+    }
+
+    public static Ranking create(int equalCount, boolean isBonusContain) {
+        if (equalCount == CHECK_SECOND_OR_THIRD_CONDITION) {
+            return getSecondOrThird(isBonusContain);
+        }
+
+        return Arrays.stream(Ranking.values())
+                .filter(ranking -> ranking.equalCount == equalCount)
+                .findFirst()
+                .orElse(NON_WINNER);
+    }
+
+    private static Ranking getSecondOrThird(boolean isBonusContain) {
+        if (isBonusContain){
+            return Ranking.SECOND;
+        }
+        return Ranking.THIRD;
+    }
+
+    public Long getPrizeMoney() {
+        return this.prizeMoney;
+    }
+}