[CT-2-2-3] 차트게임 기능 - 실행 테스트 및 버그 수정

data/src/main/java/com/yessorae/data/repository/ChartRepositoryImpl.kt

@@ -10,6 +10,7 @@ import com.yessorae.data.source.network.polygon.model.chart.asDomainModel
 import com.yessorae.domain.common.ChartRequestArgumentHelper
 import com.yessorae.domain.entity.Chart
 import com.yessorae.domain.entity.tick.TickUnit
+import com.yessorae.domain.exception.ChartGameException
 import com.yessorae.domain.repository.ChartRepository
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
@@ -23,19 +24,48 @@ class ChartRepositoryImpl @Inject constructor(
     @Dispatcher(ChartTrainerDispatcher.IO)
     private val dispatcher: CoroutineDispatcher
 ) : ChartRepository {
-    override suspend fun fetchNewChartRandomly(): Chart =
+    override suspend fun fetchNewChartRandomly(totalTurn: Int): Chart =
         withContext(dispatcher) {
-            val chart = networkDataSource
-                .getChart(
-                    ticker = chartRequestArgumentHelper.getRandomTicker(),
-                    tickUnit = appPreferences.getTickUnit(),
-                    from = chartRequestArgumentHelper.getFromDate(),
-                    to = chartRequestArgumentHelper.getToDate()
-                )
-                .asDomainModel(TickUnit.DAY)
-
-            val chartId = localDBDataSource.insertChart(chart.asEntity())
-            localDBDataSource.insertTicks(chart.ticks.map { it.asEntity(chartId = chartId) })
-            chart.copy(id = chartId)
+            fetchNewChartRandomlyWithRetry(
+                currentRetryCount = 0,
+                totalTurn = totalTurn
+            )
         }
+
+    private suspend fun fetchNewChartRandomlyWithRetry(
+        currentRetryCount: Int,
+        totalTurn: Int
+    ): Chart {
+        // RETRY_COUNT 만큼 시도했는데도 실패하면 IllegalStateException 발생.
+        // 거의 발생하지 않아도 안전망 역할
+        if (currentRetryCount > RETRY_COUNT) {
+            throw ChartGameException.HardToFetchTradeException
+        }
+
+        val dto = networkDataSource
+            .getChart(
+                ticker = chartRequestArgumentHelper.getRandomTicker(),
+                tickUnit = appPreferences.getTickUnit(),
+                from = chartRequestArgumentHelper.getFromDate(),
+                to = chartRequestArgumentHelper.getToDate()
+            )
+
+        // 서버에서 가져온 차트가 totalTurn 보다 작으면 다시 요청
+        if ((dto.ticks?.size ?: 0) < totalTurn) {
+            return fetchNewChartRandomlyWithRetry(
+                currentRetryCount = currentRetryCount + 1,
+                totalTurn = totalTurn
+            )
+        }
+
+        val chart = dto.asDomainModel(TickUnit.DAY)
+
+        val chartId = localDBDataSource.insertChart(chart.asEntity())
+        localDBDataSource.insertTicks(chart.ticks.map { it.asEntity(chartId = chartId) })
+        return chart.copy(id = chartId)
+    }
+
+    companion object {
+        private const val RETRY_COUNT = 3
+    }
 }

domain/src/main/java/com/yessorae/domain/common/Result.kt

