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

src/main/kotlin/lotto/Application.kt

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

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

@@ -0,0 +1,107 @@
+package lotto.controller
+
+import lotto.domain.model.Amount
+import lotto.domain.model.Lotto
+import lotto.domain.model.LottoCreationResult
+import lotto.domain.model.LottoNumber
+import lotto.domain.model.Rank
+import lotto.domain.model.WinningLotto
+import lotto.domain.model.WinningLottoCreationResult
+import lotto.domain.service.RankCalculator
+import lotto.domain.service.WinningListMaker
+import lotto.view.InputView
+import lotto.view.Message
+import lotto.view.OutputView
+
+class LottoController(
+    val inputView: InputView,
+    val outputView: OutputView,
+) {
+    val amount = inputAmount()
+
+    fun run() {
+        val count = getManualCount()
+        val manualLottoList = getLottoList(count)
+        val autoLottoList = getAutoLotto(amount.getCount(LOTTO_PRIZE) - count)
+
+        outputView.printPurchaseResult(manualLottoList, autoLottoList)
+
+        val winningLotto = getWinningLotto()
+        val ranks = WinningListMaker().calculateRanks(winningLotto, manualLottoList + autoLottoList)
+
+        val sortedResults = sortResultsByOriginalRankOrder(ranks)
+        val totalWinnings = RankCalculator().earningMoney(ranks)
+        val earningRate = RankCalculator().calculateEarningRate(amount.money, totalWinnings)
+
+        outputView.printResult(sortedResults, earningRate)
+    }
+
+    fun getAutoLotto(count: Int): List<Lotto> = List(count) { Lotto.createRandom() }
+
+    fun getManualCount(): Int {
+        val manualCount = inputView.getManualCount()
+        return if (amount.getCount(LOTTO_PRIZE) >= manualCount) {
+            manualCount
+        } else {
+            outputView.printErrorMessage(Message.errorCountExceeded())
+            getManualCount()
+        }
+    }
+
+    fun getLottoList(count: Int): List<Lotto> {
+        inputView.messageManualLotto()
+        return List(count) { inputLotto() }
+    }
+
+    private fun inputLotto(): Lotto {
+        when (
+            val result =
+                Lotto.create(
+                    inputView
+                        .getManualLotto()
+                        .mapNotNull { LottoNumber.createOrNull(it) }
+                        .sortedBy { it.value },
+                )
+        ) {
+            is LottoCreationResult.Success -> return result.lotto
+            is LottoCreationResult.Failure.InvalidCount -> outputView.printErrorMessage(Message.errorInvalidLotto())
+            is LottoCreationResult.Failure.DuplicatedNumbers -> outputView.printErrorMessage(Message.errorInvalidLotto())
+            is LottoCreationResult.Failure.NotSorted -> outputView.printErrorMessage(Message.errorInvalidLotto())
+        }
+        return inputLotto()
+    }
+
+    private fun inputAmount(): Amount {
+        val amount = Amount.createOrNull(inputView.getMoney())
+        return amount ?: run {
+            outputView.printErrorMessage(Message.errorInvalidAmount())
+            inputAmount()
+        }
+    }
+
+    private fun getWinningLotto(): WinningLotto {
+        when (
+            val result =
+                WinningLotto.create(
+                    inputView.getWinningLotto().mapNotNull { LottoNumber.createOrNull(it) },
+                    LottoNumber.createOrNull(inputView.getBonusNumber()) ?: return getWinningLotto(),
+                )
+        ) {
+            is WinningLottoCreationResult.Success -> return result.winningLotto
+            is WinningLottoCreationResult.Failure.NumberSizeError -> outputView.printErrorMessage(Message.errorInvalidWinningNumbers())
+            is WinningLottoCreationResult.Failure.BonusNumberDuplicated -> outputView.printErrorMessage(Message.errorInvalidBonusNumber())
+            is WinningLottoCreationResult.Failure.DuplicatedNumbers -> outputView.printErrorMessage(Message.errorInvalidWinningNumbers())
+        }
+        return getWinningLotto()
+    }
+
+    private fun sortResultsByOriginalRankOrder(ranks: List<Rank>): List<Pair<Rank, Int>> =
+        Rank.entries
+            .filter { it != Rank.MISS }
+            .map { rank -> rank to ranks.count { it == rank } }
+            .reversed()
+
+    companion object {
+        const val LOTTO_PRIZE = 1000
+    }
+}

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

@@ -11,9 +11,6 @@ class Amount private constructor(
     }
 
     companion object {
-        fun createOrNull(input: Int): Amount? {
-            if (input < 0) return null
-            return Amount(input)
-        }
+        fun createOrNull(input: Int): Amount? = if (input >= 0) Amount(input) else null
     }
 }

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

