[그리디] 하수한 로또 미션 3, 4, 5단계 제출합니다.

src/main/java/io/suhan/lotto/Main.java

@@ -1,6 +1,6 @@
 package io.suhan.lotto;
 
-import io.suhan.lotto.model.lotto.LottoController;
+import io.suhan.lotto.controller.LottoController;
 
 public class Main {
     public static void main(String[] args) {

src/main/java/io/suhan/lotto/model/lotto/LottoController.java → src/main/java/io/suhan/lotto/controller/LottoController.java

@@ -1,11 +1,17 @@
-package io.suhan.lotto.model.lotto;
+package io.suhan.lotto.controller;
+
+import static io.suhan.lotto.model.executor.PurchaseExecutor.PRICE_PER_LOTTO;
 
 import io.suhan.lotto.model.executor.DrawExecutor;
 import io.suhan.lotto.model.executor.PurchaseExecutor;
+import io.suhan.lotto.model.lotto.Lotto;
+import io.suhan.lotto.model.lotto.LottoFactory;
+import io.suhan.lotto.model.lotto.LottoNumber;
+import io.suhan.lotto.model.lotto.LottoRegistry;
+import io.suhan.lotto.model.lotto.LottoStatistics;
 import io.suhan.lotto.view.InputView;
 import io.suhan.lotto.view.OutputView;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 public class LottoController {
     private final LottoRegistry registry;
@@ -16,7 +22,7 @@ public LottoController() {
 
     public void run() {
         try {
-            int balance = InputView.getBalance();
+            int balance = InputView.getValidBalance();
 
             executePurchase(balance);
             executeDraw(balance);
@@ -26,7 +32,13 @@ public void run() {
     }
 
     private void executePurchase(int balance) {
-        PurchaseExecutor purchaseExecutor = new PurchaseExecutor(registry, balance);
+        int manualCount = InputView.getValidManualCount();
+
+        if (PRICE_PER_LOTTO * manualCount > balance) {
+            throw new IllegalArgumentException("금액이 부족합니다.");
+        }
+
+        PurchaseExecutor purchaseExecutor = new PurchaseExecutor(registry, balance, manualCount);
         purchaseExecutor.execute();
 
         OutputView.printPurchaseResult(registry.getLottos());
@@ -35,7 +47,9 @@ private void executePurchase(int balance) {
     private void executeDraw(int balance) {
         Lotto winningLotto = createWinningLotto();
 
-        DrawExecutor drawExecutor = new DrawExecutor(registry, winningLotto);
+        LottoNumber bonusNumber = InputView.getValidBonusNumber();
+
+        DrawExecutor drawExecutor = new DrawExecutor(registry, winningLotto, bonusNumber);
         drawExecutor.execute();
 
         LottoStatistics statistics = new LottoStatistics(drawExecutor.getResults());
@@ -44,11 +58,8 @@ private void executeDraw(int balance) {
     }
 
     private Lotto createWinningLotto() {
-        Set<LottoNumber> wonNumbers = InputView.getWonNumbers()
-                .stream()
-                .map(LottoNumber::new)
-                .collect(Collectors.toSet());
+        Set<LottoNumber> wonNumbers = LottoFactory.toLottoNumbers(InputView.getValidWonNumbers());
 
-        return new Lotto(wonNumbers);
+        return Lotto.of(wonNumbers);
     }
 }

src/main/java/io/suhan/lotto/model/DrawResult.java

@@ -2,16 +2,22 @@
 
 public class DrawResult {
     private final int matchedCount;
+    private final Rank rank;
 
-    private DrawResult(int matchedCount) {
+    private DrawResult(int matchedCount, boolean bonusMatched) {
         this.matchedCount = matchedCount;
+        this.rank = Rank.of(matchedCount, bonusMatched);
     }
 
-    public static DrawResult of(int matchedCount) {
-        return new DrawResult(matchedCount);
+    public static DrawResult of(int matchedCount, boolean bonusMatched) {
+        return new DrawResult(matchedCount, bonusMatched);
     }
 
     public int getMatchedCount() {
         return matchedCount;
     }
+
+    public Rank getRank() {
+        return rank;
+    }
 }

src/main/java/io/suhan/lotto/model/NumberPool.java

@@ -2,6 +2,7 @@
 
 import io.suhan.lotto.model.lotto.Lotto;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public class NumberPool {
@@ -39,6 +40,6 @@ private List<Integer> generateNumbersInRange(int from, int to) {
     }
 
     public List<Integer> getNumbers() {
-        return numbers;
+        return Collections.unmodifiableList(numbers);
     }
 }

src/main/java/io/suhan/lotto/model/Rank.java

@@ -0,0 +1,48 @@
+package io.suhan.lotto.model;
+
+import java.util.Arrays;
+
+public enum Rank {
+    FIRST(6, false, 2000000000, "6개 일치"),
+    SECOND(5, true, 30000000, "5개 일치, 보너스 볼 일치"),
+    THIRD(5, false, 1500000, "5개 일치"),
+    FOURTH(4, false, 50000, "4개 일치"),
+    FIFTH(3, false, 5000, "3개 일치"),
+    NONE(0, false, 0, ""); // fallback
+
+    private final int matchedCount;
+    private final boolean bonusRequired;
+    private final int prize;
+    private final String description;
+
+    Rank(int matchedCount, boolean bonusRequired, int prize, String description) {
+        this.matchedCount = matchedCount;
+        this.bonusRequired = bonusRequired;
+        this.prize = prize;
+        this.description = description;
+    }
+
+    public static Rank of(int matchedCount, boolean bonusMatched) {
+        return Arrays.stream(Rank.values())
+                .filter((rank) -> rank.getMatchedCount() == matchedCount)
+                .filter((rank) -> rank.isBonusRequired() == bonusMatched)
+                .findFirst()
+                .orElse(Rank.NONE);
+    }
+
+    public int getMatchedCount() {
+        return matchedCount;
+    }
+
+    public boolean isBonusRequired() {
+        return bonusRequired;
+    }
+
+    public int getPrize() {
+        return prize;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+}

src/main/java/io/suhan/lotto/model/executor/DrawExecutor.java

@@ -12,19 +12,26 @@
 public class DrawExecutor implements Executor {
     private final LottoRegistry registry;
     private final Lotto winningLotto;
+    private final LottoNumber bonusNumber;
     private final List<DrawResult> results;
 
-    public DrawExecutor(LottoRegistry registry, Lotto winningLotto) {
+    public DrawExecutor(LottoRegistry registry, Lotto winningLotto, LottoNumber bonusNumber) {
         this.registry = registry;
         this.winningLotto = winningLotto;
+        this.bonusNumber = bonusNumber;
         this.results = new ArrayList<>();
     }
 
     @Override
     public void execute() {
+        if (winningLotto.getNumbers().contains(bonusNumber)) {
+            throw new IllegalArgumentException("보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+        }
+
         for (Lotto lotto : registry.getLottos()) {
             int matchedCount = calculateMatchedCount(lotto, winningLotto);
-            results.add(DrawResult.of(matchedCount));
+            boolean bonusMatched = isBonusMatched(matchedCount, lotto);
+            results.add(DrawResult.of(matchedCount, bonusMatched));
         }
     }
 
@@ -35,6 +42,14 @@ private int calculateMatchedCount(Lotto lotto, Lotto winningLotto) {
         return numbers.size();
     }
 
+    private boolean isBonusMatched(int matchedCount, Lotto lotto) {
+        if (matchedCount != Lotto.LOTTO_SIZE - 1) {
+            return false;
+        }
+
+        return lotto.getNumbers().contains(bonusNumber);
+    }
+
     public List<DrawResult> getResults() {
         return results;
     }

src/main/java/io/suhan/lotto/model/executor/PurchaseExecutor.java

@@ -1,25 +1,47 @@
 package io.suhan.lotto.model.executor;
 
+import io.suhan.lotto.model.lotto.Lotto;
 import io.suhan.lotto.model.lotto.LottoFactory;
 import io.suhan.lotto.model.lotto.LottoRegistry;
+import io.suhan.lotto.model.lotto.LottoType;
+import io.suhan.lotto.view.InputView;
+import java.util.List;
+import java.util.Set;
 
 public class PurchaseExecutor implements Executor {
     public static final int PRICE_PER_LOTTO = 1000;
 
     private final LottoRegistry registry;
-    private final int balance;
+    private int balance;
+    private final int manualCount;
 
-    public PurchaseExecutor(LottoRegistry registry, int balance) {
+    public PurchaseExecutor(LottoRegistry registry, int balance, int manualCount) {
         this.registry = registry;
         this.balance = balance;
+        this.manualCount = manualCount;
     }
 
     @Override
     public void execute() {
-        int count = getAvailableCount(balance);
+        if (manualCount > 0) {
+            purchaseManualNumbers();
+        }
+
+        int autoCount = getAvailableCount(balance);
+
+        for (int i = 0; i < autoCount; i++) {
+            registry.add(LottoFactory.createLotto(LottoType.AUTOMATIC));
+        }
+    }
+
+    private void purchaseManualNumbers() {
+        List<Set<Integer>> manualNumbersList = InputView.getValidManualNumbers(manualCount);
+
+        for (Set<Integer> numbers : manualNumbersList) {
+            Lotto lotto = Lotto.of(LottoType.MANUAL, LottoFactory.toLottoNumbers(numbers));
 
-        for (int i = 0; i < count; i++) {
-            registry.add(LottoFactory.createLotto());
+            registry.add(lotto);
+            balance -= PRICE_PER_LOTTO;
         }
     }
 

src/main/java/io/suhan/lotto/model/lotto/Lotto.java

@@ -1,5 +1,6 @@
 package io.suhan.lotto.model.lotto;
 
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.Set;
@@ -9,22 +10,36 @@ public class Lotto {
     public static final int LOTTO_NUMBER_MIN = 1;
     public static final int LOTTO_NUMBER_MAX = 45;
 
+    private final LottoType type;
     private final Set<LottoNumber> numbers;
 
-    public Lotto(Set<LottoNumber> numbers) {
+    private Lotto(LottoType type, Set<LottoNumber> numbers) {
         if (numbers.size() != LOTTO_SIZE) {
             throw new IllegalArgumentException("로또 번호는 " + LOTTO_SIZE + "개여야 합니다.");
         }
 
+        this.type = type;
         this.numbers = new HashSet<>(numbers);
     }
 
+    public static Lotto of(Set<LottoNumber> numbers) {
+        return new Lotto(LottoType.AUTOMATIC, numbers);
+    }
+
+    public static Lotto of(LottoType type, Set<LottoNumber> numbers) {
+        return new Lotto(type, numbers);
+    }
+
     @Override
     public String toString() {
         return numbers.stream().sorted(Comparator.comparingInt(LottoNumber::getValue)).toList().toString();
     }
 
+    public LottoType getType() {
+        return type;
+    }
+
     public Set<LottoNumber> getNumbers() {
-        return numbers;
+        return Collections.unmodifiableSet(numbers);
     }
 }

src/main/java/io/suhan/lotto/model/lotto/LottoFactory.java

@@ -3,18 +3,17 @@
 import io.suhan.lotto.model.NumberPool;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
 public class LottoFactory {
-    public static Lotto createLotto() {
+    public static Lotto createLotto(LottoType type) {
         NumberPool pool = NumberPool.of(Lotto.LOTTO_NUMBER_MIN, Lotto.LOTTO_NUMBER_MAX);
-        return createLotto(pool);
+        return createLotto(type, pool);
     }
 
-    private static Lotto createLotto(NumberPool pool) {
+    public static Lotto createLotto(LottoType type, NumberPool pool) {
         List<Integer> poolNumbers = new ArrayList<>(pool.getNumbers()); // copy
         Collections.shuffle(poolNumbers);
 
@@ -23,6 +22,16 @@ private static Lotto createLotto(NumberPool pool) {
                 .map(LottoNumber::new)
                 .collect(Collectors.toSet());
 
-        return new Lotto(numbers);
+        return Lotto.of(type, numbers);
+    }
+
+    public static Set<LottoNumber> toLottoNumbers(Set<Integer> numbers) {
+        return numbers.stream()
+                .map(LottoNumber::new)
+                .collect(Collectors.toSet());
+    }
+
+    public static int getManualLottosCount(List<Lotto> lottos) {
+        return lottos.stream().filter((lotto) -> lotto.getType() == LottoType.MANUAL).toList().size();
     }
 }

src/main/java/io/suhan/lotto/model/lotto/LottoRegistry.java

@@ -1,6 +1,7 @@
 package io.suhan.lotto.model.lotto;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public class LottoRegistry {
@@ -15,6 +16,6 @@ public void add(Lotto lotto) {
     }
 
     public List<Lotto> getLottos() {
-        return lottos;
+        return Collections.unmodifiableList(lottos);
     }
 }