Improve credential grouping and sorting (#2117)

<!--
Note: This checklist is a reminder of our shared engineering expectations. 
The items in Bold are required
If your PR involves UI changes:
    1. Upload screenshots or screencasts that illustrate the changes before / after
    2. Add them under the UI changes section (feel free to add more columns if needed)
    3. Make sure these changes are tested in API 23 and API 26
If your PR does not involve UI changes, you can remove the **UI changes** section
-->

Task/Issue URL: https://app.asana.com/0/0/1202698381206771/f 

### Description
Improves the grouping and sorting of credentials in the management list view, taking into consideration accented characters, non standard-English letters, numbers etc... and applies a natural sorting to them.

### Steps to test this PR

- [x] Generate half a dozen different logins on any site
- [x] Edit one to have a title starting with a number; verify it gets its own numerical grouping
- [x] Edit one to have a title starting with a character (e.g, `$`); verify it gets put into the `#` placeholder
- [x] Edit one to have a title starting with an accented character (e.g, `ç`); verify it gets put alongside its base letter (e.g., `c`)
- [x] Edit one to have a title starting with a non-english letter (e.g, `あ`); verify it gets its own grouping

Repeat the above with adding the cases above into the domain instead of title

Author: CDRussell

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/ui/credential/management/AutofillCharacterValidator.kt

@@ -26,6 +26,7 @@ import com.duckduckgo.app.browser.favicon.FaviconManager
 import com.duckduckgo.autofill.domain.app.LoginCredentials
 import com.duckduckgo.autofill.impl.databinding.ItemRowAutofillCredentialsManagementScreenBinding
 import com.duckduckgo.autofill.impl.databinding.ItemRowAutofillCredentialsManagementScreenHeaderBinding
+import com.duckduckgo.autofill.ui.credential.management.sorting.CredentialGrouper
 import kotlinx.coroutines.launch
 
 class AutofillManagementRecyclerAdapter(
@@ -109,7 +110,7 @@ class AutofillManagementRecyclerAdapter(
 
     sealed class ListItem {
         data class Credential(val credentials: LoginCredentials) : ListItem()
-        data class GroupHeading(val initial: Char) : ListItem()
+        data class GroupHeading(val initial: String) : ListItem()
     }
 
     companion object {

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/ui/credential/management/AutofillManagementRecyclerAdapter.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2022 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.duckduckgo.autofill.ui.credential.management.sorting
+
+import com.duckduckgo.autofill.domain.app.LoginCredentials
+import com.duckduckgo.autofill.ui.credential.management.AutofillManagementRecyclerAdapter.ListItem
+import java.util.*
+import javax.inject.Inject
+
+class CredentialGrouper @Inject constructor(
+    private val initialExtractor: InitialExtractor,
+    private val sorter: CredentialListSorter
+) {
+
+    fun group(unsortedCredentials: List<LoginCredentials>): List<ListItem> {
+        val unsortedGroups = buildGroups(unsortedCredentials)
+        val sortedGroups = sortGroups(unsortedGroups)
+        return buildFlatList(sortedGroups)
+    }
+
+    private fun buildFlatList(sortedGroups: SortedMap<String, MutableList<LoginCredentials>>): MutableList<ListItem> {
+        val flattenedList = mutableListOf<ListItem>()
+
+        sortedGroups.forEach { (key, value) ->
+            flattenedList.add(ListItem.GroupHeading(key))
+
+            sorter.sort(value).forEach {
+                flattenedList.add(ListItem.Credential(it))
+            }
+        }
+
+        return flattenedList
+    }
+
+    private fun sortGroups(groups: MutableMap<String, MutableList<LoginCredentials>>): SortedMap<String, MutableList<LoginCredentials>> {
+        return groups.toSortedMap(sorter.comparator())
+    }
+
+    private fun buildGroups(unsortedCredentials: List<LoginCredentials>): MutableMap<String, MutableList<LoginCredentials>> {
+        val groups = mutableMapOf<String, MutableList<LoginCredentials>>()
+        unsortedCredentials.forEach { credential ->
+            val initial = initialExtractor.extractInitial(credential)
+            val list = groups.getOrPut(initial) { mutableListOf() }
+            list.add(credential)
+        }
+        return groups
+    }
+
+}

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/ui/credential/management/CredentialGrouper.kt

@@ -14,45 +14,61 @@
  * limitations under the License.
  */
 
-package com.duckduckgo.autofill.ui.credential.management
+package com.duckduckgo.autofill.ui.credential.management.sorting
 
 import com.duckduckgo.autofill.AutofillDomainFormatter
 import com.duckduckgo.autofill.domain.app.LoginCredentials
 import com.duckduckgo.di.scopes.FragmentScope
 import com.squareup.anvil.annotations.ContributesBinding
+import timber.log.Timber
+import java.lang.Character.*
+import java.text.Normalizer
 import javax.inject.Inject
 
 interface InitialExtractor {
-    fun extractInitial(loginCredentials: LoginCredentials): Char
-    fun extractInitialFromTitle(loginCredentials: LoginCredentials): Char?
-    fun extractInitialFromDomain(loginCredentials: LoginCredentials): Char?
+    fun extractInitial(loginCredentials: LoginCredentials): String
+    fun extractInitialFromTitle(loginCredentials: LoginCredentials): String?
+    fun extractInitialFromDomain(loginCredentials: LoginCredentials): String?
 }
 
 @ContributesBinding(FragmentScope::class)
 class CredentialInitialExtractor @Inject constructor(
-    private val domainFormatter: AutofillDomainFormatter,
-    private val characterValidator: AutofillCharacterValidator
+    private val domainFormatter: AutofillDomainFormatter
 ) : InitialExtractor {
 
-    override fun extractInitial(loginCredentials: LoginCredentials): Char {
-        val initial = extractInitialFromTitle(loginCredentials) ?: extractInitialFromDomain(loginCredentials)
+    override fun extractInitial(loginCredentials: LoginCredentials): String {
+        val rawInitial =
+            extractInitialFromTitle(loginCredentials) ?: extractInitialFromDomain(loginCredentials) ?: return INITIAL_CHAR_FOR_NON_LETTERS
 
-        if (initial == null || !characterValidator.isLetter(initial)) {
-            return INITIAL_CHAR_FOR_NON_LETTERS
+        return when (val type = getCharacterType(rawInitial)) {
+            LOWERCASE_LETTER,
+            UPPERCASE_LETTER,
+            OTHER_LETTER,
+            DECIMAL_DIGIT_NUMBER
+            -> {
+                Normalizer.normalize(rawInitial, Normalizer.Form.NFKD).firstOrNull()?.toString() ?: INITIAL_CHAR_FOR_NON_LETTERS
+            }
+            else -> {
+                Timber.v("Rejecting type %d for %s", type, rawInitial)
+                INITIAL_CHAR_FOR_NON_LETTERS
+            }
         }
+    }
 
-        return initial.uppercaseChar()
+    private fun getCharacterType(rawInitial: String): Byte {
+        val initial = rawInitial.firstOrNull() ?: return UNASSIGNED
+        return getType(initial).toByte()
     }
 
-    override fun extractInitialFromTitle(loginCredentials: LoginCredentials): Char? {
-        return loginCredentials.domainTitle?.firstOrNull()?.uppercaseChar()
+    override fun extractInitialFromTitle(loginCredentials: LoginCredentials): String? {
+        return loginCredentials.domainTitle?.firstOrNull()?.uppercaseChar()?.toString()
     }
 
-    override fun extractInitialFromDomain(loginCredentials: LoginCredentials): Char? {
-        return domainFormatter.extractDomain(loginCredentials.domain)?.firstOrNull()?.uppercaseChar()
+    override fun extractInitialFromDomain(loginCredentials: LoginCredentials): String? {
+        return domainFormatter.extractDomain(loginCredentials.domain)?.firstOrNull()?.uppercaseChar()?.toString()
     }
 
     companion object {
-        const val INITIAL_CHAR_FOR_NON_LETTERS = '#'
+        const val INITIAL_CHAR_FOR_NON_LETTERS = "#"
     }
 }