autocomplete: Add view-model ChannelLinkAutocompleteView

As of this commit, it's not yet possible in the app to initiate a
channel link autocomplete interaction. So in the widgets code that would
consume the results of such an interaction, we just throw for now,
leaving that to be implemented in a later commit.

Author: sm-sayedi

lib/model/autocomplete.dart

@@ -1,5 +1,6 @@
 import 'dart:math';
 
+import 'package:collection/collection.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:unorm_dart/unorm_dart.dart' as unorm;
@@ -10,6 +11,7 @@ import '../api/route/channels.dart';
 import '../generated/l10n/zulip_localizations.dart';
 import '../widgets/compose_box.dart';
 import 'algorithms.dart';
+import 'channel.dart';
 import 'compose.dart';
 import 'emoji.dart';
 import 'narrow.dart';
@@ -209,6 +211,7 @@ class AutocompleteViewManager {
   final Set<MentionAutocompleteView> _mentionAutocompleteViews = {};
   final Set<TopicAutocompleteView> _topicAutocompleteViews = {};
   final Set<EmojiAutocompleteView> _emojiAutocompleteViews = {};
+  final Set<ChannelLinkAutocompleteView> _channelLinkAutocompleteViews = {};
 
   AutocompleteDataCache autocompleteDataCache = AutocompleteDataCache();
 
@@ -242,6 +245,16 @@ class AutocompleteViewManager {
     assert(removed);
   }
 
+  void registerChannelLinkAutocomplete(ChannelLinkAutocompleteView view) {
+    final added = _channelLinkAutocompleteViews.add(view);
+    assert(added);
+  }
+
+  void unregisterChannelLinkAutocomplete(ChannelLinkAutocompleteView view) {
+    final removed = _channelLinkAutocompleteViews.remove(view);
+    assert(removed);
+  }
+
   void handleRealmUserRemoveEvent(RealmUserRemoveEvent event) {
     autocompleteDataCache.invalidateUser(event.userId);
   }
@@ -1021,6 +1034,20 @@ class AutocompleteDataCache {
       ??= normalizedNameForUserGroup(userGroup).split(' ');
   }
 
+  final Map<int, String> _normalizedNamesByChannel = {};
+
+  String normalizedNameForChannel(ZulipStream channel) {
+    return _normalizedNamesByChannel[channel.streamId]
+      ??= AutocompleteQuery.lowercaseAndStripDiacritics(channel.name);
+  }
+
+  final Map<int, List<String>> _normalizedNameWordsByChannel = {};
+
+  List<String> normalizedNameWordsForChannel(ZulipStream channel) {
+    return _normalizedNameWordsByChannel[channel.streamId]
+      ?? normalizedNameForChannel(channel).split(' ');
+  }
+
   void invalidateUser(int userId) {
     _normalizedNamesByUser.remove(userId);
     _normalizedNameWordsByUser.remove(userId);
@@ -1238,3 +1265,195 @@ class TopicAutocompleteResult extends AutocompleteResult {
 
   TopicAutocompleteResult({required this.topic});
 }
+
+class ChannelLinkAutocompleteView extends AutocompleteView<ChannelLinkAutocompleteQuery, ChannelLinkAutocompleteResult> {
+  ChannelLinkAutocompleteView._({
+    required super.store,
+    required super.query,
+    required this.narrow,
+    required this.sortedChannels,
+  });
+
+  factory ChannelLinkAutocompleteView.init({
+    required PerAccountStore store,
+    required Narrow narrow,
+    required ChannelLinkAutocompleteQuery query,
+  }) {
+    final view = ChannelLinkAutocompleteView._(
+      store: store,
+      query: query,
+      narrow: narrow,
+      sortedChannels: _channelsByRelevance(store: store, narrow: narrow),
+    );
+    store.autocompleteViewManager.registerChannelLinkAutocomplete(view);
+    return view;
+  }
+
+  final Narrow narrow;
+  final List<ZulipStream> sortedChannels;
+
+  static List<ZulipStream> _channelsByRelevance({
+    required PerAccountStore store,
+    required Narrow narrow,
+  }) {
+    return store.streams.values.sorted(_comparator(store: store, narrow: narrow));
+  }
+
+  static Comparator<ZulipStream> _comparator({
+    required PerAccountStore store,
+    required Narrow narrow,
+  }) {
+    // See also [ChannelLinkAutocompleteQuery._rankChannelResult];
+    // that ranking takes precedence over this.
+
+    final channelId = switch (narrow) {
+      ChannelNarrow(:var streamId) || TopicNarrow(:var streamId) => streamId,
+      DmNarrow() => null,
+      CombinedFeedNarrow()
+        || MentionsNarrow()
+        || StarredMessagesNarrow()
+        || KeywordSearchNarrow() => () {
+             assert(false, 'No compose box, thus no autocomplete is available in ${narrow.runtimeType}.');
+             return null;
+           }(),
+    };
+    return (a, b) => _compareByRelevance(a, b, currentChannelId: channelId, store: store);
+  }
+
+  // Check `typeahead_helper.compare_by_activity` in Zulip web;
+  // We follow the behavior of Web but with a small difference in that Web
+  // compares "recent activity" only for subscribed channels, but we do it
+  // for unsubscribed ones too.
+  //    https://github.com/zulip/zulip/blob/c3fdee6ed/web/src/typeahead_helper.ts#L972-L988
+  static int _compareByRelevance(ZulipStream a, ZulipStream b, {
+    required int? currentChannelId,
+    required PerAccountStore store,
+  }) {
+    final comparators = [
+      if (currentChannelId != null)
+        () => _compareByBeingCurrent(a, b, currentChannelId: currentChannelId),
+      () => _compareByBeingSubscribed(a, b, store: store),
+      () => _compareByRecentActivity(a, b),
+      () => _compareByWeeklyTraffic(a, b, store: store),
+      () => ChannelStore.compareChannelsByName(a, b),
+    ];
+    return comparators.map((compare) => compare())
+      .firstWhere((result) => result != 0, orElse: () => 0);
+  }
+
+  static int _compareByBeingCurrent(ZulipStream a, ZulipStream b, {
+    required int currentChannelId,
+  }) {
+    return switch ((a.streamId, b.streamId)) {
+      (int id, _) when id == currentChannelId => -1,
+      (_, int id) when id == currentChannelId =>  1,
+      _                                       =>  0,
+    };
+  }
+
+  static int _compareByBeingSubscribed(ZulipStream a, ZulipStream b, {
+    required PerAccountStore store,
+  }) {
+    return switch((store.subscriptions[a.streamId], store.subscriptions[b.streamId])) {
+      (Subscription(), null) => -1,
+      (null, Subscription()) =>  1,
+      (Subscription(isMuted:  false), Subscription(isMuted:   true)) => -1,
+      (Subscription(isMuted:   true), Subscription(isMuted:  false)) =>  1,
+      (Subscription(pinToTop:  true), Subscription(pinToTop: false)) => -1,
+      (Subscription(pinToTop: false), Subscription(pinToTop:  true)) =>  1,
+      _                                                              =>  0,
+    };
+  }
+
+  static int _compareByRecentActivity(ZulipStream a, ZulipStream b) {
+    return switch((a.isRecentlyActive, b.isRecentlyActive)) {
+      (true, false) => -1,
+      (false, true) =>  1,
+      // The combination of `null` and `bool` is not possible as they're both
+      // either `null` or `bool`, before or after server-10, respectively.
+      // TODO(server-10): remove the preceding comment
+      _             =>  0,
+    };
+  }
+
+  static int _compareByWeeklyTraffic(ZulipStream a, ZulipStream b, {
+    required PerAccountStore store,
+  }) {
+    // TODO(server-8)
+    //   Remove getting fallback `streamWeeklyTraffic` from [Subscription]
+    //   objects as it will always be present in [ZulipStream] objects anyways.
+    final trafficA = a.streamWeeklyTraffic ?? store.subscriptions[a.streamId]?.streamWeeklyTraffic;
+    final trafficB = b.streamWeeklyTraffic ?? store.subscriptions[b.streamId]?.streamWeeklyTraffic;
+    return switch((trafficA, trafficB)) {
+      (int a, int b) => -a.compareTo(b),
+      (int(),  null) => -1,
+      (null,  int()) =>  1,
+      _              =>  0,
+    };
+  }
+
+  @override
+  Future<List<ChannelLinkAutocompleteResult>?> computeResults() async {
+    final unsorted = <ChannelLinkAutocompleteResult>[];
+    if (await filterCandidates(filter: _testChannel,
+          candidates: sortedChannels, results: unsorted)) {
+      return null;
+    }
+
+    return bucketSort(unsorted,
+      (r) => r.rank, numBuckets: ChannelLinkAutocompleteQuery._numResultRanks);
+  }
+
+  ChannelLinkAutocompleteResult? _testChannel(ChannelLinkAutocompleteQuery query, ZulipStream channel) {
+    return query.testChannel(channel, store);
+  }
+
+  @override
+  void dispose() {
+    store.autocompleteViewManager.unregisterChannelLinkAutocomplete(this);
+    super.dispose();
+  }
+}
+
+class ChannelLinkAutocompleteQuery extends ComposeAutocompleteQuery {
+  ChannelLinkAutocompleteQuery(super.raw);
+
+  @override
+  ComposeAutocompleteView initViewModel({
+    required PerAccountStore store,
+    required ZulipLocalizations localizations,
+    required Narrow narrow,
+  }) {
+    return ChannelLinkAutocompleteView.init(store: store, query: this, narrow: narrow);
+  }
+
+  ChannelLinkAutocompleteResult? testChannel(ZulipStream channel, PerAccountStore store) {
+    final cache = store.autocompleteViewManager.autocompleteDataCache;
+    final matchQuality = _matchName(
+      normalizedName: cache.normalizedNameForChannel(channel),
+      normalizedNameWords: cache.normalizedNameWordsForChannel(channel));
+    if (matchQuality == null) return null;
+    return ChannelLinkAutocompleteResult(
+      channelId: channel.streamId, rank: _rankResult(matchQuality));
+  }
+
+  /// A measure of a channel result's quality in the context of the query,
+  /// from 0 (best) to one less than [_numResultRanks].
+  static int _rankResult(NameMatchQuality matchQuality) {
+    return switch(matchQuality) {
+      NameMatchQuality.exact        => 0,
+      NameMatchQuality.totalPrefix  => 1,
+      NameMatchQuality.wordPrefixes => 2,
+    };
+  }
+
+  /// The number of possible values returned by [_rankResult].
+  static const _numResultRanks = 3;
+}
+
+class ChannelLinkAutocompleteResult extends ComposeAutocompleteResult {
+  ChannelLinkAutocompleteResult({required this.channelId, required this.rank});
+
+  final int channelId;
+  final int rank;
+}

lib/widgets/autocomplete.dart

@@ -226,6 +226,8 @@ class ComposeAutocomplete extends AutocompleteField<ComposeAutocompleteQuery, Co
         // TODO(#1805) language-appropriate space character; check active keyboard?
         //   (maybe handle centrally in `controller`)
         replacementString = '${userGroupMention(userGroup.name, silent: query.silent)} ';
+      case ChannelLinkAutocompleteResult():
+        throw UnimplementedError(); // TODO(#124)
     }
 
     controller.value = intent.textEditingValue.replaced(
@@ -243,6 +245,7 @@ class ComposeAutocomplete extends AutocompleteField<ComposeAutocompleteQuery, Co
     final child = switch (option) {
       MentionAutocompleteResult() => MentionAutocompleteItem(
         option: option, narrow: narrow),
+      ChannelLinkAutocompleteResult() => throw UnimplementedError(), // TODO(#124)
       EmojiAutocompleteResult() => _EmojiAutocompleteItem(option: option),
     };
     return InkWell(