[로또 2단계] 시아 미션 제출합니다.

README.md

@@ -29,3 +29,9 @@
 - [x] 입력된 금액과 비교하여 수익률을 도출한다
 
 
+# 2단계
+
+### 로또 발행
+- [x] 입력된 금액에 초과되는 수동 로또 구매 숫자를 입력하면 예외처리한다.
+- [x] 입력한 수동 로또 구매 숫자에 맞춰서 로또를 입력받아서 발행한다.
+- [x] 입력값이 올바르지 않으면, 다시 입력받도록 수정한다.

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

@@ -3,10 +3,10 @@ package lotto.controller
 import lotto.model.Amount
 import lotto.model.Lotto
 import lotto.model.LottoMachine
-import lotto.model.LottoMatcher
 import lotto.model.LottoNumber
 import lotto.model.LottoNumbers
 import lotto.model.PrizeCalculator
+import lotto.model.WinningLotto
 import lotto.view.InputView
 import lotto.view.OutputView
 
@@ -17,36 +17,65 @@ class LottoController(
     fun run() {
         val amount = getAmount()
         val lottoMachine = LottoMachine(amount)
-        val publishedLotto = publishLotto(lottoMachine)
-        val winningLotto = getWinningLotto()
-        val bonusNumber = getBonusNumber()
-        val lottoMatcher = LottoMatcher(winningLotto, bonusNumber)
-        showEarningRate(amount, lottoMatcher, publishedLotto)
+        val publishedLotto = validatePublishLottoList(lottoMachine) + autoPublishLotto(lottoMachine)
+        val winningLotto = validateWinningLotto(getWinningLotto(), getBonusNumber())
+        val prizeCalculator = PrizeCalculator(winningLotto, publishedLotto, amount)
+        showEarningRate(prizeCalculator)
     }
 
     private fun getAmount(): Amount = Amount(inputView.getMoney())
 
-    private fun publishLotto(lottoMachine: LottoMachine): List<Lotto> {
-        val publishedLotto = lottoMachine.publishLottoTickets(Amount(LOTTO_PRIZE))
+    private fun validateWinningLotto(
+        number: LottoNumbers?,
+        bonus: LottoNumber?,
+    ): WinningLotto {
+        if (number == null || bonus == null) {
+            outputView.inputWinningError()
+            return validateWinningLotto(getWinningLotto(), getBonusNumber())
+        }
+        return WinningLotto(number, bonus)
+    }
+
+    private fun validatePublishLotto(lottoMachine: LottoMachine): Lotto {
+        var lotto = lottoMachine.publishManualLotto(inputView.getManualLotto())
+        while (lotto == null) {
+            outputView.inputLottoError()
+            lotto = lottoMachine.publishManualLotto(inputView.getManualLotto())
+        }
+        return lotto
+    }
+
+    private fun validatePublishLottoList(lottoMachine: LottoMachine): List<Lotto> {
+        var count = inputView.getManualCount()
+        while (lottoMachine.useMoney(Amount(count * LOTTO_PRIZE)) == false) {
+            outputView.inputCountError()
+            count = inputView.getManualCount()
+        }
+        val lottoList = mutableListOf<Lotto>()
+        inputView.lottoInputMessage()
+        for (i in 1..count) {
+            lottoList.add(validatePublishLotto(lottoMachine))
+        }
+        outputView.printManualLotto(count)
+        return lottoList
+    }
+
+    private fun autoPublishLotto(lottoMachine: LottoMachine): List<Lotto> {
+        val publishedLotto = lottoMachine.publishAutoTickets(Amount(LOTTO_PRIZE))
         outputView.printPublishedLotto(publishedLotto)
         return publishedLotto
     }
 
-    private fun getWinningLotto(): Lotto {
+    private fun getWinningLotto(): LottoNumbers? {
         val winningInput = inputView.getWinningLotto()
-        return Lotto(LottoNumbers(winningInput.map { number -> LottoNumber(number) }), Amount(LOTTO_PRIZE))
+        return LottoNumbers.create(winningInput.mapNotNull { number -> LottoNumber.create(number) })
     }
 
-    private fun getBonusNumber(): LottoNumber = LottoNumber(inputView.getBonusNumber())
+    private fun getBonusNumber(): LottoNumber? = LottoNumber.create(inputView.getBonusNumber())
 
-    private fun showEarningRate(
-        amount: Amount,
-        lottoMatcher: LottoMatcher,
-        publishedLotto: List<Lotto>,
-    ) {
-        val result = lottoMatcher.matchLotto(publishedLotto)
-        val prizeCalculator = PrizeCalculator()
-        val earningRate = prizeCalculator.calculateEarningRate(amount.money, result)
+    private fun showEarningRate(prizeCalculator: PrizeCalculator) {
+        val result = prizeCalculator.result
+        val earningRate = prizeCalculator.calculateEarningRate()
         outputView.printPrize(result, earningRate)
     }
 

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

@@ -1,21 +1,25 @@
 package lotto.model
 
 data class Amount(
-    val money: Int,
+    var money: Int,
 ) {
     init {
-        require(money > 0) { MONEY_UNDER_ZERO }
+        require(money >= 0) { MONEY_UNDER_ZERO }
+    }
+
+    fun payMoney(inputMoney: Amount) {
+        require(inputMoney.money <= money) { MONEY_OVER_INPUT }
+        money -= inputMoney.money
     }
 
     fun moneySplit(splitMoney: Amount): List<Amount> {
         val moneyList: MutableList<Amount> = mutableListOf()
-        require(money % splitMoney.money == 0) { MONEY_SPILT_ERROR }
         repeat(money / splitMoney.money) { moneyList.add(splitMoney) }
         return moneyList
     }
 
     companion object {
         const val MONEY_UNDER_ZERO = "[ERROR] 금액은 양수이어야 합니다."
-        const val MONEY_SPILT_ERROR = "[ERROR] 로또 금액에 맞게 나눌 수 없습니다"
+        const val MONEY_OVER_INPUT = "[ERROR] 입력된 금액보다 더 많은 수량의 로또는 살 수 없습니다."
     }
 }

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

@@ -2,11 +2,8 @@ package lotto.model
 
 class Lotto(
     val numbers: LottoNumbers,
-    val prize: Amount,
 ) {
     fun getNumbers(): List<LottoNumber> = numbers.numberList.map { it }
 
     fun findNumber(number: LottoNumber): Boolean = numbers.include(number)
-
-    fun countMatchedNumber(other: Lotto): Int = numbers.numberList.count { other.findNumber(it) }
 }

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

@@ -11,29 +11,41 @@ class NormalShuffle : ShuffleStrategy {
 }
 
 class LottoMachine(
-    private val amount: Amount,
+    var amount: Amount,
     private val shuffle: ShuffleStrategy = NormalShuffle(),
 ) {
     private val numbers: List<Int> = (LottoNumber.MIN_VALUE..LottoNumber.MAX_VALUE).toList()
 
-    fun publishLottoTickets(lottoPrize: Amount): List<Lotto> {
+    fun useMoney(inputMoney: Amount): Boolean {
+        if (inputMoney.money > amount.money) return false
+        amount.payMoney(inputMoney)
+        return true
+    }
+
+    fun publishManualLotto(numberList: List<Int>): Lotto? {
+        var lottoNumbers: LottoNumbers? = LottoNumbers.create(numberList.mapNotNull { it -> LottoNumber.create(it) })
+        if (lottoNumbers == null) return null
+        return Lotto(lottoNumbers)
+    }
+
+    fun publishAutoTickets(lottoPrize: Amount): List<Lotto> {
         val lottoTickets = mutableListOf<Lotto>()
         val moneyList = amount.moneySplit(lottoPrize)
         repeat(moneyList.size) {
-            val lotto = publishLotto(lottoPrize)
+            val lotto = publishLotto()
             lottoTickets.add(lotto)
         }
         return lottoTickets
     }
 
-    private fun publishLotto(prize: Amount): Lotto {
+    private fun publishLotto(): Lotto {
         val lottoNumbers =
             shuffle
                 .shuffle(numbers)
                 .take(LOTTO_NUMBER_COUNT)
                 .sorted()
                 .map { LottoNumber(it) }
-        return Lotto(LottoNumbers(lottoNumbers), prize)
+        return Lotto(LottoNumbers(lottoNumbers))
     }
 
     companion object {

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

@@ -4,15 +4,16 @@ package lotto.model
 value class LottoNumber(
     val value: Int,
 ) {
-    init {
-        require(value in MIN_VALUE..MAX_VALUE) {
-            RANGE_ERROR_MESSAGE
-        }
-    }
-
     companion object {
         const val MIN_VALUE = 1
         const val MAX_VALUE = 45
         private const val RANGE_ERROR_MESSAGE = "[ERROR] 로또 번호는 1~45 사이여야 합니다."
+
+        fun create(value: Int): LottoNumber? {
+            if (value !in MIN_VALUE..MAX_VALUE) {
+                return null
+            }
+            return LottoNumber(value)
+        }
     }
 }

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

@@ -3,20 +3,17 @@ package lotto.model
 class LottoNumbers(
     val numberList: List<LottoNumber>,
 ) {
-    init {
-        require(numberList.size == LOTTO_NUMBER_SIZE) {
-            SIZE_ERROR_MESSAGE
-        }
-        require(numberList.distinct().size == numberList.size) {
-            DUPLICATE_ERROR_MESSAGE
-        }
-    }
-
     fun include(number: LottoNumber): Boolean = numberList.contains(number)
 
     companion object {
         const val LOTTO_NUMBER_SIZE = 6
-        private const val SIZE_ERROR_MESSAGE = "[ERROR] 로또 번호는 6개여야 합니다."
-        private const val DUPLICATE_ERROR_MESSAGE = "[ERROR] 로또 번호는 중복될 수 없습니다."
+
+        fun create(numberList: List<LottoNumber>): LottoNumbers? {
+            when {
+                numberList.size != LOTTO_NUMBER_SIZE -> return null
+                numberList.distinct().size != numberList.size -> return null
+            }
+            return LottoNumbers(numberList)
+        }
     }
 }

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

@@ -1,18 +1,29 @@
 package lotto.model
 
-class PrizeCalculator {
-    fun calculateInputMoney(lottoList: List<Lotto>): Int {
-        val allAmount = 0
-        lottoList.forEach {
-            allAmount + it.prize.money
+class PrizeCalculator(
+    val winningLotto: WinningLotto,
+    val publishedLotto: List<Lotto>,
+    val amount: Amount,
+) {
+    val result: Map<Rank, Int>
+
+    init {
+        result = makeResult()
+    }
+
+    private fun makeResult(): Map<Rank, Int> {
+        val result: MutableMap<Rank, Int> = mutableMapOf()
+        publishedLotto.forEach {
+            val rank = winningLotto.findRank(it)
+            result[rank] = result.getOrDefault(rank, 0) + 1
+        }
+        Rank.entries.forEach {
+            result[it] = result.getOrDefault(it, 0)
         }
-        return allAmount
+        return result
     }
 
-    fun calculateEarningRate(
-        money: Int,
-        result: Map<Rank, Int>,
-    ): Double = calculateTotalPrize(result).toDouble() / money.toDouble()
+    fun calculateEarningRate(): Double = calculateTotalPrize(result).toDouble() / amount.money.toDouble()
 
     private fun calculateTotalPrize(result: Map<Rank, Int>): Int = result.entries.sumOf { (rank, count) -> rank.winningMoney * count }
 }

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

@@ -2,28 +2,27 @@ package lotto.model
 
 enum class Rank(
     val countOfMatch: Int,
+    val bonusRequired: Boolean,
     val winningMoney: Int,
+    val printSequence: Int?,
 ) {
-    FIRST(6, 2_000_000_000),
-    SECOND(5, 30_000_000),
-    THIRD(5, 1_500_000),
-    FOURTH(4, 50_000),
-    FIFTH(3, 5_000),
-    MISS(0, 0),
+    FIRST(6, false, 2_000_000_000, 5),
+    SECOND(5, true, 30_000_000, 4),
+    THIRD(5, false, 1_500_000, 3),
+    FOURTH(4, false, 50_000, 2),
+    FIFTH(3, false, 5_000, 1),
+    MISS(0, false, 0, null),
     ;
 
     companion object {
         fun valueOf(
             countOfMatch: Int,
             matchBonus: Boolean,
-        ): Rank =
-            when {
-                countOfMatch == FIRST.countOfMatch -> FIRST
-                countOfMatch == SECOND.countOfMatch && matchBonus -> SECOND
-                countOfMatch == THIRD.countOfMatch -> THIRD
-                countOfMatch == FOURTH.countOfMatch -> FOURTH
-                countOfMatch == FIFTH.countOfMatch -> FIFTH
-                else -> MISS
+        ): Rank {
+            entries.forEach {
+                if (countOfMatch >= it.countOfMatch && (it.bonusRequired && matchBonus) == it.bonusRequired) return it
             }
+            return MISS
+        }
     }
 }

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

@@ -0,0 +1,12 @@
+package lotto.model
+
+class WinningLotto(
+    val numbers: LottoNumbers,
+    val bonusNumber: LottoNumber,
+) {
+    fun findRank(other: Lotto): Rank = Rank.valueOf(countMatchedNumber(other), findBonusNumber(other))
+
+    private fun countMatchedNumber(other: Lotto): Int = numbers.numberList.count { other.findNumber(it) }
+
+    private fun findBonusNumber(other: Lotto): Boolean = other.findNumber(bonusNumber)
+}