autocomplete: Add "recent activity in current topic/stream" criterion

In @-mention autocomplete, users are suggested based on:
  1. Recent activity in the current topic/stream.
  2. Recent DM conversations.

Fixes part of: #228

Author: sm-sayedi

lib/model/autocomplete.dart

@@ -188,8 +188,92 @@ class MentionAutocompleteView extends ChangeNotifier {
     required Narrow narrow,
   }) {
     assert(narrow is! CombinedFeedNarrow);
-    return store.users.values.toList()
-      ..sort((userA, userB) => compareByDms(userA, userB, store: store));
+    final users = store.users.values.toList();
+    switch (narrow) {
+      case StreamNarrow():
+        users.sort((userA, userB) => _compareByRelevance(
+          userA: userA,
+          userB: userB,
+          streamId: narrow.streamId,
+          topic: null,
+          store: store));
+      case TopicNarrow():
+        users.sort((userA, userB) => _compareByRelevance(
+          userA: userA,
+          userB: userB,
+          streamId: narrow.streamId,
+          topic: narrow.topic,
+          store: store));
+      case DmNarrow():
+        users.sort((userA, userB) => _compareByRelevance(
+          userA: userA,
+          userB: userB,
+          streamId: null,
+          topic: null,
+          store: store));
+      case CombinedFeedNarrow():
+        // do nothing in this case for now
+    }
+    return users;
+  }
+
+  static int _compareByRelevance({
+    required User userA,
+    required User userB,
+    required int? streamId,
+    required String? topic,
+    required PerAccountStore store,
+  }) {
+    if (streamId != null) {
+      final result = compareByRecency(
+        userA,
+        userB,
+        streamId: streamId,
+        topic: topic,
+        store: store);
+      if (result != 0) {
+        return result;
+      }
+    }
+    return compareByDms(userA, userB, store: store);
+  }
+
+  /// Determines which of the two users has more recent activity in the topic/stream.
+  ///
+  /// First checks for the activity in [topic] if provided.
+  ///
+  /// If no [topic] is provided, or the activity in the topic is the same (which
+  /// is extremely rare) or there is no activity in the topic at all, then
+  /// checks for the activity in the stream with [streamId].
+  ///
+  /// Returns a negative number if [userA] has more recent activity than [userB],
+  /// returns a positive number if [userB] has more recent activity than [userA],
+  /// and returns `0` if both [userA] and [userB] have the same recent activity
+  /// (which is extremely rare) or has no activity at all.
+  @visibleForTesting
+  static int compareByRecency(
+    User userA,
+    User userB, {
+    required int streamId,
+    required String? topic,
+    required PerAccountStore store,
+  }) {
+    final recentSenders = store.recentSenders;
+    if (topic != null) {
+      final aMessageId = recentSenders.latestMessageIdOfSenderInTopic(
+        streamId: streamId, topic: topic, senderId: userA.userId);
+      final bMessageId = recentSenders.latestMessageIdOfSenderInTopic(
+        streamId: streamId, topic: topic, senderId: userB.userId);
+
+      final result = -compareNullable(aMessageId, bMessageId);
+      if (result != 0) return result;
+    }
+
+    final aMessageId = recentSenders.latestMessageIdOfSenderInStream(
+      streamId: streamId, senderId: userA.userId);
+    final bMessageId = recentSenders.latestMessageIdOfSenderInStream(
+      streamId: streamId, senderId: userB.userId);
+    return -compareNullable(aMessageId, bMessageId);
   }
 
   /// Determines which of the two users is more recent in DM conversations.
