Added basic convention plugins setup for modularization

feature/passes/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest>
+
+</manifest>

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesDialog.kt

@@ -0,0 +1,189 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.passes
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.itemsIndexed
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableDoubleStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.presentation.LocalSpacing
+import com.rtbishop.look4sat.core.presentation.MainTheme
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+
+private val allModes = listOf(
+    "AFSK", "AFSK S-Net", "AFSK SALSAT", "AHRPT", "AM", "APT", "BPSK", "BPSK PMT-A3",
+    "CERTO", "CW", "DQPSK", "DSTAR", "DUV", "FFSK", "FM", "FMN", "FSK", "FSK AX.100 Mode 5",
+    "FSK AX.100 Mode 6", "FSK AX.25 G3RUH", "GFSK", "GFSK Rktr", "GMSK", "HRPT", "LoRa",
+    "LRPT", "LSB", "MFSK", "MSK", "MSK AX.100 Mode 5", "MSK AX.100 Mode 6", "OFDM", "OQPSK",
+    "PSK", "PSK31", "PSK63", "QPSK", "QPSK31", "QPSK63", "SSTV", "USB", "WSJT"
+)
+
+@Preview
+@Composable
+private fun PassesDialogPreview() {
+    MainTheme { PassesDialog(24, 16.0, {}) { _, _ -> } }
+}
+
+@Composable
+fun PassesDialog(hours: Int, elevation: Double, cancel: () -> Unit, accept: (Int, Double) -> Unit) {
+    val hoursValue = remember { mutableIntStateOf(hours) }
+    val elevationValueNew = remember { mutableDoubleStateOf(elevation) }
+    val onAccept = {
+        accept(hoursValue.intValue, elevationValueNew.doubleValue).also { cancel() }
+    }
+    SharedDialog(title = stringResource(R.string.pass_filter_title), onCancel = cancel, onAccept = onAccept) {
+        SliderRow(
+            title = stringResource(R.string.pass_filter_elev),
+            value = elevationValueNew.doubleValue,
+            valuePostfix = "°",
+            valueResId = R.drawable.ic_elevation,
+            valueRange = 0f..60f
+        ) { elevationValueNew.doubleValue = it.toDouble() }
+        SliderRow(
+            title = stringResource(R.string.pass_filter_hours),
+            value = hoursValue.intValue.toDouble(),
+            valuePostfix = "h",
+            valueResId = R.drawable.ic_clock,
+            valueRange = 1f..240f
+        ) { hoursValue.intValue = it.toInt() }
+    }
+}
+
+@Composable
+private fun SliderRow(
+    title: String,
+    value: Double,
+    valuePostfix: String,
+    valueResId: Int,
+    valueRange: ClosedFloatingPointRange<Float>,
+    onChange: (Float) -> Unit
+) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(LocalSpacing.current.small),
+        modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+    ) {
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(LocalSpacing.current.small),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(
+                text = title,
+                fontSize = 16.sp,
+                modifier = Modifier.weight(1f),
+                color = MaterialTheme.colorScheme.onSurface
+            )
+            Icon(
+                painter = painterResource(id = valueResId),
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(20.dp)
+            )
+            Text(
+                text = "${value.toInt()}$valuePostfix",
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary
+            )
+        }
+        Slider(value = value.toFloat(), onValueChange = onChange, valueRange = valueRange)
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun RadiosDialogPreview() {
+    MainTheme { RadiosDialog(emptyList(), {}) { _ -> } }
+}
+
+@Composable
+fun RadiosDialog(modes: List<String>, cancel: () -> Unit, accept: (List<String>) -> Unit) {
+    val selected = remember { mutableStateListOf<String>().apply { addAll(modes) } }
+    val select = { mode: String ->
+        if (selected.contains(mode)) selected.remove(mode) else selected.add(mode)
+    }
+    val onAccept = { accept(selected.toList()).also { cancel() } }
+    SharedDialog(title = stringResource(R.string.pass_modes_title), onCancel = cancel, onAccept = onAccept) {
+        LazyVerticalGrid(
+            columns = GridCells.Adaptive(240.dp),
+            modifier = Modifier
+                .fillMaxHeight(0.69f)
+                .background(MaterialTheme.colorScheme.background),
+            horizontalArrangement = Arrangement.spacedBy(1.dp),
+            verticalArrangement = Arrangement.spacedBy(1.dp)
+        ) {
+            itemsIndexed(allModes) { index, item ->
+                Surface {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier
+                            .background(MaterialTheme.colorScheme.surface)
+                            .clickable { select(item) }
+                    ) {
+                        Text(
+                            text = "${index + 1}).",
+                            modifier = Modifier.padding(start = 16.dp, end = 8.dp),
+                            fontWeight = FontWeight.Normal,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                        Text(
+                            text = item,
+                            modifier = Modifier.weight(1f),
+                            fontWeight = FontWeight.Medium,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                        Checkbox(
+                            checked = selected.contains(item),
+                            onCheckedChange = null,
+                            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+                        )
+                    }
+                }
+            }
+        }
+    }
+}

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesScreen.kt

@@ -0,0 +1,336 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.passes
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyGridState
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.lazy.grid.rememberLazyGridState
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.pulltorefresh.PullToRefreshBox
+import androidx.compose.material3.pulltorefresh.PullToRefreshDefaults
+import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.compose.composable
+import com.rtbishop.look4sat.core.domain.predict.DeepSpaceObject
+import com.rtbishop.look4sat.core.domain.predict.NearEarthObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.presentation.EmptyListCard
+import com.rtbishop.look4sat.core.presentation.IconCard
+import com.rtbishop.look4sat.core.presentation.InfoDialog
+import com.rtbishop.look4sat.core.presentation.MainTheme
+import com.rtbishop.look4sat.core.presentation.NextPassRow
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.Screen
+import com.rtbishop.look4sat.core.presentation.ScreenColumn
+import com.rtbishop.look4sat.core.presentation.TimerRow
+import com.rtbishop.look4sat.core.presentation.TopBar
+import com.rtbishop.look4sat.core.presentation.infiniteMarquee
+import com.rtbishop.look4sat.core.presentation.isVerticalLayout
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+private val sdfDate = SimpleDateFormat("EEE dd MMM", Locale.ENGLISH)
+private val sdfTime = SimpleDateFormat("HH:mm:ss", Locale.ENGLISH)
+
+fun NavGraphBuilder.passesDestination(navigateToRadar: (Int, Long) -> Unit) {
+    composable(Screen.Passes.route) {
+        val viewModel = viewModel(
+            modelClass = PassesViewModel::class.java,
+            factory = PassesViewModel.Factory
+        )
+        val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
+        PassesScreen(uiState, navigateToRadar)
+    }
+}
+
+@Composable
+private fun PassesScreen(uiState: PassesState, navigateToRadar: (Int, Long) -> Unit) {
+    val refreshList = { uiState.takeAction(PassesAction.RefreshPasses) }
+    val showPassesDialog = { uiState.takeAction(PassesAction.TogglePassesDialog) }
+    val showRadiosDialog = { uiState.takeAction(PassesAction.ToggleRadiosDialog) }
+    if (uiState.isPassesDialogShown) {
+        PassesDialog(
+            hours = uiState.hours,
+            elevation = uiState.elevation,
+            cancel = showPassesDialog
+        ) { hours, elevation ->
+            uiState.takeAction(PassesAction.FilterPasses(hours, elevation))
+        }
+    }
+    if (uiState.isRadiosDialogShown) {
+        RadiosDialog(modes = uiState.modes, cancel = showRadiosDialog) { modes ->
+            uiState.takeAction(PassesAction.FilterRadios(modes))
+        }
+    }
+    if (uiState.shouldSeeWhatsNew) {
+        InfoDialog(
+            title = stringResource(R.string.pass_whatsnew_title),
+            text = stringResource(R.string.pass_whatsnew_message)
+        ) {
+            uiState.takeAction(PassesAction.DismissWhatsNew)
+        }
+    }
+    val gridState = rememberLazyGridState()
+    ScreenColumn(
+        topBar = { isVerticalLayout ->
+            TopBar(
+                isVerticalLayout = isVerticalLayout,
+                startAction = {
+                    IconCard(action = showPassesDialog, resId = R.drawable.ic_filter)
+                },
+                topInfo = {
+                    TimerRow(timeString = uiState.nextTime, isTimeAos = uiState.isNextTimeAos)
+                },
+                bottomInfo = {
+                    NextPassRow(pass = uiState.nextPass)
+                },
+                endAction = {
+                    IconCard(action = showRadiosDialog, resId = R.drawable.ic_radios)
+                }
+            )
+        }
+    ) { _ ->
+        PassesList(
+            isRefreshing = uiState.isRefreshing,
+            passes = uiState.itemsList,
+            navigateToRadar = navigateToRadar,
+            refreshPasses = refreshList,
+            gridState = gridState
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun PassesList(
+    isRefreshing: Boolean,
+    passes: List<OrbitalPass>,
+    navigateToRadar: (Int, Long) -> Unit,
+    refreshPasses: () -> Unit,
+    gridState: LazyGridState
+) {
+    val isVerticalLayout = isVerticalLayout()
+    val refreshState = rememberPullToRefreshState()
+    ElevatedCard(modifier = Modifier.fillMaxSize()) {
+        PullToRefreshBox(
+            isRefreshing = isRefreshing,
+            state = refreshState,
+            onRefresh = refreshPasses,
+            indicator = {
+                PullToRefreshDefaults.Indicator(
+                    state = refreshState,
+                    isRefreshing = isRefreshing,
+                    color = MaterialTheme.colorScheme.background,
+                    containerColor = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.align(Alignment.TopCenter),
+                )
+            }
+        ) {
+            if (passes.isEmpty()) {
+                EmptyListCard(message = stringResource(R.string.pass_empty_list_message))
+            } else {
+                LazyVerticalGrid(
+                    state = gridState,
+                    columns = GridCells.Adaptive(320.dp),
+                    modifier = Modifier.fillMaxSize()
+                ) {
+                    items(items = passes, key = { item -> item.catNum + item.aosTime }) { pass ->
+                        NearEarthPass(
+                            pass = pass,
+                            navigateToRadar = navigateToRadar,
+                            modifier = Modifier.animateItem(),
+                            isVerticalLayout = isVerticalLayout
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun DeepSpacePassPreview() {
+    val data = OrbitalData("Satellite", 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 45000, 0.0)
+    val satellite = DeepSpaceObject(data)
+    val pass = OrbitalPass(1L, 180.0, 10L, 360.0, 36650, 45.0, satellite, 0.5f)
+    MainTheme { NearEarthPass(pass = pass, { _, _ -> }) }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun NearEarthPassPreview() {
+    val data = OrbitalData("Satellite", 0.0, 15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 45000, 0.0)
+    val satellite = NearEarthObject(data)
+    val pass = OrbitalPass(1L, 180.0, 10L, 360.0, 36650, 45.0, satellite, 0.5f)
+    MainTheme { NearEarthPass(pass = pass, { _, _ -> }) }
+}
+
+@Composable
+private fun NearEarthPass(
+    pass: OrbitalPass,
+    navigateToRadar: (Int, Long) -> Unit,
+    modifier: Modifier = Modifier,
+    isVerticalLayout: Boolean = true
+) {
+    val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
+    val horizontalPadding = if (isVerticalLayout) 6.dp else 10.dp
+    Surface(color = MaterialTheme.colorScheme.background, modifier = modifier) {
+        Surface(modifier = Modifier
+            .padding(bottom = 2.dp)
+            .clickable { navigateToRadar(pass.catNum, pass.aosTime) }) {
+            Column(
+                verticalArrangement = Arrangement.spacedBy(1.dp),
+                modifier = Modifier
+                    .background(color = MaterialTheme.colorScheme.surface)
+                    .padding(horizontal = horizontalPadding, vertical = 4.dp)
+            ) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    Text(
+                        text = "$passSatId - ",
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                    Text(
+                        text = pass.name,
+                        modifier = Modifier
+                            .weight(1f)
+                            .padding(end = 6.dp)
+                            .infiniteMarquee(),
+                        fontWeight = FontWeight.Medium,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis
+                    )
+                    Icon(
+                        painter = painterResource(id = R.drawable.ic_elevation),
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.size(16.dp)
+                    )
+                    Spacer(modifier = Modifier.width(4.dp))
+                    Text(
+                        text = "${pass.maxElevation}°",
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    Row(
+                        modifier = Modifier.weight(1f),
+                        horizontalArrangement = Arrangement.Start,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        if (pass.isDeepSpace) {
+                            Text(text = stringResource(R.string.pass_deep_space), fontSize = 15.sp)
+                        } else {
+                            Text(
+                                text = sdfDate.format(Date(pass.aosTime)),
+                                fontSize = 15.sp
+                            )
+                        }
+                    }
+                    Row(
+                        modifier = Modifier.weight(1f),
+                        horizontalArrangement = Arrangement.Center,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Icon(
+                            painter = painterResource(id = R.drawable.ic_altitude),
+                            contentDescription = null,
+                            modifier = Modifier.size(16.dp)
+                        )
+                        Spacer(modifier = Modifier.width(4.dp))
+                        Text(
+                            text = "${pass.altitude} km",
+                            fontSize = 15.sp
+                        )
+                    }
+                    Row(
+                        modifier = Modifier.weight(1f),
+                        horizontalArrangement = Arrangement.End,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = stringResource(
+                                id = R.string.pass_aosLos,
+                                pass.aosAzimuth.toInt(),
+                                pass.losAzimuth.toInt()
+                            ),
+                            fontSize = 15.sp
+                        )
+                    }
+                }
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    val defaultTime = "   - - : - -   "
+                    Text(
+                        text = if (pass.isDeepSpace) defaultTime else sdfTime.format(Date(pass.aosTime)),
+                        fontSize = 15.sp
+                    )
+                    LinearProgressIndicator(
+                        progress = { if (pass.isDeepSpace) 100f else pass.progress },
+                        drawStopIndicator = {},
+                        modifier = modifier.fillMaxWidth(0.75f)
+                    )
+                    Text(
+                        text = if (pass.isDeepSpace) defaultTime else sdfTime.format(Date(pass.losTime)),
+                        fontSize = 15.sp
+                    )
+                }
+            }
+        }
+    }
+}

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesState.kt

@@ -0,0 +1,45 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.passes
+
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+
+data class PassesState(
+    val isPassesDialogShown: Boolean,
+    val isRadiosDialogShown: Boolean,
+    val isRefreshing: Boolean,
+    val isUtc: Boolean,
+    val nextPass: OrbitalPass,
+    val nextTime: String,
+    val isNextTimeAos: Boolean,
+    val hours: Int,
+    val elevation: Double,
+    val modes: List<String>,
+    val itemsList: List<OrbitalPass>,
+    val shouldSeeWhatsNew: Boolean,
+    val takeAction: (PassesAction) -> Unit
+)
+
+sealed class PassesAction {
+    data object DismissWhatsNew : PassesAction()
+    data class FilterPasses(val hoursAhead: Int, val minElevation: Double) : PassesAction()
+    data class FilterRadios(val modes: List<String>) : PassesAction()
+    data object RefreshPasses : PassesAction()
+    data object TogglePassesDialog : PassesAction()
+    data object ToggleRadiosDialog : PassesAction()
+}

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesViewModel.kt

@@ -0,0 +1,148 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.passes
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.utility.toTimerString
+import com.rtbishop.look4sat.core.presentation.getDefaultPass
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+class PassesViewModel(
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(
+        PassesState(
+            isPassesDialogShown = false,
+            isRadiosDialogShown = false,
+            isRefreshing = true,
+            isUtc = settingsRepo.otherSettings.value.stateOfUtc,
+            nextTime = "00:00:00",
+            isNextTimeAos = true,
+            nextPass = getDefaultPass(),
+            hours = settingsRepo.passesSettings.value.hoursAhead,
+            elevation = settingsRepo.passesSettings.value.minElevation,
+            modes = settingsRepo.passesSettings.value.selectedModes,
+            itemsList = emptyList(),
+            shouldSeeWhatsNew = settingsRepo.otherSettings.value.shouldSeeWhatsNew,
+            takeAction = ::handleAction
+        )
+    )
+    private var processing: Job? = null
+    val uiState: StateFlow<PassesState> = _uiState
+
+    init {
+        viewModelScope.launch {
+            delay(1000)
+            satelliteRepo.passes.collectLatest { passes ->
+                processing?.cancelAndJoin()
+                processing = viewModelScope.launch {
+                    while (isActive) {
+                        val timeNow = System.currentTimeMillis()
+                        val newPasses = satelliteRepo.processPasses(passes, timeNow)
+                        setPassInfo(newPasses, timeNow)
+                        _uiState.update { it.copy(isRefreshing = false, itemsList = newPasses) }
+                        delay(1000)
+                    }
+                }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.otherSettings.collectLatest { settings ->
+                _uiState.update { it.copy(shouldSeeWhatsNew = settings.shouldSeeWhatsNew) }
+            }
+        }
+    }
+
+    private fun handleAction(action: PassesAction) {
+        when (action) {
+            PassesAction.DismissWhatsNew -> settingsRepo.setWhatsNewDismissed()
+            is PassesAction.FilterPasses -> applyFilter(action.hoursAhead, action.minElevation, uiState.value.modes)
+            is PassesAction.FilterRadios -> applyFilter(uiState.value.hours, uiState.value.elevation, action.modes)
+            PassesAction.RefreshPasses -> refreshPasses()
+            PassesAction.TogglePassesDialog -> toggleFilterDialog()
+            PassesAction.ToggleRadiosDialog -> toggleRadiosDialog()
+        }
+    }
+
+    private fun applyFilter(hoursAhead: Int, minElevation: Double, modes: List<String>) = viewModelScope.launch {
+        _uiState.update { it.copy(isRefreshing = true) }
+        processing?.cancelAndJoin()
+        settingsRepo.setPassesSettings(PassesSettings(hoursAhead, minElevation, modes))
+        _uiState.update { it.copy(hours = hoursAhead, elevation = minElevation, modes = modes) }
+        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
+    }
+
+    private fun refreshPasses() = viewModelScope.launch {
+        _uiState.update { it.copy(isRefreshing = true) }
+        processing?.cancelAndJoin()
+        val (hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
+        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
+    }
+
+    private fun setPassInfo(passes: List<OrbitalPass>, timeNow: Long) {
+        if (passes.isEmpty()) return
+        try {
+            val nextPass = passes.first { it.aosTime.minus(timeNow) > 0 }
+            val time = nextPass.aosTime.minus(timeNow).toTimerString()
+            _uiState.update { it.copy(nextPass = nextPass, nextTime = time, isNextTimeAos = true) }
+        } catch (_: NoSuchElementException) {
+            val lastPass = passes.last()
+            val time = lastPass.losTime.minus(timeNow).toTimerString()
+            _uiState.update { it.copy(nextPass = lastPass, nextTime = time, isNextTimeAos = false) }
+        }
+    }
+
+    private fun toggleFilterDialog() {
+        val currentDialogState = _uiState.value.isPassesDialogShown
+        _uiState.update { it.copy(isPassesDialogShown = currentDialogState.not()) }
+    }
+
+    private fun toggleRadiosDialog() {
+        val currentDialogState = _uiState.value.isRadiosDialogShown
+        _uiState.update { it.copy(isRadiosDialogShown = currentDialogState.not()) }
+    }
+
+    companion object {
+        val Factory: ViewModelProvider.Factory = viewModelFactory {
+            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
+            initializer {
+                val container = (this[applicationKey] as IContainerProvider).getMainContainer()
+                PassesViewModel(container.satelliteRepo, container.settingsRepo)
+            }
+        }
+    }
+}