4단계 - 로또(수동)

README.md

@@ -3,7 +3,9 @@
 - 로또 1장의 가격은 1,000원이다.
 - 2등을 위해 추가 번호를 하나 더 추첨한다.
 - 당첨 통계에 2등도 추가해야 한다.
-
+- 현재 로또 생성기는 자동 생성 기능만 제공한다. 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다.
+- 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.
+- 
 ## 기능 설계
 - [x] 로또 번호는 1부터 45사이 값이 아니면 에러가 발생한다
 - [x] 로또 번호는 value class로 관리된다
@@ -13,9 +15,9 @@
 - [x] 비용을 지불해 한번에 여러장 로또를 구입할 수 있다
   - [x] 로또 구입 비용이 1,000원 미만일 경우 에러가 발생한다
   - [x] 로또 구입 비용이 1,000원 단위가 아닐 경우 에러가 발생한다
-  - [x] 로또 구입 비용에 대해 몇 장의 로또가 구입 됐는지 확인활 수 있다
-- [x] 로또 번호가 1부터 45사이의 숫자가 아니면 에러가 발생한다
-- [x] 로또 번호를 6개로 지정할 경우가 아니면 에러가 발생한다 (예를 들어 5개 또는 7개)
+  - [x] 로또 구입 비용에 대해 몇 장의 로또가 구입될 수 있는지 확인활 수 있다
+- [x] 로또 번호를 수동으로 부여할 수 있다
+- [x] 수동 로또를 여러개 구입할 수 있다
 - [x] 로또 번호를 자동으로 부여한다
   - [x] 로또 번호는 1부터 45사이의 중복되지 않는 숫자 6개로 이루어져야한다
 - [x] 로또 당첨 번호를 입력할 수 있다

src/main/kotlin/lotto/application/LottoApplication.kt

@@ -3,7 +3,10 @@ package lotto.application
 import lotto.controller.LottoController
 
 fun main() {
-    val purchasedLottoTickets = LottoController.purchaseLotto()
+    val maxPurchaseLottoCount = LottoController.getMaxPurchaseLottoCountFromPayment()
+    val manualLottoTickets = LottoController.purchaseManualLotto(maxPurchaseLottoCount)
+    val totalLottoTickets = LottoController.createAutoLotto(maxPurchaseLottoCount, manualLottoTickets)
     val lottoWinnerNumbers = LottoController.createWinningLottoNumbers()
-    LottoController.resultPayout(purchasedLottoTickets = purchasedLottoTickets, lottoWinnerNumbers = lottoWinnerNumbers)
+
+    LottoController.resultPayout(lottoTickets = totalLottoTickets, lottoWinnerNumbers = lottoWinnerNumbers)
 }

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

@@ -1,40 +1,59 @@
 package lotto.controller
 
-import lotto.domain.LottoNumber
-import lotto.domain.LottoNumbers
-import lotto.domain.LottoTicketIssuer
+import lotto.domain.AutoLottoIssuer
+import lotto.domain.LottoNumberGenerator
+import lotto.domain.LottoPurchaseCalculator
+import lotto.domain.LottoTickets
 import lotto.domain.LottoWinnerNumbers
-import lotto.domain.PurchasedLottoTickets
-import lotto.domain.generateLottoNumbers
 import lotto.view.LottoPayoutView
