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

README.md

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

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

@@ -3,51 +3,111 @@ 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.Rank
+import lotto.model.ValidationResult
+import lotto.model.WinningLotto
 import lotto.view.InputView
 import lotto.view.OutputView
 
 class LottoController(
     private val inputView: InputView = InputView(),
     private val outputView: OutputView = OutputView(),
 ) {
+    val lottoMachine = LottoMachine()
+    lateinit var money: Amount
+
     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)
+        money = getAmount()
+        val publishedLotto = publishLottoList(inputView.getManualCount()) + autoPublishLotto()
+        val winningLotto =
+            publishWinningLotto(
+                validatePublishLotto(inputView.getWinningLotto()),
+                validateBonusNumber(inputView.getBonusNumber()),
+            )
+        val prizeCalculator = PrizeCalculator(winningLotto, publishedLotto)
+        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 publishWinningLotto(
+        numbers: LottoNumbers,
+        bonus: LottoNumber,
+    ): WinningLotto {
+        if (WinningLotto.validation(numbers, bonus) == ValidationResult.Error.DuplicateError) {
+            return publishWinningLotto(
+                numbers,
+                validateBonusNumber(inputView.getBonusNumberRepeat()),
+            )
+        }
+
+        return WinningLotto(numbers, bonus)
+    }
+
+    private fun validatePublishLotto(input: List<Int>): LottoNumbers {
+        val validationResult = LottoNumbers.validation(input)
+        return when (validationResult) {
+            ValidationResult.Error.NumberRangeError ->
+                validatePublishLotto(
+                    inputView.getManualLottoRepeat(),
+                )
+
+            ValidationResult.Error.DuplicateError ->
+                validatePublishLotto(
+                    inputView.getManualLottoRepeat(),
+                )
+
+            ValidationResult.Error.NumberSizeError ->
+                validatePublishLotto(
+                    inputView.getManualLottoRepeat(),
+                )
+
+            else -> {
+                LottoNumbers(input.map { it -> LottoNumber(it) })
+            }
+        }
+    }
+
+    private fun publishLottoList(count: Int): List<Lotto> {
+        val useMoney = Amount(count * LOTTO_PRIZE)
+        if (money.validate(useMoney) == ValidationResult.Error.OverMoneyError) return publishLottoList(inputView.getManualCountRepeat())
+        money = money.payMoney(useMoney)
+        inputView.lottoInputMessage()
+        var lottoList: MutableList<Lotto> = mutableListOf()
+        repeat(count) {
+            lottoList.add(Lotto(validatePublishLotto(inputView.getManualLotto())))
+        }
+        outputView.printManualLotto(count)
+        return lottoList
+    }
+
+    private fun autoPublishLotto(): List<Lotto> {
+        val publishedLotto = lottoMachine.publishAutoTickets(money)
+        money = money.payMoney(Amount(publishedLotto.size * LOTTO_PRIZE))
         outputView.printPublishedLotto(publishedLotto)
         return publishedLotto
     }
 
