autocomplete: Add "recent DM conversations" criterion

In @-mention autocomplete, users are suggested based on:
  1. Recent DM conversations.

Fixes part of: #228

Author: sm-sayedi

lib/model/autocomplete.dart

@@ -175,7 +175,7 @@ class MentionAutocompleteView extends ChangeNotifier {
     required Narrow narrow,
   }) {
     final users = store.users.values.toList();
-    final sortedUsers = sortByRelevance(users: users);
+    final sortedUsers = sortByRelevance(users: users, narrow: narrow, store: store);
     final view = MentionAutocompleteView._(
       store: store,
       narrow: narrow,
@@ -185,8 +185,49 @@ class MentionAutocompleteView extends ChangeNotifier {
     return view;
   }
 
-  static List<User> sortByRelevance({required List<User> users}) {
-    return users; // TODO(#228) sort for most relevant first
+  static List<User> sortByRelevance({
+    required List<User> users,
+    required Narrow narrow,
+    required PerAccountStore store,
+  }) {
+    switch (narrow) {
+      case StreamNarrow():
+      case TopicNarrow():
+      case DmNarrow():
+        users.sort((userA, userB) => compareByRelevance(
+          userA: userA, userB: userB, store: store));
+      case CombinedFeedNarrow():
+        // do nothing in this case for now
+    }
+    return users;
+  }
+
+  static int compareByRelevance({
+    required User userA,
+    required User userB,
+    required PerAccountStore store,
+  }) {
+    final dmPrecedence = compareByDms(userA, userB, store: store);
+    return dmPrecedence;
+  }
+
+  /// Determines which of the two users is more recent in DM conversations.
+  ///
+  /// Returns a negative number if [userA] is more recent than [userB],
+  /// returns a positive number if [userB] is more recent than [userA],
+  /// and returns `0` if both [userA] and [userB] are equally recent
+  /// or there is no DM exchanged with them whatsoever.
+  static int compareByDms(User userA, User userB, {required PerAccountStore store}) {
+    final recentDms = store.recentDmConversationsView;
+    final aLatestMessageId = recentDms.latestMessagesByRecipient[userA.userId];
+    final bLatestMessageId = recentDms.latestMessagesByRecipient[userB.userId];
+
+    return switch((aLatestMessageId, bLatestMessageId)) {
+      (int a, int b) => -a.compareTo(b),
+      (int(),     _) => -1,
+      (_,     int()) => 1,
+      _              => 0,
+    };
   }
 
   @override

test/model/autocomplete_test.dart

@@ -5,9 +5,11 @@ import 'package:checks/checks.dart';
 import 'package:fake_async/fake_async.dart';
 import 'package:flutter/cupertino.dart';
 import 'package:test/scaffolding.dart';
+import 'package:zulip/api/model/initial_snapshot.dart';
 import 'package:zulip/api/model/model.dart';
 import 'package:zulip/model/autocomplete.dart';
 import 'package:zulip/model/narrow.dart';
+import 'package:zulip/model/store.dart';
 import 'package:zulip/widgets/compose_box.dart';
 
 import '../example_data.dart' as eg;
@@ -318,4 +320,131 @@ void main() {
       doCheck('Four F', eg.user(fullName: 'Full Name Four Words'), false);
     });
   });
