Step4

README.md

@@ -12,7 +12,7 @@
 - [x] 로또 래퍼 클래스 구현
   - [x] 로또 생성자 빈값 입력 예외 처리 검증
 - [x] 구입금액 입력 기능
-  - [ ] 구입금액 최소 단위 제한(백원 이하 오류 처리)
+  - [X] 구입금액 최소 단위 제한(백원 이하 오류 처리)
 - [X] 랜덤 로또 번호 발급 기능
   - [x] 로또 래퍼 클래스 반환
   - [x] 로또 번호 6자리 생성
@@ -28,3 +28,5 @@
 - [x] 수익률 산출 기능
 - [X] 보너스 번호 입력 기능
 - [X] 2등 상금 추가
+- [X] 수동 발급 추가
+- [x] 예산 지불 추가

src/main/java/lotto/controller/LottoController.java

@@ -11,22 +11,43 @@ public void simulateLotto() {
     }
 
     private Statistics getStatistics() {
-        return getLottos().computeStatistic(getWinLotto());
+        return getLottos(getBudget()).computeStatistic(getWinLotto());
     }
 
     private WinLotto getWinLotto() {
-        return InputView.inputLastWinLotto();
+        return InputView.retryableInputLastWinLotto();
     }
 
-    private Lottos getLottos() {
-        Lottos lottos = new Lottos(getBudget());
-        ResultView.showGeneratedLottos(lottos);
+    private Lottos getLottos(Budget budget) {
+        Count manualIssueCount = getManualIssueCount(budget);
+
+        budget = budget.spend(Price.LOTTO, manualIssueCount);
+
+        Lottos manualLottos = getManualIssuedLottos(manualIssueCount);
+        Lottos autoLottos = getAutoIssuedLottos(budget);
+
+        ResultView.showLottoQuantity(manualLottos, autoLottos);
+
+        Lottos allLottos = manualLottos.combine(autoLottos);
+        ResultView.showGeneratedLottos(allLottos);
+
+        return allLottos;
+    }
+
+    private Count getManualIssueCount(Budget budget) {
+        return InputView.retryableInputSelfIssueCount(budget);
+    }
+
+    private Lottos getManualIssuedLottos(Count count) {
+        return InputView.inputSelfIssueLottos(count);
+    }
+    private Lottos getAutoIssuedLottos(Budget budget) {
+        Lottos lottos = new Lottos(budget);
         return lottos;
     }
 
     private Budget getBudget() {
-        Budget budget = InputView.inputBuyBudget();
-        ResultView.showLottoQuantity(budget.divide(Lotto.LOTTO_PRICE));
+        Budget budget = InputView.retryableInputBuyBudget();
         return budget;
     }
 

src/main/java/lotto/domain/Budget.java

@@ -1,18 +1,36 @@
 package lotto.domain;
 
-public class Budget {
+public class Budget{
 
-    private int value;
+    private int budget;
 
     public Budget(int budget) {
-        this.value = budget;
+        validMinValue(budget);
+        this.budget = budget;
     }
 
-    public int getValue() {
-        return value;
+    private void validMinValue(int budget) {
+        if(budget % 1000 != 0)
+            throw new IllegalArgumentException("100원 단위는 입력할 수 없습니다: " + budget);
     }
 
-    public int divide(int lottoPrice) {
-        return value / lottoPrice;
+    public int purchasableQuantity(Price price) {
+        return price.divide(budget);
+    }
+
+    public boolean isEnoughToPay(Price price) {
+        return price.isEnough(budget);
+    }
+
+    public boolean isEnoughToPay(Price price, int count) {
+        return price.isEnough(budget, count);
+    }
+
+    public Budget spend(Price price) {
+        return new Budget(budget - price.getValue());
+    }
+
+    public Budget spend(Price price, Count issueCount) {
+        return new Budget(budget - price.multiple(issueCount));
     }
 }

src/main/java/lotto/domain/Count.java

@@ -0,0 +1,47 @@
+package lotto.domain;
+
+public class Count implements Comparable<Count>{
+
+    private int count;
+
+    public Count(int count) {
+        this(count, null);
+    }
+
+    public Count(int count, Budget budget) {
+        validPositiveValue(count);
+        validEnableCount(count, budget);
+        this.count = count;
+    }
+
+    private void validEnableCount(int count, Budget budget) {
+        if(budget == null) {
+            return;
+        }
+        if(!budget.isEnoughToPay(Price.LOTTO, count)){
+            throw new IllegalArgumentException("구매 가능 수량을 초과했습니다: " + count);
+        }
+    }
+
+    private void validPositiveValue(int count) {
+        if (count < 0)
+            throw new IllegalArgumentException("양수 값만 입력할 수 있습니다: " + count);
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public boolean isPositive() {
+        return count > 0;
+    }
+
+    public Count decrease() {
+        return new Count(count - 1);
+    }
+
+    @Override
+    public int compareTo(Count that) {
+        return this.count - that.count;
+    }
+}

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

@@ -1,46 +1,75 @@
 package lotto.domain;
 
-import java.util.List;
+import java.util.HashSet;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Collectors;
 
-public class Lotto {
+public class Lotto implements Comparable<Lotto>{
 
     public static final int LOTTO_PRICE = 1000;
-    private List<LottoNumber> lotto;
+    private Set<LottoNumber> lotto;
 
     public Lotto() {
         this(LottoNumbers.issueNumbers());
     }
 
-    public Lotto(List<LottoNumber> lotto) {
+    public Lotto(Set<LottoNumber> lotto) {
         validEmpty(lotto);
+        validLottoSize(lotto);
         this.lotto = lotto;
     }
 
-    public static Lotto ofNumbers(List<Integer> lottoNumbers) {
+    public static Lotto ofNumbers(Set<Integer> lottoNumbers) {
         validEmpty(lottoNumbers);
-        return new Lotto(lottoNumbers.stream().map(LottoNumber::new).collect(Collectors.toList()));
+        return new Lotto(getLottoNumbers(lottoNumbers));
     }
 
-    private static void validEmpty(List<?> lotto) {
+    private static Set<LottoNumber> getLottoNumbers(Set<Integer> lottoNumbers) {
+        return lottoNumbers.stream()
+                .map(LottoNumber::new)
+                .collect(Collectors.toSet());
+    }
+
+    private static void validEmpty(Set<?> lotto) {
         if (lotto == null || lotto.isEmpty()) {
             throw new IllegalArgumentException("입력값이 없습니다");
         }
     }
 
-    public List<LottoNumber> getLotto() {
+    private static void validLottoSize(Set<?> lotto) {
+        if(lotto.size() != 6) {
+            throw new IllegalArgumentException("유효한 Lotto size가 아닙니다: " + lotto.size());
+        }
+    }
+
+    public Set<LottoNumber> getLotto() {
         return lotto;
     }
 
     public int size() {
         return lotto.size();
     }
 
+    public boolean isContainBonus(LottoNumber bonus) {
+        return lotto.contains(bonus);
+    }
+
+    @Override
+    public int compareTo(Lotto that) {
+        Set<LottoNumber> compareSet = new HashSet<>(lotto);
+        compareSet.retainAll(that.lotto);
+        return compareSet.size();
+    }
+
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
         Lotto lotto1 = (Lotto) o;
         return Objects.equals(lotto, lotto1.lotto);
     }

src/main/java/lotto/domain/LottoNumbers.java

@@ -1,8 +1,6 @@
 package lotto.domain;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -18,11 +16,11 @@ private static List<LottoNumber> initialLottoRange() {
         return lottoNumbers;
     }
 
-    public static List<LottoNumber> issueNumbers() {
+    public static Set<LottoNumber> issueNumbers() {
         List<LottoNumber> issueNumbers = new ArrayList<>(LOTTO_NUMBERS);
         Collections.shuffle(issueNumbers);
         issueNumbers = issueNumbers.subList(0, LOTTO_SIZE);
         Collections.sort(issueNumbers);
-        return issueNumbers;
+        return new HashSet<>(issueNumbers);
     }
 }

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

@@ -4,6 +4,8 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static lotto.domain.Price.LOTTO;
+
 public class Lottos {
 
     private List<Lotto> lottos;
@@ -12,15 +14,21 @@ public Lottos(Budget budget) {
         this(generateLottosBy(budget));
     }
 
+    public Lottos(Lotto lotto) {
+        this(List.of(lotto));
+    }
+
     public Lottos(List<Lotto> lottos) {
         this.lottos = lottos;
     }
 
     private static List<Lotto> generateLottosBy(Budget budget) {
         List<Lotto> lottos = new ArrayList<>();
 
-        for (int i = 0; i < budget.divide(Lotto.LOTTO_PRICE); i++) {
+        if (budget.isEnoughToPay(LOTTO)) {
+            lottos.addAll(generateLottosBy(budget.spend(LOTTO)));
             lottos.add(new Lotto());
+            return lottos;
         }
         return lottos;
     }
@@ -29,6 +37,10 @@ public List<Lotto> getLottos() {
         return lottos;
     }
 
+    public int size() {
+        return lottos.size();
+    }
+
     public Statistics computeStatistic(WinLotto winLotto) {
         return new Statistics(checkStatisticNumberMatch(winLotto));
     }
@@ -45,4 +57,11 @@ private static Statistic getStatistic(WinLotto winLotto, Lotto lotto) {
                 winLotto.isContainBonus(lotto)
         );
     }
+
+    public Lottos combine(Lottos lottos) {
+        List<Lotto> newLottos = new ArrayList<>(this.lottos);
+        List<Lotto> combineLottos = lottos.getLottos();
+        newLottos.addAll(combineLottos);
+        return new Lottos(newLottos);
+    }
 }

src/main/java/lotto/domain/Price.java

@@ -0,0 +1,32 @@
+package lotto.domain;
+
+public enum Price {
+
+    LOTTO(1000);
+
+    private final int value;
+
+    Price(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public int multiple(Count count) {
+        return count.getCount() * value;
+    }
+
+    public int divide(int budget) {
+        return budget / value;
+    }
+
+    public boolean isEnough(int budget) {
+        return value <= budget;
+    }
+
+    public boolean isEnough(int budget, int count) {
+        return value * count <= budget;
+    }
+}