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

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,33 @@
+package lotto.domain;
+
+public class BonusNumber {
+
+    private final int number;
+
+    private BonusNumber(int number) {
+        this.number = number;
+    }
+
+    public static BonusNumber from(Lotto lotto, int number) {
+        validateRange(lotto, number);
+        validateDuplication(lotto, number);
+        return new BonusNumber(number);
+    }
+
+    private static void validateRange(Lotto lotto, int number) {
+        if (lotto.isNotInRange(number)) {
+            throw new IllegalArgumentException(String.format("[ERROR] %d는 범위를 벗어난 숫자입니다.", number));
+        }
+
+    }
+
+    private static void validateDuplication(Lotto lotto, int number) {
+        if (lotto.has(number)) {
+            throw new IllegalArgumentException(String.format("[ERROR] %d는 당첨 번호와 중복됩니다.", number));
+        }
+    }
+
+    public int getNumber() {
+        return number;
+    }
+}

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

@@ -0,0 +1,72 @@
+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 boolean isNotInRange(int number) {
+        return number < MIN_VALUE || number > MAX_VALUE;
+    }
+
+    public boolean has(int number) {
+        return numbers.contains(number);
+    }
+
+    public LottoResult getResult(Lotto other, int bonusNumber) {
+        return LottoResult.find(getMatchingNumber(other), numbers.contains(bonusNumber));
+    }
+
+    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) {
+        if (hasNumberOutOfRange(numbers)) {
+            throw new IllegalArgumentException(String.format("[ERROR] 로또 번호는 %d부터 %d 사이의 숫자여야 합니다.", MIN_VALUE, MAX_VALUE));
+        }
+    }
+
+    private boolean hasNumberOutOfRange(List<Integer> numbers) {
+        return numbers.stream().anyMatch(this::isNotInRange);
+    }
+
+    private void validateDuplication(List<Integer> numbers) {
+        if (new HashSet<>(numbers).size() != THE_NUMBER_OF_LOTTO) {
+            throw new IllegalArgumentException("중복되는 번호가 포함되어 있습니다.");
+        }
+    }
+
+    private int getMatchingNumber(Lotto other) {
+        return (int) numbers.stream()
+                .filter(other.numbers::contains)
+                .count();
+    }
+}

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

@@ -0,0 +1,34 @@
+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;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = new ArrayList<>(lottos);
+    }
+
+    public static Lottos from(LottoGenerator lottoGenerator, int quantity) {
+        return new Lottos(Stream.generate(() -> Lotto.from(lottoGenerator))
+                .limit(quantity)
+                .collect(Collectors.toList()));
+    }
+
+    public List<LottoResult> compare(Lotto winningLotto, int bonusNumber) {
+        return lottos.stream()
+                .map(lotto -> lotto.getResult(winningLotto, bonusNumber))
+                .collect(Collectors.toList());
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+}

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

@@ -0,0 +1,38 @@
+package lotto.domain;
+
+public class PurchasingMoney {
+
+    private static final int UNIT = 1000;
+
+    private final int money;
+
+    private PurchasingMoney(int money) {
+        validatePositive(money);
+        validateUnit(money);
+        this.money = money;
+    }
+
+    public static PurchasingMoney from(int money) {
+        return new PurchasingMoney(money);
+    }
+
+    public int getMoney() {
+        return money;
+    }
+
+    public int getQuantity() {
+        return money / UNIT;
+    }
+
+    private void validatePositive(int money) {
+        if (money <= 0) {
+            throw new IllegalArgumentException("[ERROR] 구입금액은 양수여야 합니다.");
+        }
+    }
+
+    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,26 @@
+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 static final LottoGenerator ISSUED_LOTTO_GENERATOR = new IssuedLottoGenerator();
+
+    private IssuedLottoGenerator() {
+    }
+
+    public static LottoGenerator create() {
+        return ISSUED_LOTTO_GENERATOR;
+    }
+
+    @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,43 @@
+package lotto.domain.result;
+
+import java.util.Arrays;
+
+public enum LottoResult {
+
+    FIRST_PRIZE(6, false, 2_000_000_000),
+    SECOND_PRIZE(5, true, 30_000_000),
+    THIRD_PRIZE(5, false, 1_500_000),
+    FOURTH_PRIZE(4, false, 50_000),
+    FIFTH_PRIZE(3, false, 5_000),
+    NO_PRIZE(0, false, 0);
+
+    private final int matchingNumber;
+    private final boolean hasBonusNumber;
+    private final int prize;
+
+    LottoResult(int matchingNumber, boolean hasBonusNumber, int prize) {
+        this.matchingNumber = matchingNumber;
+        this.hasBonusNumber = hasBonusNumber;
+        this.prize = prize;
+    }
+
+    public static LottoResult find(int matchingNumber, boolean hasBonusNumber) {
+        return Arrays.stream(values())
+                .filter(value -> value.matchingNumber == matchingNumber)
+                .filter(value -> !value.hasBonusNumber || hasBonusNumber)
+                .findAny()
+                .orElse(NO_PRIZE);
+    }
+
+    public int getPrize() {
+        return prize;
+    }
+
+    @Override
+    public String toString() {
+        if (hasBonusNumber) {
+            return String.format("%d개 일치, 보너스 볼 일치 (%,d원)", matchingNumber, prize);
+        }
+        return String.format("%d개 일치 (%,d원)", matchingNumber, prize);
+    }
+}

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

@@ -0,0 +1,19 @@
+package lotto.domain.result;
+
+public class ProfitRate {
+
+    private final double value;
+
+    private ProfitRate(double value) {
+        this.value = value;
+    }
+
+    public static ProfitRate from(int prize, int purchasingMoney) {
+        return new ProfitRate(((double) prize / purchasingMoney) * 100);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%.1f", value);
+    }
+}