[2단계 - 로또(수동)] 기론(김규철) 미션 제출합니다.

docs/README.md

@@ -1,4 +1,4 @@
-# 로또(자동) 🤑
+# 로또(자동) + (수동) 🤑
 
 ## 기능요구사항 😎
 
@@ -9,6 +9,11 @@
 - [x] 지난주 당첨 번호 입력
 - [x] 보너스 볼 입력
 - [x] 6자리인 당첨 번호 입력
+- [x] 수동으로 구매할 로또 수 입력
+    - [x] 자연수가 아니면, 예외 발생
+- [x] 수동으로 구매할 로또 번호 입력
+    - [x] 번호 개수가 6개가 아니면, 예외 발생
+    - [x] 중복된 번호가 있으면, 예외 발생
 
 ### 로또
 
@@ -18,6 +23,7 @@
 
 ### 당첨 로또 확인
 
+- [x] 수동 로또와 자동 로또 합쳐서 계산
 - [x] 로또에서 일치하는 번호 개수 확인
     - [x] 당첨 번호에 중복된 번호가 있을 시 예외 발생
 - [x] 당첨 번호 통계 기능

src/main/java/Application.java

@@ -1,7 +1,30 @@
+import controller.LottoController;
+import controller.dto.LottosDto;
+import controller.dto.StatisticDto;
+import domain.Money;
+import service.LottoService;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+
 public class Application {
     public static void main(String[] args) {
-        LottoMachine lottoMachine = new LottoMachine();
-        lottoMachine.start();
+        LottoController lottoController = new LottoController(new LottoService());
+        int inputMoney = InputView.askInputMoney();
+        int manualLottoCount = InputView.askManualLottoCount();
+        List<String[]> manualLottoNumbers = InputView.askManualLottoNumbers(manualLottoCount);
+        LottosDto lottosDto = lottoController.purchase(inputMoney, manualLottoCount, manualLottoNumbers);
+        OutputView.printCountOfLotto(lottosDto.getSize(), manualLottoCount);
+
+        OutputView.printLottos(lottosDto);
+        String[] inputWinningNumber = InputView.askInputWinningNumber();
+        int inputBonusBall = InputView.askInputBonusBall();
+
+        StatisticDto statisticDto = lottoController.winningResult(inputWinningNumber, inputBonusBall,
+                manualLottoNumbers, inputMoney);
+        OutputView.printStatistics(statisticDto);
+        OutputView.printProfitRate(statisticDto.getProfitRate());
 
     }
 }

src/main/java/controller/LottoController.java

@@ -0,0 +1,39 @@
+package controller;
+
+import controller.dto.LottosDto;
+import controller.dto.StatisticDto;
+import domain.*;
+import service.LottoService;
+
+import java.util.List;
+
+public class LottoController {
+
+    private final LottoService lottoService;
+
+    public LottoController(LottoService lottoService) {
+        this.lottoService = lottoService;
+    }
+
+    public LottosDto purchase(int inputMoney, int manualLottoCount, List<String[]> manualLottoNumbers) {
+        Money money = lottoService.createMoney(inputMoney);
+        int autoLottoCount = lottoService.getAutoLottoCount(money, manualLottoCount);
+        Lottos lottos = lottoService.generateLottos(manualLottoNumbers, autoLottoCount);
+
+        return LottosDto.from(lottos, lottos.size());
+    }
+
+    public StatisticDto winningResult(String[] inputWinningNumber,
+                                      int inputBonusBall,
+                                      List<String[]> manualLottoNumbers,
+                                      int inputMoney) {
+        WinningLotto winningLotto = lottoService.generateWinningLotto(
+                new ManualLottoGenerator(inputWinningNumber),
+                inputBonusBall);
+
+        Lottos lottos = lottoService.generateLottos(manualLottoNumbers, 0);
+        Statistic winningStatistics = lottos.getWinningStatistics(winningLotto);
+        Money money = lottoService.createMoney(inputMoney);
+        return StatisticDto.from(winningStatistics, winningStatistics.getProfitRate(money));
+    }
+}

src/main/java/controller/dto/LottoDto.java

@@ -0,0 +1,27 @@
+package controller.dto;
+
+import domain.Lotto;
+import domain.LottoNumber;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class LottoDto {
+    private final Set<Integer> numbers;
+
+    public LottoDto(Set<Integer> numbers) {
+        this.numbers = new LinkedHashSet<>(numbers);
+    }
+
+    public static LottoDto from(Lotto lotto) {
+        Set<LottoNumber> lottoNumbers = lotto.getNumbers();
+        return lottoNumbers.stream()
+                .map(LottoNumber::getLottoNumber)
+                .collect(Collectors.collectingAndThen(Collectors.toUnmodifiableSet(), LottoDto::new));
+    }
+
+    public Set<Integer> getNumbers() {
+        return numbers;
+    }
+}

src/main/java/controller/dto/LottosDto.java

