feat: allow profile deletion

Introduce deleteProfile() and batch deleteProfiles() methods for
removing user profiles. Deletion removes both the registry entry
(SharedPreferences) and the on-disk data directory.

The only guard is: the currently active profile cannot be deleted.
The default profile can be deleted if the user has switched to
another profile. Batch deletion validates all IDs upfront before
touching anything, ensuring no partial deletes if one ID is invalid

Author: criticalAY

AnkiDroid/src/main/java/com/ichi2/anki/multiprofile/ProfileManager.kt

@@ -229,6 +229,48 @@ class ProfileManager private constructor(
         // TODO: Implement process restart logic (e.g. ProcessPhoenix)
     }
 
+    /**
+     * Permanently deletes multiple profiles in a single batch.
+     *
+     * @param profileIds The profiles to delete.
+     * @throws IllegalArgumentException if any ID is the
+     *   currently active profile.
+     */
+    fun deleteProfiles(profileIds: List<ProfileId>) {
+        val activeId = profileRegistry.getLastActiveProfileId()
+
+        for (id in profileIds) {
+            require(id != activeId) {
+                "Cannot delete the currently active profile (${id.value}). Switch first."
+            }
+        }
+
+        profileRegistry.removeProfiles(profileIds)
+
+        for (id in profileIds) {
+            val profileDir = resolveProfileDirectory(id)
+            if (profileDir.file.exists()) {
+                val deleted = profileDir.file.deleteRecursively()
+                if (!deleted) {
+                    Timber.w("Failed to fully delete profile directory: ${profileDir.file.absolutePath}")
+                }
+            }
+        }
+
+        Timber.i("Deleted ${profileIds.size} profiles: ${profileIds.map { it.value }}")
+    }
+
+    /**
+     * Permanently deletes a single profile.
+     *
+     * @param profileId The [ProfileId] to delete.
+     * @throws IllegalArgumentException if [profileId] is the
+     *   currently active profile.
+     */
+    fun deleteProfile(profileId: ProfileId) {
+        deleteProfiles(listOf(profileId))
+    }
+
     /**
      * Holds the meta-data for a profile.
      * Converted to JSON for storage to allow future extensibility (e.g. avatars, themes).
@@ -327,6 +369,20 @@ class ProfileManager private constructor(
             return result
         }
 
+        /**
+         * Removes multiple profile entries from the registry in a
+         * single SharedPreferences transaction.
+         *
+         * @param ids The [ProfileId]s to remove.
+         */
+        fun removeProfiles(ids: List<ProfileId>) {
+            globalPrefs.edit {
+                for (id in ids) {
+                    remove(id.value)
+                }
+            }
+        }
+
         fun contains(id: ProfileId): Boolean = globalPrefs.contains(id.value)
     }
 

AnkiDroid/src/test/java/com/ichi2/anki/multiprofile/ProfileManagerTest.kt

@@ -36,6 +36,7 @@ import io.mockk.unmockkAll
 import io.mockk.verify
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
@@ -200,4 +201,104 @@ class ProfileManagerTest {
         assertEquals(1, allProfiles.size)
         assertTrue(allProfiles.containsKey(ProfileId.DEFAULT))
     }
+
+    @Test
+    fun `deleteProfile removes profile from registry`() {
+        val manager = ProfileManager.create(context)
+        val profileId = manager.createNewProfile("Temporary")
+
+        manager.deleteProfile(profileId)
+
+        val allProfiles = manager.getAllProfiles()
+        assertFalse(allProfiles.containsKey(profileId))
+    }
+
+    @Test
+    fun `deleteProfile allows deleting default when not active`() {
+        val manager = ProfileManager.create(context)
+        val other = manager.createNewProfile("Other")
+
+        prefs.edit(commit = true) {
+            putString(KEY_LAST_ACTIVE_PROFILE_ID, other.value)
+        }
+
+        val freshManager = ProfileManager.create(context)
+        freshManager.deleteProfile(ProfileId.DEFAULT)
+
+        assertFalse(freshManager.getAllProfiles().containsKey(ProfileId.DEFAULT))
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `deleteProfile throws when deleting active profile`() {
+        val manager = ProfileManager.create(context)
+        val profileId = manager.createNewProfile("Active")
+
+        prefs.edit(commit = true) {
+            putString(KEY_LAST_ACTIVE_PROFILE_ID, profileId.value)
+        }
+
+        val freshManager = ProfileManager.create(context)
+        freshManager.deleteProfile(profileId)
+    }
+
+    @Test
+    fun `deleteProfiles removes all specified profiles`() {
+        val manager = ProfileManager.create(context)
+        val profile1 = manager.createNewProfile("One")
+        val profile2 = manager.createNewProfile("Two")
+        val profile3 = manager.createNewProfile("Three")
+
+        manager.deleteProfiles(listOf(profile1, profile2, profile3))
+
+        val allProfiles = manager.getAllProfiles()
+        assertEquals(1, allProfiles.size)
+        assertTrue(allProfiles.containsKey(ProfileId.DEFAULT))
+    }
+
+    @Test
+    fun `deleteProfiles does not remove profiles outside the list`() {
+        val manager = ProfileManager.create(context)
+        val keep = manager.createNewProfile("Keep")
+        val remove1 = manager.createNewProfile("Remove1")
+        val remove2 = manager.createNewProfile("Remove2")
+
+        manager.deleteProfiles(listOf(remove1, remove2))
+
+        val allProfiles = manager.getAllProfiles()
+        assertEquals(2, allProfiles.size)
+        assertTrue(allProfiles.containsKey(ProfileId.DEFAULT))
+        assertTrue(allProfiles.containsKey(keep))
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `deleteProfiles throws if active profile is in the list`() {
+        val manager = ProfileManager.create(context)
+        val profile1 = manager.createNewProfile("One")
+        val profile2 = manager.createNewProfile("Two")
+
+        prefs.edit(commit = true) {
+            putString(KEY_LAST_ACTIVE_PROFILE_ID, profile1.value)
+        }
+
+        val freshManager = ProfileManager.create(context)
+        freshManager.deleteProfiles(listOf(profile1, profile2))
+    }
+
+    @Test
+    fun `deleteProfiles is atomic - nothing deleted if one ID is active`() {
+        val manager = ProfileManager.create(context)
+        val valid = manager.createNewProfile("Valid")
+
+        val before = manager.getAllProfiles().size
+
+        try {
+            // default is active, so this should fail
+            manager.deleteProfiles(listOf(valid, ProfileId.DEFAULT))
+        } catch (_: IllegalArgumentException) {
+            // expected
+        }
+
+        assertEquals(before, manager.getAllProfiles().size)
+        assertTrue(manager.getAllProfiles().containsKey(valid))
+    }
 }