feat(duplicates): implement delete all exact duplicates action

Introduces a bulk deletion feature strictly for exact binary duplicates, streamlining the cleanup process. The implementation ensures visually similar media (like burst shots) are ignored to prevent accidental data loss.

- Added `deleteAllExactDuplicates` to `DuplicatesViewModel` to strictly target `DuplicateGroup` items while preserving the oldest file.
- Implemented `SHOW_CONFIRM_DELETE_ALL_EXACT` preference in `PreferencesRepository` to persist the "Do not ask again" dialog state.
- Added `DeleteSweep` action button to `DuplicatesScreen` TopAppBar, conditionally visible only when exact duplicates exist.
- Integrated a confirmation dialog with a "Do not ask again" checkbox to warn users about the bulk operation.

Author: loopotto

app/src/main/java/com/cleansweep/data/repository/PreferencesRepository.kt

@@ -158,6 +158,7 @@ class PreferencesRepository @Inject constructor(
         val SHOW_CONFIRM_FORGET_FOLDER = booleanPreferencesKey("show_confirm_forget_folder")
         val SHOW_CONFIRM_RESET_SOURCE_FAVS = booleanPreferencesKey("show_confirm_reset_source_favs")
         val SHOW_CONFIRM_RESET_TARGET_FAVS = booleanPreferencesKey("show_confirm_reset_target_favs")
+        val SHOW_CONFIRM_DELETE_ALL_EXACT = booleanPreferencesKey("show_confirm_delete_all_exact")
         val UNSELECT_ALL_IN_SEARCH_SCOPE = stringPreferencesKey("unselect_all_in_search_scope")
     }
 
