[로또 2단계] 모찌 미션 제출합니다.

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

@@ -1,39 +1,68 @@
 package lotto.controller
 
-import lotto.contants.LottoRuleConstants
-import lotto.model.LottoMachine
+import lotto.model.LottoIssueType
 import lotto.model.LottoResult
+import lotto.model.LottoStoreCashier
 import lotto.model.LottoTicket
+import lotto.model.LottoTicketIssueManager
 import lotto.model.WinningLotto
 import lotto.view.UserInterface
 
 class LottoController(
     private val userInterface: UserInterface = UserInterface(),
 ) {
     fun run() {
-        val lottoTickets = generateLottoTickets()
+        val possibleToLottoTicketCount = meetLottoStoreCashier()
+        val lottoTickets = getLottoTickets(possibleToLottoTicketCount)
         val winningLotto = getWinningLotto()
-        val lottoResult = winningLotto.getResult(lottoTickets)
-        getResult(lottoResult)
+        getResult(lottoTickets, winningLotto)
     }
 
-    private fun generateLottoTickets(): List<LottoTicket> {
-        val amount = userInterface.inputPurchaseAmount()
-        val count = calculatePurchaseCount(amount)
-        val lottoTickets = LottoMachine().purchase(count)
-        userInterface.printLottoTickets(lottoTickets)
-        return lottoTickets
+    private fun meetLottoStoreCashier(): Int {
+        val money = userInterface.inputPurchaseAmount()
+        val lottoStoreCashier = LottoStoreCashier(money)
+        val possibleToLottoTicketCount = lottoStoreCashier.calculatePossibleToBuyLottoTicketCount()
+        val customerAnswer = userInterface.printLottoCount(possibleToLottoTicketCount)
+        if (customerAnswer) {
+            val change = lottoStoreCashier.calculateChange(possibleToLottoTicketCount)
+            userInterface.printChange(change)
+        }
+        return possibleToLottoTicketCount
     }
 
-    private fun calculatePurchaseCount(amount: Int) = amount / LottoRuleConstants.LOTTO_AMOUNT.value
+    private fun getLottoTickets(possibleToLottoTicketCount: Int): List<LottoTicket> {
+        val customerWantToBuyManualLottoTicketCount = userInterface.getManualLottoCount()
+        val manualLottoNumbers =
+            if (customerWantToBuyManualLottoTicketCount != 0) {
+                userInterface.getManualLottoNumbers(customerWantToBuyManualLottoTicketCount)
+            } else {
+                emptyList()
+            }
+        val lottoTicketIssueManager =
+            LottoTicketIssueManager(
+                possibleToLottoTicketCount,
+                customerWantToBuyManualLottoTicketCount,
+                manualLottoNumbers,
+            )
+        val lottoTickets = lottoTicketIssueManager.getLottoTickets(manualLottoNumbers)
+        val autoLottoTicketCount = lottoTicketIssueManager.getCustomerWantToBuyManualLottoTicketCount()
+        userInterface.printLottoTickets(customerWantToBuyManualLottoTicketCount, autoLottoTicketCount, lottoTickets)
+        return lottoTickets
+    }
 
     private fun getWinningLotto(): WinningLotto {
         val winningNumbers = userInterface.getWinningNumbers()
         val bonusNumber = userInterface.getBonusNumber()
-        return WinningLotto(winningNumbers, bonusNumber)
+        val winningLottoTicket = LottoTicket(LottoIssueType.WINNING, winningNumbers)
+        return WinningLotto(winningLottoTicket, bonusNumber)
     }
 
-    private fun getResult(lottoResult: LottoResult) {
+    private fun getResult(
+        lottoTickets: List<LottoTicket>,
+        winningLotto: WinningLotto,
+    ) {
+        val ranks = winningLotto.getRanks(lottoTickets)
+        val lottoResult = LottoResult(ranks)
         val winningStatus = lottoResult.getWinningStatus()
         val profit = lottoResult.calculateProfit()
         userInterface.printResult(winningStatus)

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

@@ -0,0 +1,17 @@
+package lotto.model
+
+import lotto.contants.LottoRuleConstants
+
+class AutoLottoTicketGenerator : LottoTicketGenerator {
+    override val type: LottoIssueType = LottoIssueType.AUTO
+
+    override fun generateLottoTicket(): LottoTicket {
+        val lottoNumbers =
+            (LottoRuleConstants.MINIMUM_NUMBER.value..LottoRuleConstants.MAXIMUM_NUMBER.value)
+                .shuffled()
+                .take(LottoRuleConstants.LOTTO_PICK_COUNT.value)
+                .sorted()
+                .map(::LottoNumber)
+        return LottoTicket(LottoIssueType.AUTO, lottoNumbers)
+    }
+}

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

@@ -0,0 +1,9 @@
+package lotto.model
+
+enum class LottoIssueType(
+    val issueType: String,
+) {
+    AUTO("자동"),
+    MANUAL("수동"),
+    WINNING("당첨"),
+}

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

@@ -1,5 +1,24 @@
 package lotto.model
 
+// 로또 발행하는 머신
 class LottoMachine {
-    fun purchase(count: Int): List<LottoTicket> = List(count) { LottoTicket() }
+    // 로또 티켓을 발행한다.
+    fun issueLottoTickets(
+        customerWantToBuyAutoLottoTicketCount: LottoTicketCount,
+        manualLottoNumbers: List<List<Int>>,
+    ): List<LottoTicket> = purchaseManualLottoTickets(manualLottoNumbers) + purchaseAutoLottoTickets(customerWantToBuyAutoLottoTicketCount)
+
+    // 자동 로또를 발행
+    private fun purchaseAutoLottoTickets(customerWantToBuyAutoLottoTicketCount: LottoTicketCount): List<LottoTicket> {
+        val autoLottoGenerator = AutoLottoTicketGenerator()
+        val autoLottoTickets =
+            List(customerWantToBuyAutoLottoTicketCount.toInt()) { autoLottoGenerator.generateLottoTicket() }
+        return autoLottoTickets
+    }
+
+    // 수동 로또를 발행
+    private fun purchaseManualLottoTickets(manualLottoNumbers: List<List<Int>>): List<LottoTicket> {
+        val manualLottoTickets = manualLottoNumbers.map { ManualLottoTicketGenerator(it).generateLottoTicket() }
+        return manualLottoTickets
+    }
 }

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

@@ -0,0 +1,29 @@
+package lotto.model
+
+import lotto.contants.LottoRuleConstants
+
+// 돈 계산을 해주는 클래스
+class LottoStoreCashier(
+    private val customerMoney: Int,
+) {
+    private val possibleToLottoTicketCount = calculatePossibleToBuyLottoTicketCount()
+
+    // 로또의 가격은 천원이다. 로또를 구매할려면 천원이상 넣어야한다.
+    init {
+        require(customerMoney >= LottoRuleConstants.LOTTO_AMOUNT.value) { INSUFFICIENT_MONEY_FOR_LOTTO_PURCHASE }
+    }
+
+    // 고객이 준 돈에서 몇장을 살 수 있는 지 계산한다.
+    fun calculatePossibleToBuyLottoTicketCount(): Int = customerMoney / LottoRuleConstants.LOTTO_AMOUNT.value
+
+    // 고객이 몇장을 사고 싶다고 이야기를 하면 가능한지 계산한다.
+    fun isPossibleToBuy(customerWantBuyLottoTicketCount: Int): Boolean = possibleToLottoTicketCount >= customerWantBuyLottoTicketCount
+
+    // 고객에게 전달할 잔돈을 계산한다.
+    fun calculateChange(customerWantBuyLottoTicketCount: Int): Int =
+        customerMoney - (LottoRuleConstants.LOTTO_AMOUNT.value * possibleToLottoTicketCount)
+
+    companion object {
+        private const val INSUFFICIENT_MONEY_FOR_LOTTO_PURCHASE = "로또는 천원이상 넣어야지 구매 가능합니다."
+    }
+}

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

@@ -3,28 +3,35 @@ package lotto.model
 import lotto.contants.LottoRuleConstants
 
 class LottoTicket(
-    private val numbers: Set<LottoNumber> = generateLotto(),
+    val lottoIssueType: LottoIssueType,
+    private val numbers: List<LottoNumber>,
 ) {
+    private val lottoNumbers: Set<LottoNumber> = numbers.toSet()
+
     init {
-        require(numbers.size == LottoRuleConstants.LOTTO_PICK_COUNT.value)
-        { ERROR_NUMBERS_COUNT }
+        require(numbers.size == LottoRuleConstants.LOTTO_PICK_COUNT.value) { ERROR_NUMBERS_COUNT }
+    }
+
+    fun getSize() = lottoNumbers.size
+
+    fun containsNumber(number: LottoNumber): Boolean {
+        return lottoNumbers.contains(number)
     }
 
-    fun getSize() = numbers.size
+    fun getNumbers(): Set<LottoNumber> {
+        return lottoNumbers
+    }
 
-    fun getNumbers() = numbers
+    fun matchNumbersSize(lottoTicket: LottoTicket) = numbers.intersect(lottoTicket.getNumbers()).size
 
     companion object {
         private const val ERROR_NUMBERS_COUNT = "로또 번호의 개수는 6개입니다."
 
-        private fun generateLotto(): Set<LottoNumber> =
-            (LottoRuleConstants.MINIMUM_NUMBER.value..LottoRuleConstants.MAXIMUM_NUMBER.value)
-                .shuffled()
-                .take(LottoRuleConstants.LOTTO_PICK_COUNT.value)
-                .sorted()
-                .map { LottoNumber(it) }
-                .toSet()
-
-            fun create(vararg lottoNumbers: LottoNumber): LottoTicket = LottoTicket(lottoNumbers.toSet())
+        fun create(
+            lottoIssueType: LottoIssueType,
+            vararg lottoNumbers: Int,
+        ): LottoTicket {
+            return LottoTicket(lottoIssueType, lottoNumbers.map { LottoNumber(it) })
+        }
     }
 }

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

@@ -0,0 +1,17 @@
+package lotto.model
+
+import lotto.contants.LottoRuleConstants
+
+class LottoTicketCount(
+    private val count: Int,
+) {
+    init {
+        require(count >= LottoRuleConstants.ZERO.value) { LOTTO_TICKET_COUNT_NOT_NEGATIVE }
+    }
+
+    fun toInt() = count
+
+    companion object {
+        private const val LOTTO_TICKET_COUNT_NOT_NEGATIVE = "로또 구매 장 수는 음수가 될수 없습니다."
+    }
+}

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

@@ -0,0 +1,7 @@
+package lotto.model
+
+interface LottoTicketGenerator {
+    val type: LottoIssueType
+
+    fun generateLottoTicket(): LottoTicket
+}

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

@@ -0,0 +1,29 @@
+package lotto.model
+
+// 수동이랑 자동 로또 계산해주는 매니저, 로또 티켓까지 주는 역할 담당
+class LottoTicketIssueManager(
+    totalCount: Int,
+    manualCount: Int,
+    manualLottoNumbers: List<List<Int>>,
+) {
+    private val manualLottoTicketCount = LottoTicketCount(manualCount)
+    private val autoLottoTicketCount =
+        LottoTicketCount(totalCount - manualCount)
+
+    // 발행가능한 개수보다 수동으로 로또 발행받고 싶은 개수가 크면 안된다.
+    init {
+        require(totalCount >= manualCount) { EXCEEDED_MANUAL_LOTTO_COUNT }
+        require(manualCount == manualLottoNumbers.size) { LOTTO_COUNT_NOT_MATCH_LOTTO_NUMBERS }
+    }
+
+    // 로또를 발행해서 준다.
+    fun getLottoTickets(manualLottoNumbers: List<List<Int>>): List<LottoTicket> =
+        LottoMachine().issueLottoTickets(autoLottoTicketCount, manualLottoNumbers)
+
+    fun getCustomerWantToBuyManualLottoTicketCount(): Int = autoLottoTicketCount.toInt()
+
+    companion object {
+        private const val LOTTO_COUNT_NOT_MATCH_LOTTO_NUMBERS = "수동 구매 개수와 수동 번호 입력 개수가 일치하지 않습니다."
+        private const val EXCEEDED_MANUAL_LOTTO_COUNT = "전체 발행 가능한 로또 개수보다 수동로또 발행 개수가 더 많습니다."
+    }
+}

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

@@ -0,0 +1,9 @@
+package lotto.model
+
+class ManualLottoTicketGenerator(
+    private val numbers: List<Int>,
+) : LottoTicketGenerator {
+    override val type: LottoIssueType = LottoIssueType.MANUAL
+
+    override fun generateLottoTicket(): LottoTicket = LottoTicket(LottoIssueType.MANUAL, numbers.map(::LottoNumber))
+}

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

@@ -1,37 +1,39 @@
 package lotto.model
 
-import lotto.contants.LottoRuleConstants.LOTTO_PICK_COUNT
-
+// 당첨 번호 확인하는 로직
 class WinningLotto(
-    private val winningNumbers: Set<LottoNumber>,
+    private val winningLottoTicket: LottoTicket,
     private val bonusNumber: LottoNumber,
 ) {
     init {
-        require(winningNumbers.size == LOTTO_PICK_COUNT.value) { ERROR_NUMBERS_COUNT }
-        require(!winningNumbers.contains(bonusNumber)) { ERROR_LOTTO_NUMBERS_NOT_CONTAIN_BONUS_NUMBER }
+        require(!winningLottoTicket.containsNumber(bonusNumber)) { ERROR_LOTTO_NUMBERS_NOT_CONTAIN_BONUS_NUMBER }
     }
 
-    fun getResult(lottoTickets: List<LottoTicket>): LottoResult {
-        val result = lottoTickets.map { getRank(it) }
-        return LottoResult(result)
-    }
+    // 전체 당첨 확인 결과 반환
+    fun getRanks(lottoTickets: List<LottoTicket>): List<Rank> = lottoTickets.map { getRank(it) }
 
-    fun getRank(lottoTicket: LottoTicket): Rank {
+    // 몇 등에 당첨 되었는 지 확인
+    private fun getRank(lottoTicket: LottoTicket): Rank {
         val countOfMatch: Int = getCountOfMatch(lottoTicket)
         val matchBonus: Boolean = getMatchBonus(lottoTicket)
         return Rank.valueOf(countOfMatch, matchBonus)
     }
 
-    private fun getCountOfMatch(lottoTicket: LottoTicket): Int = winningNumbers.intersect(lottoTicket.getNumbers()).size
+    // 몇 개 맞는 지 확인
+    private fun getCountOfMatch(lottoTicket: LottoTicket): Int = winningLottoTicket.matchNumbersSize(lottoTicket)
 
-    private fun getMatchBonus(lottoTicket: LottoTicket): Boolean = lottoTicket.getNumbers().contains(bonusNumber)
+    // 보너스 번호 확인
+    private fun getMatchBonus(lottoTicket: LottoTicket): Boolean = lottoTicket.containsNumber(bonusNumber)
 
     companion object {
-        private const val ERROR_NUMBERS_COUNT = "로또 번호의 개수는 6개입니다."
         private const val ERROR_LOTTO_NUMBERS_NOT_CONTAIN_BONUS_NUMBER = "로또 당첨 번호는 보너스 번호를 포함하지 말아야합니다."
 
-        fun create(vararg lottoNumbers: LottoNumber, bonusNumber: LottoNumber): WinningLotto {
-            return WinningLotto(lottoNumbers.toSet(), bonusNumber)
+        fun create(
+            vararg lottoNumbers: Int,
+            bonusNumber: Int,
+        ): WinningLotto {
+            val winningNumbers = LottoTicket(LottoIssueType.WINNING, lottoNumbers.map { LottoNumber(it) })
+            return WinningLotto(winningNumbers, LottoNumber(bonusNumber))
         }
     }
 }

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

@@ -7,16 +7,10 @@ class InputValidator {
 
     fun validateOverZero(input: String) = require(input.toInt() > LottoRuleConstants.ZERO.value) { ERROR_INVALID_OVER_ZERO }
 
-    fun validateAmountUnits1000(input: String) =
-        require(
-            input.toInt() % LottoRuleConstants.LOTTO_AMOUNT.value == LottoRuleConstants.ZERO.value,
-        ) {
-            ERROR_INVALID_DIVISION
-        }
+    fun validateNoNegativeNumber(input: String) = require(input.toInt() >= LottoRuleConstants.ZERO.value) { ERROR_INVALID_OVER_ZERO }
 
     companion object {
         private const val ERROR_INVALID_INTEGER = "정수를 입력해야 합니다."
         private const val ERROR_INVALID_OVER_ZERO = "구입금액은 0보다 커야 합니다."
-        private const val ERROR_INVALID_DIVISION = "구입금액은 1000의 배수여야 합니다."
     }
 }

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

@@ -1,5 +1,7 @@
 package lotto.view
 
 object OutputView {
-    fun printMessage(msg: Any) = println(msg)
+    fun printlnMessage(msg: Any) = println(msg)
+
+    fun printMessage(msg: Any) = print(msg)
 }