[2단계 - 로또(수동)] 오찌(오지훈) 미션 제출합니다.

src/main/java/controller/LottoController.java

@@ -1,64 +1,127 @@
 package controller;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import model.Lotto;
 import model.LottoFactory;
+import model.LottoOrder;
 import model.LottoPurchasingMoney;
 import model.LottoRank;
 import model.WinningLotto;
 import model.WinningStatistics;
+import model.dto.LottoDto;
+import model.dto.WinningStatisticsDto;
 import view.InputView;
 import view.OutputView;
 
 public class LottoController {
     public void run() {
-        LottoPurchasingMoney inputLottoPurchasingMoney = inputMoney();
+        LottoPurchasingMoney lottoPurchasingMoney = inputPurchasingMoney();
 
-        List<Lotto> lotteries = purchaseLottoTickets(inputLottoPurchasingMoney);
-        OutputView.printPurchasedTickets(lotteries);
+        LottoOrder lottoOrder = inputLottoOrder(lottoPurchasingMoney);
 
-        WinningLotto winningLotto = inputWinningNumbers();
+        List<Lotto> lotteries = purchaseLotteries(lottoOrder);
+        printPurchasedLotteries(lottoOrder, lotteries);
+
+        WinningLotto winningLotto = inputWinningLotto();
 
         WinningStatistics winningStatistics = calculateStatistics(lotteries, winningLotto);
 
-        OutputView.printStatistics(winningStatistics, inputLottoPurchasingMoney);
+        printWinningStatistics(winningStatistics, lottoPurchasingMoney);
     }
 
-    private WinningStatistics calculateStatistics(List<Lotto> lotteries, WinningLotto winningLotto) {
-        WinningStatistics winningStatistics = new WinningStatistics();
-
-        lotteries.forEach(lotto -> {
-            LottoRank lottoRank = LottoRank.getRank(
-                    winningLotto.countMatching(lotto),
-                    winningLotto.containBonusBall(lotto)
-            );
-            winningStatistics.put(lottoRank);
-        });
-
-        return winningStatistics;
+    private void printPurchasedLotteries(LottoOrder lottoOrder, List<Lotto> lotteries) {
+        List<LottoDto> lotteriesDto = lotteries.stream()
+                .map(lotto -> new LottoDto(lotto.getLottoNumbers()))
+                .collect(Collectors.toUnmodifiableList());
+        OutputView.printPurchasedLotteries(lottoOrder, lotteriesDto);
     }
 
-    private LottoPurchasingMoney inputMoney() {
+    private LottoPurchasingMoney inputPurchasingMoney() {
         try {
             return LottoPurchasingMoney.valueOf(InputView.inputMoney());
         } catch (IOException | IllegalArgumentException e) {
             OutputView.printErrorMessage(e.getMessage());
-            return inputMoney();
+            return inputPurchasingMoney();
+        }
+    }
+
+    private LottoOrder inputLottoOrder(LottoPurchasingMoney lottoPurchasingMoney) {
+        try {
+            int manualLottoCount = InputView.inputManualLottoCount();
+            return new LottoOrder(lottoPurchasingMoney, manualLottoCount);
+        } catch (IOException | IllegalArgumentException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return inputLottoOrder(lottoPurchasingMoney);
+        }
+    }
+
+    private List<Lotto> purchaseLotteries(LottoOrder lottoOrder) {
+        return Stream.of(purchaseManualLotteries(lottoOrder), purchaseAutoLotteries(lottoOrder))
+                .flatMap(Collection::stream)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    private List<List<Integer>> inputManualLottoNumbers(LottoOrder lottoOrder) {
+        try {
+            return InputView.inputManualLottoNumbers(lottoOrder.getManualLottoCount());
+        } catch (IOException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return inputManualLottoNumbers(lottoOrder);
+        }
+    }
+
+    private List<Lotto> purchaseManualLotteries(LottoOrder lottoOrder) {
+        LottoFactory lottoFactory = LottoFactory.getInstance();
+        try {
+            List<List<Integer>> manualLottoNumbers = inputManualLottoNumbers(lottoOrder);
+            return manualLottoNumbers.stream()
+                    .map(lottoFactory::generateManual)
+                    .collect(Collectors.toUnmodifiableList());
+        } catch (IllegalArgumentException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return purchaseManualLotteries(lottoOrder);
+        }
+    }
+
+    private List<Lotto> purchaseAutoLotteries(LottoOrder lottoOrder) {
+        LottoFactory lottoFactory = LottoFactory.getInstance();
+        List<Lotto> autoLotteries = new ArrayList<>();
+        for (int i = 0; i < lottoOrder.getAutoLottoCount(); i++) {
+            autoLotteries.add(lottoFactory.generateAuto());
         }
+        return autoLotteries;
     }
 
-    private WinningLotto inputWinningNumbers() {
+    private WinningLotto inputWinningLotto() {
         try {
             return WinningLotto.of(InputView.inputWinningNumbers(), InputView.inputBonusBall());
         } catch (IOException | IllegalArgumentException e) {
             OutputView.printErrorMessage(e.getMessage());
-            return inputWinningNumbers();
+            return inputWinningLotto();
         }
     }
 
-    private List<Lotto> purchaseLottoTickets(LottoPurchasingMoney inputLottoPurchasingMoney) {
-        LottoFactory ticketFactory = LottoFactory.getInstance();
-        return ticketFactory.generateLotteries(inputLottoPurchasingMoney);
+    private WinningStatistics calculateStatistics(List<Lotto> lotteries, WinningLotto winningLotto) {
+        WinningStatistics winningStatistics = new WinningStatistics();
+
+        lotteries.forEach(lotto -> {
+            LottoRank lottoRank = LottoRank.getRank(
+                    winningLotto.countMatching(lotto),
+                    winningLotto.containBonusBall(lotto)
+            );
+            winningStatistics.put(lottoRank);
+        });
+
+        return winningStatistics;
+    }
+
+    private void printWinningStatistics(WinningStatistics winningStatistics, LottoPurchasingMoney lottoPurchasingMoney) {
+        OutputView.printStatistics(new WinningStatisticsDto(winningStatistics.getWinningCounts(),
+                winningStatistics.getEarningsRate(lottoPurchasingMoney)));
     }
 }

src/main/java/model/Lotto.java

@@ -11,12 +11,12 @@ public class Lotto {
     private final List<LottoNumber> lottoNumbers;
 
     private Lotto(List<LottoNumber> lottoNumbers) {
+        lottoNumbers = List.copyOf(lottoNumbers);
+        validate(lottoNumbers);
         this.lottoNumbers = lottoNumbers;
     }
 
     public static Lotto from(List<LottoNumber> lottoNumbers) {
-        lottoNumbers = List.copyOf(lottoNumbers);
-        validate(lottoNumbers);
         return new Lotto(lottoNumbers);
     }
 
@@ -34,18 +34,18 @@ public boolean contains(LottoNumber lottoNumber) {
         return lottoNumbers.contains(lottoNumber);
     }
 
-    private static void validate(List<LottoNumber> lottoNumbers) {
+    private void validate(List<LottoNumber> lottoNumbers) {
         validateSize(lottoNumbers);
         validateIsNotDuplicated(lottoNumbers);
     }
 
-    private static void validateSize(List<LottoNumber> lottoNumbers) {
+    private void validateSize(List<LottoNumber> lottoNumbers) {
         if (lottoNumbers.size() != LOTTO_NUMBER_COUNT) {
             throw new IllegalArgumentException(INVALID_LOTTO_NUMBER_COUNT);
         }
     }
 
-    private static void validateIsNotDuplicated(List<LottoNumber> lottoNumbers) {
+    private void validateIsNotDuplicated(List<LottoNumber> lottoNumbers) {
         long distinctSize = lottoNumbers.stream()
                 .distinct().count();
         if (distinctSize != lottoNumbers.size()) {

src/main/java/model/LottoFactory.java

@@ -4,40 +4,26 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 
 public class LottoFactory {
     private static final LottoFactory LOTTO_FACTORY = new LottoFactory();
 
-    private static final int LOTTO_PRICE = 1000;
-
-    private final List<LottoNumber> lottoNumberPool;
-
     private LottoFactory() {
-        lottoNumberPool = createLottoNumbers();
+
     }
 
     public static LottoFactory getInstance() {
         return LOTTO_FACTORY;
     }
 
-    private List<LottoNumber> createLottoNumbers() {
-        return IntStream.rangeClosed(1, 45)
-                .mapToObj(LottoNumber::valueOf)
-                .collect(Collectors.toList());
-    }
-
-    public List<Lotto> generateLotteries(LottoPurchasingMoney money) {
-        return IntStream.range(0, getAvailableLottoCount(money))
-                .mapToObj(i -> generateAuto())
-                .collect(Collectors.toUnmodifiableList());
-    }
-
-    private int getAvailableLottoCount(LottoPurchasingMoney money) {
-        return money.getAmount() / LOTTO_PRICE;
+    public Lotto generateManual(List<Integer> manualNumbers) {
+        return Lotto.from(manualNumbers.stream()
+                .map(LottoNumber::valueOf)
+                .collect(Collectors.toUnmodifiableList()));
     }
 
-    private Lotto generateAuto() {
+    public Lotto generateAuto() {
+        List<LottoNumber> lottoNumberPool = new ArrayList<>(LottoNumber.LOTTO_NUMBER_POOL.values());
         Collections.shuffle(lottoNumberPool);
         return Lotto.from(new ArrayList<>(lottoNumberPool.subList(0, 6)));
     }

src/main/java/model/LottoNumber.java

@@ -1,7 +1,8 @@
 package model;
 
-import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -10,12 +11,12 @@ public class LottoNumber {
     private static final int MAX_LOTTO_NUMBER = 45;
     static final String INVALID_LOTTO_NUMBER_RANGE = "[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.";
 
-    private static final List<LottoNumber> LOTTO_NUMBER_POOL;
+    static final Map<Integer, LottoNumber> LOTTO_NUMBER_POOL;
 
     static {
         LOTTO_NUMBER_POOL = IntStream.rangeClosed(MIN_LOTTO_NUMBER, MAX_LOTTO_NUMBER)
-                .mapToObj(LottoNumber::new)
-                .collect(Collectors.toUnmodifiableList());
+                .boxed()
+                .collect(Collectors.toUnmodifiableMap(Function.identity(), LottoNumber::new));
     }
 
     private final int number;
@@ -27,7 +28,7 @@ private LottoNumber(int number) {
 
     public static LottoNumber valueOf(int number) {
         validateRange(number);
-        return LOTTO_NUMBER_POOL.get(number - 1);
+        return LOTTO_NUMBER_POOL.get(number);
     }
 
     private static void validateRange(int number) {

src/main/java/model/LottoOrder.java

@@ -0,0 +1,28 @@
+package model;
+
+public class LottoOrder {
+    static final String TOO_MANY_MANUAL = "[ERROR] 수동 로또 구매 수는 전체 구매 수를 넘을 수 없습니다.";
+
+    private final int manualLottoCount;
+    private final int autoLottoCount;
+
+    public LottoOrder(LottoPurchasingMoney lottoPurchasingMoney, int manualLottoCount) {
+        validateManualCount(lottoPurchasingMoney, manualLottoCount);
+        this.manualLottoCount = manualLottoCount;
+        this.autoLottoCount = lottoPurchasingMoney.getPurchasableCount() - manualLottoCount;
+    }
+
+    public int getManualLottoCount() {
+        return manualLottoCount;
+    }
+
+    public int getAutoLottoCount() {
+        return autoLottoCount;
+    }
+
+    private void validateManualCount(LottoPurchasingMoney lottoPurchasingMoney, int manualLottoCount) {
+        if (lottoPurchasingMoney.getPurchasableCount() < manualLottoCount) {
+            throw new IllegalArgumentException(TOO_MANY_MANUAL);
+        }
+    }
+}

src/main/java/model/LottoPurchasingMoney.java

@@ -10,19 +10,23 @@ public class LottoPurchasingMoney {
     private final int amount;
 
     private LottoPurchasingMoney(int amount) {
-        this.amount = amount;
+        validateEnough(amount);
+        this.amount = amount / LOTTO_PRICE * LOTTO_PRICE;
     }
 
     public static LottoPurchasingMoney valueOf(int amount) {
-        validateEnough(amount);
         return new LottoPurchasingMoney(amount);
     }
 
     public int getAmount() {
         return amount;
     }
 
-    private static void validateEnough(int amount) {
+    public int getPurchasableCount() {
+        return amount / LOTTO_PRICE;
+    }
+
+    private void validateEnough(int amount) {
         if (amount < LOTTO_PRICE) {
             throw new IllegalArgumentException(NOT_ENOUGH_MONEY);
         }

src/main/java/model/WinningStatistics.java

@@ -1,33 +1,38 @@
 package model;
 
-import java.util.Arrays;
 import java.util.EnumMap;
+import java.util.Map;
 
 public class WinningStatistics {
-    private final EnumMap<LottoRank, Integer> winningStatistics;
+    private final EnumMap<LottoRank, Integer> winningCounts;
 
     public WinningStatistics() {
-        winningStatistics = new EnumMap<>(LottoRank.class);
-        Arrays.stream(LottoRank.values())
-                .forEach(lottoRank -> winningStatistics.put(lottoRank, 0));
+        winningCounts = new EnumMap<>(LottoRank.class);
+        for (LottoRank each : LottoRank.values()) {
+            winningCounts.put(each, 0);
+        }
     }
 
     public void put(LottoRank lottoRank) {
-        winningStatistics.put(lottoRank, winningStatistics.get(lottoRank) + 1);
+        winningCounts.put(lottoRank, winningCounts.get(lottoRank) + 1);
     }
 
     public int get(LottoRank lottoRank) {
-        return winningStatistics.get(lottoRank);
+        return winningCounts.get(lottoRank);
     }
 
-    public double getEarningsRate(int money) {
+    public Map<LottoRank, Integer> getWinningCounts() {
+        return winningCounts;
+    }
+
+    public double getEarningsRate(LottoPurchasingMoney lottoPurchasingMoney) {
         long totalPrize = getTotalPrize();
-        return totalPrize / (double)money;
+        return totalPrize / (double)lottoPurchasingMoney.getAmount();
     }
 
     long getTotalPrize() {
-        return winningStatistics.keySet().stream()
-                .mapToLong(lottoRank -> lottoRank.getPrizeMoney() * winningStatistics.get(lottoRank))
+        return winningCounts.keySet().stream()
+                .mapToLong(lottoRank -> lottoRank.getPrizeMoney() * winningCounts.get(lottoRank))
                 .sum();
     }
 }

src/main/java/model/dto/LottoDto.java

@@ -0,0 +1,16 @@
+package model.dto;
+
+import java.util.List;
+import model.LottoNumber;
+
+public class LottoDto {
+    private final List<LottoNumber> lottoNumbers;
+
+    public LottoDto(List<LottoNumber> lottoNumbers) {
+        this.lottoNumbers = List.copyOf(lottoNumbers);
+    }
+
+    public List<LottoNumber> getLottoNumbers() {
+        return lottoNumbers;
+    }
+}