Step4 - 로또(수동)

src/main/kotlin/lotto/Main.kt

@@ -1,25 +1,43 @@
 package lotto
 
-import lotto.domain.DefaultLottoGenerateStrategy
+import lotto.domain.AutoLottoNumbersGenerateStrategy
 import lotto.domain.Lotto
-import lotto.domain.LottoGenerator
+import lotto.domain.LottoNumber
 import lotto.domain.LottoStore
+import lotto.domain.Lottos
+import lotto.domain.ManualLottoNumbersGenerateStrategy
 import lotto.domain.WinningLotto
 import lotto.ui.InputView
 import lotto.ui.ResultView
 
 fun main() {
-    val generator = LottoGenerator(DefaultLottoGenerateStrategy())
-    val store = LottoStore(generator)
+    val store = LottoStore()
 
     val money = InputView.inputMoney()
-    val boughtLottos = store.buyLottos(money)
-    ResultView.showBoughtLottos(boughtLottos)
+    val boughtManualLottoCounts = InputView.inputManualLottoCount()
 
-    val winningLotto = WinningLotto(Lotto(InputView.inputWinningNumbers()), InputView.inputBonusNumber())
+    val manualLottosPrice = boughtManualLottoCounts * LottoStore.LOTTO_PRICE
 
-    val checkedLottos = boughtLottos.matchAll(winningLotto)
-    val returnRate = checkedLottos.totalReward() / money.toDouble()
+    require(money >= manualLottosPrice) {
+        "로또를 구매할 돈이 부족합니다."
+    }
 
-    ResultView.showResult(checkedLottos, returnRate)
+    val manualLottos = List(boughtManualLottoCounts) {
+        val lottoNumbers = InputView.inputManualLottoNumber()
+
+        store.buyLotto(ManualLottoNumbersGenerateStrategy(lottoNumbers))
+    }.let { Lottos(it) }
+
+    val autoLottos = store.buyLottos(money - manualLottosPrice, AutoLottoNumbersGenerateStrategy())
+
+    val boughtLottos = manualLottos + autoLottos
+
+    ResultView.showBoughtLottos(boughtLottos, boughtManualLottoCounts)
+
+    val winningLotto = WinningLotto(Lotto.of(InputView.inputWinningNumbers()), LottoNumber(InputView.inputBonusNumber()))
+    val matchedLotto = boughtLottos.matchAll(winningLotto)
+
+    val returnRate = matchedLotto.totalReward() / money.toDouble()
+
+    ResultView.showResult(matchedLotto, returnRate)
 }

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

@@ -0,0 +1,12 @@
+package lotto.domain
+
+class AutoLottoNumbersGenerateStrategy : LottoNumbersGenerateStrategy {
+    private val numberPool: IntRange = LottoNumber.MIN_NUMBER..LottoNumber.MAX_NUMBER
+    override fun generate(): LottoNumbers {
+        return numberPool
+            .shuffled()
+            .subList(0, Lotto.NUMBERS_COUNT)
+            .sorted()
+            .let { LottoNumbers.of(it) }
+    }
+}

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

