Refactor: HomeViewModel 단순화

Author: wjdrjs00

presentation/src/main/java/com/threegap/bitnagil/presentation/screen/home/HomeViewModel.kt

@@ -3,28 +3,22 @@ package com.threegap.bitnagil.presentation.screen.home
 import android.util.Log
 import androidx.lifecycle.ViewModel
 import com.threegap.bitnagil.domain.emotion.usecase.ObserveDailyEmotionUseCase
-import com.threegap.bitnagil.domain.onboarding.usecase.GetOnBoardingRecommendRoutineEventFlowUseCase
-import com.threegap.bitnagil.domain.routine.model.RoutineCompletionInfo
-import com.threegap.bitnagil.domain.routine.model.RoutineCompletionInfos
-import com.threegap.bitnagil.domain.routine.usecase.FetchWeeklyRoutinesUseCase
-import com.threegap.bitnagil.domain.routine.usecase.GetWriteRoutineEventFlowUseCase
-import com.threegap.bitnagil.domain.routine.usecase.RoutineCompletionUseCase
-import com.threegap.bitnagil.domain.routine.usecase.ToggleRoutineUseCase
+import com.threegap.bitnagil.domain.routine.model.ToggleStrategy
+import com.threegap.bitnagil.domain.routine.usecase.ApplyRoutineToggleUseCase
+import com.threegap.bitnagil.domain.routine.usecase.ObserveWeeklyRoutinesUseCase
 import com.threegap.bitnagil.domain.user.usecase.ObserveUserProfileUseCase
 import com.threegap.bitnagil.presentation.screen.home.contract.HomeSideEffect
 import com.threegap.bitnagil.presentation.screen.home.contract.HomeState
-import com.threegap.bitnagil.presentation.screen.home.model.ToggleStrategy
 import com.threegap.bitnagil.presentation.screen.home.model.toUiModel
 import com.threegap.bitnagil.presentation.screen.home.util.getCurrentWeekDays
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.launch
 import org.orbitmvi.orbit.Container
 import org.orbitmvi.orbit.ContainerHost
 import org.orbitmvi.orbit.viewmodel.container
