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

README.md

@@ -3,6 +3,20 @@
 ## 기능 요구 사항
 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
 로또 1장의 가격은 1000원이다.
+
+## 유의할 사항
+
+- 클래스 프로퍼티로 선언할때는 주의, 여러번 호출하거나 동시에 호출하면 꼬인다.
+- 절차지향 x 객체끼리의 관계를 작성하자
+- 객체를 어떻게 재활용할까? 혹은 의존성을 연결시킬까? 
+- private 함수를 테스트 하기 쉬운 방법 중 하나는 객체에게 역할을 넘기는 것
+- 뷰와 도메인이 결합되지 않도록 주의
+- 예외처리에 대해 너무 하루종일 생각하지 말자
+- 코드의 일관성 유지
+- 객체의 프로퍼티를 var로 해버리면 나중에 초기 유효성 검사를 무시할 가능성이 있다.
+- 함수의 이름으로 어떤 기능을 하는지 유추할 수 있도록 하자
+- 뭐든지 너무 매몰되지 말자
+- 외부에서 유효성 검사를 호출해야만 할 수 있으면 의미가 없다.
 ## 기능 목록
 ### 로또 번호
 - [x] 로또 번호는 1~45 사이이다.
@@ -11,11 +25,13 @@
 - [x] 로또 번호는 중복되지 않는다.
 - [x] 로또 번호는 오름차순으로 정렬된다.
 ### 구입금액 및 수량
-- [x] 구입 금액은 천원 단위이다.
 - [x] 구입 금액을 로또 가격으로 나누면 로또 수량이다.
-- [x] 구입 금액은 최소 천원 이상이다.
+- [x] 금액은 음수일 수 없다.
+- [ ] 구매 후 남은 금액은 마지막에 출력한다.
 ### 로또 발행
-- [x] 입력된 금액에 맞게 로또를 발행한다.
+- [x] 입력된 횟수에 맞게 수동으로 로또를 입력받는다
+- [x] 입력된 금액에 맞는 로또를 생성한다.
+- [x] 남은 금액에 맞게 자동 로또를 발행한다.
 ### 당첨 통계
 - [x] 당첨 로또 번호와 보너스 볼의 중복 여부를 확인한다.
 - [x] 당첨 로또 번호와 로또 번호를 비교하여 순위를 리턴한다.
@@ -27,5 +43,3 @@
 ### 당첨금 계산
 - [x] 당첨 총 금액을 모든 로또의 순위에 따라 계산한다
 - [x] 입력된 금액과 비교하여 수익률을 도출한다
-
-

src/main/kotlin/lotto/Application.kt

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

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

@@ -1,55 +1,106 @@
 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.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(
-    private val inputView: InputView = InputView(),
-    private val outputView: OutputView = OutputView(),
+    val inputView: InputView,
+    val outputView: OutputView,
 ) {
+    val amount = inputAmount()
+
     fun run() {
-        val amount = getAmount()
-        val lottoMachine = LottoMachine(amount)
-        val publishedLotto = publishLotto(lottoMachine)
+        val count = getManualCount()
+        val manualLottoList = getLottoList(count)
+        val autoLottoList = getAutoLotto(amount.getCount(LOTTO_PRIZE) - count)
+
+        outputView.printPurchaseResult(manualLottoList, autoLottoList)
+
         val winningLotto = getWinningLotto()
-        val bonusNumber = getBonusNumber()
-        val lottoMatcher = LottoMatcher(winningLotto, bonusNumber)
-        showEarningRate(amount, lottoMatcher, publishedLotto)
+        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)
     }
 
-    private fun getAmount(): Amount = Amount(inputView.getMoney())
+    fun getAutoLotto(count: Int): List<Lotto> = List(count) { Lotto.createRandom() }
 
