🚀 4단계 - 로또(수동)

README.md

@@ -3,5 +3,5 @@
 🚀 3단계 - 로또(2등)
 ## 구현 기능 목록
 
-- [x] 2등을 위해 추가 번호를 하나 더 추첨한다.
-- [x] 당첨 통계에 2등을 추가한다.
+- [x] 현재 로또 생성기는 자동 생성 기능만 제공한다. 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다
+- [x] 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.

src/main/kotlin/lotto/controller/LottoController.kt

@@ -1,18 +1,23 @@
 package lotto.controller
 
 import lotto.domain.LottoPrice
+import lotto.domain.LottoPurchaseManager
 import lotto.service.LottoService
 import lotto.view.InputView
 import lotto.view.ResultView
 
 fun main() {
-    val purchaseAmount = InputView().readPurchaseAmount()
-    val lottos = LottoService().purchase(LottoPrice(purchaseAmount))
-    ResultView().printPurchaseResult(lottos)
+    val purchaseAmount = LottoPrice(InputView().readPurchaseAmount())
+
+    val manualCount = InputView().readManualLottoCount()
+    val manualLottos = InputView().readManualLottoNumbers(manualCount)
+
+    val lottos = LottoService(LottoPurchaseManager()).purchase(purchaseAmount, manualLottos)
+    ResultView().printPurchaseResult(manualCount, lottos)
 
     val winningNumbers = InputView().readWinningNumbers()
     val bonusBall = InputView().readBonusBall(winningNumbers)
-    val winningResult = LottoService().checkWinning(lottos, winningNumbers, bonusBall)
+    val winningResult = LottoService(LottoPurchaseManager()).checkWinning(lottos, winningNumbers, bonusBall)
 
     ResultView().printWinningStatistics(winningResult)
     ResultView().printProfitRate(winningResult.calculateProfitRate(purchaseAmount))

src/main/kotlin/lotto/domain/LottoFactory.kt

@@ -3,9 +3,8 @@ package lotto.domain
 import Lottos
 
 object LottoFactory {
-    fun create(price: LottoPrice): Lottos {
-        val purchaseCount = price.calculatePurchaseCount()
-        val tickets = (1..purchaseCount).map { LottoRandomGenerator.randomGenerate() }
+    fun create(count: Int): Lottos {
+        val tickets = (1..count).map { LottoRandomGenerator.randomGenerate() }
         return Lottos(tickets)
     }
 }

src/main/kotlin/lotto/domain/LottoPrice.kt

@@ -1,11 +1,14 @@
 package lotto.domain
 
 @JvmInline
-value class LottoPrice(val money: Int) {
+value class LottoPrice(private val money: Int) {
     init {
         require(money >= LottoConstants.LOTTO_PRICE) { "로또 구입 금액은 1000원 이상이어야 합니다." }
     }
 
+    val value: Int
+        get() = money
+
     fun calculatePurchaseCount(): Int {
         return money / LottoConstants.LOTTO_PRICE
     }

src/main/kotlin/lotto/domain/LottoPurchaseManager.kt

@@ -0,0 +1,17 @@
+package lotto.domain
+
+import Lottos
+
+class LottoPurchaseManager {
+    fun purchase(
+        price: LottoPrice,
+        manualLottos: Lottos,
+    ): Lottos {
+        val totalCount = price.calculatePurchaseCount()
+        val autoCount = totalCount - manualLottos.size
+        require(autoCount >= 0) { "수동 구매 개수가 총 구매 가능 개수를 초과했습니다." }
+
+        val autoLottos = LottoFactory.create(autoCount)
+        return Lottos(manualLottos + autoLottos)
+    }
+}

src/main/kotlin/lotto/domain/Lottos.kt

@@ -19,7 +19,16 @@ class Lottos(private val tickets: List<Lotto>) {
     ): Map<Rank, Int> {
         return tickets
             .map { it.match(winningNumber, bonusBall) }
-            .groupBy { it }
-            .mapValues { it.value.size }
+            .groupingBy {
+                it
+            }.eachCount()
+    }
+
+    operator fun plus(lotto: Lottos): List<Lotto> {
+        return tickets + lotto.tickets
+    }
+
+    companion object {
+        fun from(lottos: List<Lotto>): Lottos = Lottos(lottos)
     }
 }

src/main/kotlin/lotto/domain/WinningResult.kt

@@ -11,8 +11,8 @@ class WinningResult(private val winningStatistics: Map<Rank, Int>) {
         }
     }
 
-    fun calculateProfitRate(purchaseAmount: Int): Double {
-        return calculateTotalPrize().toDouble() / purchaseAmount
+    fun calculateProfitRate(purchaseAmount: LottoPrice): Double {
+        return calculateTotalPrize().toDouble() / purchaseAmount.value
     }
 
     fun getWinningCount(rank: Rank): Int {

src/main/kotlin/lotto/service/LottoService.kt

@@ -2,15 +2,18 @@ package lotto.service
 
 import Lottos
 import lotto.domain.Lotto
-import lotto.domain.LottoFactory
 import lotto.domain.LottoNumber
 import lotto.domain.LottoPrice
+import lotto.domain.LottoPurchaseManager
 import lotto.domain.WinningLotto
 import lotto.domain.WinningResult
 
-class LottoService {
-    fun purchase(price: LottoPrice): Lottos {
-        return LottoFactory.create(price)
+class LottoService(private val purchaseManager: LottoPurchaseManager) {
+    fun purchase(
+        price: LottoPrice,
+        manualLottos: Lottos,
+    ): Lottos {
+        return purchaseManager.purchase(price, manualLottos)
     }
 
     fun checkWinning(

src/main/kotlin/lotto/view/InputView.kt

@@ -1,5 +1,6 @@
 package lotto.view
 
+import Lottos
 import lotto.domain.Lotto
 import lotto.domain.LottoNumber
 
@@ -29,4 +30,23 @@ class InputView {
         require(!winningNumbers.numbers.contains(bonusBallNumber)) { "보너스 볼은 당첨 번호와 중복될 수 없습니다." }
         return bonusBallNumber
     }
+
+    fun readManualLottoCount(): Int {
+        println("\n수동으로 구매할 로또 수를 입력해 주세요.")
+        return readln().toInt()
+    }
+
+    fun readManualLottoNumbers(count: Int): Lottos {
+        println("\n수동으로 구매할 번호를 입력해 주세요.")
+
+        val manualLottos =
+            (1..count).map {
+                val numbers =
+                    readln().split(",")
+                        .map { it.trim().toInt() }
+                        .map { LottoNumber(it) }
+                Lotto(numbers)
+            }
+        return Lottos.from(manualLottos)
+    }
 }

src/main/kotlin/lotto/view/ResultView.kt

@@ -5,9 +5,13 @@ import lotto.domain.Rank
 import lotto.domain.WinningResult
 
 class ResultView {
-    fun printPurchaseResult(lottos: Lottos) {
-        println("${lottos.size}개를 구매했습니다.")
-        lottos.lottos.forEach { println(it) }
+    fun printPurchaseResult(
+        manualCount: Int,
+        lottos: Lottos,
+    ) {
+        val autoCount = lottos.size - manualCount
+        println("\n수동으로 ${manualCount}장, 자동으로 ${autoCount}장을 구매했습니다.")
+        lottos.lottos.forEach { println(it.numbers.map { num -> num.number }) }
     }
 
     fun printWinningStatistics(winningResult: WinningResult) {

src/test/kotlin/lotto/LottoGameTest.kt

@@ -4,6 +4,7 @@ import Lottos
 import lotto.domain.Lotto
 import lotto.domain.LottoNumber
 import lotto.domain.LottoPrice
+import lotto.domain.LottoPurchaseManager
 import lotto.domain.Rank
 import lotto.service.LottoService
 import org.assertj.core.api.Assertions.assertThat
@@ -17,12 +18,25 @@ class LottoGameTest {
     }
 
     @ParameterizedTest
-    @CsvSource("1000", "2000", "3000")
-    fun `구매한 로또 만큼 랜덤한 번호를 생성한다`(money: Int) {
+    @CsvSource(
+        "2000, 1",
+        "3000, 2",
+    )
+    fun `수동과 자동 로또를 합쳐서 구매 금액만큼 로또를 생성한다`(
+        money: Int,
+        manualCount: Int,
+    ) {
         val lottoPrice = LottoPrice(money)
-        val purchasedLottos = LottoService().purchase(lottoPrice)
+        val manualLottos =
+            List(manualCount) {
+                Lotto(createLottoNumbers(1, 2, 3, 4, 5, 6))
+            }
+
+        val purchasedLottos = LottoService(LottoPurchaseManager()).purchase(lottoPrice, Lottos(manualLottos))
 
         assertThat(purchasedLottos.size).isEqualTo(lottoPrice.calculatePurchaseCount())
+        assertThat(purchasedLottos.lottos.take(manualCount))
+            .containsExactlyElementsOf(manualLottos)
 
         purchasedLottos.lottos.forEach {
             assertThat(it.numbers.distinct().size).isEqualTo(6)
@@ -58,7 +72,7 @@ class LottoGameTest {
         val winningNumbers = Lotto(createLottoNumbers(1, 2, 3, 4, 5, 6))
         val bonusNumber = LottoNumber(7)
 
-        val winningResult = LottoService().checkWinning(lottos, winningNumbers, bonusNumber)
+        val winningResult = LottoService(LottoPurchaseManager()).checkWinning(lottos, winningNumbers, bonusNumber)
 
         assertThat(winningResult.getWinningCount(Rank.NONE)).isEqualTo(0)
     }
@@ -77,7 +91,7 @@ class LottoGameTest {
         val winningNumbers = Lotto(createLottoNumbers(1, 2, 3, 4, 5, 6))
         val bonusNumber = LottoNumber(7)
 
-        val winningResult = LottoService().checkWinning(lottos, winningNumbers, bonusNumber)
+        val winningResult = LottoService(LottoPurchaseManager()).checkWinning(lottos, winningNumbers, bonusNumber)
 
         assertThat(winningResult.getWinningCount(Rank.FIRST)).isEqualTo(1)
         assertThat(winningResult.getWinningCount(Rank.SECOND)).isEqualTo(1)
@@ -96,7 +110,7 @@ class LottoGameTest {
         val winningNumbers = Lotto(createLottoNumbers(1, 2, 3, 4, 5, 6))
         val bonusNumber = LottoNumber(7)
 
-        val winningResult = LottoService().checkWinning(lottos, winningNumbers, bonusNumber)
+        val winningResult = LottoService(LottoPurchaseManager()).checkWinning(lottos, winningNumbers, bonusNumber)
 
         assertThat(winningResult.getWinningCount(Rank.FIFTH)).isEqualTo(0)
         assertThat(winningResult.getWinningCount(Rank.FOURTH)).isEqualTo(0)
@@ -118,7 +132,7 @@ class LottoGameTest {
         val winningNumbers = Lotto(createLottoNumbers(1, 2, 3, 4, 5, 6))
         val bonusNumber = LottoNumber(7)
 
-        val winningResult = LottoService().checkWinning(lottos, winningNumbers, bonusNumber)
+        val winningResult = LottoService(LottoPurchaseManager()).checkWinning(lottos, winningNumbers, bonusNumber)
 
         assertThat(winningResult.getWinningCount(Rank.FIRST)).isEqualTo(1)
         assertThat(winningResult.getWinningCount(Rank.SECOND)).isEqualTo(1)

src/test/kotlin/lotto/WinningResultTest.kt

@@ -1,5 +1,6 @@
 package lotto
 
+import lotto.domain.LottoPrice
 import lotto.domain.Rank
 import lotto.domain.WinningResult
 import org.assertj.core.api.Assertions.assertThat
@@ -47,7 +48,7 @@ class WinningResultTest {
     @Test
     fun `수익률을 계산한다`() {
         val winningStatistics = mapOf(Rank.FOURTH to 1)
-        val purchaseAmount = 10000
+        val purchaseAmount = LottoPrice(10000)
         val winningResult = WinningResult(winningStatistics)
         val profitRate = winningResult.calculateProfitRate(purchaseAmount)
         assertThat(profitRate).isEqualTo(0.5)

src/test/kotlin/lotto/domain/RankTest.kt

@@ -0,0 +1,47 @@
+package lotto.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class RankTest {
+    @Test
+    fun `6개 맞추면 1등이다`() {
+        val rank = Rank.from(matchCount = 6, matchBonus = false)
+        assertThat(rank).isEqualTo(Rank.FIRST)
+    }
+
+    @Test
+    fun `5개와 보너스 볼을 맞추면 2등이다`() {
+        val rank = Rank.from(matchCount = 5, matchBonus = true)
+        assertThat(rank).isEqualTo(Rank.SECOND)
+    }
+
+    @Test
+    fun `5개 맞추고 보너스 볼을 못 맞추면 3등이다`() {
+        val rank = Rank.from(matchCount = 5, matchBonus = false)
+        assertThat(rank).isEqualTo(Rank.THIRD)
+    }
+
+    @Test
+    fun `4개 맞추면 4등이다`() {
+        val rank = Rank.from(matchCount = 4, matchBonus = false)
+        assertThat(rank).isEqualTo(Rank.FOURTH)
+    }
+
+    @Test
+    fun `3개 맞추면 5등이다`() {
+        val rank = Rank.from(matchCount = 3, matchBonus = false)
+        assertThat(rank).isEqualTo(Rank.FIFTH)
+    }
+
+    @Test
+    fun `2개 이하 맞추면 미당첨이다`() {
+        val rank2 = Rank.from(matchCount = 2, matchBonus = false)
+        val rank1 = Rank.from(matchCount = 1, matchBonus = false)
+        val rank0 = Rank.from(matchCount = 0, matchBonus = false)
+
+        assertThat(rank2).isEqualTo(Rank.NONE)
+        assertThat(rank1).isEqualTo(Rank.NONE)
+        assertThat(rank0).isEqualTo(Rank.NONE)
+    }
+}