@@ -33,145 +27,110 @@ import javax.inject.Inject
 
 @HiltViewModel
 class HomeViewModel @Inject constructor(
-    private val fetchWeeklyRoutinesUseCase: FetchWeeklyRoutinesUseCase,
+    private val observeWeeklyRoutinesUseCase: ObserveWeeklyRoutinesUseCase,
     private val observeUserProfileUseCase: ObserveUserProfileUseCase,
     private val observeDailyEmotionUseCase: ObserveDailyEmotionUseCase,
-    private val routineCompletionUseCase: RoutineCompletionUseCase,
-    private val getWriteRoutineEventFlowUseCase: GetWriteRoutineEventFlowUseCase,
-    private val getOnBoardingRecommendRoutineEventFlowUseCase: GetOnBoardingRecommendRoutineEventFlowUseCase,
-    private val toggleRoutineUseCase: ToggleRoutineUseCase,
+    private val applyRoutineToggleUseCase: ApplyRoutineToggleUseCase,
 ) : ContainerHost<HomeState, HomeSideEffect>, ViewModel() {
 
     override val container: Container<HomeState, HomeSideEffect> =
         container(
             initialState = HomeState.INIT,
             buildSettings = { repeatOnSubscribedStopTimeout = 5_000L },
+            onCreate = {
+                observeDailyEmotion()
+                observeUserProfile()
+                observeWeeklyRoutines()
+            },
         )
 
-    private val pendingChangesByDate = mutableMapOf<String, MutableMap<String, RoutineCompletionInfo>>()
-    private val routineSyncTrigger = MutableSharedFlow<String>(extraBufferCapacity = 64)
-
-    init {
-        initialize()
-        observeDailyEmotion()
-    }
-
     private fun observeDailyEmotion() {
         intent {
             repeatOnSubscription {
                 observeDailyEmotionUseCase().collect { result ->
                     result.fold(
-                        onSuccess = { dailyEmotion ->
-                            reduce { state.copy(dailyEmotion = dailyEmotion.toUiModel()) }
-                        },
+                        onSuccess = { reduce { state.copy(dailyEmotion = it.toUiModel()) } },
                         onFailure = {},
                     )
                 }
             }
         }
     }
 
-    fun selectDate(data: LocalDate) {
+    private fun observeUserProfile() {
         intent {
-            val previousDateKey = state.selectedDate.toString()
-            if (pendingChangesByDate.containsKey(previousDateKey)) {
-                syncRoutineChangesForDate(previousDateKey)
+            repeatOnSubscription {
+                observeUserProfileUseCase().collect { result ->
+                    result.fold(
+                        onSuccess = { reduce { state.copy(userNickname = it.nickname) } },
+                        onFailure = {},
+                    )
+                }
             }
-
-            reduce { state.copy(selectedDate = data) }
         }
     }
 
-    fun getNextWeek() {
+    @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
+    private fun observeWeeklyRoutines() {
         intent {
-            val currentDateKey = state.selectedDate.toString()
-            if (pendingChangesByDate.containsKey(currentDateKey)) {
-                syncRoutineChangesForDate(currentDateKey)
+            repeatOnSubscription {
+                container.stateFlow
+                    .map { it.currentWeeks }
+                    .distinctUntilChanged()
+                    .debounce(300L)
+                    .flatMapLatest { weeks ->
+                        observeWeeklyRoutinesUseCase(weeks.first().toString(), weeks.last().toString())
+                    }
+                    .catch { e -> Log.e("HomeViewModel", "루틴 가져오기 실패: ${e.message}") }
+                    .collect { reduce { state.copy(routineSchedule = it.toUiModel()) } }
             }
+        }
+    }
 
+    fun selectDate(date: LocalDate) {
+        intent {
+            reduce { state.copy(selectedDate = date) }
+        }
+    }
+
+    fun getNextWeek() {
+        intent {
             val newWeek = state.selectedDate.plusWeeks(1).getCurrentWeekDays()
             reduce { state.copy(currentWeeks = newWeek, selectedDate = newWeek.first()) }
         }
     }
 
     fun getPreviousWeek() {
         intent {
-            val currentDateKey = state.selectedDate.toString()
-            if (pendingChangesByDate.containsKey(currentDateKey)) {
-                syncRoutineChangesForDate(currentDateKey)
-            }
-
             val newWeek = state.selectedDate.minusWeeks(1).getCurrentWeekDays()
             reduce { state.copy(currentWeeks = newWeek, selectedDate = newWeek.first()) }
         }
     }
 
     fun toggleRoutine(routineId: String) {
         intent {
-            updateRoutineState(routineId, ToggleStrategy.Main)
+            applyToggle(routineId, ToggleStrategy.Main)
         }
     }
 
     fun toggleSubRoutine(routineId: String, subRoutineIndex: Int) {
         intent {
-            updateRoutineState(routineId, ToggleStrategy.Sub(subRoutineIndex))
+            applyToggle(routineId, ToggleStrategy.Sub(subRoutineIndex))
         }
     }
 
-    private suspend fun updateRoutineState(routineId: String, strategy: ToggleStrategy) {
+    private suspend fun applyToggle(routineId: String, strategy: ToggleStrategy) {
         subIntent {
             val dateKey = state.selectedDate.toString()
-            val dailySchedule = state.routineSchedule.dailyRoutines[dateKey] ?: return@subIntent
-            val routine = dailySchedule.routines.find { it.id == routineId } ?: return@subIntent
-
-            val toggledState = when (strategy) {
-                is ToggleStrategy.Main -> {
-                    toggleRoutineUseCase.toggleMainRoutine(
-                        isCompleted = routine.isCompleted,
-                        subRoutineStates = routine.subRoutineCompletionStates,
-                    )
-                }
-
-                is ToggleStrategy.Sub -> {
-                    toggleRoutineUseCase.toggleSubRoutine(
-                        index = strategy.index,
-                        subRoutineStates = routine.subRoutineCompletionStates,
-                    )
-                }
-            } ?: return@subIntent
-
-            val updatedRoutines = dailySchedule.routines.map { routine ->
-                if (routine.id == routineId) {
-                    routine.copy(
-                        isCompleted = toggledState.isCompleted,
-                        subRoutineCompletionStates = toggledState.subRoutinesIsCompleted,
-                    )
-                } else {
-                    routine
-                }
-            }
+            val routine = state.selectedDateRoutines.find { it.id == routineId } ?: return@subIntent
 
-            val updatedDailySchedule = dailySchedule.copy(
-                routines = updatedRoutines,
-                isAllCompleted = updatedRoutines.all { it.isCompleted },
-            )
-
-            val newSchedule = state.routineSchedule.copy(
-                dailyRoutines = state.routineSchedule.dailyRoutines + (dateKey to updatedDailySchedule),
-            )
-
-            reduce { state.copy(routineSchedule = newSchedule) }
-
-            val change = RoutineCompletionInfo(
+            applyRoutineToggleUseCase(
+                dateKey = dateKey,
                 routineId = routineId,
-                routineCompleteYn = toggledState.isCompleted,
-                subRoutineCompleteYn = toggledState.subRoutinesIsCompleted,
+                isCompleted = routine.isCompleted,
+                subRoutineCompletionStates = routine.subRoutineCompletionStates,
+                strategy = strategy,
             )
-
-            val dateChanges = pendingChangesByDate.getOrPut(dateKey) { mutableMapOf() }
-            dateChanges[routineId] = change
-
-            routineSyncTrigger.emit(dateKey)
         }
     }
 
@@ -199,111 +158,4 @@ class HomeViewModel @Inject constructor(
             postSideEffect(HomeSideEffect.NavigateToRoutineList(selectedDate))
         }
     }
-
-    private fun initialize() {
-        intent {
-            coroutineScope {
-                launch { observeUserProfile() }
-                launch { fetchWeeklyRoutines(state.currentWeeks) }
-                launch { observeWriteRoutineEvent() }
-                launch { observeRecommendRoutineEvent() }
-                launch { observeWeekChanges() }
-                launch { observeRoutineUpdates() }
-            }
-        }
-    }
-
-    private suspend fun observeWriteRoutineEvent() {
-        subIntent {
-            getWriteRoutineEventFlowUseCase().collect {
-                fetchWeeklyRoutines(state.currentWeeks)
-            }
-        }
-    }
-
-    private suspend fun observeRecommendRoutineEvent() {
-        subIntent {
-            getOnBoardingRecommendRoutineEventFlowUseCase().collect {
-                fetchWeeklyRoutines(state.currentWeeks)
-            }
-        }
-    }
-
-    @OptIn(FlowPreview::class)
-    private suspend fun observeWeekChanges() {
-        subIntent {
-            container.stateFlow
-                .map { it.currentWeeks }
-                .distinctUntilChanged()
-                .drop(1)
-                .debounce(500L)
-                .collect { newWeeks ->
-                    fetchWeeklyRoutines(newWeeks)
-                }
-        }
-    }
-
-    @OptIn(FlowPreview::class)
-    private suspend fun observeRoutineUpdates() {
-        subIntent {
-            routineSyncTrigger
-                .debounce(500L)
-                .collect { dateKey ->
-                    syncRoutineChangesForDate(dateKey)
-                }
-        }
-    }
-
-    private fun observeUserProfile() {
-        intent {
-            repeatOnSubscription {
-                reduce { state.copy(loadingCount = state.loadingCount + 1) }
-                observeUserProfileUseCase().collect { result ->
-                    result.fold(
-                        onSuccess = {
-                            reduce { state.copy(userNickname = it.nickname, loadingCount = state.loadingCount - 1) }
-                        },
-                        onFailure = {
-                            Log.e("HomeViewModel", "유저 정보 가져오기 실패: ${it.message}")
-                            reduce { state.copy(loadingCount = state.loadingCount - 1) }
-                        },
-                    )
-                }
-            }
-        }
-    }
-
-    private suspend fun fetchWeeklyRoutines(currentWeeks: List<LocalDate>) {
-        subIntent {
-            reduce { state.copy(loadingCount = state.loadingCount + 1) }
-            val startDate = currentWeeks.first().toString()
-            val endDate = currentWeeks.last().toString()
-            fetchWeeklyRoutinesUseCase(startDate, endDate).fold(
-                onSuccess = {
-                    reduce { state.copy(routineSchedule = it.toUiModel(), loadingCount = state.loadingCount - 1) }
-                },
-                onFailure = {
-                    Log.e("HomeViewModel", "루틴 가져오기 실패: ${it.message}")
-                    reduce { state.copy(loadingCount = state.loadingCount - 1) }
-                },
-            )
-        }
-    }
-
-    private fun syncRoutineChangesForDate(dateKey: String) {
-        intent {
-            val dateChanges = pendingChangesByDate.remove(dateKey)
-            if (dateChanges.isNullOrEmpty()) return@intent
-
-            val changesToSync = dateChanges.values.toList()
-            val syncRequest = RoutineCompletionInfos(routineCompletionInfos = changesToSync)
-
-            routineCompletionUseCase(syncRequest).fold(
-                onSuccess = {},
-                onFailure = { error ->
-                    fetchWeeklyRoutines(state.currentWeeks)
-                },
-            )
-        }
-    }
 }

presentation/src/main/java/com/threegap/bitnagil/presentation/screen/home/contract/HomeState.kt

@@ -7,22 +7,17 @@ import com.threegap.bitnagil.presentation.screen.home.util.getCurrentWeekDays
 import java.time.LocalDate
 
 data class HomeState(
-    val loadingCount: Int,
     val userNickname: String,
     val dailyEmotion: DailyEmotionUiModel,
     val selectedDate: LocalDate,
     val currentWeeks: List<LocalDate>,
     val routineSchedule: RoutineScheduleUiModel,
 ) {
-    val isLoading: Boolean
-        get() = loadingCount > 0
-
     val selectedDateRoutines: List<RoutineUiModel>
         get() = routineSchedule.dailyRoutines[selectedDate.toString()]?.routines ?: emptyList()
 
     companion object {
         val INIT = HomeState(
-            loadingCount = 0,
             userNickname = "",
             dailyEmotion = DailyEmotionUiModel.INIT,
             selectedDate = LocalDate.now(),