[로또] 어정윤 제출합니다.

src/main/java/lotto/Application.java

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

src/main/java/lotto/domain/BonusNumber.java

@@ -0,0 +1,23 @@
+package lotto.domain;
+
+import lotto.util.Convertor;
+
+public class BonusNumber {
+
+    private final int number;
+
+    private BonusNumber(int number) {
+        this.number = number;
+    }
+
+    public static BonusNumber from(Lotto lotto, String input) {
+        int number = Convertor.toInteger(input);
+        lotto.validateRange(number);
+        lotto.validateDuplication(number);
+        return new BonusNumber(number);
+    }
+
+    public int getNumber() {
+        return number;
+    }
+}

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

@@ -0,0 +1,86 @@
+package lotto.domain;
+
+import lotto.domain.generator.LottoGenerator;
+import lotto.domain.result.LottoResult;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+public class Lotto {
+
+    private static final int THE_NUMBER_OF_LOTTO = 6;
+    private static final int MIN_VALUE = 1;
+    private static final int MAX_VALUE = 45;
+
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validateSize(numbers);
+        validateRange(numbers);
+        validateDuplication(numbers);
+        this.numbers = new ArrayList<>(numbers);
+    }
+
+    public static Lotto from(LottoGenerator lottoGenerator) {
+        return new Lotto(lottoGenerator.issue(MIN_VALUE, MAX_VALUE, THE_NUMBER_OF_LOTTO));
+    }
+
+    public List<LottoResult> compare(Lottos issuedLotto, BonusNumber bonusNumber) {
+        return issuedLotto.compare(numbers, bonusNumber);
+    }
+
+    public void validateDuplication(int bonusNumber) {
+        if (numbers.contains(bonusNumber)) {
+            throw new IllegalArgumentException(String.format("[ERROR] %d는 당첨 번호와 중복됩니다.", bonusNumber));
+        }
+    }
+
+    public void validateRange(int number) {
+        if (isNotInRange(number)) {
+            throw new IllegalArgumentException(String.format("[ERROR] 로또 번호는 %d부터 %d 사이의 숫자여야 합니다.", MIN_VALUE, MAX_VALUE));
+        }
+    }
+
+    public LottoResult getResult(List<Integer> other, BonusNumber bonusNumber) {
+        int matchingNumber = (int) numbers.stream()
+                .filter(other::contains)
+                .count();
+        if (matchingNumber < LottoResult.FIFTH_PRIZE.getMatchingNumber()) {
+            return LottoResult.NO_PRIZE;
+        }
+        int matchingNumberWithBonusNumber = (int) numbers.stream()
+                .filter(number -> number == bonusNumber.getNumber())
+                .count();
+        return LottoResult.find(matchingNumber, matchingNumberWithBonusNumber);
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+    private void validateSize(List<Integer> numbers) {
+        if (numbers.size() != THE_NUMBER_OF_LOTTO) {
+            throw new IllegalArgumentException(String.format("[ERROR] 로또 번호의 개수가 %d개가 아닙니다.", THE_NUMBER_OF_LOTTO));
+        }
+    }
+
+    private void validateRange(List<Integer> numbers) {
+        numbers.stream()
+                .filter(this::isNotInRange)
+                .findAny()
+                .ifPresent(number -> {
+                    throw new IllegalArgumentException(String.format("[ERROR] 로또 번호는 %d부터 %d 사이의 숫자여야 합니다.", MIN_VALUE, MAX_VALUE));
+                });
+    }
+
+    private boolean isNotInRange(int number) {
+        return number < MIN_VALUE || number > MAX_VALUE;
+    }
+
+    private void validateDuplication(List<Integer> numbers) {
+        if (new HashSet<>(numbers).size() != THE_NUMBER_OF_LOTTO) {
+            throw new IllegalArgumentException("중복되는 번호가 포함되어 있습니다.");
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+package lotto.domain;
+
+import lotto.domain.generator.LottoGenerator;
+import lotto.domain.result.LottoResult;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Lottos {
+
+    private final List<Lotto> lottos;
+    private final int quantity;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = new ArrayList<>(lottos);
+        this.quantity = lottos.size();
+    }
+
+    public static Lottos from(LottoGenerator lottoGenerator, PurchasingMoney purchasingMoney) {
+        return new Lottos(Stream.generate(() -> Lotto.from(lottoGenerator))
+                .limit(purchasingMoney.getQuantity())
+                .collect(Collectors.toList()));
+    }
+
+    public List<LottoResult> compare(List<Integer> winningLotto, BonusNumber bonusNumber) {
+        return lottos.stream()
+                .map(lotto -> lotto.getResult(winningLotto, bonusNumber))
+                .collect(Collectors.toList());
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+}

src/main/java/lotto/domain/PurchasingMoney.java

@@ -0,0 +1,35 @@
+package lotto.domain;
+
+import lotto.util.Convertor;
+
+public class PurchasingMoney {
+
+    private static final int UNIT = 1000;
+
+    private final int money;
+    private final int quantity;
+
+    private PurchasingMoney(int money) {
+        validateUnit(money);
+        this.money = money;
+        this.quantity = money / UNIT;
+    }
+
+    public static PurchasingMoney from(String input) {
+        return new PurchasingMoney(Convertor.toInteger(input));
+    }
+
+    public int getMoney() {
+        return money;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+
+    private void validateUnit(int money) {
+        if (money % UNIT != 0) {
+            throw new IllegalArgumentException(String.format("[ERROR] 구입금액은 %d원 단위여야 합니다.", UNIT));
+        }
+    }
+}

src/main/java/lotto/domain/generator/IssuedLottoGenerator.java

@@ -0,0 +1,24 @@
+package lotto.domain.generator;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class IssuedLottoGenerator implements LottoGenerator {
+
+    private IssuedLottoGenerator() {
+    }
+
+    public static IssuedLottoGenerator create() {
+        return new IssuedLottoGenerator();
+    }
+
+    @Override
+    public List<Integer> issue(int minValue, int maxValue, int quantity) {
+        return Randoms.pickUniqueNumbersInRange(minValue, maxValue, quantity)
+                .stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+}

src/main/java/lotto/domain/generator/LottoGenerator.java

@@ -0,0 +1,8 @@
+package lotto.domain.generator;
+
+import java.util.List;
+
+public interface LottoGenerator {
+
+    List<Integer> issue(int minValue, int maxValue, int quantity);
+}

src/main/java/lotto/domain/generator/WinningLottoGenerator.java

@@ -0,0 +1,63 @@
+package lotto.domain.generator;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class WinningLottoGenerator implements LottoGenerator {
+
+    private static final String DELIMITER = ",";
+
+    private final String input;
+
+    private WinningLottoGenerator(String input) {
+        this.input = input;
+    }
+
+    public static WinningLottoGenerator from(String input) {
+        return new WinningLottoGenerator(input);
+    }
+
+    @Override
+    public List<Integer> issue(int minValue, int maxValue, int quantity) {
+        String[] numbers = input.split(DELIMITER);
+        validateDelimiter(numbers, quantity);
+        validateSize(numbers, quantity);
+        validateDuplication(numbers, quantity);
+        validateRange(numbers, minValue, maxValue);
+        return Arrays.stream(numbers)
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+    }
+
+    private void validateDelimiter(String[] numbers, int quantity) {
+        if (numbers.length != quantity) {
+            throw new IllegalArgumentException(String.format("[ERROR] %s 외 구분자가 입력되었습니다.", DELIMITER));
+        }
+    }
+
+    private void validateDuplication(String[] numbers, int quantity) {
+        int numberWithoutDuplication = (int) Arrays.stream(numbers)
+                .distinct()
+                .count();
+        if (numberWithoutDuplication != quantity) {
+            throw new IllegalArgumentException("[ERROR] 당첨 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    private void validateSize(String[] numbers, int quantity) {
+        if (numbers.length != quantity) {
+            throw new IllegalArgumentException(String.format("[ERROR] 당첨 번호의 개수가 %d개가 아닙니다.", quantity));
+        }
+    }
+
+    private void validateRange(String[] numbers, int minValue, int maxValue) {
+        Arrays.stream(numbers)
+                .mapToInt(Integer::parseInt)
+                .filter(number -> number < minValue || number > maxValue)
+                .findAny()
+                .ifPresent(number -> {
+                    throw new IllegalArgumentException(String.format("[ERROR] 로또 번호는 %d부터 %d 사이의 숫자여야 합니다.", minValue, maxValue));
+                });
+    }
+}

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

@@ -0,0 +1,44 @@
+package lotto.domain.result;
+
+import java.util.Arrays;
+
+public enum LottoResult {
+
+    FIRST_PRIZE(6, 0, 2000000000, "6개 일치"),
+    SECOND_PRIZE(5, 1, 30000000, "5개 일치, 보너스 볼 일치"),
+    THIRD_PRIZE(5, 0, 1500000, "5개 일치"),
+    FOURTH_PRIZE(4, 0, 50000, "4개 일치"),
+    FIFTH_PRIZE(3, 0, 5000, "3개 일치"),
+    NO_PRIZE(0, 0, 0, "");
+
+    private final int matchingNumber;
+    private final int matchingNumberWithBonusNumber;
+    private final int prize;
+    private final String message;
+
+    LottoResult(int matchingNumber, int matchingNumberWithBonusNumber, int prize, String message) {
+        this.matchingNumber = matchingNumber;
+        this.matchingNumberWithBonusNumber = matchingNumberWithBonusNumber;
+        this.prize = prize;
+        this.message = message;
+    }
+
+    public static LottoResult find(int matchingNumber, int matchingNumberWithBonusNumber) {
+        return Arrays.stream(values())
+                .filter(value -> value.matchingNumber == matchingNumber && value.matchingNumberWithBonusNumber <= matchingNumberWithBonusNumber)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 해당 로또에 대한 결과가 없습니다."));
+    }
+
+    public int getMatchingNumber() {
+        return matchingNumber;
+    }
+
+    public int getPrize() {
+        return prize;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/lotto/domain/result/ProfitRate.java

@@ -0,0 +1,24 @@
+package lotto.domain.result;
+
+public class ProfitRate {
+
+    private static final int CIPHER = 10;
+
+    private final double value;
+
+    private ProfitRate(double value) {
+        this.value = value;
+    }
+
+    public static ProfitRate from(int prize, int purchasingMoney) {
+        return new ProfitRate(round(((double) prize / purchasingMoney) * 100));
+    }
+
+    public double getValue() {
+        return value;
+    }
+
+    private static double round(double profitRate) {
+        return Math.round(profitRate * CIPHER) / (double) CIPHER;
+    }
+}