-import lotto.view.PurchaseLottoResultView
+import lotto.view.ManualLottoView
 import lotto.view.PurchaseLottoView
 import lotto.view.WinnerLottoNumberView
 
 object LottoController {
-    fun purchaseLotto(): PurchasedLottoTickets {
+    fun getMaxPurchaseLottoCountFromPayment(): Int {
         val amountPaid = PurchaseLottoView.inputPurchaseCost()
+        return LottoPurchaseCalculator.getMaxPurchasedLottoTicketCount(amountPaid)
+    }
+
+    fun purchaseManualLotto(maxPurchaseLottoCount: Int): LottoTickets {
+        val manualLottoCount = ManualLottoView.inputManualLottoCount(maxPurchaseLottoCount)
+        return ManualLottoView.repeatInputManualLottoNumbers(manualLottoCount)
+    }
 
-        val purchasedLottoTickets =
-            LottoTicketIssuer.issueTickets(amountPaid = amountPaid, generateLottoNumbers = { generateLottoNumbers() })
+    fun createAutoLotto(
+        maxPurchaseLottoCount: Int,
+        manualLottoTickets: LottoTickets,
+    ): LottoTickets {
+        val autoLottoCount = maxPurchaseLottoCount - manualLottoTickets.lottoTickets.size
 
-        PurchaseLottoResultView.displayPurchaseLottoResults(purchasedLottoTickets = purchasedLottoTickets)
+        val autoLottoTickets =
+            AutoLottoIssuer.issueAutoLottoTickets(autoLottoCount) {
+                LottoNumberGenerator.generateAutoLottoNumbers()
+            }
 
-        return purchasedLottoTickets
+        PurchaseLottoView.displayPurchasedLottosView(
+            manualLottoTickets = manualLottoTickets,
+            autoLottoTickets = autoLottoTickets,
+        )
+
+        val combinedManualLottoAndAutoLotto = manualLottoTickets.lottoTickets.plus(autoLottoTickets.lottoTickets)
+
+        return LottoTickets(combinedManualLottoAndAutoLotto)
     }
 
     fun createWinningLottoNumbers(): LottoWinnerNumbers {
         val inputLottoNumbers = WinnerLottoNumberView.inputWinningLottoNumbers()
-        val lottoNumbers = LottoNumbers(inputLottoNumbers.map { LottoNumber.of(it) }.toSet())
         val inputBonusNumber = WinnerLottoNumberView.inputBonusNumber()
-        return LottoWinnerNumbers(lottoNumbers = lottoNumbers, bonusNumber = LottoNumber.of(inputBonusNumber))
+
+        return LottoWinnerNumbers(lottoNumbers = inputLottoNumbers, bonusNumber = inputBonusNumber)
     }
 
     fun resultPayout(
-        purchasedLottoTickets: PurchasedLottoTickets,
+        lottoTickets: LottoTickets,
         lottoWinnerNumbers: LottoWinnerNumbers,
     ) {
-        val purchasedLottoResults = lottoWinnerNumbers.resultLottoPayout(purchasedLottoTickets)
+        val purchasedLottoResults = lottoWinnerNumbers.resultLottoPayout(lottoTickets)
         return LottoPayoutView.displayWinningStatistics(purchasedLottoResults = purchasedLottoResults)
     }
 }

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

@@ -0,0 +1,14 @@
+package lotto.domain
+
+object AutoLottoIssuer {
+    fun issueAutoLottoTickets(
+        autoLottoCount: Int,
+        generateLottoNumbers: () -> LottoNumbers,
+    ): LottoTickets {
+        val autoLottoTickets = mutableListOf<LottoTicket.AutoLottoTicket>()
+
+        repeat(autoLottoCount) { autoLottoTickets.add(LottoTicket.AutoLottoTicket { generateLottoNumbers() }) }
+
+        return LottoTickets(autoLottoTickets)
+    }
+}

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

@@ -1,10 +1,13 @@
 package lotto.domain
 
-import lotto.domain.LottoNumber.Companion.LOTTO_NUMBER_MAX_VALUE
-import lotto.domain.LottoNumber.Companion.LOTTO_NUMBER_MIN_VALUE
-import lotto.domain.LottoNumbers.Companion.LOTTO_NUMBER_COUNT
+object LottoNumberGenerator {
+    fun generateAutoLottoNumbers(): LottoNumbers {
+        val randomNumbers = generatorRandomNumber()
+        return LottoNumbers(randomNumbers.map { LottoNumber.of(it) }.toSet())
+    }
 
-fun generateLottoNumbers(): Set<Int> {
-    return (LOTTO_NUMBER_MIN_VALUE..LOTTO_NUMBER_MAX_VALUE)
-        .toSet().shuffled().take(LOTTO_NUMBER_COUNT).sorted().toSet()
+    fun generatorRandomNumber(): List<Int> {
+        return (LottoNumber.LOTTO_NUMBER_MIN_VALUE..LottoNumber.LOTTO_NUMBER_MAX_VALUE)
+            .shuffled().take(LottoNumbers.LOTTO_NUMBER_COUNT).sorted()
+    }
 }

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

@@ -0,0 +1,18 @@
+package lotto.domain
+
+object LottoPurchaseCalculator {
+    fun getMaxPurchasedLottoTicketCount(amountPaid: Int): Int {
+        checkAmountPaid(amountPaid)
+        return amountPaid / DEFAULT_LOTTO_PRICE
+    }
+
+    private fun checkAmountPaid(amountPaid: Int) {
+        require(amountPaid >= DEFAULT_LOTTO_PRICE) { INVALID_MIN_COST_LOTTO_PAID_MESSAGE }
+        require(amountPaid % DEFAULT_LOTTO_PRICE == CHECK_SURPLUS) { INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE }
+    }
+
+    const val DEFAULT_LOTTO_PRICE: Int = 1000
+    private const val CHECK_SURPLUS: Int = 0
+    private const val INVALID_MIN_COST_LOTTO_PAID_MESSAGE: String = "로또 구입 비용은 최소 1,000원 이상 이어야 합니다"
+    private const val INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE: String = "로또 구입 비용은 1,000원 단위로 지불해야 합니다"
+}

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

@@ -1,11 +1,17 @@
 package lotto.domain
 
-data class LottoTicket(private val generateLottoNumbers: () -> Set<Int>) {
-    val lottoNumbers = LottoNumbers(generateLottoNumbers().map { LottoNumber.of(it) }.toSet())
+sealed class LottoTicket {
+    abstract val lottoNumbers: LottoNumbers
 
     fun checkLottoWinnerRank(lottoWinnerNumbers: LottoWinnerNumbers): LottoWinnerRank {
         val matchCount = lottoNumbers.checkLottoNumbersMatch(lottoWinnerNumbers.lottoNumbers)
         val bonusCheck = lottoNumbers.contains(lottoWinnerNumbers.bonusNumber)
         return LottoWinnerRank.getRankByMatches(matchCount = matchCount, bonusCheck = bonusCheck)
     }
+
+    class ManualLottoTicket(override val lottoNumbers: LottoNumbers) : LottoTicket()
+
+    class AutoLottoTicket(private val generateLottoNumbers: () -> LottoNumbers) : LottoTicket() {
+        override val lottoNumbers: LottoNumbers = generateLottoNumbers()
+    }
 }

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

@@ -0,0 +1,3 @@
+package lotto.domain
+
+data class LottoTickets(val lottoTickets: List<LottoTicket>)

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

@@ -5,15 +5,15 @@ data class LottoWinnerNumbers(val lottoNumbers: LottoNumbers, val bonusNumber: L
         require(!lottoNumbers.contains(bonusNumber)) { INVALID_WINNER_NUMBERS_MESSAGE }
     }
 
-    fun resultLottoPayout(purchasedLottoTickets: PurchasedLottoTickets): PurchasedLottoResults {
+    fun resultLottoPayout(lottoTickets: LottoTickets): PurchasedLottoResults {
         val rankCounts: Map<LottoWinnerRank, Int> =
-            purchasedLottoTickets.purchasedLottoTickets
+            lottoTickets.lottoTickets
                 .map { lottoTicket -> lottoTicket.checkLottoWinnerRank(this) }
                 .groupingBy { it }
                 .eachCount()
 
         return PurchasedLottoResults(
-            purchasedCount = purchasedLottoTickets.purchasedCount,
+            purchasedCount = lottoTickets.lottoTickets.size,
             firstRankCount = rankCounts[LottoWinnerRank.FIRST] ?: 0,
             secondRankCount = rankCounts[LottoWinnerRank.SECOND] ?: 0,
             thirdRankCount = rankCounts[LottoWinnerRank.THIRD] ?: 0,

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

@@ -1,8 +1,6 @@
 package lotto.domain
 
-import lotto.domain.LottoTicketIssuer.DEFAULT_LOTTO_PRICE
-import lotto.domain.PurchasedLottoTickets.Companion.INVALID_PURCHASED_COUNT_MESSAGE
-import lotto.domain.PurchasedLottoTickets.Companion.PURCHASED_COUNT_MIN_VALUE
+import lotto.domain.LottoPurchaseCalculator.DEFAULT_LOTTO_PRICE
 
 data class PurchasedLottoResults(
     val purchasedCount: Int,
@@ -38,6 +36,8 @@ data class PurchasedLottoResults(
 
     companion object {
         const val LOTTO_MATCH_COUNT_MIN_VALUE: Int = 0
+        const val PURCHASED_COUNT_MIN_VALUE: Int = 1
+        const val INVALID_PURCHASED_COUNT_MESSAGE: String = "구입한 로또 개수가 올바르지 않습니다"
         const val INVALID_LOTTO_MATCH_COUNT_MESSAGE: String = "로또 당첨 번호 매치 결과는 0 이상 이어야합니다"
         const val INVALID_PURCHASED_COUNT_LOTTO_MATCH_COUNT_MESSAGE: String = "당첨된 내역의 합이 구매한 개수보다 많을 수 없습니다"
     }

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

@@ -0,0 +1,40 @@
+package lotto.view
+
+import lotto.domain.LottoNumbers
+import lotto.domain.LottoTicket.ManualLottoTicket
+import lotto.domain.LottoTickets
+import lotto.view.util.splitInputNumbersCommand
+
+object ManualLottoView {
+    fun inputManualLottoCount(maxPurchaseLottoCount: Int): Int {
+        println("\n수동으로 구매할 로또 수를 입력해 주세요.")
+        val inputManualLottoCountCommand: String? = readlnOrNull()
+        requireNotNull(inputManualLottoCountCommand) { "입력된 수동 로또 개수가 없습니다." }
+
+        val inputManualLottoCount = inputManualLottoCountCommand.toIntOrNull()
+        requireNotNull(inputManualLottoCount) { "구입금액이 올바르게 입력되지 않았습니다." }
+        require(inputManualLottoCount >= 0) { "수동 로또 개수는 0개부터 입력 가능합니다." }
+        require(inputManualLottoCount <= maxPurchaseLottoCount) { "구입 가능한 수동 로또 개수를 초과했습니다." }
+
+        return inputManualLottoCount
+    }
+
+    fun repeatInputManualLottoNumbers(manualLottoCount: Int): LottoTickets {
+        println("\n수동으로 구매할 번호를 입력해 주세요.")
+
+        val lottoNumbersList = mutableListOf<LottoNumbers>()
+        repeat(manualLottoCount) { lottoNumbersList.add(inputManualLottoNumbers()) }
+
+        val lottoTickets = lottoNumbersList.map { ManualLottoTicket(it) }
+
+        return LottoTickets(lottoTickets)
+    }
+
+    private fun inputManualLottoNumbers(): LottoNumbers {
+        val inputManualNumbersCommand: String? = readlnOrNull()
+
+        requireNotNull(inputManualNumbersCommand) { "입력된 수동 번호가 없습니다." }
+
+        return splitInputNumbersCommand(inputManualNumbersCommand)
+    }
+}

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

@@ -1,11 +1,26 @@
 package lotto.view
 
+import lotto.domain.LottoTickets
+
 object PurchaseLottoView {
     fun inputPurchaseCost(): Int {
         println("구입금액을 입력해 주세요.")
         val inputCost: String? = readlnOrNull()
         requireNotNull(inputCost) { "구입금액이 입력되지 않았습니다" }
         requireNotNull(inputCost.toIntOrNull()) { "구입금액이 올바르게 입력되지 않았습니다" }
+
         return inputCost.toInt()
     }
+
+    fun displayPurchasedLottosView(
+        manualLottoTickets: LottoTickets,
+        autoLottoTickets: LottoTickets,
+    ) {
+        val manualLottoCount = manualLottoTickets.lottoTickets.size
+        val autoLottoCount = autoLottoTickets.lottoTickets.size
+        println("\n수동으로 ${manualLottoCount}장, 자동으로 ${autoLottoCount}개를 구매했습니다.")
+
+        manualLottoTickets.lottoTickets.forEach { println(it.lottoNumbers.getNumbers()) }
+        autoLottoTickets.lottoTickets.forEach { println(it.lottoNumbers.getNumbers()) }
+    }
 }