[로또 2단계] 공백 미션 제출합니다.

README.md

@@ -20,13 +20,23 @@
 - [x] 총 수익률을 반환한다.
     - [x] 수익률은 소숫점 둘 째 자리까지만 출력한다.
 - [x] 로또의 번호는 중복될 수 없다.
+- [x] 로또는 수동으로 구매할 수 있다.
 
 ## 🖥️ 출력 예시
 
 ```
 구입금액을 입력해 주세요.
 14000
-14개를 구매했습니다.
+
+수동으로 구매할 로또 수를 입력해 주세요.
+3
+
+수동으로 구매할 번호를 입력해 주세요.
+8, 21, 23, 41, 42, 43
+3, 5, 11, 16, 32, 38
+7, 11, 16, 35, 36, 44
+
+수동으로 3장, 자동으로 11장을 구매했습니다.
 [8, 21, 23, 41, 42, 43]
 [3, 5, 11, 16, 32, 38]
 [7, 11, 16, 35, 36, 44]
@@ -54,5 +64,5 @@
 5개 일치 (1500000원)- 0개
 5개 일치, 보너스 볼 일치(30000000원) - 0개
 6개 일치 (2000000000원)- 0개
-총 수익률은 0.35입니다.(기준이 1이기 때문에 결과적으로 손해라는 의미임)
+총 수익률은 0.35입니다.(기준이 1이기 때문에 결과적으로 손해(이)라는 의미임)
 ```

src/main/kotlin/lotto/Application.kt

@@ -1,14 +1,12 @@
 package lotto
 
 import lotto.controller.LottoController
-import lotto.service.LottoService
 import lotto.view.InputView
 import lotto.view.OutputView
 
 fun main() {
     val inputView = InputView()
     val outputView = OutputView()
-    val lottoService = LottoService()
 
-    LottoController(inputView, outputView, lottoService).run()
+    LottoController(inputView, outputView).run()
 }

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

@@ -1,49 +1,94 @@
 package lotto.controller
 
+import lotto.model.Amount
+import lotto.model.AutoLottoMachine
+import lotto.model.LottoMarket
+import lotto.model.LottoMarket.Companion.EMPTY_LOTTO_QUANTITY
+import lotto.model.LottoProfitCalculator
+import lotto.model.LottoWallet
+import lotto.model.ManualLottoMachine
 import lotto.model.ProfitStatus
