MVVM vs MVI: Which Android Architecture Should You Use?

data class Product(val id: String, val name: String, val price: Double)

interface ProductRepository {
    suspend fun search(query: String): List<Product>   // throws IOException on network failure
}

data class SearchUiState(
    val query: String = "",
    val isLoading: Boolean = false,
    val results: List<Product> = emptyList(),
    val error: String? = null,
)

class SearchViewModel(private val repository: ProductRepository) : ViewModel() {

    private val _uiState = MutableStateFlow(SearchUiState())
    val uiState: StateFlow<SearchUiState> = _uiState.asStateFlow()

    // One-off navigation events: buffered so they aren't lost, consumed once.
    private val _navigation = Channel<String>(Channel.BUFFERED)
    val navigation: Flow<String> = _navigation.receiveAsFlow()

    private var searchJob: Job? = null

    fun onQueryChange(query: String) {
        _uiState.update { it.copy(query = query) }
        searchJob?.cancel()
        searchJob = viewModelScope.launch {
            delay(300)                 // debounce: only search after typing pauses
            search(query)
        }
    }

    fun retry() {
        viewModelScope.launch { search(_uiState.value.query) }
    }

    fun onProductClick(product: Product) {
        viewModelScope.launch { _navigation.send(product.id) }
    }

    private suspend fun search(query: String) {
        if (query.isBlank()) {
            _uiState.update { it.copy(results = emptyList(), error = null, isLoading = false) }
            return
        }
        _uiState.update { it.copy(isLoading = true, error = null) }
        try {
            val results = repository.search(query)
            _uiState.update { it.copy(isLoading = false, results = results) }
        } catch (e: IOException) {
            _uiState.update { it.copy(isLoading = false, error = "Couldn't load results. Check your connection.") }
        }
    }
}

// Everything the user can do
sealed interface SearchIntent {
    data class QueryChanged(val query: String) : SearchIntent
    data object Retry : SearchIntent
    data class ProductClicked(val product: Product) : SearchIntent
}

// Everything that can happen as a result (internal to the ViewModel)
sealed interface SearchResult {
    data class QueryUpdated(val query: String) : SearchResult
    data object Loading : SearchResult
    data class Loaded(val products: List<Product>) : SearchResult
    data class Failed(val message: String) : SearchResult
    data object Cleared : SearchResult
}

// One-off effects the UI should perform exactly once
sealed interface SearchEffect {
    data class OpenProduct(val id: String) : SearchEffect
}

data class SearchState(
    val query: String = "",
    val isLoading: Boolean = false,
    val results: List<Product> = emptyList(),
    val error: String? = null,
)

// Pure: no coroutines, no repository, trivially unit-testable.
fun reduce(state: SearchState, result: SearchResult): SearchState = when (result) {
    is SearchResult.QueryUpdated -> state.copy(query = result.query)
    SearchResult.Loading -> state.copy(isLoading = true, error = null)
    is SearchResult.Loaded -> state.copy(isLoading = false, results = result.products)
    is SearchResult.Failed -> state.copy(isLoading = false, error = result.message)
    SearchResult.Cleared -> state.copy(isLoading = false, results = emptyList(), error = null)
}

class SearchMviViewModel(private val repository: ProductRepository) : ViewModel() {

    private val _state = MutableStateFlow(SearchState())
    val state: StateFlow<SearchState> = _state.asStateFlow()

    private val _effects = Channel<SearchEffect>(Channel.BUFFERED)
    val effects: Flow<SearchEffect> = _effects.receiveAsFlow()

    private var searchJob: Job? = null

    // The single entry point for everything the UI does.
    fun process(intent: SearchIntent) {
        when (intent) {
            is SearchIntent.QueryChanged -> {
                emit(SearchResult.QueryUpdated(intent.query))
                searchJob?.cancel()
                searchJob = viewModelScope.launch {
                    delay(300)
                    search(intent.query)
                }
            }
            SearchIntent.Retry -> viewModelScope.launch { search(_state.value.query) }
            is SearchIntent.ProductClicked ->
                viewModelScope.launch { _effects.send(SearchEffect.OpenProduct(intent.product.id)) }
        }
    }

    private suspend fun search(query: String) {
        if (query.isBlank()) return emit(SearchResult.Cleared)
        emit(SearchResult.Loading)
        try {
            emit(SearchResult.Loaded(repository.search(query)))
        } catch (e: IOException) {
            emit(SearchResult.Failed("Couldn't load results. Check your connection."))
        }
    }

    private fun emit(result: SearchResult) = _state.update { reduce(it, result) }
}

@Composable
fun SearchScreen(
    viewModel: SearchMviViewModel,
    onOpenProduct: (String) -> Unit,
) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    val lifecycleOwner = LocalLifecycleOwner.current

    // Collect one-off effects only while the screen is visible.
    LaunchedEffect(viewModel, lifecycleOwner) {
        lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
            viewModel.effects.collect { effect ->
                when (effect) {
                    is SearchEffect.OpenProduct -> onOpenProduct(effect.id)
                }
            }
        }
    }

    Column(Modifier.fillMaxSize().padding(16.dp)) {
        OutlinedTextField(
            value = state.query,
            onValueChange = { viewModel.process(SearchIntent.QueryChanged(it)) },
            label = { Text("Search products") },
            modifier = Modifier.fillMaxWidth(),
        )
        when {
            state.isLoading -> CircularProgressIndicator(Modifier.padding(24.dp))
            state.error != null -> Column(Modifier.padding(top = 16.dp)) {
                Text(state.error!!, color = MaterialTheme.colorScheme.error)
                TextButton(onClick = { viewModel.process(SearchIntent.Retry) }) { Text("Retry") }
            }
            else -> LazyColumn {
                items(state.results, key = { it.id }) { product ->
                    ListItem(
                        headlineContent = { Text(product.name) },
                        supportingContent = { Text("₹%.2f".format(product.price)) },
                        modifier = Modifier.clickable { viewModel.process(SearchIntent.ProductClicked(product)) },
                    )
                }
            }
        }
    }
}

class SearchReducerTest {
    @Test
    fun `failure stops loading and shows error`() {
        val loading = SearchState(query = "phone", isLoading = true)
        val result = reduce(loading, SearchResult.Failed("offline"))
        assertFalse(result.isLoading)
        assertEquals("offline", result.error)
        assertEquals("phone", result.query)   // unrelated fields untouched
    }
}