[Step3] 로또(2등) 구현

src/main/kotlin/lotto/LottoCreator.kt

@@ -0,0 +1,28 @@
+package lotto
+
+import lotto.const.LottoConst
+import lotto.domain.Lotto
+import lotto.domain.LottoNumber
+import lotto.domain.WinningLotto
+import lotto.util.NumberGenerator
+import lotto.util.RandomNumberGenerator
+
+class LottoCreator(private val numberGenerator: NumberGenerator = RandomNumberGenerator()) {
+    fun createLottos(count: Int): List<Lotto> {
+        return List(count) { createSingleLotto() }
+    }
+
+    fun createWinningLotto(
+        winningNumbers: Set<Int>,
+        bonusNumber: Int,
+    ): WinningLotto {
+        val winningLotto = Lotto(winningNumbers.map { LottoNumber(it) }.toSet())
+        return WinningLotto(winningLotto, LottoConst.getLottoNumber(bonusNumber))
+    }
+
+    private fun createSingleLotto(): Lotto {
+        val randomNumbers = numberGenerator.generate()
+        val lotto = Lotto(randomNumbers.map { LottoConst.LOTTO_NUMBERS[it - 1] }.toSet())
+        return lotto
+    }
+}

src/main/kotlin/lotto/LottoShop.kt

@@ -0,0 +1,21 @@
+package lotto
+
+import lotto.const.LottoConst.UNIT_OF_AMOUNT
+import lotto.domain.Order
+
+class LottoShop(private val lottoCreator: LottoCreator) {
+    fun makeOrder(amount: Int): Order {
+        validateAmountIsPositive(amount)
+        val lottoCounts = calculateLottoCounts(amount)
+        return Order(amount, lottoCreator.createLottos(lottoCounts))
+    }
+
+    private fun validateAmountIsPositive(amount: Int) {
+        require(amount > 0) { "로또 구매 금액은 음수이거나 0원일 수 없습니다. (현재 입력 금액: $amount)" }
+    }
+
+    private fun calculateLottoCounts(amount: Int): Int {
+        require(amount % UNIT_OF_AMOUNT == 0) { "로또 구매 금액은 1000원 단위로 입력되어야 합니다. (현재 입력 금액: $amount)" }
+        return amount / UNIT_OF_AMOUNT
+    }
+}

src/main/kotlin/lotto/Main.kt

@@ -1,15 +1,24 @@
 package lotto
 
+import lotto.view.InputView
+import lotto.view.ResultView
+
 fun main() {
-    val lottoSystem = LottoSystem()
+    val lottoCreator = LottoCreator()
+    val lottoShop = LottoShop(lottoCreator)
+    val winningLottoMatcher = WinningLottoMatcher()
 
+    // 주문 생성
     val amount = InputView.getAmount()
-    val order = lottoSystem.createOrder(amount)
+    val order = lottoShop.makeOrder(amount)
     ResultView.printCreatedLottos(order.lottos)
 
+    // 당첨번호 및 보너스번호 생성
     val winNumberInput = InputView.getWinNumberInput()
-    val winNumbers = lottoSystem.createWinNumbers(winNumberInput)
+    val bonusNumber = InputView.getBonusNumber()
+    val winNumbers = lottoCreator.createWinningLotto(winNumberInput, bonusNumber)
 
-    val result = lottoSystem.createWinningResult(order, winNumbers)
+    // 결과 출력
+    val result = winningLottoMatcher.checkAndGetResult(order, winNumbers)
     ResultView.printResult(result)
 }

src/main/kotlin/lotto/WinningLottoMatcher.kt

@@ -0,0 +1,41 @@
+package lotto
+
+import lotto.domain.Lotto
+import lotto.domain.LottoResult
+import lotto.domain.Order
+import lotto.domain.Rank
+import lotto.domain.WinningLotto
+import lotto.domain.WinningResult
+
+class WinningLottoMatcher {
+    fun checkAndGetResult(
+        order: Order,
+        winningLotto: WinningLotto,
+    ): WinningResult {
+        val winningMatchCounts = aggregateLottoResult(order.lottos, winningLotto)
+        return WinningResult(winningMatchCounts, order.amount)
+    }
+
+    private fun aggregateLottoResult(
+        lottos: List<Lotto>,
+        winningLotto: WinningLotto,
+    ): List<LottoResult> {
+        val result = groupByRank(lottos, winningLotto)
+        return result
+            .map { (rank, count) -> LottoResult(count, rank) }
+            .sortedBy { it.rank.prizeAmount }
+    }
+
+    private fun groupByRank(
+        lottos: List<Lotto>,
+        winningLotto: WinningLotto,
+    ): Map<Rank, Int> {
+        val result = Rank.entries.filter { it !== Rank.MISS }.associateWith { 0 }
+        val rankWithMatchCounts =
+            lottos.map { winningLotto.matchLotto(it) }
+                .filter { it !== Rank.MISS }
+                .groupBy { it }
+                .mapValues { (_, values) -> values.size }
+        return result.mapValues { (rank, count) -> rankWithMatchCounts[rank] ?: count }
+    }
+}