@@ -1,41 +1,22 @@
 package lotto.domain
 
 class Lotto(
-    val numbers: List<Int>,
-    val winning: LottoWinning = LottoWinning.Miss,
+    val numbers: LottoNumbers,
 ) {
-    init {
-        require(numbers.size == NUMBERS_COUNT) {
-            "로또 번호는 항상 ${NUMBERS_COUNT}개 여야 합니다."
-        }
-        require(numbers.distinct().size == NUMBERS_COUNT) {
-            "로또 번호는 중복이 없어야 합니다."
-        }
-        require(numbers.all { it in MIN_NUMBER..MAX_NUMBER }) {
-            "로또 번호는 항상 ${MIN_NUMBER}에서 ${MAX_NUMBER}사이 값이어야 합니다."
-        }
-        require(numbers.isSortedNumber()) {
-            "로또 번호는 항상 정렬되어야 합니다."
-        }
-    }
-
-    fun match(winningLotto: WinningLotto): Lotto {
-        val correctCount = winningLotto.lotto.numbers.count { numbers.contains(it) }
+    fun match(winningLotto: WinningLotto): MatchedLotto {
+        val correctCount = winningLotto.lotto.numbers.containsCount(numbers)
         val matchBonus = numbers.contains(winningLotto.bonusNumber)
 
-        return Lotto(
-            numbers = numbers,
-            winning = LottoWinning.of(correctCount, matchBonus)
-        )
-    }
-
-    private fun List<Int>.isSortedNumber(): Boolean {
-        return zipWithNext { a, b -> a <= b }.all { it }
+        return MatchedLotto(this, LottoWinning.of(correctCount, matchBonus))
     }
 
     companion object {
         const val NUMBERS_COUNT = 6
-        const val MIN_NUMBER = 1
-        const val MAX_NUMBER = 45
+
+        fun of(numbers: List<Int>): Lotto {
+            val lottoNumbers = LottoNumbers(numbers.map { LottoNumber(it) })
+
+            return Lotto(lottoNumbers)
+        }
     }
 }

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

@@ -1,7 +1,7 @@
 package lotto.domain
 
-class LottoGenerator(private val lottoGenerateStrategy: LottoGenerateStrategy) {
-    fun publish(): Lotto {
-        return lottoGenerateStrategy.generate()
+class LottoGenerator {
+    fun publish(lottoNumbersGenerateStrategy: LottoNumbersGenerateStrategy): Lotto {
+        return Lotto(lottoNumbersGenerateStrategy.generate())
     }
 }

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

@@ -0,0 +1,19 @@
+package lotto.domain
+
+@JvmInline
+value class LottoNumber(val value: Int) : Comparable<LottoNumber> {
+    init {
+        require(value in MIN_NUMBER..MAX_NUMBER) {
+            "로또 번호는 항상 ${MIN_NUMBER}에서 ${MAX_NUMBER}사이 값이어야 합니다."
+        }
+    }
+
+    override fun compareTo(other: LottoNumber): Int {
+        return value.compareTo(other.value)
+    }
+
+    companion object {
+        const val MIN_NUMBER = 1
+        const val MAX_NUMBER = 45
+    }
+}

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

@@ -0,0 +1,49 @@
+package lotto.domain
+
+@JvmInline
+value class LottoNumbers(private val value: List<LottoNumber>) {
+
+    init {
+        require(value.size == Lotto.NUMBERS_COUNT) {
+            "로또 번호는 항상 ${Lotto.NUMBERS_COUNT}개 여야 합니다."
+        }
+        require(!hasDuplicate()) {
+            "로또 번호는 중복이 없어야 합니다."
+        }
+        require(isSorted()) {
+            "로또 번호는 항상 정렬되어야 합니다."
+        }
+    }
+
+    val size: Int
+        get() = value.size
+
+    val numbers: List<Int>
+        get() = value.map { it.value }
+
+    fun contains(lottoNumber: LottoNumber): Boolean {
+        return value.contains(lottoNumber)
+    }
+
+    fun containsCount(other: LottoNumbers): Int {
+        return value.count { other.value.contains(it) }
+    }
+
+    private fun hasDuplicate(): Boolean {
+        return value.distinct() != value
+    }
+
+    private fun isSorted(): Boolean {
+        return value.map { it.value }
+            .zipWithNext { a, b -> a <= b }
+            .all { it }
+    }
+
+    companion object {
+        fun of(numbers: List<Int>): LottoNumbers {
+            val lottoNumbers = numbers.map { LottoNumber(it) }
+
+            return LottoNumbers(lottoNumbers)
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+package lotto.domain
+
+fun interface LottoNumbersGenerateStrategy {
+    fun generate(): LottoNumbers
+}

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

@@ -1,14 +1,22 @@
 package lotto.domain
 
-private const val LOTTO_PRICE = 1000
+class LottoStore {
+    private val lottoGenerator = LottoGenerator()
 
-class LottoStore(private val lottoGenerator: LottoGenerator) {
-    fun buyLottos(money: Int): Lottos {
+    fun buyLotto(lottoNumbersGenerateStrategy: LottoNumbersGenerateStrategy): Lotto {
+        return lottoGenerator.publish(lottoNumbersGenerateStrategy)
+    }
+
+    fun buyLottos(money: Int, lottoNumbersGenerateStrategy: LottoNumbersGenerateStrategy): Lottos {
         val lottoCount = money / LOTTO_PRICE
         val lottos = List(lottoCount) {
-            lottoGenerator.publish()
+            lottoGenerator.publish(lottoNumbersGenerateStrategy)
         }
 
         return Lottos(lottos)
     }
+
+    companion object {
+        const val LOTTO_PRICE = 1000
+    }
 }

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

@@ -2,13 +2,13 @@ package lotto.domain
 
 @JvmInline
 value class Lottos(val value: List<Lotto>) {
-    fun matchAll(winningLotto: WinningLotto): Lottos {
-        val lottos = value.map { it.match(winningLotto) }
+    fun matchAll(winningLotto: WinningLotto): MatchedLottos {
+        val matchedLottos = value.map { it.match(winningLotto) }
 
-        return Lottos(lottos)
+        return MatchedLottos(matchedLottos)
     }
 
-    fun totalReward(): Int {
-        return value.sumOf { it.winning.reward }
+    operator fun plus(other: Lottos): Lottos {
+        return Lottos(value + other.value)
     }
 }

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

@@ -0,0 +1,9 @@
+package lotto.domain
+
+class ManualLottoNumbersGenerateStrategy(
+    private val lottoNumbers: List<Int>,
+) : LottoNumbersGenerateStrategy {
+    override fun generate(): LottoNumbers {
+        return LottoNumbers.of(lottoNumbers)
+    }
+}

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

@@ -0,0 +1,6 @@
+package lotto.domain
+
+class MatchedLotto(
+    val lotto: Lotto,
+    val winning: LottoWinning,
+)

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

@@ -0,0 +1,8 @@
+package lotto.domain
+
+@JvmInline
+value class MatchedLottos(val value: List<MatchedLotto>) {
+    fun totalReward(): Int {
+        return value.sumOf { it.winning.reward }
+    }
+}

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

@@ -2,15 +2,11 @@ package lotto.domain
 
 data class WinningLotto(
     val lotto: Lotto,
-    val bonusNumber: Int,
+    val bonusNumber: LottoNumber,
 ) {
     init {
         require(!lotto.numbers.contains(bonusNumber)) {
             "보너스 번호는 로또 번호에 포함되면 안됩니다."
         }
-
-        require(bonusNumber in Lotto.MIN_NUMBER..Lotto.MAX_NUMBER) {
-            "보너스 번호는 항상 ${Lotto.MIN_NUMBER}에서 ${Lotto.MAX_NUMBER}사이 값이어야 합니다."
-        }
     }
 }

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

@@ -7,6 +7,21 @@ object InputView {
         return readln().toInt()
     }
 
+    fun inputManualLottoCount(): Int {
+        println("수동으로 구매할 로또 수를 입력해 주세요.")
+
+        return readln().toInt()
+    }
+
+    fun inputManualLottoNumber(): List<Int> {
+        println("수동으로 구매할 번호를 입력해 주세요.")
+
+        return readln()
+            .split(",")
+            .map { it.toInt() }
+            .sorted()
+    }
+
     fun inputWinningNumbers(): List<Int> {
         println("지난 주 당첨 번호를 입력해 주세요.")
 

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

@@ -2,17 +2,18 @@ package lotto.ui
 
 import lotto.domain.LottoWinning
 import lotto.domain.Lottos
+import lotto.domain.MatchedLottos
 import java.text.DecimalFormat
 
 object ResultView {
-    fun showBoughtLottos(lottos: Lottos) {
-        println("${lottos.value.size}개를 구매했습니다.")
+    fun showBoughtLottos(lottos: Lottos, manualLottoCount: Int) {
+        println("수동으로 ${manualLottoCount}장 자동으로 ${lottos.value.size - manualLottoCount}개를 구매했습니다.")
         lottos.value.forEach {
             println("numbers = ${it.numbers}")
         }
     }
 
-    fun showResult(lottos: Lottos, returnRate: Double) {
+    fun showResult(lottos: MatchedLottos, returnRate: Double) {
         val winningLottos = lottos.value
             .groupBy { it.winning }