-import lotto.model.Rank
-import lotto.service.LottoService
+import lotto.model.WinningDiscriminator
 import lotto.view.InputView
 import lotto.view.OutputView
 
 class LottoController(
     private val inputView: InputView,
     private val outputView: OutputView,
-    private val lottoService: LottoService,
 ) {
     fun run() {
+        val purchaseAmount = getPurchaseAmount()
+        val manualLottoQuantity = getManualQuantity()
+
+        val lottoMarket = purchaseLottos(purchaseAmount, manualLottoQuantity)
+        val lottoWallet = storeLottos(lottoMarket, manualLottoQuantity)
+
+        val winningDiscriminator = getWinningInfo()
+        discriminateLottos(winningDiscriminator, lottoWallet, purchaseAmount)
+    }
+
+    private fun getPurchaseAmount(): Amount {
         outputView.printPurchaseAmountGuide()
         val purchaseAmount = inputView.readPurchaseAmount()
-        val lottos = lottoService.getPurchaseLottos(purchaseAmount)
+        return Amount(purchaseAmount)
+    }
 
-        outputView.printPurchaseLottoQuantity(lottos.lottos.size)
-        lottos.lottos.forEach { lotto ->
-            outputView.printLottoNumbers(lotto.numbers.map { it.number })
-        }
+    private fun getManualQuantity(): Int {
+        outputView.printManualLottoQuantityGuide()
+        val manualLottoQuantity = inputView.readManualLottoQuantity()
+        return manualLottoQuantity
+    }
 
-        outputView.printWinningNumbersGuide()
-        val winningNumbers = inputView.readWinningNumbers()
+    private fun purchaseLottos(
+        purchaseAmount: Amount,
+        manualLottoQuantity: Int,
+    ): LottoMarket {
+        val autoLottoMachine = AutoLottoMachine()
+        val manualLottoMachine = ManualLottoMachine()
+        val lottoMarket = LottoMarket(purchaseAmount, manualLottoQuantity, manualLottoMachine, autoLottoMachine)
+        outputView.printManualLottoNumbersGuide(manualLottoQuantity > EMPTY_LOTTO_QUANTITY)
+        return lottoMarket
+    }
 
-        outputView.printBonusNumberGuide()
-        val bonusNumber = inputView.readBonusNumber()
+    private fun storeLottos(
+        lottoMarket: LottoMarket,
+        manualLottoQuantity: Int,
+    ): LottoWallet {
+        val lottoWallet = LottoWallet()
 
-        val lottoWinningResult = lottoService.getLottosDiscriminateResult(lottos, winningNumbers, bonusNumber)
+        lottoMarket.buy(
+            List(manualLottoQuantity) { inputView.readLottoNumbers() },
+            lottoWallet,
+        )
 
+        outputView.printPurchaseLottoQuantity(manualLottoQuantity, lottoMarket.autoLottoQuantity)
+        outputView.printLotto(lottoWallet.lottos)
+        return lottoWallet
+    }
+
+    private fun discriminateLottos(
+        winningDiscriminator: WinningDiscriminator,
+        lottoWallet: LottoWallet,
+        purchaseAmount: Amount,
+    ) {
+        val winningResult = winningDiscriminator.getResult(lottoWallet)
         outputView.printWinningResultTitle()
-        lottoWinningResult.forEach { (rank, count) ->
-            if (rank == Rank.MISS) return@forEach
-
-            outputView.printWinningResult(
-                requiredMatch = rank.countOfMatch,
-                profit = rank.winningMoney,
-                matchBonus = rank == Rank.SECOND,
-                countOfMatch = count,
-            )
-        }
-
-        val profitRate = lottoService.getProfitRate(lottoWinningResult, purchaseAmount)
+        outputView.printWinningLottoResult(winningResult)
+
+        val lottoProfitCalculator = LottoProfitCalculator()
+        val profitRate = lottoProfitCalculator.getProfitRate(winningResult, purchaseAmount)
         val profitStatus = ProfitStatus.from(profitRate)
+        outputView.printProfitRate(profitRate, profitStatus)
+    }
+
+    private fun getWinningInfo(): WinningDiscriminator {
+        outputView.printWinningNumbersGuide()
+        val winningNumbers = inputView.readLottoNumbers()
+
+        outputView.printBonusNumberGuide()
+        val bonusNumber = inputView.readBonusNumber()
 
-        outputView.printProfitRate(profitRate, profitStatus.krDescription)
+        val winningDiscriminator = WinningDiscriminator(winningNumbers, bonusNumber)
+        return winningDiscriminator
     }
 }

src/main/kotlin/lotto/model/LottoCashier.kt → src/main/kotlin/lotto/model/Amount.kt

@@ -1,27 +1,30 @@
 package lotto.model
 