@@ -3,7 +3,7 @@ package com.yessorae.domain.common
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEmpty
+import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onStart
 
 sealed class Result<out T> {
@@ -31,7 +31,7 @@ private fun <T> Flow<T>.mapToSuccessResult(): Flow<Result<T>> {
 }
 
 private fun Flow<Result<Unit>>.emitSuccessResultOnEmpty(): Flow<Result<Unit>> {
-    return this.onEmpty {
+    return this.onCompletion {
         emit(Result.Success(data = Unit))
     }
 }

domain/src/main/java/com/yessorae/domain/entity/ChartGame.kt

@@ -21,29 +21,50 @@ data class ChartGame(
     // 유저의 게임 강제 종료 여부
     val isQuit: Boolean
 ) {
-    val totalProfit: Money = currentBalance - startBalance
-
-    val rateOfProfit: Double = (totalProfit / startBalance).value * 100
-
-    val tradeCount: Int
-        get() = trades.size
-
-    val totalCommission: Money = Money(trades.sumOf { trade -> trade.commission.value })
-
     val visibleTicks: List<Tick> =
         chart.ticks
             .sortedBy { it.startTimestamp }
             .subList(0, chart.ticks.size - totalTurn + currentTurn - 1)
 
-    val ownedStockCount = trades.sumOf { trade -> trade.count }
+    val ownedStockCount = trades.sumOf { trade ->
+        if (trade.type.isBuy()) {
+            trade.count
+        } else {
+            -trade.count
+        }
+    }
+
+    private val ownedTotalStockPrice = trades.sumOf { trade ->
+        if (trade.type.isBuy()) {
+            trade.totalTradeMoney.value
+        } else {
+            -(trade.totalTradeMoney.value)
+        }
+    }
+
+    val ownedAverageStockPrice = if (ownedStockCount != 0) {
+        Money(ownedTotalStockPrice / ownedStockCount)
+    } else {
+        Money(0.0)
+    }
 
-    private val ownedTotalStockPrice = trades.sumOf { trade -> trade.totalTradeMoney.value }
+    private val currentClosePrice: Money = (visibleTicks.lastOrNull()?.closePrice ?: Money(0.0))
 
-    val ownedAverageStockPrice = Money(ownedTotalStockPrice / ownedStockCount)
+    val totalProfit: Money = if (ownedStockCount != 0) {
+        currentClosePrice - ownedAverageStockPrice
+    } else {
+        Money(0.0)
+    }
+
+    val rateOfProfit: Double = if (ownedStockCount != 0) {
+        (totalProfit / ownedAverageStockPrice).value * 100
+    } else {
+        0.0
+    }
 
     val currentStockPrice: Money = visibleTicks.lastOrNull()?.closePrice ?: Money(0.0)
 
-    val currentGameProgress: Float = currentTurn / totalTurn.toFloat() * 100f
+    val currentGameProgress: Float = currentTurn / totalTurn.toFloat()
 
     // 게임 모든 턴을 끝까지 완료한 경우 true
     val isGameComplete: Boolean = currentTurn == totalTurn
@@ -70,7 +91,7 @@ data class ChartGame(
     internal fun copyFrom(newTrade: Trade): ChartGame {
         return copy(
             trades = trades + newTrade,
-            currentBalance = currentBalance + newTrade.profit
+            currentBalance = currentBalance - newTrade.totalTradeMoney
         )
     }
 

domain/src/main/java/com/yessorae/domain/entity/trade/TradeType.kt

@@ -2,5 +2,8 @@ package com.yessorae.domain.entity.trade
 
 enum class TradeType {
     Buy,
-    Sell
+    Sell;
+
+    fun isBuy(): Boolean = this == Buy
+    fun isSell(): Boolean = this == Sell
 }

domain/src/main/java/com/yessorae/domain/exception/ChartGameException.kt

@@ -9,6 +9,9 @@ sealed class ChartGameException(override val message: String = "") : Exception(m
         override val message: String
     ) : ChartGameException(message = message)
 
+    // 설정한 제한 보다 많은 재시도를 했음에도 조건에 맞는 차트를 찾지 못했을 때 발생하는 예외
+    object HardToFetchTradeException : ChartGameException("")
+
     data class CanNotChangeTradeException(
         override val message: String
     ) : ChartGameException(message = message)

domain/src/main/java/com/yessorae/domain/repository/ChartRepository.kt

@@ -3,5 +3,5 @@ package com.yessorae.domain.repository
 import com.yessorae.domain.entity.Chart
 
 interface ChartRepository {
-    suspend fun fetchNewChartRandomly(): Chart
+    suspend fun fetchNewChartRandomly(totalTurn: Int): Chart
 }

domain/src/main/java/com/yessorae/domain/usecase/ChangeChartUseCase.kt

@@ -5,11 +5,13 @@ import com.yessorae.domain.common.delegateEmptyResultFlow
 import com.yessorae.domain.exception.ChartGameException
 import com.yessorae.domain.repository.ChartGameRepository
 import com.yessorae.domain.repository.ChartRepository
+import com.yessorae.domain.repository.UserRepository
 import javax.inject.Inject
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 
 class ChangeChartUseCase @Inject constructor(
+    private val userRepository: UserRepository,
     private val chartRepository: ChartRepository,
     private val chartGameRepository: ChartGameRepository
 ) {
@@ -25,7 +27,9 @@ class ChangeChartUseCase @Inject constructor(
 
             chartGameRepository.updateChartGame(
                 chartGame = oldChartGame.copyFrom(
-                    newChart = chartRepository.fetchNewChartRandomly()
+                    newChart = chartRepository.fetchNewChartRandomly(
+                        totalTurn = userRepository.fetchTotalTurnConfig()
+                    )
                 )
             )
         }.delegateEmptyResultFlow()

domain/src/main/java/com/yessorae/domain/usecase/SubscribeChartGameUseCase.kt

@@ -16,10 +16,12 @@ class SubscribeChartGameUseCase @Inject constructor(
 ) {
     suspend operator fun invoke(gameId: Long?): Flow<Result<ChartGame>> {
         if (gameId == null) {
+            val totalTurn = userRepository.fetchTotalTurnConfig()
+
             val newGameId = chartGameRepository.createNewChartGame(
                 chartGame = ChartGame.new(
-                    chart = chartRepository.fetchNewChartRandomly(),
-                    totalTurn = userRepository.fetchTotalTurnConfig(),
+                    chart = chartRepository.fetchNewChartRandomly(totalTurn = totalTurn),
+                    totalTurn = totalTurn,
                     startBalance = userRepository.fetchCurrentBalance()
                 )
             )

domain/src/main/java/com/yessorae/domain/usecase/UpdateNextTickUseCase.kt

@@ -13,14 +13,14 @@ class UpdateNextTickUseCase @Inject constructor(
 ) {
     operator fun invoke(gameId: Long): Flow<Result<Unit>> =
         flow<Nothing> {
-            val newChartGame = chartGameRepository.fetchChartGame(gameId = gameId).getNextTurn()
+            val oldChartGame = chartGameRepository.fetchChartGame(gameId = gameId)
 
-            if (newChartGame.isGameEnd) {
+            if (oldChartGame.isGameEnd) {
                 throw ChartGameException.CanNotUpdateNextTickException(
                     message = "can't update next tick because game has been end"
                 )
             }
 
-            chartGameRepository.updateChartGame(chartGame = newChartGame)
+            chartGameRepository.updateChartGame(chartGame = oldChartGame.getNextTurn())
         }.delegateEmptyResultFlow()
 }

presentation/src/main/java/com/yessorae/presentation/MainActivity.kt

@@ -10,6 +10,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
+import com.yessorae.presentation.ui.chartgame.ChartGameScreen
 import com.yessorae.presentation.ui.designsystem.theme.ChartTrainerTheme
 import dagger.hilt.android.AndroidEntryPoint
 
@@ -24,7 +25,7 @@ class MainActivity : ComponentActivity() {
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background
                 ) {
-                    Greeting("Android")
+                    ChartGameScreen()
                 }
             }
         }

presentation/src/main/java/com/yessorae/presentation/ui/chartgame/ChartGameScreen.kt

@@ -21,46 +21,24 @@ import com.yessorae.presentation.ui.chartgame.component.ChartGameTopAppBarUi
 import com.yessorae.presentation.ui.chartgame.component.order.TradeOrderUi
 import com.yessorae.presentation.ui.chartgame.model.ChartGameEvent
 import com.yessorae.presentation.ui.chartgame.model.ChartGameScreenUserAction
+import com.yessorae.presentation.ui.designsystem.component.ChartTrainerLoadingProgressBar
 import com.yessorae.presentation.ui.designsystem.util.showToast
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.collectLatest
 
 @Composable
 fun ChartGameScreen(viewModel: ChartGameViewModel = viewModel()) {
-    val state by viewModel.screenState.collectAsState()
-    val context = LocalContext.current
-
-    LaunchedEffect(key1 = Unit) {
-        viewModel.screenEvent.collectLatest { event ->
-            when (event) {
-                is ChartGameEvent.InputBuyingStockCount -> {
-                    context.showToast(context.getString(R.string.chart_game_toast_trade_buy))
-                }
-
-                is ChartGameEvent.InputSellingStockCount -> {
-                    context.showToast(context.getString(R.string.chart_game_toast_trade_sell))
-                }
-
-                is ChartGameEvent.TradeFail -> {
-                    context.showToast(context.getString(R.string.chart_game_toast_trade_fail))
-                }
-
-                is ChartGameEvent.MoveToBack -> {
-                    // TODO::LATER #23-navigation 셋업과 함께 추가될 내용
-                }
+    ChartGameEventHandler(screenEvent = viewModel.screenEvent)
 
-                is ChartGameEvent.MoveToTradeHistory -> {
-                    // TODO::LATER #6-트레이드 내역 확인 기능과 #23-navigation 셋업과 함께 추가될 내용
-                }
-            }
-        }
-    }
+    val state by viewModel.screenState.collectAsState()
 
     Scaffold(
         topBar = {
             ChartGameTopAppBarUi(
-                isStart = state.isStart,
+                isBeforeStart = state.isBeforeStart,
                 totalProfit = state.totalProfit,
                 totalRateOfProfit = state.rateOfProfit,
+                enableChangeChartButton = state.enableChangeChartButton,
                 onClickNewChartButton = {
                     state.onUserAction(ChartGameScreenUserAction.ClickNewChartButton)
                 },
@@ -109,14 +87,58 @@ fun ChartGameScreen(viewModel: ChartGameViewModel = viewModel()) {
                 )
             }
 
-            TradeOrderUi(
-                modifier = Modifier.fillMaxWidth(),
-                tradeOrderUi = state.tradeOrderUi
+            TradeOrderUi(tradeOrderUi = state.tradeOrderUi)
+
+            ChartTrainerLoadingProgressBar(
+                modifier = Modifier.fillMaxSize(),
+                show = state.showLoading
             )
         }
     }
 }
 
+@Composable
+private fun ChartGameEventHandler(screenEvent: SharedFlow<ChartGameEvent>) {
+    val context = LocalContext.current
+    LaunchedEffect(key1 = Unit) {
+        screenEvent.collectLatest { event ->
+            when (event) {
+                is ChartGameEvent.InputBuyingStockCount -> {
+                    context.showToast(context.getString(R.string.chart_game_toast_trade_buy))
+                }
+
+                is ChartGameEvent.InputSellingStockCount -> {
+                    context.showToast(context.getString(R.string.chart_game_toast_trade_sell))
+                }
+
+                is ChartGameEvent.TradeFail -> {
+                    context.showToast(context.getString(R.string.chart_game_toast_trade_fail))
+                }
+
+                is ChartGameEvent.HardToFetchTrade -> {
+                    // TODO::LATER #5-유저(익명) 정보 확인/수정 기능이 추가되면 Screen 뒤로가기 추가
+                    context.showToast(
+                        context.getString(R.string.chart_game_toast_hard_to_fetch_trade)
+                    )
+                }
+
+                is ChartGameEvent.GameHasEnded -> {
+                    // TODO::LATER #5-유저(익명) 정보 확인/수정 기능이 추가되면 Screen 뒤로가기로 변경
+                    context.showToast(context.getString(R.string.chart_game_toast_game_has_ended))
+                }
+
+                is ChartGameEvent.MoveToBack -> {
+                    // TODO::LATER #23-navigation 셋업과 함께 추가될 내용
+                }
+
+                is ChartGameEvent.MoveToTradeHistory -> {
+                    // TODO::LATER #6-트레이드 내역 확인 기능과 #23-navigation 셋업과 함께 추가될 내용
+                }
+            }
+        }
+    }
+}
+
 @Preview
 @Composable
 fun ChartGameScreenPreview() {