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

@@ -183,6 +183,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?)
@@ -206,6 +207,7 @@ class MentionAutocompleteView extends ChangeNotifier {
   /// Called in particular when we get a [RealmUserEvent].
   void refreshStaleUserResults() {
     if (_query != null) {
+      _sortedUsers = null;
       _startSearch(_query!);
     }
   }
@@ -244,11 +246,116 @@ class MentionAutocompleteView extends ChangeNotifier {
     notifyListeners();
   }
 
+  List<User>? _sortedUsers;
+
+  int compareByDms(User userA, User userB) {
+    final aRecencyIndex = store.recentDmConversationsView.getRecencyIndex(userA.userId);
+    final bRecencyIndex = store.recentDmConversationsView.getRecencyIndex(userB.userId);
+
+    if (aRecencyIndex > bRecencyIndex) {
+      return -1;
+    } else if (bRecencyIndex > aRecencyIndex) {
+      return 1;
+    }
+
+    final aIsPartner = store.recentDmConversationsView.isPartner(userA.userId);
+    final bIsPartner = store.recentDmConversationsView.isPartner(userB.userId);
+
+    // This code will never run except in the rare case that one has no
+    // recent DM message history with a user, but does have some older
+    // message history.
+    if (aIsPartner && !bIsPartner) {
+      return -1;
+    } else if (bIsPartner && !aIsPartner) {
+      return 1;
+    }
+
+    if (!userA.isBot && userB.isBot) {
+      return -1;
+    } else if (userA.isBot && !userB.isBot) {
+      return 1;
+    }
+
+    if (userA.fullName.toLowerCase().compareTo(
+      userB.fullName.toLowerCase()) < 0) {
+      return -1;
+    }
+    return 1;
+  }
+
+  int compareByRelevance({
+    required User userA,
+    required User userB,
+    int Function(User, User)? compareByCurrentConversation,
+  }) {
+    // TODO(#234): give preference to "all", "everyone" or "stream".
+
+    // TODO(#618): give preference to subscribed users first.
+
+    if (compareByCurrentConversation != null) {
+      final preference = compareByCurrentConversation(userA, userB);
+      if (preference != 0) {
+        return preference;
+      }
+    }
+
+    return compareByDms(userA, userB);
+  }
+
+  List<User> sortByRelevance({
+    required List<User> users,
+    required int? currentStreamId,
+    required String? currentTopic,
+  }) {
+    // Sorting for DMs narrow
+    if (currentStreamId == null) {
+      users.sort((userA, userB) => compareByRelevance(
+        userA: userA,
+        userB: userB));
+    } else { // Sorting for stream/topic narrow
+      users.sort((userA, userB) => compareByRelevance(
+        userA: userA,
+        userB: userB,
+        compareByCurrentConversation: (userA, userB) => store.recentSenders.compareByRecency(
+          userA: userA,
+          userB: userB,
+          streamId: currentStreamId,
+          topic: currentTopic)));
+    }
+    return users;
+  }
+
+  void _sortUsers() {
+    final users = store.users.values.toList();
+    switch(narrow) {
+      case StreamNarrow():
+        _sortedUsers = sortByRelevance(
+            users: users,
+            currentStreamId: (narrow as StreamNarrow).streamId,
+            currentTopic: null);
+      case TopicNarrow():
+        _sortedUsers = sortByRelevance(
+            users: users,
+            currentStreamId: (narrow as TopicNarrow).streamId,
+            currentTopic: (narrow as TopicNarrow).topic);
+      case DmNarrow():
+        _sortedUsers = sortByRelevance(
+            users: users,
+            currentStreamId: null,
+            currentTopic: null);
+      case AllMessagesNarrow():
+        _sortedUsers = []; // TODO: sort (maybe in future)
+    }
+  }
+
   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;
     bool isDone = false;
     while (!isDone) {
       // CPU perf: End this task; enqueue a new one for resuming this work
@@ -270,7 +377,7 @@ class MentionAutocompleteView extends ChangeNotifier {
         }
       }
     }
-    return results; // TODO(#228) sort for most relevant first
+    return results;
   }
 }
 

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.processStreamMessage(message);
       }
     }
     _fetched = true;

lib/model/recent_dm_conversations.dart