@@ -453,6 +454,9 @@ class PreferencesRepository @Inject constructor(
     val showConfirmResetTargetFavsFlow: Flow<Boolean> = context.dataStore.data
         .map { preferences -> preferences[PreferencesKeys.SHOW_CONFIRM_RESET_TARGET_FAVS] ?: true }
 
+    val showConfirmDeleteAllExactFlow: Flow<Boolean> = context.dataStore.data
+        .map { preferences -> preferences[PreferencesKeys.SHOW_CONFIRM_DELETE_ALL_EXACT] ?: true }
+
     val unselectAllInSearchScopeFlow: Flow<UnselectScanScope> = context.dataStore.data
         .map { preferences ->
             val scopeName = preferences[PreferencesKeys.UNSELECT_ALL_IN_SEARCH_SCOPE] ?: UnselectScanScope.GLOBAL.name
@@ -873,13 +877,18 @@ class PreferencesRepository @Inject constructor(
         context.dataStore.edit { prefs -> prefs[PreferencesKeys.SHOW_CONFIRM_RESET_TARGET_FAVS] = enabled }
     }
 
+    suspend fun setShowConfirmDeleteAllExact(enabled: Boolean) {
+        context.dataStore.edit { prefs -> prefs[PreferencesKeys.SHOW_CONFIRM_DELETE_ALL_EXACT] = enabled }
+    }
+
     suspend fun resetDialogConfirmations() {
         context.dataStore.edit { preferences ->
             preferences[PreferencesKeys.SHOW_CONFIRM_MARK_AS_SORTED] = true
             preferences[PreferencesKeys.SHOW_CONFIRM_RESET_ALL_HISTORY] = true
             preferences[PreferencesKeys.SHOW_CONFIRM_FORGET_FOLDER] = true
             preferences[PreferencesKeys.SHOW_CONFIRM_RESET_SOURCE_FAVS] = true
             preferences[PreferencesKeys.SHOW_CONFIRM_RESET_TARGET_FAVS] = true
+            preferences[PreferencesKeys.SHOW_CONFIRM_DELETE_ALL_EXACT] = true
         }
     }
 

app/src/main/java/com/cleansweep/ui/screens/duplicates/DuplicatesScreen.kt

@@ -95,6 +95,7 @@ fun DuplicatesScreen(
     val uiState by viewModel.uiState.collectAsState()
     val context = LocalContext.current
     var showConfirmDeleteDialog by remember { mutableStateOf(false) }
+    var showConfirmDeleteAllExactDialog by remember { mutableStateOf(false) }
     val displayedUnscannableFiles by viewModel.displayedUnscannableFiles.collectAsState()
 
     val permissionLauncher = rememberLauncherForActivityResult(
@@ -153,6 +154,53 @@ fun DuplicatesScreen(
         )
     }
 
+    if (showConfirmDeleteAllExactDialog) {
+        var doNotAskAgain by remember { mutableStateOf(false) }
+
+        AlertDialog(
+            onDismissRequest = { showConfirmDeleteAllExactDialog = false },
+            title = { Text("Delete All Exact Duplicates?") },
+            text = {
+                Column {
+                    Text("This will automatically keep the oldest file in each group of exact duplicates and delete the rest.\n\nNote: even groups flagged as exact duplicates might have false positives. Reviewing manually is recommended.")
+                    Spacer(modifier = Modifier.height(16.dp))
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .clickable { doNotAskAgain = !doNotAskAgain },
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Checkbox(
+                            checked = doNotAskAgain,
+                            onCheckedChange = { doNotAskAgain = it }
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text("Do not ask again")
+                    }
+                }
+            },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        if (doNotAskAgain) {
+                            viewModel.setShowConfirmDeleteAllExact(false)
+                        }
+                        viewModel.deleteAllExactDuplicates()
+                        showConfirmDeleteAllExactDialog = false
+                    },
+                    colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.error)
+                ) {
+                    Text("Delete All")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showConfirmDeleteAllExactDialog = false }) {
+                    Text("Cancel")
+                }
+            }
+        )
+    }
+
     if (uiState.showUnscannableFilesDialog) {
         UnscannableFilesDialog(
             filePaths = displayedUnscannableFiles,
@@ -184,6 +232,25 @@ fun DuplicatesScreen(
                 },
                 actions = {
                     if (uiState.scanState == ScanState.Complete) {
+                        val hasExactDuplicates = uiState.resultGroups.any { it is DuplicateGroup }
+                        if (hasExactDuplicates) {
+                            TooltipBox(
+                                positionProvider = TooltipDefaults.rememberPlainTooltipPositionProvider(),
+                                tooltip = { PlainTooltip { Text("Delete All Exact Duplicates") } },
+                                state = rememberTooltipState()
+                            ) {
+                                IconButton(onClick = {
+                                    if (uiState.showConfirmDeleteAllExact) {
+                                        showConfirmDeleteAllExactDialog = true
+                                    } else {
+                                        viewModel.deleteAllExactDuplicates()
+                                    }
+                                }) {
+                                    Icon(Icons.Outlined.DeleteSweep, contentDescription = "Delete All Exact Duplicates", tint = MaterialTheme.colorScheme.error)
+                                }
+                            }
+                        }
+
                         TooltipBox(
                             positionProvider = TooltipDefaults.rememberPlainTooltipPositionProvider(),
                             tooltip = { PlainTooltip { Text("New Scan") } },

app/src/main/java/com/cleansweep/ui/screens/duplicates/DuplicatesViewModel.kt

@@ -4,7 +4,6 @@
  *
  * 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 any later version.
  *
  * This program is distributed in the hope that it will be useful,
@@ -88,6 +87,7 @@ data class DuplicatesUiState(
     val detailedGroup: ScanResultGroup? = null,
     val detailViewColumnCount: Int = 2,
     val gridViewColumnCount: Int = 2,
+    val showConfirmDeleteAllExact: Boolean = true,
     // Scan Scope properties
     val scanScope: DuplicateScanScope = DuplicateScanScope.ALL_FILES,
     val includeList: Set<String> = emptySet(),
@@ -175,6 +175,13 @@ class DuplicatesViewModel @Inject constructor(
             }
         }
 
+        // Collect preference for confirm dialog
+        viewModelScope.launch {
+            preferencesRepository.showConfirmDeleteAllExactFlow.collectLatest { show ->
+                _uiState.update { it.copy(showConfirmDeleteAllExact = show) }
+            }
+        }
+
 
         // One-time check for valid cache to show/hide the "Load" button
         viewModelScope.launch {
@@ -471,6 +478,44 @@ class DuplicatesViewModel @Inject constructor(
         _uiState.update { it.copy(selectedForDeletion = newSelection, spaceToReclaim = reclaimableSpace) }
     }
 
+    fun setShowConfirmDeleteAllExact(enabled: Boolean) {
+        viewModelScope.launch {
+            preferencesRepository.setShowConfirmDeleteAllExact(enabled)
+        }
+    }
+
+    fun deleteAllExactDuplicates() {
+        val allIds = mutableSetOf<String>()
+        val currentState = _uiState.value
+
+        // Only process EXACT duplicates (DuplicateGroup), ignore SimilarGroup
+        val exactGroups = currentState.resultGroups.filterIsInstance<DuplicateGroup>()
+
+        if (exactGroups.isEmpty()) {
+            _uiState.update { it.copy(toastMessage = "No exact duplicates found.") }
+            return
+        }
+
+        exactGroups.forEach { group ->
+            // Sort by date added (oldest first), then by ID for deterministic behavior
+            val sorted = group.items.sortedWith(compareBy<MediaItem> { it.dateAdded }.thenBy { it.id })
+            if (sorted.size > 1) {
+                // Keep the first one (oldest), mark the rest for deletion
+                val toDelete = sorted.drop(1).map { it.id }
+                allIds.addAll(toDelete)
+            }
+        }
+
+        if (allIds.isEmpty()) {
+            _uiState.update { it.copy(toastMessage = "No duplicates found to delete.") }
+            return
+        }
+
+        updateSelection(allIds)
+        // Trigger the existing deletion logic which consumes the selection we just set
+        deleteSelectedFiles()
+    }
+
     fun deleteSelectedFiles() {
         val currentState = _uiState.value
         val itemsToProcess = currentState.selectedForDeletion