-class LottoCashier(
-    val amount: Int,
+@JvmInline
+value class Amount(
+    val value: Int,
 ) {
     init {
         validateAmountMinimumRange()
         validateAmountUnit()
     }
 
+    fun isAffordable(manualQuantity: Int): Boolean = value - manualQuantity * LOTTO_EACH_AMOUNT >= 0
+
+    fun getAutoLottoQuantity(manualQuantity: Int): Int = value / LOTTO_EACH_AMOUNT - manualQuantity
+
     private fun validateAmountMinimumRange() {
-        require(amount > LOTTO_MIN_AMOUNT) {
-            "[ERROR] ${LOTTO_MIN_AMOUNT}원 이상의 금액으로 입력해 주세요. 입력값: $amount"
+        require(value > LOTTO_MIN_AMOUNT) {
+            "[ERROR] ${LOTTO_MIN_AMOUNT}원 이상의 금액으로 입력해 주세요. 입력값: $value"
         }
     }
 
     private fun validateAmountUnit() {
-        require(amount % LOTTO_EACH_AMOUNT == 0) {
-            "[ERROR] ${LOTTO_EACH_AMOUNT}원 단위의 금액으로 입력해 주세요. 입력값: $amount"
+        require(value % LOTTO_EACH_AMOUNT == 0) {
+            "[ERROR] ${LOTTO_EACH_AMOUNT}원 단위의 금액으로 입력해 주세요. 입력값: $value"
         }
     }
 
-    fun getPurchaseQuantity(): Int = amount / LOTTO_EACH_AMOUNT
-
     companion object {
         private const val LOTTO_MIN_AMOUNT = 0
         private const val LOTTO_EACH_AMOUNT = 1000

src/main/kotlin/lotto/model/AutoLottoMachine.kt

@@ -0,0 +1,17 @@
+package lotto.model
+
+import lotto.model.Lotto.Companion.LOTTO_NUMBER_SIZE
+import lotto.model.LottoNumber.Companion.cachedLottoNumbers
+
+class AutoLottoMachine : LottoMachine {
+    override fun generate(
+        manualTicket: List<List<Int>>,
+        quantity: Int,
+    ): List<Lotto> = List(quantity) { Lotto(getAutoNumbers()) }
+
+    private fun getAutoNumbers(): List<LottoNumber> =
+        cachedLottoNumbers
+            .shuffled()
+            .take(LOTTO_NUMBER_SIZE)
+            .sortedBy { number -> number.value }
+}

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

@@ -1,28 +1,29 @@
 package lotto.model
 
-class Lotto private constructor(
+class Lotto(
     val numbers: List<LottoNumber>,
 ) {
     init {
-        validateLottoNumbersCount(numbers)
-        validateLottoNumbersDuplicate(numbers)
+        validateLottoNumbersCount()
+        validateLottoNumbersDuplicate()
     }
 
-    private fun validateLottoNumbersCount(numbers: List<LottoNumber>) {
+    fun countMatchNumbers(other: Lotto): Int = numbers.count { number -> number in other.numbers }
+
+    fun contains(number: LottoNumber): Boolean = numbers.contains(number)
+
+    private fun validateLottoNumbersCount() {
         require(numbers.size == LOTTO_NUMBER_SIZE) {
             "[ERROR] 로또는 ${LOTTO_NUMBER_SIZE}개의 번호만 가질 수 있습니다."
         }
     }
 
-    private fun validateLottoNumbersDuplicate(lottoNumbers: List<LottoNumber>) {
-        val uniqueNumbers = lottoNumbers.map { it.number }.toSet()
-        require(uniqueNumbers.size == lottoNumbers.size) {
+    private fun validateLottoNumbersDuplicate() {
+        require(numbers.distinct().size == numbers.size) {
             "[ERROR] 로또 번호는 중복될 수 없습니다."
         }
     }
 
-    fun isHaveBonus(number: LottoNumber): Boolean = numbers.contains(number)
-
     companion object {
         const val LOTTO_NUMBER_SIZE = 6
 

src/main/kotlin/lotto/model/LottoMachine.kt

@@ -1,17 +1,8 @@
 package lotto.model
 
-import lotto.model.Lotto.Companion.LOTTO_NUMBER_SIZE
-import lotto.model.LottoNumber.Companion.ALL_LOTTO_NUMBERS
-
-class LottoMachine {
-    fun getLottos(lottoQuantity: Int): Lottos {
-        val lottos = List(lottoQuantity) { Lotto.from(getLottoNumbers()) }
-        return Lottos(lottos)
-    }
-
-    private fun getLottoNumbers(): List<Int> =
-        ALL_LOTTO_NUMBERS
-            .shuffled()
-            .take(LOTTO_NUMBER_SIZE)
-            .sorted()
+interface LottoMachine {
+    fun generate(
+        manualTicket: List<List<Int>> = emptyList(),
+        quantity: Int = manualTicket.size,
+    ): List<Lotto>
 }

src/main/kotlin/lotto/model/LottoMarket.kt

@@ -0,0 +1,36 @@
+package lotto.model
+
+class LottoMarket(
+    private val amount: Amount,
+    private val manualQuantity: Int,
+    private val manualLottoMachine: ManualLottoMachine = ManualLottoMachine(),
+    private val autoLottoMachine: AutoLottoMachine = AutoLottoMachine(),
+) {
+    val autoLottoQuantity: Int = amount.getAutoLottoQuantity(manualQuantity)
+
+    init {
+        validateManualLottoQuantity()
+    }
+
+    fun buy(
+        manualNumbers: List<List<Int>> = emptyList(),
+        lottoWallet: LottoWallet,
+    ) {
+        lottoWallet.addAll(
+            when (manualNumbers.isNotEmpty()) {
+                true -> manualLottoMachine.generate(manualTicket = manualNumbers)
+                false -> autoLottoMachine.generate(quantity = autoLottoQuantity)
+            },
+        )
+    }
+
+    private fun validateManualLottoQuantity() {
+        require(amount.isAffordable(manualQuantity)) {
+            "[ERROR] 낸 금액보다 많은 수동 로또를 살 수 없습니다. 금액: ${amount.value}, 수동 로또: ${manualQuantity}장"
+        }
+    }
+
+    companion object {
+        const val EMPTY_LOTTO_QUANTITY = 0
+    }
+}

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

@@ -1,17 +1,19 @@
 package lotto.model
 
 class LottoNumber private constructor(
-    val number: Int,
+    val value: Int,
 ) {
     companion object {
         private const val LOTTO_NUMBER_MIN_RANGE = 1
         private const val LOTTO_NUMBER_MAX_RANGE = 45
 
-        val ALL_LOTTO_NUMBERS = (LOTTO_NUMBER_MIN_RANGE..LOTTO_NUMBER_MAX_RANGE)
-        private val CACHE = ALL_LOTTO_NUMBERS.associateWith { LottoNumber(it) }
+        private val CACHE_LOTTO_NUMBER =
+            (LOTTO_NUMBER_MIN_RANGE..LOTTO_NUMBER_MAX_RANGE).associateWith { LottoNumber(it) }
+
+        val cachedLottoNumbers: List<LottoNumber> by lazy { CACHE_LOTTO_NUMBER.values.toList() }
 
         fun from(number: Int): LottoNumber =
-            CACHE[number]
+            CACHE_LOTTO_NUMBER[number]
                 ?: throw IllegalArgumentException("[ERROR] 로또 번호의 범위는 $LOTTO_NUMBER_MIN_RANGE 이상 $LOTTO_NUMBER_MAX_RANGE 이하여야 합니다.")
     }
 }

src/main/kotlin/lotto/model/LottoProfitCalculator.kt

@@ -2,15 +2,15 @@ package lotto.model
 
 class LottoProfitCalculator {
     fun getProfitRate(
-        countLottoByRank: Map<Rank, Int>,
-        purchaseAmount: Int,
+        winningResult: Map<Rank, Int>,
+        purchaseAmount: Amount,
     ): Float {
-        val totalProfit = countLottoByRank.entries.sumOf { it.key.winningMoney * it.value }
+        val totalProfit = winningResult.entries.sumOf { rank -> rank.key.winningMoney * rank.value }
         return formatProfitRate(totalProfit, purchaseAmount)
     }
 
     private fun formatProfitRate(
         totalProfit: Int,
-        purchaseAmount: Int,
-    ): Float = totalProfit.toFloat() / purchaseAmount.toFloat()
+        purchaseAmount: Amount,
+    ): Float = totalProfit.toFloat() / purchaseAmount.value.toFloat()
 }