+
+  group('MentionAutocompleteView sorting users results', () {
+    late PerAccountStore store;
+
+    Future<void> prepare({
+      List<User> users = const [],
+      List<RecentDmConversation> dmConversations = const [],
+    }) async {
+      store = eg.store(initialSnapshot: eg.initialSnapshot(
+        recentPrivateConversations: dmConversations));
+      await store.addUsers(users);
+    }
+
+    group('MentionAutocompleteView.compareByDms', () {
+      test('has DMs with userA and userB, latest with userA, prioritizes userA', () async {
+        await prepare(dmConversations: [
+          RecentDmConversation(userIds: [1],    maxMessageId: 200),
+          RecentDmConversation(userIds: [1, 2], maxMessageId: 100),
+        ]);
+
+        final userA = eg.user(userId: 1);
+        final userB = eg.user(userId: 2);
+        final compareAB = MentionAutocompleteView.compareByDms(userA, userB, store: store);
+        check(compareAB).isNegative();
+      });
+
+      test('has DMs with userA and userB, latest with userB, prioritizes userB', () async {
+        await prepare(dmConversations: [
+          RecentDmConversation(userIds: [2],    maxMessageId: 200),
+          RecentDmConversation(userIds: [1, 2], maxMessageId: 100),
+        ]);
+
+        final userA = eg.user(userId: 1);
+        final userB = eg.user(userId: 2);
+        final compareAB = MentionAutocompleteView.compareByDms(userA, userB, store: store);
+        check(compareAB).isGreaterThan(0);
+      });
+
+      test('has DMs with userA and userB, equally recent, prioritizes neither', () async {
+        await prepare(dmConversations: [
+          RecentDmConversation(userIds: [1, 2], maxMessageId: 100),
+        ]);
+
+        final userA = eg.user(userId: 1);
+        final userB = eg.user(userId: 2);
+        final compareAB = MentionAutocompleteView.compareByDms(userA, userB, store: store);
+        check(compareAB).equals(0);
+      });
+
+      test('has DMs with userA but not userB, prioritizes userA', () async {
+        await prepare(dmConversations: [
+          RecentDmConversation(userIds: [1], maxMessageId: 100),
+        ]);
+
+        final userA = eg.user(userId: 1);
+        final userB = eg.user(userId: 2);
+        final compareAB = MentionAutocompleteView.compareByDms(userA, userB, store: store);
+        check(compareAB).isNegative();
+      });
+
+      test('has DMs with userB but not userA, prioritizes userB', () async {
+        await prepare(dmConversations: [
+          RecentDmConversation(userIds: [2], maxMessageId: 100),
+        ]);
+
+        final userA = eg.user(userId: 1);
+        final userB = eg.user(userId: 2);
+        final compareAB = MentionAutocompleteView.compareByDms(userA, userB, store: store);
+        check(compareAB).isGreaterThan(0);
+      });
+
+      test('doesn\'t have DMs with userA or userB, prioritizes neither', () async {
+        await prepare(dmConversations: []);
+
+        final userA = eg.user(userId: 1);
+        final userB = eg.user(userId: 2);
+        final compareAB = MentionAutocompleteView.compareByDms(userA, userB, store: store);
+        check(compareAB).equals(0);
+      });
+    });
+
+    test('autocomplete suggests relevant users in the following order: '
+      '1. Users most recent in the DM conversations', () async {
+      final users = [
+        eg.user(userId: 0),
+        eg.user(userId: 1),
+        eg.user(userId: 2),
+        eg.user(userId: 3),
+        eg.user(userId: 4),
+      ];
+
+      final dmConversations = [
+        RecentDmConversation(userIds: [3],    maxMessageId: 300),
+        RecentDmConversation(userIds: [0],    maxMessageId: 200),
+        RecentDmConversation(userIds: [0, 1], maxMessageId: 100),
+      ];
+
+      Future<void> checkResultsIn(Narrow narrow, {required List<int> expected}) async {
+        await prepare(users: users, dmConversations: dmConversations);
+        final view = MentionAutocompleteView.init(store: store, narrow: narrow);
+
+        bool done = false;
+        view.addListener(() { done = true; });
+        view.query = MentionAutocompleteQuery('');
+        await Future(() {});
+        check(done).isTrue();
+        final results = view.results
+          .map((e) => (e as UserMentionAutocompleteResult).userId)
+          .toList();
+        check(results).deepEquals(expected);
+      }
+
+      const streamNarrow = StreamNarrow(1);
+      await checkResultsIn(streamNarrow, expected: [3, 0, 1, 2, 4]);
+
+      const topicNarrow = TopicNarrow(1, 'topic');
+      await checkResultsIn(topicNarrow, expected: [3, 0, 1, 2, 4]);
+
+      final dmNarrow = DmNarrow(allRecipientIds: [eg.selfUser.userId], selfUserId: eg.selfUser.userId);
+      await checkResultsIn(dmNarrow, expected: [3, 0, 1, 2, 4]);
+
+      const allMessagesNarrow = CombinedFeedNarrow();
+      // Results are in the original order as we do not sort them for
+      // [CombinedFeedNarrow] because we can not access autocomplete for now.
+      await checkResultsIn(allMessagesNarrow, expected: [0, 1, 2, 3, 4]);
+    });
+  });
 }