@@ -11,35 +11,53 @@ import 'narrow.dart';
 /// This maintains the list of recent DM conversations,
 /// plus additional data in order to efficiently maintain the list.
 class RecentDmConversationsView extends ChangeNotifier {
-  factory RecentDmConversationsView({
+  RecentDmConversationsView({
     required List<RecentDmConversation> initial,
-    required selfUserId,
+    required this.selfUserId,
   }) {
-    final entries = initial.map((conversation) => MapEntry(
-        DmNarrow.ofRecentDmConversation(conversation, selfUserId: selfUserId),
-        conversation.maxMessageId,
-      )).toList()..sort((a, b) => -a.value.compareTo(b.value));
-    return RecentDmConversationsView._(
-      map: Map.fromEntries(entries),
-      sorted: QueueList.from(entries.map((e) => e.key)),
-      selfUserId: selfUserId,
-    );
-  }
+    final entries = <MapEntry<DmNarrow, int>>[];
+    for (final conversation in initial) {
+      entries.add(MapEntry(
+          DmNarrow.ofRecentDmConversation(conversation, selfUserId: selfUserId),
+          conversation.maxMessageId));
 
-  RecentDmConversationsView._({
-    required this.map,
-    required this.sorted,
-    required this.selfUserId,
-  });
+      for (final userId in conversation.userIds) {
+        if (userId == selfUserId) {
+          continue;
+        }
+        _addRecencyIndex(userId: userId, maxId: conversation.maxMessageId);
+      }
+    }
+    entries.sort((a, b) => -a.value.compareTo(b.value));
+    map = Map.fromEntries(entries);
+    sorted = QueueList.from(entries.map((e) => e.key));
+  }
 
   /// The latest message ID in each conversation.
-  final Map<DmNarrow, int> map;
+  late final Map<DmNarrow, int> map;
 
   /// The [DmNarrow] keys of the map, sorted by latest message descending.
-  final QueueList<DmNarrow> sorted;
+  late final QueueList<DmNarrow> sorted;
 
   final int selfUserId;
 
+  // The ID of the latest messages exchanged with other users.
+  final Map<int, int> _dmRecencyData = {};
+
+  /// The ID of the latest message exchanged with this user.
+  ///
+  /// Returns -1 if there has been no DM message exchanged ever.
+  int getRecencyIndex(final int userId) => _dmRecencyData[userId] ?? -1;
+
+  void _addRecencyIndex({required int userId, required int maxId}) {
+    final oldMaxId = _dmRecencyData[userId] ?? -1;
+    if (maxId > oldMaxId) {
+      _dmRecencyData[userId] = maxId;
+    }
+  }
+
+  bool isPartner(final int userId) => getRecencyIndex(userId) != -1;
+
   /// Insert the key at the proper place in [sorted].
   ///
   /// Optimized, taking O(1) time, for the case where that place is the start,

lib/model/recent_senders.dart

@@ -0,0 +1,146 @@
+
+import 'dart:math' as math;
+
+import '../api/model/model.dart';
+
+extension Max<T extends num> on Iterable<T> {
+  /// Finds the maximum number in an [Iterable].
+  ///
+  /// Returns null if the [Iterable] is empty.
+  T? max() => isNotEmpty ? reduce(math.max) : null;
+}
+
+/// A data structure to keep track of message ids.
+class IdTracker {
+  final Set<int> _ids = {};
+
+  int _maxId = -1;
+
+  void add(int id) {
+    _ids.add(id);
+
+    if (id > _maxId) {
+      _maxId = id;
+    }
+  }
+
+  // TODO: remove
+
+  int maxId() {
+    if (_maxId == -1) {
+      _maxId = _ids.max() ?? -1;
+    }
+    return _maxId;
+  }
+
+  @override
+  String toString() {
+    return _ids.toString();
+  }
+}
+
+/// A data structure to keep track of stream and topic messages.
+///
+/// The owner should call [clear] in order to free resources.
+class RecentSenders {
+  // streamSenders[streamId][senderId] = IdTracker
+  final Map<int, Map<int, IdTracker>> _streamSenders = {};
+
+  // topicSenders[streamId][topic][senderId] = IdTracker
+  final Map<int, Map<String, Map<int, IdTracker>>> _topicSenders = {};
+
+  void clear() {
+    _streamSenders.clear();
+    _topicSenders.clear();
+  }
+
+  int maxIdForStreamSender({required int streamId, required int senderId}) {
+    return _streamSenders[streamId]?[senderId]?.maxId() ?? -1;
+  }
+
+  int maxIdForStreamTopicSender({
+    required int streamId,
+    required String topic,
+    required int senderId,
+  }) {
+    topic = topic.toLowerCase();
+    return _topicSenders[streamId]?[topic]?[senderId]?.maxId() ?? -1;
+  }
+
+  void addStreamMessage({
+    required int streamId,
+    required int senderId,
+    required messageId,
+  }) {
+    final senderMap = _streamSenders[streamId] ?? {};
+    final idTracker = senderMap[senderId] ?? IdTracker();
+    _streamSenders[streamId] = senderMap;
+    senderMap[senderId] = idTracker;
+    idTracker.add(messageId);
+  }
+
+  void addTopicMessage({
+    required int streamId,
+    required String topic,
+    required int senderId,
+    required messageId,
+  }) {
+    topic = topic.toLowerCase();
+    final topicMap = _topicSenders[streamId] ?? {};
+    final senderMap = topicMap[topic] ?? {};
+    final idTracker = senderMap[senderId] ?? IdTracker();
+    _topicSenders[streamId] = topicMap;
+    topicMap[topic] = senderMap;
+    senderMap[senderId] = idTracker;
+    idTracker.add(messageId);
+  }
+
+  void processStreamMessage(Message message) {
+    if (message is! StreamMessage) {
+      return;
+    }
+
+    final streamId = message.streamId;
+    final topic = message.subject;
+    final senderId = message.senderId;
+    final messageId = message.id;
+
+    addStreamMessage(
+        streamId: streamId, senderId: senderId, messageId: messageId);
+    addTopicMessage(
+        streamId: streamId,
+        topic: topic,
+        senderId: senderId,
+        messageId: messageId);
+  }
+
+  // TODO: removeTopicMessage
+
+  int compareByRecency({
+    required User userA,
+    required User userB,
+    required int streamId,
+    // TODO(#493): may turn this into a non-nullable string.
+    required String? topic,
+  }) {
+    int aMessageId, bMessageId;
+
+    if (topic != null) {
+      aMessageId = maxIdForStreamTopicSender(
+          streamId: streamId, topic: topic, senderId: userA.userId);
+      bMessageId = maxIdForStreamTopicSender(
+          streamId: streamId, topic: topic, senderId: userB.userId);
+
+      if (aMessageId != bMessageId) {
+        return bMessageId - aMessageId;
+      }
+    }
+
+    aMessageId =
+        maxIdForStreamSender(streamId: streamId, senderId: userA.userId);
+    bMessageId =
+        maxIdForStreamSender(streamId: streamId, senderId: userB.userId);
+
+    return bMessageId - aMessageId;
+  }
+}