-    private fun publishLotto(lottoMachine: LottoMachine): List<Lotto> {
-        val publishedLotto = lottoMachine.publishLottoTickets(Amount(LOTTO_PRIZE))
-        outputView.printPublishedLotto(publishedLotto)
-        return publishedLotto
+    fun getManualCount(): Int {
+        val manualCount = inputView.getManualCount()
+        return if (amount.getCount(LOTTO_PRIZE) >= manualCount) {
+            manualCount
+        } else {
+            outputView.printErrorMessage(Message.errorCountExceeded())
+            getManualCount()
+        }
     }
 
-    private fun getWinningLotto(): Lotto {
-        val winningInput = inputView.getWinningLotto()
-        return Lotto(LottoNumbers(winningInput.map { number -> LottoNumber(number) }), Amount(LOTTO_PRIZE))
+    fun getLottoList(count: Int): List<Lotto> {
+        inputView.messageManualLotto()
+        return List(count) { inputLotto() }
     }
 
-    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 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

@@ -0,0 +1,16 @@
+package lotto.domain.model
+
+class Amount private constructor(
+    val money: Int,
+) {
+    fun getCount(lottoPrize: Int): Int = money / lottoPrize
+
+    fun paymentOrNull(payMoney: Int): Amount? {
+        if (money < payMoney) return null
+        return Amount(money - payMoney)
+    }
+
+    companion object {
+        fun createOrNull(input: Int): Amount? = if (input >= 0) Amount(input) else null
+    }
+}

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

@@ -0,0 +1,46 @@
+package lotto.domain.model
+
+interface SortStrategy {
+    fun sort(numberList: List<LottoNumber>): List<LottoNumber>
+}
+
+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) { throw IllegalArgumentException() }
+    }
+
+    companion object {
+        const val LOTTO_NUMBER_QUANTITY = 6
+        private val LOTTO_NUMBERS: List<LottoNumber> = (1..45).map { LottoNumber.valueOf(it) }
+
+        fun create(numberList: List<LottoNumber>): LottoCreationResult =
+            when {
+                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).take(LOTTO_NUMBER_QUANTITY).sortedBy { it.value })
+    }
+}

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

@@ -0,0 +1,22 @@
+package lotto.domain.model
+
+data class LottoNumber private constructor(
+    val value: Int,
+) {
+    companion object {
+        private val VALID_RANGE = 1..45
+        private const val RANGE_ERROR = "[ERROR] 범위 외의 값입니다."
+
+        fun valueOf(value: Int): LottoNumber {
+            require(value in VALID_RANGE) { RANGE_ERROR }
+            return LottoNumber(value)
+        }
+
+        fun createOrNull(value: Int): LottoNumber? {
+            if (validation(value)) return LottoNumber(value)
+            return null
+        }
+
+        private fun validation(value: Int): Boolean = value in VALID_RANGE
+    }
+}

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

@@ -0,0 +1,25 @@
+package lotto.domain.model
+
+enum class Rank(
+    val countOfMatch: Int,
+    val winningMoney: Int,
+    val matchBonus: Boolean,
+) {
+    FIRST(6, 2_000_000_000, false),
+    SECOND(5, 30_000_000, true),
+    THIRD(5, 1_500_000, false),
+    FOURTH(4, 50_000, false),
+    FIFTH(3, 5_000, false),
+    MISS(0, 0, false),
+    ;
+
+    companion object {
+        fun valueOf(
+            countOfMatch: Int,
+            matchBonus: Boolean,
+        ): Rank =
+            entries.firstOrNull {
+                (it.countOfMatch <= countOfMatch) && ((it.matchBonus && matchBonus) == it.matchBonus)
+            } ?: MISS
+    }
+}

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

@@ -0,0 +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 bonusMatched = lotto.numberList.contains(bonusNumber)
+        return Rank.valueOf(countOfMatch, bonusMatched)
+    }
+
+    companion object {
+        const val WINNING_LOTTO_NUMBER_QUANTITY = 6
+
+        fun create(
+            numbers: List<LottoNumber>,
+            bonusNumber: LottoNumber,
+        ): 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

@@ -0,0 +1,15 @@
+package lotto.domain.service
+
+import lotto.domain.model.Rank
+
+class RankCalculator {
+    fun earningMoney(winningList: List<Rank>): Int = winningList.sumOf { it.winningMoney }
+
+    fun calculateEarningRate(
+        inputMoney: Int,
+        earningMoney: Int,
+    ): Double {
+        require(inputMoney != 0) { "[ERROR] 입력 금액이 0입니다" }
+        return earningMoney.toDouble() / inputMoney.toDouble()
+    }
+}

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

@@ -0,0 +1,12 @@
+package lotto.domain.service
+
+import lotto.domain.model.Lotto
+import lotto.domain.model.Rank
+import lotto.domain.model.WinningLotto
+
+class WinningListMaker {
+    fun calculateRanks(
+        winningLotto: WinningLotto,
+        lottoList: List<Lotto>,
+    ): List<Rank> = lottoList.map { winningLotto.findRank(it) }
+}