feat: week select

app/src/main/java/agzam/vyatsu/data/local/PreferencesDao.kt

@@ -15,4 +15,16 @@ interface PreferencesDao {
 
     @Query("DELETE FROM preferences WHERE key = 'selectedGroupId'")
     suspend fun clearSelectedGroup()
+
+    @Query("SELECT value FROM preferences WHERE key = 'selectedWeekStart'")
+    suspend fun selectedWeekStart(): String?
+
+    @Query("INSERT OR REPLACE INTO preferences(key, value) VALUES('selectedWeekStart', :weekStart)")
+    suspend fun setSelectedWeekStart(weekStart: String)
+
+    @Query("SELECT value FROM preferences WHERE key = 'selectedDayDate'")
+    suspend fun selectedDayDate(): String?
+
+    @Query("INSERT OR REPLACE INTO preferences(key, value) VALUES('selectedDayDate', :date)")
+    suspend fun setSelectedDayDate(date: String)
 }

app/src/main/java/agzam/vyatsu/data/repository/PreferencesRepositoryImpl.kt

@@ -9,4 +9,8 @@ class PreferencesRepositoryImpl(
     override suspend fun selectedGroupId(): String? = dao.selectedGroupId()
     override suspend fun setSelectedGroup(groupId: String) = dao.setSelectedGroup(groupId)
     override suspend fun clearSelectedGroup() = dao.clearSelectedGroup()
+    override suspend fun selectedWeekStart(): String? = dao.selectedWeekStart()
+    override suspend fun setSelectedWeekStart(weekStart: String) = dao.setSelectedWeekStart(weekStart)
+    override suspend fun selectedDayDate(): String? = dao.selectedDayDate()
+    override suspend fun setSelectedDayDate(date: String) = dao.setSelectedDayDate(date)
 }

app/src/main/java/agzam/vyatsu/domain/model/Schedule.kt

@@ -15,4 +15,7 @@ data class Schedule(
 ) {
     fun periodOf(date: LocalDate): SchedulePeriod? =
         periods.firstOrNull { !date.isBefore(it.weekStart) && !date.isAfter(it.weekEnd) }
+
+    fun daysOf(period: SchedulePeriod): List<Day> =
+        days.filter { !it.date.isBefore(period.weekStart) && !it.date.isAfter(period.weekEnd) }
 }

app/src/main/java/agzam/vyatsu/domain/repository/PreferencesRepository.kt

@@ -4,4 +4,8 @@ interface PreferencesRepository {
     suspend fun selectedGroupId(): String?
     suspend fun setSelectedGroup(groupId: String)
     suspend fun clearSelectedGroup()
+    suspend fun selectedWeekStart(): String?
+    suspend fun setSelectedWeekStart(weekStart: String)
+    suspend fun selectedDayDate(): String?
+    suspend fun setSelectedDayDate(date: String)
 }

app/src/main/java/agzam/vyatsu/ui/schedule/ScheduleScreen.kt

@@ -1,6 +1,7 @@
 package agzam.vyatsu.ui.schedule
 
 import agzam.vyatsu.domain.model.Day
+import agzam.vyatsu.domain.model.SchedulePeriod
 import agzam.vyatsu.domain.model.TimeSlot
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
@@ -13,6 +14,7 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.systemBars
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
@@ -35,6 +37,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import java.time.DayOfWeek
+import java.time.LocalDate
 import java.time.format.DateTimeFormatter
 
 @OptIn(ExperimentalMaterial3Api::class)
@@ -55,7 +58,7 @@ fun ScheduleScreen(viewModel: ScheduleViewModel, onSwitchGroup: () -> Unit) {
             },
             windowInsets = WindowInsets.systemBars.only(androidx.compose.foundation.layout.WindowInsetsSides.Top)
         )