@@ -215,6 +299,7 @@ class MentionAutocompleteView extends ChangeNotifier {
   /// non-null and returns a positive number if [b] is null and [a] is non-null.
   ///
   /// If both are null, returns zero.
+  @visibleForTesting
   static int compareNullable(int? a, int? b) => switch ((a, b)) {
     (int a, int b) => a.compareTo(b),
     (int(),     _) => 1,

lib/model/message_list.dart

@@ -383,6 +383,7 @@ class MessageListView with ChangeNotifier, _MessageSequence {
       if (_messageVisible(message)) {
         _addMessage(message);
       }
+      store.recentSenders.handleMessage(message);
     }
     _fetched = true;
     _haveOldest = result.foundOldest;
@@ -420,6 +421,10 @@ 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);
+      }
+
       _insertAllMessages(0, fetchedMessages);
       _haveOldest = result.foundOldest;
     } finally {

test/model/autocomplete_test.dart

@@ -358,10 +358,12 @@ void main() {
     Future<void> prepare({
       List<User> users = const [],
       List<RecentDmConversation> dmConversations = const [],
+      List<Message> messages = const [],
     }) async {
       store = eg.store(initialSnapshot: eg.initialSnapshot(
         recentPrivateConversations: dmConversations));
       await store.addUsers(users);
+      await store.addMessages(messages);
     }
 
     group('MentionAutocompleteView.compareNullable', () {
@@ -378,6 +380,71 @@ void main() {
 
       test('both of [a] and [b] are null', () async {
         check(MentionAutocompleteView.compareNullable(null, null)).equals(0);
+        check(MentionAutocompleteView.compareNullable(null, null)).equals(0);
+      });
+    });
+
+    group('MentionAutocompleteView.compareByRecency', () {
+      final userA = eg.otherUser;
+      final userB = eg.thirdUser;
+      final stream = eg.stream();
+      const topic1 = 'topic1';
+      const topic2 = 'topic2';
+
+      Message message(User sender, String topic) {
+        return eg.streamMessage(
+          sender: sender,
+          stream: stream,
+          topic: topic,
+        );
+      }
+
+      /// Determines the priority between [userA] and [userB] based on their activity.
+      ///
+      /// The activity is first looked for in [topic] then in [stream].
+      ///
+      /// Returns a negative number if [userA] has more recent activity,
+      /// returns a positive number if [userB] has more recent activity, and
+      /// returns `0` if the activity is the same or there is no activity at all.
+      int compareAB({required String? topic}) {
+        return MentionAutocompleteView.compareByRecency(
+          userA,
+          userB,
+          streamId: stream.streamId,
+          topic: topic,
+          store: store,
+        );
+      }
+
+      test('prioritizes the user with more recent activity in the topic', () async {
+        await prepare(messages: [
+          message(userA, topic1),
+          message(userB, topic1),
+        ]);
+        check(compareAB(topic: topic1)).isGreaterThan(0);
+      });
+
+      test('prioritizes the user with more recent activity in the stream '
+        'if there is no activity in the topic from both users', () async {
+        await prepare(messages: [
+          message(userA, topic1),
+          message(userB, topic1),
+        ]);
+        check(compareAB(topic: topic2)).isGreaterThan(0);
+      });
+
+      test('prioritizes the user with more recent activity in the stream '
+        'if there is no topic provided', () async {
+        await prepare(messages: [
+          message(userA, topic1),
+          message(userB, topic2),
+        ]);
+        check(compareAB(topic: null)).isGreaterThan(0);
+      });
+
+      test('prioritizes none of the users if there is no activity in the stream from both users', () async {
+        await prepare(messages: []);
+        check(compareAB(topic: null)).equals(0);
       });
     });
 
@@ -435,8 +502,11 @@ void main() {
     });
 
     group('autocomplete suggests relevant users in the intended order', () {
-      // The order should be:
-      // 1. Users most recent in the DM conversations
+      // 1. Users most recent in the current topic/stream
+      // 2. Users most recent in the DM conversations
+
+      final stream = eg.stream();
+      const topic = 'topic';
 
       Future<void> checkResultsIn(Narrow narrow, {required List<int> expected}) async {
         final users = [
@@ -453,7 +523,22 @@ void main() {
           RecentDmConversation(userIds: [0, 1], maxMessageId: 100),
         ];
 
-        await prepare(users: users, dmConversations: dmConversations);
+        final messages = [
+          eg.streamMessage(
+            sender: users[0],
+            stream: stream,
+            topic: topic,
+          ),
+          eg.streamMessage(
+            sender: users[4],
+            stream: stream,
+          ),
+        ];
+
+        await prepare(
+          users: users,
+          dmConversations: dmConversations,
+          messages: messages);
         final view = MentionAutocompleteView.init(store: store, narrow: narrow);
 
         bool done = false;
@@ -467,11 +552,11 @@ void main() {
       }
 
       test('StreamNarrow', () async {
-        await checkResultsIn(const StreamNarrow(1), expected: [3, 0, 1, 2, 4]);
+        await checkResultsIn(StreamNarrow(stream.streamId), expected: [4, 0, 3, 1, 2]);
       });
 
       test('TopicNarrow', () async {
-        await checkResultsIn(const TopicNarrow(1, 'topic'), expected: [3, 0, 1, 2, 4]);
+        await checkResultsIn(TopicNarrow(stream.streamId, topic), expected: [0, 4, 3, 1, 2]);
       });
 
       test('DmNarrow', () async {