Refactor HighlightsViewModel

UIState no longer exposes the raw backend list. Filtered highlights are now precomputed in the ViewModel, so the UI can observe state directly without recalculating on every recomposition.

Author: amjiao

app/src/main/java/com/cornellappdev/score/viewmodel/HighlightsViewModel.kt

@@ -6,54 +6,47 @@ import com.cornellappdev.score.model.HighlightData
 import com.cornellappdev.score.model.HighlightsRepository
 import com.cornellappdev.score.model.Sport
 import com.cornellappdev.score.model.SportSelection
-import com.cornellappdev.score.model.map
-import com.cornellappdev.score.util.parseIsoDateToLocalDateOrNull
 import dagger.hilt.android.lifecycle.HiltViewModel
 import java.time.LocalDate
 import javax.inject.Inject
 
 data class HighlightsUiState(
     val sportSelect: SportSelection,
     val loadedState: ApiResponse<List<HighlightData>>,
-    val sportSelectionList: List<SportSelection>
-) {
-    //TODO: refactor filters to use flows - not best practice to expose original games list to the view
-    val filteredHighlights: List<HighlightData>
-        get() = when (loadedState) {
-            is ApiResponse.Success -> loadedState.data.filter { highlight ->
-                (sportSelect is SportSelection.All ||
-                        (sportSelect is SportSelection.SportSelect && highlight.sport == sportSelect.sport))
-            }
+    val sportSelectionList: List<SportSelection>,
+    val filteredHighlights: List<HighlightData>,
+    val todayHighlights: List<HighlightData>,
+    val pastThreeDaysHighlights: List<HighlightData>
+)
 
-            ApiResponse.Loading -> emptyList()
-            ApiResponse.Error -> emptyList()
-        }.sortedBy { it.date }
+private fun buildDerivedLists(
+    highlights: List<HighlightData>,
+    sportSelect: SportSelection
+): Triple<List<HighlightData>, List<HighlightData>, List<HighlightData>> {
 
-    val todayHighlights: List<HighlightData>
-        get() = when (loadedState) {
-            is ApiResponse.Success -> loadedState.data
+    val today = LocalDate.now()
+    val threeDaysAgo = today.minusDays(3)
 
-            ApiResponse.Loading -> emptyList()
-            ApiResponse.Error -> emptyList()
-        }.filter { highlight ->
-                parseIsoDateToLocalDateOrNull(highlight.date) == LocalDate.now()
-        }.sortedBy { highlight ->
-            parseIsoDateToLocalDateOrNull(highlight.date)
+    // Keep only highlights with a date and matching the sport filter
+    val validHighlights = highlights
+        .filter { it.date != null }
+        .filter { highlight ->
+            when (sportSelect) {
+                is SportSelection.All -> true
+                is SportSelection.SportSelect ->
+                    highlight.sport == sportSelect.sport
+            }
         }
 
-    val pastThreeDaysHighlights: List<HighlightData>
-        get() = when (loadedState) {
-            is ApiResponse.Success -> loadedState.data
-
-            ApiResponse.Loading -> emptyList()
-            ApiResponse.Error -> emptyList()
-        }.filter { highlight ->
-            val date = parseIsoDateToLocalDateOrNull(highlight.date)
-            date != null && !date.isBefore(LocalDate.now().minusDays(3))
-        }.sortedBy { highlight ->
-            parseIsoDateToLocalDateOrNull(highlight.date)
-        }
+    val filtered = validHighlights.sortedBy { it.date }
+
+    val todayHighlights = validHighlights.filter { it.date == today }
+
+    val pastThreeDaysHighlights = validHighlights
+        .filter { it.date!! >= threeDaysAgo } // null dates filtered out in line 32
+        .sortedBy { it.date }
 
+    return Triple(filtered, todayHighlights, pastThreeDaysHighlights)
 }
 
 @HiltViewModel
@@ -63,24 +56,48 @@ class HighlightsViewModel @Inject constructor(
     HighlightsUiState(
         sportSelect = SportSelection.All,
         loadedState = ApiResponse.Loading,
-        sportSelectionList = Sport.getSportSelectionList(GenderDivision.ALL)
+        sportSelectionList = Sport.getSportSelectionList(GenderDivision.ALL),
+        filteredHighlights = emptyList(),
+        todayHighlights = emptyList(),
+        pastThreeDaysHighlights = emptyList()
     )
 ) {
     init {
         highlightsRepository.fetchHighlights()
         asyncCollect(highlightsRepository.highlightsFlow) { response ->
             applyMutation {
-                copy(
-                    loadedState = response.map { highlights ->
-                        highlights
-                            .sortedByDescending { highlight ->
-                                when (highlight) {
-                                    is HighlightData.Video -> highlight.data.date
-                                    is HighlightData.Article -> highlight.data.date
-                                }
-                            }
+                when (response) {
+                    is ApiResponse.Success -> {
+                        val sorted =
+                            response.data.sortedByDescending { it.date }
+
+                        val (filtered, today, pastThreeDays) =
+                            buildDerivedLists(sorted, sportSelect)
+
+                        copy(
+                            loadedState = ApiResponse.Success(sorted),
+                            filteredHighlights = filtered,
+                            todayHighlights = today,
+                            pastThreeDaysHighlights = pastThreeDays
+                        )
                     }
-                )
+
+                    ApiResponse.Loading ->
+                        copy(
+                            loadedState = ApiResponse.Loading,
+                            filteredHighlights = emptyList(),
+                            todayHighlights = emptyList(),
+                            pastThreeDaysHighlights = emptyList()
+                        )
+
+                    ApiResponse.Error ->
+                        copy(
+                            loadedState = ApiResponse.Error,
+                            filteredHighlights = emptyList(),
+                            todayHighlights = emptyList(),
+                            pastThreeDaysHighlights = emptyList()
+                        )
+                }
             }
         }
     }
@@ -89,14 +106,24 @@ class HighlightsViewModel @Inject constructor(
         applyMutation {
             copy(loadedState = ApiResponse.Loading)
         }
-
         highlightsRepository.fetchHighlights()
     }
 
     fun onSportSelected(sport: SportSelection) {
         applyMutation {
+            val highlights = when (val state = loadedState) {
+                is ApiResponse.Success -> state.data
+                else -> emptyList()
+            }
+
+            val (filtered, today, pastThreeDays) =
+                buildDerivedLists(highlights, sport)
+
             copy(
-                sportSelect = sport
+                sportSelect = sport,
+                filteredHighlights = filtered,
+                todayHighlights = today,
+                pastThreeDaysHighlights = pastThreeDays
             )
         }
     }