Implement multiple deletion of note types

The user can now select multiple note types and delete them with one
click.

While multi selecting the rename and delete options are disabled and
a check indicator is shown.
Filtering still works allowing the user to search for specific note types
and selecting them, while preserving previous selected items.

A selection summary is displayed through a floating toolbar. This was
built manually as the material themes provided one was buggy(and we don't
use proper theme colors).

BACK while there's a multiple selection clears it.

Author: lukstbit

AnkiDroid/src/main/java/com/ichi2/anki/notetype/ManageNoteTypesState.kt

@@ -44,6 +44,12 @@ data class ManageNoteTypesState(
      * and after marked as consumed.
      */
     val destination: Destination? = null,
+    /**
+     * Flag to indicate if we are selecting multiple items. This being true implies that at least
+     * one item in the list of [com.ichi2.anki.notetype.NoteTypeItemState] has its isSelected
+     * property set to true.
+     */
+    val isInMultiSelectMode: Boolean = false,
 ) {
     /** Simple message to be shown to the user, usually in a [Snackbar] or [Toast] */
     enum class UserMessage {
@@ -87,6 +93,16 @@ data class NoteTypeItemState(
     val id: NoteTypeId,
     val name: String,
     val useCount: Int,
+    /**
+     * Only set and used in multiple selection mode, true if this entry is currently selected,
+     * false otherwise.
+     */
+    val isSelected: Boolean = false,
+    /**
+     * Flag to indicate if the ui should show this item or not, used for filtering items when we
+     * want to hide entries but still holding on to them for their state.
+     */
+    val shouldBeDisplayed: Boolean = true,
 ) {
     companion object {
         fun asModel(source: NotetypeNameIdUseCount) = NoteTypeItemState(source.id, source.name, source.useCount)

AnkiDroid/src/main/java/com/ichi2/anki/notetype/ManageNoteTypesViewModel.kt

@@ -16,12 +16,15 @@
 
 package com.ichi2.anki.notetype
 
+import androidx.annotation.VisibleForTesting
+import androidx.annotation.VisibleForTesting.Companion.PRIVATE
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import anki.collection.OpChanges
 import anki.notetypes.Notetype
 import anki.notetypes.copy
 import com.ichi2.anki.CollectionManager.withCol
+import com.ichi2.anki.exception.CombinedException
 import com.ichi2.anki.libanki.Collection
 import com.ichi2.anki.libanki.NoteTypeId
 import com.ichi2.anki.libanki.getNotetype
@@ -40,17 +43,18 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import net.ankiweb.rsdroid.BackendException
+import timber.log.Timber
 
 class ManageNoteTypesViewModel : ViewModel() {
     private val _state = MutableStateFlow(ManageNoteTypesState())
     val state: StateFlow<ManageNoteTypesState> = _state.asStateFlow()
-    private lateinit var initialNoteTypes: List<NoteTypeItemState>
 
     init {
         refreshNoteTypes()
     }
 
     fun refreshNoteTypes() {
+        Timber.i("Refreshing list of notetypes")
         _state.update { oldState -> oldState.copy(isLoading = true) }
         viewModelScope.launch {
             withCol { safeGetNotetypeNameIdUseCount() }
@@ -59,7 +63,6 @@ class ManageNoteTypesViewModel : ViewModel() {
                         oldState.copy(isLoading = false, error = ReportableException(it))
                     }
                 }.onSuccess {
-                    initialNoteTypes = it
                     _state.update { oldState ->
                         oldState.copy(isLoading = false, noteTypes = it)
                     }
@@ -68,11 +71,12 @@ class ManageNoteTypesViewModel : ViewModel() {
     }
 
     fun filter(query: String) {
-        val matchedNoteTypes =
-            initialNoteTypes.filter { entry ->
-                entry.name.contains(query)
-            }
+        Timber.i("Filtering list of notetypes with query=$query")
         _state.update { oldState ->
+            val matchedNoteTypes =
+                oldState.noteTypes.map {
+                    it.copy(shouldBeDisplayed = it.name.contains(query))
+                }
             oldState.copy(isLoading = false, noteTypes = matchedNoteTypes, searchQuery = query)
         }
     }
@@ -81,21 +85,15 @@ class ManageNoteTypesViewModel : ViewModel() {
         nid: NoteTypeId,
         name: String,
     ) {
+        Timber.i("Renaming notetype with id $nid")
         _state.update { oldState -> oldState.copy(isLoading = true) }
         viewModelScope.launch {
             undoableOp<OpChanges> {
                 safeRenameNoteType(nid, name)
                     .onSuccess { changes ->
                         _state.update { oldState ->
                             val updatedNoteTypes =
-                                oldState.noteTypes
-                                    .map { noteTypeState ->
-                                        if (noteTypeState.id == nid) {
-                                            noteTypeState.copy(name = name)
-                                        } else {
-                                            noteTypeState
-                                        }
-                                    }.also { initialNoteTypes = it }
+                                oldState.noteTypes.withUpdatedItem(nid) { old -> old.copy(name = name) }
                             oldState.copy(isLoading = false, noteTypes = updatedNoteTypes)
                         }
                         return@undoableOp changes
@@ -116,7 +114,9 @@ class ManageNoteTypesViewModel : ViewModel() {
         }
     }
 
+    /** Deletes the note type with [nid] and also updates the multi select mode status if needed */
     fun delete(nid: NoteTypeId) {
+        Timber.i("Deleting notetype with id $nid")
         _state.update { oldState -> oldState.copy(isLoading = true) }
         val noteTypesCount = _state.value.noteTypes.size
         viewModelScope.launch {
@@ -130,11 +130,12 @@ class ManageNoteTypesViewModel : ViewModel() {
                 safeRemoveNoteType(nid)
                     .onSuccess { changes ->
                         _state.update { oldState ->
-                            val updatedNoteTypes =
-                                oldState.noteTypes
-                                    .filter { it.id != nid }
-                                    .also { initialNoteTypes = it }
-                            oldState.copy(isLoading = false, noteTypes = updatedNoteTypes)
+                            val updatedNoteTypes = oldState.noteTypes.filterNot { it.id == nid }
+                            oldState.copy(
+                                isLoading = false,
+                                noteTypes = updatedNoteTypes,
+                                isInMultiSelectMode = updatedNoteTypes.multiSelectModeStatus,
+                            )
                         }
                         return@undoableOp changes
                     }.onFailure {
@@ -149,30 +150,177 @@ class ManageNoteTypesViewModel : ViewModel() {
     }
 
     fun onItemClick(entry: NoteTypeItemState) {
+        if (_state.value.isInMultiSelectMode) {
+            Timber.i("onItemClick: already in multiple selection mode, toggling selection for notetype with id: ${entry.id} ")
+            _state.update { oldState ->
+                val updatedNoteTypes =
+                    oldState.noteTypes.withUpdatedItem(entry.id) { noteType ->
+                        noteType.copy(isSelected = !noteType.isSelected)
+                    }
+                oldState.copy(
+                    noteTypes = updatedNoteTypes,
+                    isInMultiSelectMode = updatedNoteTypes.multiSelectModeStatus,
+                )
+            }
+        } else {
+            Timber.i("onItemClick: not in multiple selection mode, sending show fields editor request")
+            _state.update { oldState ->
+                oldState.copy(destination = FieldsEditor(entry.id, entry.name))
+            }
+        }
+    }
+
+    fun onItemLongClick(entry: NoteTypeItemState) {
+        if (_state.value.isInMultiSelectMode) {
+            Timber.i("onItemLongClick: already in multiple selection mode, toggling selection for notetype with id: ${entry.id} ")
+            _state.update { oldState ->
+                val updatedNoteTypes =
+                    oldState.noteTypes.withUpdatedItem(entry.id) { noteType ->
+                        noteType.copy(isSelected = !noteType.isSelected)
+                    }
+                oldState.copy(
+                    noteTypes = updatedNoteTypes,
+                    isInMultiSelectMode = updatedNoteTypes.multiSelectModeStatus,
+                )
+            }
+        } else {
+            Timber.i("onItemLongClick: no previous selection, starting multi select mode with notetype(${entry.id}) selected")
+            _state.update { oldState ->
+                val updatedNoteTypes =
+                    oldState.noteTypes.withUpdatedItem(entry.id) { noteType ->
+                        noteType.copy(isSelected = true)
+                    }
+                oldState.copy(noteTypes = updatedNoteTypes, isInMultiSelectMode = true)
+            }
+        }
+    }
+
+    /** Updates the check status for a selected note type also updates the multi select mode status if needed */
+    fun onItemChecked(
+        entry: NoteTypeItemState,
+        isChecked: Boolean,
+    ) {
+        Timber.i("onItemCheck: update selection for notetype(${entry.id}) with new status: $isChecked")
+        _state.update { oldState ->
+            val updatedNoteTypes =
+                _state.value.noteTypes.withUpdatedItem(entry.id) { old -> old.copy(isSelected = isChecked) }
+            oldState.copy(
+                noteTypes = updatedNoteTypes,
+                isInMultiSelectMode = updatedNoteTypes.multiSelectModeStatus,
+            )
+        }
+    }
+
+    /** Clears any selected note types and also exits the multi select mode */
+    fun clearSelection() {
+        Timber.i("Clearing selected notetypes")
+        _state.update { oldState ->
+            val updatedNoteTypes =
+                oldState.noteTypes.map { noteTypeItemState ->
+                    noteTypeItemState.copy(isSelected = false)
+                }
+            oldState.copy(
+                noteTypes = updatedNoteTypes,
+                isInMultiSelectMode = updatedNoteTypes.multiSelectModeStatus,
+            )
+        }
+    }
+
+    /**
+     * Deletes all the [NoteTypeItemState] which are currently selected. Any errors when deleting
+     * the [Notetype]s will be combined into a single [CombinedException] to present to the user.
+     */
+    fun deleteSelectedNoteTypes() {
+        val noteTypesToDelete = selectedNoteTypes.toMutableList()
+        Timber.i("Deleting currently selected notetypes: ${noteTypesToDelete.map { it.id }}")
+        // show loading and clear selection
         _state.update { oldState ->
-            oldState.copy(destination = FieldsEditor(entry.id, entry.name))
+            val updateNotetypes =
+                oldState.noteTypes.map { noteType ->
+                    noteType.copy(isSelected = false)
+                }
+            oldState.copy(
+                isLoading = true,
+                noteTypes = updateNotetypes,
+                isInMultiSelectMode = false,
+            )
+        }
+        viewModelScope.launch {
+            val errors = mutableMapOf<NoteTypeItemState, Throwable>()
+            noteTypesToDelete.forEach { noteType ->
+                undoableOp<OpChanges> {
+                    safeRemoveNoteType(noteType.id)
+                        .onFailure { exception ->
+                            errors[noteType] = exception
+                            OpChanges.getDefaultInstance()
+                        }.onSuccess { return@undoableOp it }
+                    OpChanges.getDefaultInstance()
+                }
+            }
+            // look through any errors we might have and remove from our list of note types the ones
+            // that were in noteTypesToDelete but not in errors map(which presumably weren't deleted)
+            val removedIds = noteTypesToDelete.map { it.id } - errors.keys.map { it.id }.toSet()
+            val updatedNoteTypes = _state.value.noteTypes.filterNot { it.id in removedIds }
+            val combinedException =
+                CombinedException.from(
+                    errors.map { (state, throwable) ->
+                        "${state.name} - $throwable" to throwable
+                    },
+                )
+            _state.update { oldState ->
+                oldState.copy(
+                    isLoading = false,
+                    noteTypes = updatedNoteTypes,
+                    error = combinedException?.let { throwable -> ReportableException(throwable) },
+                )
+            }
         }
     }
 
     fun onCardEditorRequested(entry: NoteTypeItemState) {
+        Timber.i("Sending open card editor request")
         _state.update { oldState ->
             oldState.copy(destination = CardEditor(entry.id))
         }
     }
 
+    /** Clears any previous user messages from the state */
     fun clearMessage() {
+        Timber.i("Clearing user message from state")
         _state.update { oldState -> oldState.copy(message = null) }
     }
 
+    /** Clears any previous errors from the state */
     fun clearError() {
+        Timber.i("Clearing errors from state")
         _state.update { oldState -> oldState.copy(error = null) }
     }
 
+    /** Clears any previous destinations requested by the user from the state */
     fun clearDestination() {
+        Timber.i("Clearing requested destinations from state")
         _state.update { oldState -> oldState.copy(destination = null) }
     }
+
+    /**
+     * Returns a new list where all items are unchanged with the exception of the [NoteTypeItemState]
+     * identified by [nid] which is replaced by the result of invoking the [update] lambda.
+     */
+    private fun List<NoteTypeItemState>.withUpdatedItem(
+        nid: NoteTypeId,
+        update: (NoteTypeItemState) -> NoteTypeItemState,
+    ): List<NoteTypeItemState> = map { noteType -> if (noteType.id == nid) update(noteType) else noteType }
+
+    /** True if we are selecting multiple items(implies at least one item is currently selected), false otherwise. */
+    @VisibleForTesting(otherwise = PRIVATE)
+    val List<NoteTypeItemState>.multiSelectModeStatus: Boolean
+        get() = any { it.isSelected }
 }
 
+/** The list of [NoteTypeItemState] that are currently selected */
+val ManageNoteTypesViewModel.selectedNoteTypes: List<NoteTypeItemState>
+    get() = state.value.noteTypes.filter { it.isSelected }
+
 private fun Collection.safeRenameNoteType(
     nid: NoteTypeId,
     newName: String,