step4

src/main/java/lotto/domain/BonusBall.java

@@ -1,17 +1,19 @@
 package lotto.domain;
 
+import lotto.exception.TicketNumberOutOfBoundException;
+
 public class BonusBall {
-    private final Integer bonusBall;
+    private final LottoNo bonusBall;
 
-    private BonusBall(Integer bonusBall) {
+    private BonusBall(LottoNo bonusBall) {
         this.bonusBall = bonusBall;
     }
 
-    public static BonusBall from(String bonusBall) {
-        return new BonusBall(Integer.valueOf(bonusBall));
+    public static BonusBall from(String bonusBall) throws TicketNumberOutOfBoundException {
+        return new BonusBall(LottoNo.from(Integer.valueOf(bonusBall)));
     }
 
-    public Integer getBonusBall() {
+    public LottoNo getBonusBall() {
         return bonusBall;
     }
 }

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

@@ -10,9 +10,9 @@
 
 public class LottoGenerator {
 
-    public static LottoTickets generateTickets(long money) {
+    public static LottoTickets generateAutoTickets(long numberOfTicket) {
         List<Ticket> tickets = new ArrayList<>();
-        long numberOfTickets = money / LOTTO_PRICE;
+        long numberOfTickets = numberOfTicket;
 
         for (int i = 0; i < numberOfTickets; i++) {
             List<Integer> candidateNumbers = makeCandidateNumbers();
@@ -24,10 +24,13 @@ public static LottoTickets generateTickets(long money) {
         return LottoTickets.from(tickets);
     }
 
+    public static LottoTickets generateManualTickets(List<Ticket> tickets) {
+        return LottoTickets.from(tickets);
+    }
+
     private static List<Integer> makeCandidateNumbers() {
-        List<Integer> candidateNumbers = IntStream.rangeClosed(MIN_LOTTO_NUMBER, MAX_LOTTO_NUMBER)
+        return IntStream.rangeClosed(MIN_LOTTO_NUMBER, MAX_LOTTO_NUMBER)
                 .boxed()
                 .collect(Collectors.toList());
-        return candidateNumbers;
     }
 }

src/main/java/lotto/domain/LottoNo.java

@@ -0,0 +1,32 @@
+package lotto.domain;
+
+import lotto.exception.TicketNumberOutOfBoundException;
+
+public class LottoNo {
+    int number;
+
+    private LottoNo(int number) throws TicketNumberOutOfBoundException {
+        if (checkValid(number)) {
+            this.number = number;
+        }
+    }
+
+    public static LottoNo from(int number) throws TicketNumberOutOfBoundException {
+        return new LottoNo(number);
+    }
+
+    private boolean checkValid(int number) throws TicketNumberOutOfBoundException {
+        if (number < 0 || number > 45) {
+            throw new TicketNumberOutOfBoundException("1 ~ 45 범위만 입력 가능합니다.");
+        }
+        return true;
+    }
+
+    public int number() {
+        return this.number;
+    }
+
+    public boolean equals(LottoNo lottoNo) {
+        return this.number == lottoNo.number();
+    }
+}

src/main/java/lotto/domain/LottoTickets.java

@@ -1,61 +1,84 @@
 package lotto.domain;
 
+import lotto.exception.TicketNumberOutOfBoundException;
+import lotto.exception.TicketPriceOutOfBoundException;
+
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static lotto.domain.Ticket.LOTTO_PRICE;
+
 public class LottoTickets {
     private final List<Ticket> tickets;
+    private final Integer numberOfManualTickets;
+    private final Integer numberOfAutoTickets;
 
-    private LottoTickets(List<Ticket> tickets) {
+    private LottoTickets(List<Ticket> tickets, int numberOfManualTickets, int numberOfAutoTickets) {
         this.tickets = tickets;
+        this.numberOfManualTickets = numberOfManualTickets;
+        this.numberOfAutoTickets = numberOfAutoTickets;
     }
 
     public static LottoTickets from(List<Ticket> tickets) {
-        return new LottoTickets(tickets);
+        return new LottoTickets(tickets, 0, 0);
+    }
+
+    public static LottoTickets of(LottoTickets manualTickets, LottoTickets autoTickets) {
+        return new LottoTickets(manualTickets.merge(autoTickets), manualTickets.numberOfTickets(), autoTickets.numberOfTickets());
+    }
+
+    private List<Ticket> merge(LottoTickets tickets) {
+        List<Ticket> mergedTickets = new ArrayList<>();
+        mergedTickets.addAll(this.tickets);
+        mergedTickets.addAll(tickets.getTickets());
+        return mergedTickets;
     }
 
     public int numberOfTickets() {
         return tickets.size();
     }
 
     public int totalPrice() {
-        return tickets.size() * 1000;
+        return tickets.size() * LOTTO_PRICE;
+    }
+
+    public static LottoTickets buyTickets(long money, List<Ticket> manualTickets) throws TicketNumberOutOfBoundException, TicketPriceOutOfBoundException {
+        if (money < 0) {
+            throw new TicketPriceOutOfBoundException("가격은 음수가 불가능합니다.");
+        }
+        int numberOfManualTicket = manualTickets.size();
+        int numberOfAutoTicket = (int) (money / LOTTO_PRICE) - numberOfManualTicket;
+        return LottoTickets.of(buyManualTickets(manualTickets), buyAutoTickets(numberOfAutoTicket));
     }
 
-    public boolean checkValidTickets() {
-        return tickets.stream().allMatch(Ticket::checkValidTickets);
+    public static LottoTickets buyManualTickets(List<Ticket> tickets) {
+        return LottoGenerator.generateManualTickets(tickets);
     }
 
-    public static LottoTickets buyTickets(long money) {
-        return LottoGenerator.generateTickets(money);
+    public static LottoTickets buyAutoTickets(long numberOfTicket) throws TicketNumberOutOfBoundException {
+        if (numberOfTicket < 0) {
+            throw new TicketNumberOutOfBoundException("티켓 개수는 음수가 불가능합니다.");
+        }
+        return LottoGenerator.generateAutoTickets(numberOfTicket);
     }
 
     public List<Ticket> getTickets() {
         return tickets;
     }
 
     public WinningStatus winningStatus(WinningNumber winningNumber) {
-        List<PrizeType> prizeTypes = listOfPrize(winningNumber);
-        return makeWinningStatus(prizeTypes);
+        List<Prize> prizeTypesOfTickets = listOfPrize(winningNumber);
+        return makeWinningStatus(prizeTypesOfTickets);
     }
 
-    public List<PrizeType> listOfPrize(WinningNumber winningNumber) {
+    public List<Prize> listOfPrize(WinningNumber winningNumber) {
         return tickets.stream()
                 .map(ticket -> ticket.checkLotteryWinningStatus(winningNumber))
                 .collect(Collectors.toList());
     }
 
-    private WinningStatus makeWinningStatus(List<PrizeType> prizeTypes) {
-        Map<PrizeType, Integer> winningStatus = new HashMap<>();
-        Arrays.stream(PrizeType.values())
-                .forEach(prizeType -> winningStatus.put(prizeType, countPrizeType(prizeTypes, prizeType)));
-        return WinningStatus.from(winningStatus);
-    }
-
-    public int countPrizeType(List<PrizeType> prizeTypes, PrizeType prizeType) {
-        return (int) prizeTypes.stream()
-                .filter(t -> t == prizeType)
-                .count();
+    private WinningStatus makeWinningStatus(List<Prize> prizeTypesOfTickets) {
+        return WinningStatus.from(prizeTypesOfTickets);
     }
 
     public double returnRate(WinningNumber winningNumber) {
@@ -65,10 +88,18 @@ public double returnRate(WinningNumber winningNumber) {
 
     private long sumOfPrize(WinningNumber winningNumber) {
         long sum = 0;
-        List<PrizeType> types = listOfPrize(winningNumber);
-        for (PrizeType type : types) {
+        List<Prize> types = listOfPrize(winningNumber);
+        for (Prize type : types) {
             sum += type.prize();
         }
         return sum;
     }
-}
+
+    public int getNumberOfManualTickets() {
+        return numberOfManualTickets;
+    }
+
+    public int getNumberOfAutoTickets() {
+        return numberOfAutoTickets;
+    }
+}

src/main/java/lotto/domain/Prize.java

@@ -0,0 +1,58 @@
+package lotto.domain;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public enum Prize {
+    FIRST_PRIZE(6, false, 2_000_000_000),
+
+    SECOND_PRIZE(5, true, 300_000_000),
+
+    THIRD_PRIZE(5, false, 1_500_000),
+
+    FOURTH_PRIZE(4, false, 50_000),
+
+    FIFTH_PRIZE(3, false, 5_000),
+
+    NOT_MATCHING(0, false, 0);
+
+    private final Integer numberOfMatching;
+    private final Boolean bonusMatching;
+    private final Long prize;
+
+    Prize(int numberOfMatching, boolean bonusMatching, long prize) {
+        this.numberOfMatching = numberOfMatching;
+        this.bonusMatching = bonusMatching;
+        this.prize = prize;
+    }
+
+    public int numberOfMatching() {
+        return numberOfMatching;
+    }
+
+    public static Prize create(int numberOfMatching, boolean bonusMatching) {
+        return Arrays.stream(Prize.values())
+                .filter(p -> p.numberOfMatching == numberOfMatching && p.bonusMatching == bonusMatching)
+                .findFirst()
+                .orElse(NOT_MATCHING);
+    }
+
+    public static Map<Prize, Integer> winningStatus(List<Prize> prizeTypesOfTickets) {
+        Map<Prize, Integer> map = new HashMap<>();
+        Arrays.stream(Prize.values())
+                .forEach(prizeType -> map.put(prizeType, countPrizeType(prizeTypesOfTickets, prizeType)));
+        return map;
+    }
+
+    private static int countPrizeType(List<Prize> prizeTypesOfTickets, Prize prize) {
+        return (int) prizeTypesOfTickets.stream()
+                .filter(t -> t == prize)
+                .count();
+    }
+
+    public long prize() {
+        return prize;
+    }
+}

src/main/java/lotto/domain/Ticket.java

@@ -1,39 +1,69 @@
 package lotto.domain;
 
+import lotto.exception.TicketNumberOutOfBoundException;
+
+import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class Ticket {
-    private final List<Integer> numbers;
+    private final List<LottoNo> numbers;
     public static final int MIN_LOTTO_NUMBER = 1;
     public static final int MAX_LOTTO_NUMBER = 45;
     public static final int SIZE_LOTTO_NUMBER = 6;
     public static final int LOTTO_PRICE = 1000;
 
-    private Ticket(List<Integer> numbers) {
+    private Ticket(List<LottoNo> numbers) {
         this.numbers = numbers;
     }
 
     public static Ticket from(List<Integer> numbers) {
-        return new Ticket(numbers);
+        return new Ticket(numbers.stream()
+                .map(LottoNo::from)
+                .collect(Collectors.toList()));
     }
 
-    public boolean checkValidTickets() {
-        return numbers.stream().allMatch(num -> num >= MIN_LOTTO_NUMBER && num <= MAX_LOTTO_NUMBER);
+    public static Ticket fromString(String input) {
+        return fromLottoNoList(splitAndMakeList(input));
+    }
+
+    public static Ticket fromLottoNoList(List<LottoNo> numbers) {
+        return new Ticket(numbers);
     }
 
-    public PrizeType checkLotteryWinningStatus(WinningNumber winningNumber) {
-        return PrizeType.create(countMatchingNumber(winningNumber), isBonusBallMatched(winningNumber));
+    public Prize checkLotteryWinningStatus(WinningNumber winningNumber) {
+        return Prize.create(countMatchingNumber(winningNumber), isBonusBallMatched(winningNumber));
     }
 
     public int countMatchingNumber(WinningNumber winningNumber) {
-        return winningNumber.countMatchingNumber(numbers);
+        return winningNumber.countMatchingNumber(Ticket.fromLottoNoList(numbers));
     }
 
     public boolean isBonusBallMatched(WinningNumber winningNumber) {
-        return winningNumber.isBonusBallMatched(numbers);
+        return winningNumber.isBonusBallMatched(Ticket.fromLottoNoList(numbers));
     }
 
-    public List<Integer> getNumbers() {
+    public List<LottoNo> getNumbers() {
         return numbers;
     }
+
+    public boolean contains(LottoNo target) {
+        return numbers.stream()
+                .anyMatch(lottoNo -> lottoNo.equals(target));
+    }
+
+    private static List<LottoNo> splitAndMakeList(String input) {
+        String[] split = input.split(",");
+        return Arrays.stream(split)
+                .map(String::trim)
+                .map(Integer::parseInt)
+                .map(num -> {
+                    try {
+                        return LottoNo.from(num);
+                    } catch (TicketNumberOutOfBoundException e) {
+                        throw new RuntimeException(e);
+                    }
+                })
+                .collect(Collectors.toList());
+    }
 }