@@ -8,38 +8,39 @@ class RandomSort : SortStrategy {
     override fun sort(numberList: List<LottoNumber>): List<LottoNumber> = numberList.shuffled()
 }
 
+sealed class LottoCreationResult {
+    data class Success(
+        val lotto: Lotto,
+    ) : LottoCreationResult()
+
+    sealed class Failure : LottoCreationResult() {
+        object NotSorted : Failure()
+
+        object InvalidCount : Failure()
+
+        object DuplicatedNumbers : Failure()
+    }
+}
+
 class Lotto private constructor(
     val numberList: List<LottoNumber>,
 ) {
     init {
-        require(numberList.sortedBy { it.value } == numberList) { LOTTO_NOT_SORTED }
+        require(numberList.sortedBy { it.value } == numberList) { throw IllegalArgumentException() }
     }
 
     companion object {
         const val LOTTO_NUMBER_QUANTITY = 6
-        const val LOTTO_NOT_SORTED = "[ERROR] 로또 번호가 정렬되지 않았습니다."
-        const val NUMBER_COUNT_ERROR = "[ERROR] 로또 번호 갯수가 ${LOTTO_NUMBER_QUANTITY}가 아닙니다"
-        const val NUMBER_DUPLICATE_ERROR = "[ERROR] 로또 번호가 중복됩니다."
-        private val LOTTO_NUMBERS: List<LottoNumber> = (1..45).map { it -> LottoNumber.valueOf(it) }
-
-        fun valueOf(numberList: List<LottoNumber>): Lotto {
-            require(numberList.size == LOTTO_NUMBER_QUANTITY) { NUMBER_COUNT_ERROR }
-            require(numberList.distinctBy { it.value }.size == numberList.size) { NUMBER_DUPLICATE_ERROR }
-            return Lotto(numberList)
-        }
-
-        fun createOrNull(numberList: List<LottoNumber>): Lotto? =
+        private val LOTTO_NUMBERS: List<LottoNumber> = (1..45).map { LottoNumber.valueOf(it) }
+
+        fun create(numberList: List<LottoNumber>): LottoCreationResult =
             when {
-                numberList.size != LOTTO_NUMBER_QUANTITY -> null
-                numberList.distinctBy { it.value }.size != numberList.size -> null
-                else -> Lotto(numberList)
+                numberList.size != LOTTO_NUMBER_QUANTITY -> LottoCreationResult.Failure.InvalidCount
+                numberList.distinctBy { it.value }.size != numberList.size -> LottoCreationResult.Failure.DuplicatedNumbers
+                else -> LottoCreationResult.Success(Lotto(numberList.sortedBy { it.value }))
             }
 
         fun createRandom(sortStrategy: SortStrategy = RandomSort()): Lotto =
-            Lotto(
-                sortStrategy.sort(LOTTO_NUMBERS).slice(0..5).sortedBy {
-                    it.value
-                },
-            )
+            Lotto(sortStrategy.sort(LOTTO_NUMBERS).take(LOTTO_NUMBER_QUANTITY).sortedBy { it.value })
     }
 }

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

@@ -19,9 +19,7 @@ enum class Rank(
             matchBonus: Boolean,
         ): Rank =
             entries.firstOrNull {
-                (it.countOfMatch == countOfMatch) && ((it.matchBonus && matchBonus) == it.matchBonus)
-            } ?: throw IllegalArgumentException(RANK_FIND_ERROR)
-
-        const val RANK_FIND_ERROR = "[ERROR] 순위를 찾을 수 없습니다"
+                (it.countOfMatch <= countOfMatch) && ((it.matchBonus && matchBonus) == it.matchBonus)
+            } ?: MISS
     }
 }

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

@@ -1,36 +1,41 @@
 package lotto.domain.model
 