-        Column(Modifier.fillMaxSize().padding(horizontal =  16.dp, vertical = 0.dp)) {
+        Column(Modifier.fillMaxSize().padding(horizontal = 16.dp, vertical = 0.dp)) {
             when {
                 state.isSyncing && state.schedule == null -> {
                     Row(
@@ -83,12 +86,17 @@ fun ScheduleScreen(viewModel: ScheduleViewModel, onSwitchGroup: () -> Unit) {
 
                 else -> {
                     val schedule = state.schedule!!
-                    val day = schedule.days.getOrNull(state.selectedIndex)
+                    val weekDays = state.weekStart
+                        ?.let { ws -> schedule.periods.firstOrNull { it.weekStart == ws } }
+                        ?.let { schedule.daysOf(it) }
+                        .orEmpty()
+                    val day = schedule.days.firstOrNull { it.date == state.dayDate }
+
                     if (day == null) {
                         Text("Занятий нет", style = MaterialTheme.typography.bodyLarge)
                     } else {
-                        val isToday = state.selectedIndex == state.todayIndex
+                        val isTodayDay = day.date == state.todayDate
-                        val dayLabel = if (isToday) "Сегодня " else ""
+                        val dayLabel = if (isTodayDay) "Сегодня " else ""
 
                         Text(
                             "$dayLabel ${dayName(day.date.dayOfWeek)} · ${day.date.format(FULL_DATE)}",
@@ -99,7 +107,7 @@ fun ScheduleScreen(viewModel: ScheduleViewModel, onSwitchGroup: () -> Unit) {
                             horizontalArrangement = Arrangement.spacedBy(8.dp)
                         ) {
                             TextButton(onClick = { viewModel.clearSelectedPeriod() }) {
-                                Text("Очистить неделю")
+                                Text("Очистить эту неделю")
                             }
                             TextButton(onClick = { viewModel.clearAll() }) {
                                 Text("Очистить всё")
@@ -107,10 +115,19 @@ fun ScheduleScreen(viewModel: ScheduleViewModel, onSwitchGroup: () -> Unit) {
                         }
                         HorizontalDivider(Modifier.padding(vertical = 8.dp))
 
+                        WeekChips(
+                            periods = schedule.periods,
+                            selectedWeekStart = state.weekStart,
+                            todayWeekStart = state.todayDate?.let { schedule.periodOf(it)?.weekStart },
+                            onSelect = viewModel::selectWeek
+                        )
+
+                        HorizontalDivider(Modifier.padding(vertical = 8.dp))
+
                         DayChips(
-                            days = schedule.days,
+                            days = weekDays,
-                            selectedIndex = state.selectedIndex,
+                            selectedDate = state.dayDate,
-                            todayIndex = state.todayIndex,
+                            todayDate = state.todayDate,
                             onSelect = viewModel::selectDay
                         )
 
@@ -136,19 +153,56 @@ fun ScheduleScreen(viewModel: ScheduleViewModel, onSwitchGroup: () -> Unit) {
 }
 
 @Composable
-private fun DayChips(
+private fun WeekChips(
-    days: List<Day>,
+    periods: List<SchedulePeriod>,
-    selectedIndex: Int,
+    selectedWeekStart: LocalDate?,
-    todayIndex: Int,
+    todayWeekStart: LocalDate?,
-    onSelect: (Int) -> Unit
+    onSelect: (LocalDate) -> Unit
 ) {
     LazyRow(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-        itemsIndexed(days) { index, day ->
+        items(periods, key = { it.weekStart.toEpochDay() }) { period ->
-            val selected = selectedIndex == index
+            val selected = selectedWeekStart == period.weekStart
-            val isTodayChip = todayIndex == index
+            val isTodayWeek = todayWeekStart == period.weekStart
             FilterChip(
                 selected = selected,
-                onClick = { onSelect(index) },
+                onClick = { onSelect(period.weekStart) },
+                label = {
+                    Text(
+                        weekLabel(period),
+                        style = MaterialTheme.typography.labelLarge
+                    )
+                },
+                modifier = Modifier.padding(vertical = 2.dp),
+                border = if (isTodayWeek && !selected) {
+                    FilterChipDefaults.filterChipBorder(
+                        borderColor = MaterialTheme.colorScheme.primary,
+                        borderWidth = 1.dp,
+                        enabled = true,
+                        selected = false
+                    )
+                } else {
+                    FilterChipDefaults.filterChipBorder(enabled = true, selected = selected)
+                },
+                shape = RoundedCornerShape(8.dp)
+            )
+        }
+    }
+}
+
+@Composable
+private fun DayChips(
+    days: List<Day>,
+    selectedDate: LocalDate?,
+    todayDate: LocalDate?,
+    onSelect: (LocalDate) -> Unit
+) {
+    LazyRow(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+        items(days, key = { it.date.toEpochDay() }) { day ->
+            val selected = selectedDate == day.date
+            val isTodayChip = todayDate == day.date
+            FilterChip(
+                selected = selected,
+                onClick = { onSelect(day.date) },
                 label = {
                     Column(horizontalAlignment = Alignment.CenterHorizontally) {
                         Text(
@@ -183,6 +237,11 @@ private fun DayChips(
     }
 }
 
+private fun weekLabel(period: SchedulePeriod): String {
+    val first = period.weekStart
+    return "с ${first.format(CHIP_DATE)}"
+}
+
 @Composable
 private fun LessonSlot(slotIndex: Int, slot: TimeSlot) {
     Column(Modifier.fillMaxWidth()) {
@@ -226,4 +285,4 @@ private fun dayName(dayOfWeek: DayOfWeek): String = when (dayOfWeek) {
 
 private val FULL_DATE: DateTimeFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy")
 private val CHIP_DATE: DateTimeFormatter = DateTimeFormatter.ofPattern("dd.MM")
-private val TIME: DateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm")
+private val TIME: DateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm")

app/src/main/java/agzam/vyatsu/ui/schedule/ScheduleViewModel.kt

@@ -1,7 +1,6 @@
 package agzam.vyatsu.ui.schedule
 
 import agzam.vyatsu.domain.ScheduleDates
-import agzam.vyatsu.domain.model.Day
 import agzam.vyatsu.domain.model.Schedule
 import agzam.vyatsu.domain.repository.PreferencesRepository
 import agzam.vyatsu.domain.repository.ScheduleRepository
@@ -11,6 +10,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import java.time.LocalDate
 
 class ScheduleViewModel(
     private val scheduleRepository: ScheduleRepository,
@@ -37,21 +37,22 @@ class ScheduleViewModel(
         currentGroupId = groupId
         viewModelScope.launch {
             preferencesRepository.setSelectedGroup(groupId)
-            _uiState.value = _uiState.value.copy(noGroup = false)
+
+            val savedWeekStart = runCatching {
+                preferencesRepository.selectedWeekStart()?.let(LocalDate::parse)
+            }.getOrNull()
+            val savedDayDate = runCatching {
+                preferencesRepository.selectedDayDate()?.let(LocalDate::parse)
+            }.getOrNull()
+            _uiState.value = _uiState.value.copy(
+                noGroup = false,
+                weekStart = savedWeekStart,
+                dayDate = savedDayDate
+            )
 
             launch {
                 scheduleRepository.observeSchedule(groupId).collect { schedule ->
-                    currentGroupId?.let {
+                    currentGroupId?.let { applySchedule(schedule) }
-                        val days = schedule?.days.orEmpty()
-                        val today = todayIndex(days)
-                        val current = _uiState.value
-                        val selected = current.selectedIndex.takeIf { i -> i in days.indices } ?: today
-                        _uiState.value = current.copy(
-                            schedule = schedule,
-                            todayIndex = today,
-                            selectedIndex = selected
-                        )
-                    }
                 }
             }
 
@@ -61,6 +62,68 @@ class ScheduleViewModel(
         }
     }
 
+    private suspend fun applySchedule(schedule: Schedule?) {
+        val current = _uiState.value
+        if (schedule == null || schedule.periods.isEmpty()) {
+            _uiState.value = current.copy(schedule = schedule, todayDate = null)
+            return
+        }
+        val today = ScheduleDates.moscowToday()
+        val todayDate = if (schedule.periodOf(today) != null) today else null
+
+        val weekStart = when {
+            schedule.periods.any { it.weekStart == current.weekStart } -> current.weekStart!!
+            todayDate != null -> schedule.periodOf(todayDate)!!.weekStart
+            else -> schedule.periods.first().weekStart
+        }
+        val period = schedule.periods.first { it.weekStart == weekStart }
+        val weekDays = schedule.daysOf(period)
+
+        val dayDate = when {
+            weekDays.any { it.date == current.dayDate } -> current.dayDate
+            weekDays.any { it.date == todayDate && todayDate != null } -> todayDate
+            else -> weekDays.firstOrNull()?.date
+        }
+
+        preferencesRepository.setSelectedWeekStart(weekStart.toString())
+        dayDate?.let { preferencesRepository.setSelectedDayDate(it.toString()) }
+
+        _uiState.value = current.copy(
+            schedule = schedule,
+            weekStart = weekStart,
+            dayDate = dayDate,
+            todayDate = todayDate
+        )
+    }
+
+    fun selectWeek(weekStart: LocalDate) {
+        val state = _uiState.value
+        val schedule = state.schedule ?: return
+        val period = schedule.periods.firstOrNull { it.weekStart == weekStart } ?: return
+        viewModelScope.launch {
+            val today = ScheduleDates.moscowToday()
+            val weekDays = schedule.daysOf(period)
+            val dayDate = when {
+                weekDays.any { it.date == today } -> today
+                else -> weekDays.firstOrNull()?.date
+            }
+            preferencesRepository.setSelectedWeekStart(weekStart.toString())
+            dayDate?.let { preferencesRepository.setSelectedDayDate(it.toString()) }
+            _uiState.value = _uiState.value.copy(weekStart = weekStart, dayDate = dayDate)
+        }
+    }
+
+    fun selectDay(date: LocalDate) {
+        val state = _uiState.value
+        val schedule = state.schedule ?: return
+        val period = schedule.periodOf(date) ?: return
+        viewModelScope.launch {
+            preferencesRepository.setSelectedWeekStart(period.weekStart.toString())
+            preferencesRepository.setSelectedDayDate(date.toString())
+            _uiState.value = _uiState.value.copy(weekStart = period.weekStart, dayDate = date)
+        }
+    }
+
     private suspend fun syncIfMissingToday(groupId: String) {
         val schedule = scheduleRepository.getSchedule(groupId)
         val today = ScheduleDates.moscowToday()
@@ -84,23 +147,10 @@ class ScheduleViewModel(
         viewModelScope.launch {
             _uiState.value = _uiState.value.copy(isRefreshing = true)
             scheduleRepository.sync(groupId)
-            val current = _uiState.value
+            _uiState.value = _uiState.value.copy(isRefreshing = false)
-            val days = current.schedule?.days.orEmpty()
-            val today = todayIndex(days)
-            _uiState.value = current.copy(
-                isRefreshing = false,
-                todayIndex = today,
-                selectedIndex = current.selectedIndex.takeIf { it in days.indices } ?: today
-            )
         }
     }
 
-    fun selectDay(index: Int) {
-        val days = _uiState.value.schedule?.days.orEmpty()
-        if (index !in days.indices) return
-        _uiState.value = _uiState.value.copy(selectedIndex = index)
-    }
-
     fun clearAll() {
         val groupId = currentGroupId ?: return
         viewModelScope.launch {
@@ -111,21 +161,12 @@ class ScheduleViewModel(
     fun clearSelectedPeriod() {
         val state = _uiState.value
         val schedule = state.schedule ?: return
-        val day = schedule.days.getOrNull(state.selectedIndex) ?: return
+        val weekStart = state.weekStart ?: return
-        val period = schedule.periodOf(day.date) ?: return
+        val period = schedule.periods.firstOrNull { it.weekStart == weekStart } ?: return
         viewModelScope.launch {
             scheduleRepository.clearPeriod(schedule.groupId, period)
         }
     }
-
-    private fun todayIndex(days: List<Day>): Int {
-        if (days.isEmpty()) return 0
-        val today = ScheduleDates.moscowToday()
-        val exact = days.indexOfFirst { it.date == today }
-        if (exact >= 0) return exact
-        val next = days.indexOfFirst { !it.date.isBefore(today) }
-        return if (next >= 0) next else days.lastIndex
-    }
 }
 
 data class ScheduleUiState(
@@ -133,6 +174,7 @@ data class ScheduleUiState(
     val isRefreshing: Boolean = false,
     val isSyncing: Boolean = false,
     val schedule: Schedule? = null,
-    val todayIndex: Int = 0,
+    val weekStart: LocalDate? = null,
-    val selectedIndex: Int = 0
+    val dayDate: LocalDate? = null,
+    val todayDate: LocalDate? = null
 )