@@ -0,0 +1,35 @@
+package controller.dto;
+
+import domain.Lottos;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LottosDto {
+    private final List<LottoDto> lottoDtos;
+    private final int size;
+
+    public LottosDto(List<LottoDto> lottoDtos, int size) {
+        this.lottoDtos = new ArrayList<>(lottoDtos);
+        this.size = size;
+    }
+
+    public List<LottoDto> getLottoDtos() {
+        return lottoDtos;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public static LottosDto from(Lottos lottos, int size) {
+        return lottos.getLottos()
+                .stream()
+                .map(LottoDto::from)
+                .collect(Collectors.collectingAndThen(
+                        Collectors.toUnmodifiableList(),
+                        lottoDtos -> new LottosDto(lottoDtos, size)
+                ));
+    }
+}

src/main/java/controller/dto/RankDto.java

@@ -0,0 +1,37 @@
+package controller.dto;
+
+import domain.Rank;
+
+public class RankDto {
+    private final int count;
+    private final int winningPrice;
+    private final boolean hasBonusBall;
+
+    public RankDto(int count, int winningPrice, boolean hasBonusBall) {
+        this.count = count;
+        this.winningPrice = winningPrice;
+        this.hasBonusBall = hasBonusBall;
+    }
+
+
+    public static RankDto from(Rank rank) {
+        return new RankDto(
+                rank.getCount(),
+                rank.getWinningPrice(),
+                rank.hasBonusBall()
+        );
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public int getWinningPrice() {
+        return winningPrice;
+    }
+
+    public boolean hasBonusBall() {
+        return hasBonusBall;
+    }
+
+}

src/main/java/controller/dto/StatisticDto.java

@@ -0,0 +1,37 @@
+package controller.dto;
+
+import domain.Statistic;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class StatisticDto {
+    private final Map<RankDto, Integer> statisticDto;
+    private final double profitRate;
+
+    public StatisticDto(Map<RankDto, Integer> statisticDto, double profitRate) {
+        this.statisticDto = new LinkedHashMap<>(statisticDto);
+        this.profitRate = profitRate;
+    }
+
+    public static StatisticDto from(Statistic statistics, double profitRate) {
+        return statistics.getStatistics().entrySet()
+                .stream()
+                .collect(Collectors.collectingAndThen(Collectors.toMap(
+                                statistic -> RankDto.from(statistic.getKey()),
+                                Map.Entry::getValue,
+                                (key, value) -> key,
+                                LinkedHashMap::new
+                        ), statisticDto1 -> new StatisticDto(statisticDto1, profitRate))
+                );
+    }
+
+    public Map<RankDto, Integer> getStatisticDto() {
+        return new LinkedHashMap<>(statisticDto);
+    }
+
+    public double getProfitRate() {
+        return profitRate;
+    }
+}

src/main/java/domain/AutoLottoGenerator.java

@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static domain.Lotto.LOTTO_LENGTH;
+
+public class AutoLottoGenerator implements LottoGenerator {
+
+    @Override
+    public Lotto generateLotto() {
+        List<LottoNumber> numbers = LottoNumber.values();
+        Collections.shuffle(numbers);
+        return new Lotto(numbers.stream()
+                .limit(LOTTO_LENGTH)
+                .collect(Collectors.toSet()));
+    }
+}

src/main/java/domain/Lotto.java

@@ -1,65 +1,32 @@
 package domain;
 
 import java.util.*;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
+
 
 public class Lotto {
-    private static final String LOTTO_DUPLICATED_MESSAGE = "[ERROR] 로또 번호에 중복된 숫자가 들어가면 안됩니다.";
-    private static final String LOTTO_SIZE_MESSAGE = "[ERROR] 로또의 숫자는 6개여야 합니다.";
-    private static final int LOTTO_START = 0;
-    private static final int LOTTO_END = 6;
-    private static final int LOTTO_SIZE = 6;
+    public static final int LOTTO_LENGTH = 6;
+    private static final String LOTTO_SIZE_MESSAGE = "[ERROR] 로또의 숫자는 중복 없이 6개여야 합니다.";
 
-    private final List<LottoNumber> numbers;
+    private final Set<LottoNumber> numbers;
 
-    public Lotto(List<LottoNumber> numbers) {
+    public Lotto(Set<LottoNumber> numbers) {
         validateSize(numbers);
-        validateDuplicate(numbers);
-        Collections.sort(numbers);
-        this.numbers = new ArrayList<>(numbers);
+        this.numbers = new HashSet<>(numbers);
     }
 
-    private void validateSize(List<LottoNumber> lotto) {
-        if (lotto.size() != LOTTO_SIZE) {
+    private void validateSize(Set<LottoNumber> lotto) {
+        if (lotto.size() != LOTTO_LENGTH) {
             throw new IllegalArgumentException(LOTTO_SIZE_MESSAGE);
         }
     }
 
-    private void validateDuplicate(List<LottoNumber> numbers) {
-        if (isDuplicated(numbers)) {
-            throw new IllegalArgumentException(LOTTO_DUPLICATED_MESSAGE);
-        }
-    }
-
-    private boolean isDuplicated(List<LottoNumber> numbers) {
-        return numbers.size() != numbers.stream()
-                .distinct()
-                .count();
-    }
-
-    public List<LottoNumber> getLotto() {
-        return new ArrayList<>(numbers);
-    }
-
-    public static Lotto generateLottoNumber(int minNumber, int maxNumber) {
-        List<LottoNumber> lottoRange = IntStream.rangeClosed(minNumber, maxNumber)
-                .mapToObj(LottoNumber::generateLottoNumber)
-                .collect(Collectors.toList());
-        Collections.shuffle(lottoRange);
-        List<LottoNumber> numbers = lottoRange.subList(LOTTO_START, LOTTO_END);
-        return new Lotto(numbers);
-    }
-
-    public Rank match(WinningLotto winningNumber) {
-        int matchCount = getMatchCount(winningNumber);
-        boolean hasBonusBall = winningNumber.isBonusBallMatch(this);
-        return Rank.valueOf(matchCount, hasBonusBall);
+    public Set<LottoNumber> getNumbers() {
+        return new HashSet<>(numbers);
     }
 
-    private int getMatchCount(WinningLotto winningNumber) {
+    public int getMatchCount(Lotto lotto) {
         return (int) numbers.stream()
-                .filter(winningNumber::contains)
+                .filter(lotto::contains)
                 .count();
     }
 

src/main/java/domain/LottoGenerator.java

@@ -0,0 +1,5 @@
+package domain;
+
+public interface LottoGenerator {
+    Lotto generateLotto();
+}