autocomplete: Sort user-mention autocomplete results

The @-mention autocomplete shows relevant results in the following order
of priority:
  * Recent conversation users
  * Recent DM users
  * Alphabetical order

Fixes: zulip#228

Author: sm-sayedi

lib/model/autocomplete.dart

@@ -145,6 +145,18 @@ class AutocompleteViewManager {
     autocompleteDataCache.invalidateUser(event.userId);
   }
 
+  void handleMessageEvent(MessageEvent event) {
+    for (final view in _mentionAutocompleteViews) {
+      view.refreshStaleUserResults();
+    }
+  }
+
+  void handleOlderMessages() {
+    for (final view in _mentionAutocompleteViews) {
+      view.refreshStaleUserResults();
+    }
+  }
+
   /// Called when the app is reassembled during debugging, e.g. for hot reload.
   ///
   /// Calls [MentionAutocompleteView.reassemble] for all that are registered.
@@ -190,6 +202,7 @@ class MentionAutocompleteView extends ChangeNotifier {
   @override
   void dispose() {
     store.autocompleteViewManager.unregisterMentionAutocomplete(this);
+    _sortedUsers = null;
     // We cancel in-progress computations by checking [hasListeners] between tasks.
     // After [super.dispose] is called, [hasListeners] returns false.
     // TODO test that logic (may involve detecting an unhandled Future rejection; how?)
@@ -213,6 +226,7 @@ class MentionAutocompleteView extends ChangeNotifier {
   /// Called in particular when we get a [RealmUserEvent].
   void refreshStaleUserResults() {
     if (_query != null) {
+      _sortedUsers = null;
       _startSearch(_query!);
     }
   }
@@ -222,6 +236,7 @@ class MentionAutocompleteView extends ChangeNotifier {
   /// This will redo the search from scratch for the current query, if any.
   void reassemble() {
     if (_query != null) {
+      _sortedUsers = null;
       _startSearch(_query!);
     }
   }
@@ -251,11 +266,95 @@ class MentionAutocompleteView extends ChangeNotifier {
     notifyListeners();
   }
 
+  List<User>? _sortedUsers;
+
+  int compareByRelevance({
+    required User userA,
+    required User userB,
+    required int? streamId,
+    required String? topic,
+  }) {
+    // TODO(#234): give preference to "all", "everyone" or "stream".
+
+    // TODO(#618): give preference to subscribed users first.
+
+    if (streamId != null) {
+      final conversationPrecedence = store.recentSenders.compareByRecency(
+        userA,
+        userB,
+        streamId: streamId,
+        topic: topic);
+      if (conversationPrecedence != 0) {
+        return conversationPrecedence;
+      }
+    }
+
+    final dmPrecedence = store.recentDmConversationsView.compareByDms(userA, userB);
+    if (dmPrecedence != 0) {
+      return dmPrecedence;
+    }
+
+    if (!userA.isBot && userB.isBot) {
+      return -1;
+    } else if (userA.isBot && !userB.isBot) {
+      return 1;
+    }
+
+    final userAName = store.autocompleteViewManager.autocompleteDataCache
+      .normalizedNameForUser(userA);
+    final userBName = store.autocompleteViewManager.autocompleteDataCache
+      .normalizedNameForUser(userB);
+    return userAName.compareTo(userBName);
+  }
+
+  List<User> sortByRelevance({
+    required List<User> users,
+    required Narrow narrow,
+  }) {
+    switch (narrow) {
+      case StreamNarrow():
+        users.sort((userA, userB) => compareByRelevance(
+          userA: userA,
+          userB: userB,
+          streamId: narrow.streamId,
+          topic: null));
+      case TopicNarrow():
+        users.sort((userA, userB) => compareByRelevance(
+          userA: userA,
+          userB: userB,
+          streamId: narrow.streamId,
+          topic: narrow.topic));
+      case DmNarrow():
+        users.sort((userA, userB) => compareByRelevance(
+          userA: userA,
+          userB: userB,
+          streamId: null,
+          topic: null));
+      case AllMessagesNarrow():
+        // do nothing in this case for now
+    }
+    return users;
+  }
+
+  void _sortUsers() {
+    final users = store.users.values.toList();
+    _sortedUsers = sortByRelevance(users: users, narrow: narrow);
+  }
+
+  bool _areUsersModified = false;
+  void _usersModified() {
+    _areUsersModified = true;
+  }
+
   Future<List<MentionAutocompleteResult>?> _computeResults(MentionAutocompleteQuery query) async {
     final List<MentionAutocompleteResult> results = [];
-    final Iterable<User> users = store.users.values;
 
-    final iterator = users.iterator;
+    if (_sortedUsers == null) {
+      _sortUsers();
+    }
+
+    final iterator = _sortedUsers!.iterator;
+    store.users.addListener(_usersModified);
     bool isDone = false;
     while (!isDone) {
       // CPU perf: End this task; enqueue a new one for resuming this work
@@ -266,7 +365,12 @@ class MentionAutocompleteView extends ChangeNotifier {
       }
 
       for (int i = 0; i < 1000; i++) {
-        if (!iterator.moveNext()) { // Can throw ConcurrentModificationError
+        if (_areUsersModified) {
+          _areUsersModified = false;
+          _sortedUsers = null;
+          throw ConcurrentModificationError();
+        }
+        if (!iterator.moveNext()) {
           isDone = true;
           break;
         }
@@ -277,7 +381,8 @@ class MentionAutocompleteView extends ChangeNotifier {
         }
       }
     }
-    return results; // TODO(#228) sort for most relevant first
+    store.users.removeListener(_usersModified);
+    return results;
   }
 }
 
@@ -337,13 +442,22 @@ class MentionAutocompleteQuery {
 }
 
 class AutocompleteDataCache {
+  final Map<int, String> _normalizedNamesByUser = {};
+
+  /// The lowercase `fullName` of [user].
+  String normalizedNameForUser(User user) {
+    return _normalizedNamesByUser[user.userId] ??= user.fullName.toLowerCase();
+  }
+
   final Map<int, List<String>> _nameWordsByUser = {};
 
   List<String> nameWordsForUser(User user) {
-    return _nameWordsByUser[user.userId] ??= user.fullName.toLowerCase().split(' ');
+    return _nameWordsByUser[user.userId] ??=
+      normalizedNameForUser(user).split(' ');
   }
 
   void invalidateUser(int userId) {
+    _normalizedNamesByUser.remove(userId);
     _nameWordsByUser.remove(userId);
   }
 }

lib/model/message_list.dart

@@ -381,6 +381,7 @@ class MessageListView with ChangeNotifier, _MessageSequence {
     for (final message in result.messages) {
       if (_messageVisible(message)) {
         _addMessage(message);
+        store.recentSenders.handleMessage(message);
       }
     }
     _fetched = true;
@@ -417,6 +418,11 @@ class MessageListView with ChangeNotifier, _MessageSequence {
         ? result.messages // Avoid unnecessarily copying the list.
         : result.messages.where(_messageVisible);
 
+      for (final message in fetchedMessages) {
+        store.recentSenders.handleMessage(message);
+      }
+      store.autocompleteViewManager.handleOlderMessages();
+
       _insertAllMessages(0, fetchedMessages);
       _haveOldest = result.foundOldest;
     } finally {

lib/model/recent_dm_conversations.dart

@@ -19,16 +19,30 @@ class RecentDmConversationsView extends ChangeNotifier {
         DmNarrow.ofRecentDmConversation(conversation, selfUserId: selfUserId),
         conversation.maxMessageId,
       )).toList()..sort((a, b) => -a.value.compareTo(b.value));
+    final map = Map.fromEntries(entries);
+    final sorted = QueueList.from(entries.map((e) => e.key));
+
+    final msgsByUser = <int, int>{};
+    for (final dmNarrow in sorted) {
+      for (final userId in dmNarrow.otherRecipientIds) {
+        // only take the latest message of a user among all the conversations.
+        if (!msgsByUser.containsKey(userId)) {
+          msgsByUser[userId] = map[dmNarrow]!;
+        }
+      }
+    }
     return RecentDmConversationsView._(
-      map: Map.fromEntries(entries),
-      sorted: QueueList.from(entries.map((e) => e.key)),
+      map: map,
+      sorted: sorted,
+      latestMessagesByRecipient: msgsByUser,
       selfUserId: selfUserId,
     );
   }
 
   RecentDmConversationsView._({
     required this.map,
     required this.sorted,
+    required this.latestMessagesByRecipient,
     required this.selfUserId,
   });
 
@@ -38,8 +52,24 @@ class RecentDmConversationsView extends ChangeNotifier {
   /// The [DmNarrow] keys of [map], sorted by latest message descending.
   final QueueList<DmNarrow> sorted;
 
+  /// Map from user ID to the latest message ID in any conversation with the user.
+  ///
+  /// Both 1:1 and group DM conversations are considered.
+  /// The self-user ID is excluded even if there is a self-DM conversation.
+  ///
+  /// (The identified message was not necessarily sent by the identified user;
+  /// it might have been sent by anyone in its conversation.)
+  final Map<int, int> latestMessagesByRecipient;
+
   final int selfUserId;
 
+  int compareByDms(User userA, User userB) {
+    final aLatestMessageId = latestMessagesByRecipient[userA.userId] ?? -1;
+    final bLatestMessageId = latestMessagesByRecipient[userB.userId] ?? -1;
+
+    return bLatestMessageId.compareTo(aLatestMessageId);
+  }
+
   /// Insert the key at the proper place in [sorted].
   ///
   /// Optimized, taking O(1) time, for the case where that place is the start,
@@ -117,6 +147,14 @@ class RecentDmConversationsView extends ChangeNotifier {
         _insertSorted(key, message.id);
       }
     }
+    for (final recipient in key.otherRecipientIds) {
+      latestMessagesByRecipient.update(
+        recipient,
+        (latestMessageId) =>
+            message.id > latestMessageId ? message.id : latestMessageId,
+        ifAbsent: () => message.id,
+      );
+    }
     notifyListeners();
   }