+sealed class WinningLottoCreationResult {
+    data class Success(
+        val winningLotto: WinningLotto,
+    ) : WinningLottoCreationResult()
+
+    sealed class Failure : WinningLottoCreationResult() {
+        object BonusNumberDuplicated : Failure()
+
+        object DuplicatedNumbers : Failure()
+
+        object NumberSizeError : Failure()
+    }
+}
+
 class WinningLotto private constructor(
     private val lottoNumbers: List<LottoNumber>,
     private val bonusNumber: LottoNumber,
 ) {
     fun findRank(lotto: Lotto): Rank {
-        val countOfMatch =
-            lottoNumbers.intersect(lotto.numberList).size
+        val countOfMatch = lottoNumbers.intersect(lotto.numberList).size
         val bonusMatched = lotto.numberList.contains(bonusNumber)
         return Rank.valueOf(countOfMatch, bonusMatched)
     }
 
     companion object {
-        const val NUMBER_LIST_DUPLICATED = "[ERROR] 당첨 번호가 중복됩니다."
-        const val BONUS_NUMBER_DUPLICATED = "[ERROR] 보너스 번호가 중복됩니다."
-
-        fun valueOf(
-            inputNumbers: List<LottoNumber>,
-            bonusNumber: LottoNumber,
-        ): WinningLotto {
-            require(!inputNumbers.contains(bonusNumber)) { BONUS_NUMBER_DUPLICATED }
-            require(inputNumbers.distinctBy { it.value } == inputNumbers) { NUMBER_LIST_DUPLICATED }
-            return WinningLotto(inputNumbers, bonusNumber)
-        }
+        const val WINNING_LOTTO_NUMBER_QUANTITY = 6
 
-        fun createOrNull(
-            inputNumbers: List<LottoNumber>,
+        fun create(
+            numbers: List<LottoNumber>,
             bonusNumber: LottoNumber,
-        ): WinningLotto? {
-            if (inputNumbers.contains(bonusNumber)) return null
-            if (inputNumbers.distinctBy { it.value } != inputNumbers) return null
-            return WinningLotto(inputNumbers, bonusNumber)
-        }
+        ): WinningLottoCreationResult =
+            when {
+                numbers.size != WINNING_LOTTO_NUMBER_QUANTITY -> WinningLottoCreationResult.Failure.NumberSizeError
+                numbers.distinctBy { it.value }.size != numbers.size -> WinningLottoCreationResult.Failure.DuplicatedNumbers
+                numbers.contains(bonusNumber) -> WinningLottoCreationResult.Failure.BonusNumberDuplicated
+                else -> WinningLottoCreationResult.Success(WinningLotto(numbers, bonusNumber))
+            }
     }
 }

src/main/kotlin/lotto/domain/service/RankCalculator.kt

@@ -9,11 +9,7 @@ class RankCalculator {
         inputMoney: Int,
         earningMoney: Int,
     ): Double {
-        require(inputMoney != 0) { INPUT_MONEY_ZERO }
+        require(inputMoney != 0) { "[ERROR] 입력 금액이 0입니다" }
         return earningMoney.toDouble() / inputMoney.toDouble()
     }
-
-    companion object {
-        const val INPUT_MONEY_ZERO = "[Error] 입력 금액이 0입니다"
-    }
 }

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

@@ -0,0 +1,53 @@
+package lotto.view
+
+import lotto.view.InputMessage.ALERT_INPUT_LOTTO
+import lotto.view.InputMessage.BONUS_NUMBER_INPUT_MESSAGE
+import lotto.view.InputMessage.COUNT_INPUT_MESSAGE
+import lotto.view.InputMessage.ERROR_MESSAGE
+import lotto.view.InputMessage.MONEY_INPUT_MESSAGE
+import lotto.view.InputMessage.WINNING_LOTTO_INPUT_MESSAGE
+
+object InputMessage {
+    const val MONEY_INPUT_MESSAGE = "구입금액을 입력해 주세요."
+    const val WINNING_LOTTO_INPUT_MESSAGE = "\n지난 주 당첨 번호를 입력해 주세요."
+    const val BONUS_NUMBER_INPUT_MESSAGE = "보너스 볼을 입력해 주세요."
+    const val COUNT_INPUT_MESSAGE = "\n수동으로 구매할 로또 수를 입력해 주세요."
+    const val ALERT_INPUT_LOTTO = "수동으로 구매할 번호를 입력해 주세요."
+    const val ERROR_MESSAGE = "[ERROR] 입력이 올바르지 않습니다. 다시 입력해 주세요."
+}
+
+class InputView {
+    fun getMoney(): Int = getValidSingleNumber(MONEY_INPUT_MESSAGE)
+
+    fun getWinningLotto(): List<Int> = getValidMultipleNumbers(WINNING_LOTTO_INPUT_MESSAGE)
+
+    fun getBonusNumber(): Int = getValidSingleNumber(BONUS_NUMBER_INPUT_MESSAGE)
+
+    fun getManualCount(): Int = getValidSingleNumber(COUNT_INPUT_MESSAGE)
+
+    fun messageManualLotto() = println(ALERT_INPUT_LOTTO)
+
+    fun getManualLotto(): List<Int> = getValidMultipleNumbers(null)
+
+    private fun getValidSingleNumber(message: String): Int {
+        while (true) {
+            println(message)
+            val input = readln().trim()
+            val number = input.toIntOrNull()
+
+            if (number != null) return number
+            println(ERROR_MESSAGE)
+        }
+    }
+
+    private fun getValidMultipleNumbers(message: String?): List<Int> {
+        while (true) {
+            message?.let { println(it) }
+            val input = readln().trim()
+            val numbers = input.split(",").mapNotNull { it.trim().toIntOrNull() }
+
+            if (numbers.isNotEmpty() && numbers.size == input.split(",").size) return numbers
+            println(ERROR_MESSAGE)
+        }
+    }
+}