Shopping Checklist

import androidx.lifecycle.viewmodel.compose.viewModel

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { MiniTheme { ShoppingScreen() } }
    }
}

@Composable
private fun ShoppingScreen(model: ShoppingViewModel = viewModel()) {
    val state by model.uiState.collectAsStateWithLifecycle()
    Surface(modifier = Modifier.fillMaxSize()) {
        Column(
            modifier = Modifier.fillMaxSize()
                .windowInsetsPadding(WindowInsets.safeDrawing)
                .imePadding()
                .padding(16.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp)
        ) {
            Text(stringResource(R.string.screen_title), style = MaterialTheme.typography.headlineMedium)
            // One bounded lazy list owns all scrolling, including the form on small screens.
            LazyColumn(
                modifier = Modifier.weight(1f).fillMaxWidth(),
                verticalArrangement = Arrangement.spacedBy(12.dp)
            ) {

package com.mastercoding.miniprojects.shopping

data class ShoppingItem(
    val id: Long,
    val name: String,
    val quantity: Int,
    val purchased: Boolean = false
)

enum class ShoppingInputError { NAME_REQUIRED, INVALID_QUANTITY }

fun validateShoppingInput(name: String, quantity: String): ShoppingInputError? = when {
    name.isBlank() -> ShoppingInputError.NAME_REQUIRED
    (quantity.trim().toIntOrNull() ?: 0) < 1 -> ShoppingInputError.INVALID_QUANTITY
    else -> null
}

fun togglePurchased(items: List<ShoppingItem>, id: Long): List<ShoppingItem> =
    items.map { if (it.id == id) it.copy(purchased = !it.purchased) else it }

fun deleteShoppingItem(items: List<ShoppingItem>, id: Long): List<ShoppingItem> =
    items.filterNot { it.id == id }

/** In-memory state survives rotation, but it is not permanent database storage. */
class ShoppingViewModel : ViewModel() {
    private val mutableUiState = MutableStateFlow(ShoppingUiState())
    val uiState = mutableUiState.asStateFlow()
    private var nextId = 1L

    fun updateName(value: String) {
        mutableUiState.update { it.copy(name = value, error = null) }
    }

    fun updateQuantity(value: String) {
        mutableUiState.update { it.copy(quantity = value, error = null) }
    }

    fun addItem() {
        val state = mutableUiState.value
        val error = validateShoppingInput(state.name, state.quantity)
        if (error != null) {
            mutableUiState.update { it.copy(error = error) }
            return
        }
        // UI events run on the main thread; IDs never depend on row positions.
        val item = ShoppingItem(nextId++, state.name.trim(), state.quantity.trim().toInt())
        mutableUiState.value = state.copy(
            name = "", quantity = "1", items = state.items + item, error = null

    }

    fun addItem() {
        val state = mutableUiState.value
        val error = validateShoppingInput(state.name, state.quantity)
        if (error != null) {
            mutableUiState.update { it.copy(error = error) }
            return
        }
        // UI events run on the main thread; IDs never depend on row positions.
        val item = ShoppingItem(nextId++, state.name.trim(), state.quantity.trim().toInt())
        mutableUiState.value = state.copy(
            name = "", quantity = "1", items = state.items + item, error = null
        )
    }

    fun toggle(id: Long) {
        mutableUiState.update { it.copy(items = togglePurchased(it.items, id)) }
    }

    fun delete(id: Long) {
        mutableUiState.update { it.copy(items = deleteShoppingItem(it.items, id)) }
    }
}

@Composable
private fun ShoppingScreen(model: ShoppingViewModel = viewModel()) {
    val state by model.uiState.collectAsStateWithLifecycle()
    Surface(modifier = Modifier.fillMaxSize()) {
        Column(
            modifier = Modifier.fillMaxSize()
                .windowInsetsPadding(WindowInsets.safeDrawing)
                .imePadding()
                .padding(16.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp)
        ) {
            Text(stringResource(R.string.screen_title), style = MaterialTheme.typography.headlineMedium)
            // One bounded lazy list owns all scrolling, including the form on small screens.
            LazyColumn(
                modifier = Modifier.weight(1f).fillMaxWidth(),
                verticalArrangement = Arrangement.spacedBy(12.dp)
            ) {
                item(key = "instructions") { Text(stringResource(R.string.instructions)) }
                item(key = "form") {
                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
                        OutlinedTextField(
                            value = state.name,
                            onValueChange = model::updateName,
                            label = { Text(stringResource(R.string.item_name)) },
                            isError = state.error == ShoppingInputError.NAME_REQUIRED,
                            singleLine = true,

                    item(key = "empty") { Text(stringResource(R.string.empty_list)) }
                }
                items(state.items, key = { it.id }) { item ->
                    ShoppingItemCard(item, onToggle = { model.toggle(item.id) }, onDelete = { model.delete(item.id) })
                }
            }
        }
    }
}

@Composable
private fun ShoppingItemCard(item: ShoppingItem, onToggle: () -> Unit, onDelete: () -> Unit) {
    val toggleDescription = stringResource(
        if (item.purchased) R.string.mark_remaining else R.string.mark_purchased, item.name
    )
    val deleteDescription = stringResource(R.string.delete_description, item.name)
    Card(modifier = Modifier.fillMaxWidth()) {
        Row(
            modifier = Modifier.fillMaxWidth().padding(8.dp),
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.spacedBy(4.dp)
        ) {
            Checkbox(
                checked = item.purchased,
                onCheckedChange = { onToggle() },
                modifier = Modifier.semantics { contentDescription = toggleDescription }

/** In-memory state survives rotation, but it is not permanent database storage. */
class ShoppingViewModel : ViewModel() {
    private val mutableUiState = MutableStateFlow(ShoppingUiState())
    val uiState = mutableUiState.asStateFlow()
    private var nextId = 1L

    fun updateName(value: String) {
        mutableUiState.update { it.copy(name = value, error = null) }
    }

    fun updateQuantity(value: String) {
        mutableUiState.update { it.copy(quantity = value, error = null) }
    }

    fun addItem() {
        val state = mutableUiState.value
        val error = validateShoppingInput(state.name, state.quantity)
        if (error != null) {
            mutableUiState.update { it.copy(error = error) }
            return
        }
        // UI events run on the main thread; IDs never depend on row positions.
        val item = ShoppingItem(nextId++, state.name.trim(), state.quantity.trim().toInt())
        mutableUiState.value = state.copy(
            name = "", quantity = "1", items = state.items + item, error = null
        )

    }

    @Test fun toggleTargetsStableIdEvenWhenNamesAreDuplicated() {
        val original = listOf(ShoppingItem(1L, "Milk", 1), ShoppingItem(2L, "Milk", 2))
        val updated = togglePurchased(original, 2L)
        assertFalse(updated[0].purchased)
        assertTrue(updated[1].purchased)
        assertFalse(original[1].purchased)
    }

    @Test fun deleteDoesNotChangeOtherItemsOrOriginalList() {
        val original = listOf(ShoppingItem(10L, "Rice", 1), ShoppingItem(11L, "Bread", 3))
        val updated = deleteShoppingItem(original, 10L)
        assertEquals(listOf(ShoppingItem(11L, "Bread", 3)), updated)
        assertEquals(2, original.size)
        assertTrue(deleteShoppingItem(updated, 11L).isEmpty())
    }
}