feat: allow profile deletion

Introduce deleteProfile() for removing a single user profile.
Deletion removes both the registry entry (SharedPreferences) and
the on-disk data directory. The only guard is: the currently active
profile cannot be deleted, all other profiles including default
are deletable.

Author: criticalAY

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

@@ -229,6 +229,49 @@ class ProfileManager private constructor(
         // TODO: Implement process restart logic (e.g. ProcessPhoenix)
     }
 
+    /**
+     * Permanently deletes a profile, removing both its on-disk data
+     * directory and its registry entry.
+     *
+     * Scope of deletion is limited to the profile's private-storage
+     * directory (under `/storage/emulated/0/Android/data/com.ichi2.anki/files/...`):
+     * the collection database and any files the app writes inside that
+     * directory. Backups live in a separate, user-accessible location
+     * (`/storage/emulated/0/AnkiDroid/backups`) and are **not** touched
+     * here — their lifecycle is managed by the collection-folder guard
+     * elsewhere in the app. Deletion is irreversible.
+     *
+     * Ordering is important: the on-disk directory is removed **before**
+     * the registry entry. If the process is killed mid-operation, the
+     * registry entry survives, so the user can see the profile still
+     * exists (possibly in a half-deleted state) and retry the deletion.
+     * The reverse ordering would leak orphaned files on disk with no
+     * registry reference to clean them up later.
+     *
+     * @param profileId The [ProfileId] of the profile to delete.
+     * @throws IllegalArgumentException if [profileId] is the
+     *   currently active profile.
+     */
+    fun deleteProfile(profileId: ProfileId) {
+        require(profileRegistry.getLastActiveProfileId() != profileId) {
+            "Cannot delete the currently active profile ($profileId). Switch first."
+        }
+
+        val profileDir = resolveProfileDirectory(profileId)
+        if (profileDir.file.exists()) {
+            val deleted = profileDir.file.deleteRecursively()
+            if (!deleted) {
+                // Leave the registry entry intact so the user can retry.
+                Timber.w("Failed to fully delete profile directory for $profileId; registry entry preserved for retry")
+                return
+            }
+        }
+
+        profileRegistry.removeProfile(profileId)
+
+        Timber.i("Deleted profile: $profileId")
+    }
+
     /**
      * Holds the meta-data for a profile.
      * Converted to JSON for storage to allow future extensibility (e.g. avatars, themes).
@@ -327,6 +370,18 @@ class ProfileManager private constructor(
             return result
         }
 
+        /**
+         * Removes a profile entry from the registry.
+         *
+         * Does **not** delete the profile's data directory on disk.
+         * Callers are responsible for cleaning up file-system resources.
+         *
+         * @param id The [ProfileId] of the profile to remove.
+         */
+        fun removeProfile(id: ProfileId) {
+            globalPrefs.edit { 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,57 @@ 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 does not remove other profiles`() {
+        val manager = ProfileManager.create(context)
+        val keep = manager.createNewProfile("Keep")
+        val remove = manager.createNewProfile("Remove")
+
+        manager.deleteProfile(remove)
+
+        val allProfiles = manager.getAllProfiles()
+        assertEquals(2, allProfiles.size)
+        assertTrue(allProfiles.containsKey(ProfileId.DEFAULT))
+        assertTrue(allProfiles.containsKey(keep))
+    }
+
+    @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)
+    }
 }