src/main/kotlin/lotto/const/LottoConst.kt

@@ -0,0 +1,12 @@
+package lotto.const
+
+import lotto.domain.LottoNumber
+
+object LottoConst {
+    const val UNIT_OF_AMOUNT = 1000
+    val LOTTO_NUMBERS = IntRange(1, 45).map { LottoNumber(it) }.toList()
+
+    fun getLottoNumber(number: Int): LottoNumber {
+        return requireNotNull(LOTTO_NUMBERS.find { it == LottoNumber(number) }) { "일치하는 번호의 로또번호가 존재하지 않습니다." }
+    }
+}

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

@@ -1,18 +1,11 @@
-package lotto
-
-class Lotto(generatedNumbers: Set<Int>) {
-    val numbers: Set<LottoNumber>
+package lotto.domain
 
+class Lotto(val numbers: Set<LottoNumber>) {
     init {
-        validateSize(generatedNumbers)
-        numbers = generatedNumbers.map { LottoNumber(it) }.toSet()
-    }
-
-    fun countMatchingNumbers(targetLotto: Set<LottoNumber>): Int {
-        return targetLotto.count { it in this.numbers }
+        validateSize(numbers)
     }
 
-    private fun validateSize(numbers: Set<Int>) {
+    private fun validateSize(numbers: Set<LottoNumber>) {
         require(numbers.size == LOTTO_NUMBER_SIZE) { "로또 번호는 ${LOTTO_NUMBER_SIZE}개여야 합니다. 현재 전달된 개수는 ${numbers.size}개 입니다." }
     }
 

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

@@ -1,4 +1,4 @@
-package lotto
+package lotto.domain
 
 @JvmInline
 value class LottoNumber(private val number: Int) {
@@ -10,6 +10,10 @@ value class LottoNumber(private val number: Int) {
         require(this.number in LOTTO_RANGE) { "로또 번호는 ${LOTTO_RANGE.first} ~ ${LOTTO_RANGE.last} 내의 숫자여야 합니다." }
     }
 
+    override fun toString(): String {
+        return "$number"
+    }
+
     companion object {
         private val LOTTO_RANGE = 1..45
     }

src/main/kotlin/lotto/domain/LottoResult.kt

@@ -0,0 +1,10 @@
+package lotto.domain
+
+data class LottoResult(
+    val totalCount: Int,
+    val rank: Rank,
+) {
+    fun getTotalPrizeMoney(): Int {
+        return this.rank.prizeAmount * totalCount
+    }
+}

src/main/kotlin/lotto/domain/Order.kt

@@ -0,0 +1,17 @@
+package lotto.domain
+
+import lotto.const.LottoConst.UNIT_OF_AMOUNT
+
+data class Order(
+    val amount: Int,
+    val lottos: List<Lotto>,
+) {
+    init {
+        validateLottoCounts()
+    }
+
+    private fun validateLottoCounts() {
+        val count = amount / UNIT_OF_AMOUNT
+        require(lottos.size == count) { "구매한 금액과 로또의 수량이 일치하지 않습니다." }
+    }
+}

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

@@ -0,0 +1,24 @@
+package lotto.domain
+
+enum class Rank(
+    val matchCount: Int,
+    val prizeAmount: Int,
+    private val match: (Int, Boolean) -> Boolean,
+) {
+    FIRST(6, 2_000_000_000, { count, _ -> count == 6 }),
+    SECOND(5, 30_000_000, { count, isBonusMatch -> count == 5 && isBonusMatch }),
+    THIRD(5, 1_500_000, { count, _ -> count == 5 }),
+    FOURTH(4, 50_000, { count, _ -> count == 4 }),
+    FIFTH(3, 5_000, { count, _ -> count == 3 }),
+    MISS(0, 0, { count, _ -> count < 3 }), ;
+
+    companion object {
+        fun findByMatchCount(
+            matchCount: Int,
+            isBonusMatch: Boolean = false,
+        ): Rank {
+            return entries.firstOrNull { it.match(matchCount, isBonusMatch) }
+                ?: throw RuntimeException("일치하는 숫자의 개수에 해당하는 상품이 존재하지 않습니다.")
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package lotto.domain
+
+class WinningLotto(
+    val winningNumbers: Lotto,
+    val bonusNumber: LottoNumber,
+) {
+    fun matchLotto(targetLotto: Lotto): Rank {
+        return Rank.findByMatchCount(
+            countMatchingNumbers(targetLotto),
+            matchBonusNumber(targetLotto),
+        )
+    }
+
+    fun countMatchingNumbers(targetLotto: Lotto): Int {
+        return targetLotto.numbers.count { it in winningNumbers.numbers }
+    }
+
+    fun matchBonusNumber(targetLotto: Lotto): Boolean {
+        return targetLotto.numbers.contains(bonusNumber)
+    }
+}