-    private fun getWinningLotto(): Lotto {
-        val winningInput = inputView.getWinningLotto()
-        return Lotto(LottoNumbers(winningInput.map { number -> LottoNumber(number) }), Amount(LOTTO_PRIZE))
+    private fun validateBonusNumber(input: Int): LottoNumber {
+        if (LottoNumber.validation(input) == ValidationResult.Error.NumberRangeError) {
+            return validateBonusNumber(inputView.getBonusNumberRepeat())
+        }
+        return LottoNumber(input)
     }
 
-    private fun getBonusNumber(): LottoNumber = LottoNumber(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)
-        outputView.printPrize(result, earningRate)
+    private fun showEarningRate(prizeCalculator: PrizeCalculator) {
+        val result =
+            prizeCalculator.rankCount
+                .filter { it.key != Rank.MISS }
+                .toList()
+                .sortedBy { it.first.ordinal }
+                .reversed()
+                .toMap()
+        val earningRate = prizeCalculator.calculateEarningRate()
+        outputView.printPrize(result, earningRate, money)
     }
 
     companion object {

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

@@ -4,18 +4,23 @@ data class Amount(
     val money: Int,
 ) {
     init {
-        require(money > 0) { MONEY_UNDER_ZERO }
+        require(money >= 0) { MONEY_UNDER_ZERO }
     }
 
+    fun payMoney(inputMoney: Amount): Amount = Amount(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
     }
 
+    fun validate(inputMoney: Amount): ValidationResult {
+        if (money < inputMoney.money) return ValidationResult.Error.OverMoneyError
+        return ValidationResult.Success
+    }
+
     companion object {
-        const val MONEY_UNDER_ZERO = "[ERROR] 금액은 양수이어야 합니다."
-        const val MONEY_SPILT_ERROR = "[ERROR] 로또 금액에 맞게 나눌 수 없습니다"
+        const val MONEY_UNDER_ZERO = "[ERROR] 금액은 0 이상이여야 합니다."
     }
 }

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,32 +11,31 @@ class NormalShuffle : ShuffleStrategy {
 }
 
 class LottoMachine(
-    private val 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 publishAutoTickets(money: Amount): List<Lotto> {
         val lottoTickets = mutableListOf<Lotto>()
-        val moneyList = amount.moneySplit(lottoPrize)
-        repeat(moneyList.size) {
-            val lotto = publishLotto(lottoPrize)
+        repeat(money.moneySplit(LOTTO_PRIZE).size) {
+            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 {
         private const val LOTTO_NUMBER_COUNT = 6
+        private val LOTTO_PRIZE = Amount(1000)
     }
 }

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

@@ -5,14 +5,19 @@ value class LottoNumber(
     val value: Int,
 ) {
     init {
-        require(value in MIN_VALUE..MAX_VALUE) {
-            RANGE_ERROR_MESSAGE
-        }
+        require(value in MIN_VALUE..MAX_VALUE) { NUMBER_RANGE_ERROR }
     }
 
     companion object {
         const val MIN_VALUE = 1
         const val MAX_VALUE = 45
-        private const val RANGE_ERROR_MESSAGE = "[ERROR] 로또 번호는 1~45 사이여야 합니다."
+        const val NUMBER_RANGE_ERROR = "[ERROR] 로또 숫자가 범위를 벗어났습니다."
+
+        fun validation(number: Int): ValidationResult {
+            if (number !in MIN_VALUE..MAX_VALUE) {
+                return ValidationResult.Error.NumberRangeError
+            }
+            return ValidationResult.Success
+        }
     }
 }

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

@@ -1,22 +1,31 @@
 package lotto.model
 
+import kotlin.collections.distinct
+
 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
-        }
+        require(numberList.size == LOTTO_NUMBER_SIZE) { NUMBER_SIZE_ERROR }
+        require(numberList.distinct().size == numberList.size) { NUMBER_DUPLICATE_ERROR }
     }
 
     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] 로또 번호는 중복될 수 없습니다."
+        const val NUMBER_SIZE_ERROR = "[ERROR] 로또 번호의 갯수가 ${LOTTO_NUMBER_SIZE}개가 아닙니다"
+        const val NUMBER_DUPLICATE_ERROR = "[ERROR] 로또 번호가 중복되었습니다."
+
+        fun validation(numberList: List<Int>): ValidationResult {
+            when {
+                numberList.size != LOTTO_NUMBER_SIZE -> return ValidationResult.Error.NumberSizeError
+                numberList.distinct().size != numberList.size -> return ValidationResult.Error.DuplicateError
+            }
+            numberList.forEach {
+                if (LottoNumber.validation(it) == ValidationResult.Error.NumberRangeError) return ValidationResult.Error.NumberRangeError
+            }
+            return ValidationResult.Success
+        }
     }
 }

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

@@ -1,18 +1,32 @@
 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 rankCount: Map<Rank, Int>
+
+    init {
+        rankCount = 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
         }
-        return allAmount
+        Rank.entries.forEach {
+            result[it] = result.getOrDefault(it, 0)
+        }
+        return result
     }
 
-    fun calculateEarningRate(
-        money: Int,
-        result: Map<Rank, Int>,
-    ): Double = calculateTotalPrize(result).toDouble() / money.toDouble()
+    fun calculateEarningRate(): Double = calculateTotalPrize(rankCount).toDouble() / (LOTTO_PRIZE * publishedLotto.size).toDouble()
 
     private fun calculateTotalPrize(result: Map<Rank, Int>): Int = result.entries.sumOf { (rank, count) -> rank.winningMoney * count }
+
+    companion object {
+        const val LOTTO_PRIZE = 1000
+    }
 }