autocomplete: Implement targeted topic autocomplete

Fixes: #310

Author: Khader-1

lib/api/route/streams.dart

@@ -0,0 +1,42 @@
+import 'package:json_annotation/json_annotation.dart';
+
+import '../core.dart';
+part 'streams.g.dart';
+
+/// https://zulip.com/api/get-stream-topics
+Future<GetTopicsResult> getStreamTopics(
+  ApiConnection connection, {
+  required int streamId,
+}) {
+  return connection.get('getStreamTopics', GetTopicsResult.fromJson,
+      'users/me/$streamId/topics', {});
+}
+
+@JsonSerializable(fieldRename: FieldRename.snake)
+class GetTopicsResult {
+  final List<Topic>? topics;
+
+  GetTopicsResult({
+    required this.topics,
+  });
+
+  factory GetTopicsResult.fromJson(Map<String, dynamic> json) =>
+      _$GetTopicsResultFromJson(json);
+
+  Map<String, dynamic> toJson() => _$GetTopicsResultToJson(this);
+}
+
+@JsonSerializable(fieldRename: FieldRename.snake)
+class Topic {
+  final int maxId;
+  final String name;
+
+  Topic({
+    required this.maxId,
+    required this.name,
+  });
+
+  factory Topic.fromJson(Map<String, dynamic> json) => _$TopicFromJson(json);
+
+  Map<String, dynamic> toJson() => _$TopicToJson(this);
+}

lib/api/route/streams.g.dart

@@ -3,6 +3,7 @@ import 'package:flutter/services.dart';
 
 import '../api/model/events.dart';
 import '../api/model/model.dart';
+import '../api/route/streams.dart';
 import '../widgets/compose_box.dart';
 import 'narrow.dart';
 import 'store.dart';
@@ -112,8 +113,10 @@ class AutocompleteIntent {
 /// On reassemble, call [reassemble].
 class AutocompleteViewManager {
   final Set<MentionAutocompleteView> _mentionAutocompleteViews = {};
+  final Set<TopicAutocompleteView> _topicAutocompleteViews = {};
 
   AutocompleteDataCache autocompleteDataCache = AutocompleteDataCache();
+  TopicAutocompleteDataCache topicAutocompleteDataCache = TopicAutocompleteDataCache();
 
   void registerMentionAutocomplete(MentionAutocompleteView view) {
     final added = _mentionAutocompleteViews.add(view);
@@ -145,6 +148,16 @@ class AutocompleteViewManager {
     autocompleteDataCache.invalidateUser(event.userId);
   }
 
+  void registerTopicAutocomplete(TopicAutocompleteView view) {
+    final added = _topicAutocompleteViews.add(view);
+    assert(added);
+  }
+
+  void unregisterTopicAutocomplete(TopicAutocompleteView view) {
+    final removed = _topicAutocompleteViews.remove(view);
+    assert(removed);
+  }
+
   /// Called when the app is reassembled during debugging, e.g. for hot reload.
   ///
   /// Calls [MentionAutocompleteView.reassemble] for all that are registered.
@@ -363,3 +376,133 @@ class UserMentionAutocompleteResult extends MentionAutocompleteResult {
 // TODO(#233): // class UserGroupMentionAutocompleteResult extends MentionAutocompleteResult {
 
 // TODO(#234): // class WildcardMentionAutocompleteResult extends MentionAutocompleteResult {
+
+/// A per-account manager for stream topics autocomplete interactions.
+class TopicAutocompleteView extends AutocompleteView<TopicAutocompleteQuery, Topic> {
+  TopicAutocompleteView._({
+    required this.topics,
+    required this.store,
+    required this.narrow,
+  });
+
+  List<Topic>? topics;
+  final PerAccountStore store;
+  final StreamNarrow narrow;
+
+  static Future<TopicAutocompleteView> init({
+      required PerAccountStore store,
+      required StreamNarrow narrow
+  }) async {
+    final view = TopicAutocompleteView._(
+      store: store,
+      narrow: narrow,
+      topics: null,
+    );
+    store.autocompleteViewManager.registerTopicAutocomplete(view);
+    return view;
+  }
+
+  @override
+  void dispose() {
+    store.autocompleteViewManager.unregisterTopicAutocomplete(this);
+    super.dispose();
+  }
+
+  Future<void> fetch() async {
+    final result = await getStreamTopics(store.connection, streamId: narrow.streamId);
+    topics = result.topics;
+    notifyListeners();
+  }
+
+  @override
+  Future<List<Topic>?> _computeResults(TopicAutocompleteQuery query) async {
+    if (topics == null) return [];
+
+    final List<Topic> results = [];
+
+    final iterator = topics!.iterator;
+    bool isDone = false;
+    while (!isDone) {
+      // CPU perf: End this task; enqueue a new one for resuming this work
+      await Future(() {});
+
+      if (query != _query || !hasListeners) { // false if [dispose] has been called.
+        return null;
+      }
+
+      for (int i = 0; i < 1000; i++) {
+        if (!iterator.moveNext()) { // Can throw ConcurrentModificationError
+          isDone = true;
+          break;
+        }
+
+        final Topic topic = iterator.current;
+        if (query.testTopic(topic, store.autocompleteViewManager.topicAutocompleteDataCache)) {
+          results.add(topic);
+        }
+      }
+    }
+    return results; // TODO(#228) sort for most relevant first
+  }
+}
+
+class TopicAutocompleteQuery {
+  TopicAutocompleteQuery(this.raw)
+    : _lowercaseWords = raw.toLowerCase().split(' ');
+
+  final String raw;
+
+
+  final List<String> _lowercaseWords;
+
+  bool testTopic(Topic topic, TopicAutocompleteDataCache cache) {
+    return _testName(topic, cache);
+  }
+
+  bool _testName(Topic topic, TopicAutocompleteDataCache cache) {
+    // TODO(#237) test with diacritics stripped, where appropriate
+
+    final List<String> nameWords = cache.nameWordsForTopic(topic);
+
+    int nameWordsIndex = 0;
+    int queryWordsIndex = 0;
+    while (true) {
+      if (queryWordsIndex == _lowercaseWords.length) {
+        return true;
+      }
+      if (nameWordsIndex == nameWords.length) {
+        return false;
+      }
+
+      if (nameWords[nameWordsIndex].startsWith(_lowercaseWords[queryWordsIndex])) {
+        queryWordsIndex++;
+      }
+      nameWordsIndex++;
+    }
+  }
+
+  @override
+  String toString() {
+    return '${objectRuntimeType(this, 'MentionAutocompleteQuery')}(raw: $raw)';
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return other is TopicAutocompleteQuery && other.raw == raw;
+  }
+
+  @override
+  int get hashCode => Object.hash('MentionAutocompleteQuery', raw);
+}
+
+class TopicAutocompleteDataCache {
+  final Map<int, List<String>> _nameWordsByTopic = {};
+
+  List<String> nameWordsForTopic(Topic topic) {
+    return _nameWordsByTopic[topic.maxId] ??= topic.name.toLowerCase().split(' ');
+  }
+
+  void invalidateTopic(int topicMaxId) {
+    _nameWordsByTopic.remove(topicMaxId);
+  }
+}

lib/model/autocomplete.dart

@@ -7,6 +7,8 @@ import 'package:image_picker/image_picker.dart';
 
 import '../api/model/model.dart';
 import '../api/route/messages.dart';
+import '../api/route/streams.dart';
+import '../model/autocomplete.dart' as autocomplete;
 import '../model/compose.dart';
 import '../model/narrow.dart';
 import '../model/store.dart';
@@ -372,6 +374,79 @@ class _StreamContentInputState extends State<_StreamContentInput> {
   }
 }
 
+/// The content input for _StreamComposeBox.
+class _StreamTopicInput extends StatefulWidget {
+  const _StreamTopicInput({
+    required this.narrow,
+    required this.controller,
+    required this.focusNode,
+  });
+
+  final StreamNarrow narrow;
+  final ComposeTopicController controller;
+  final FocusNode focusNode;
+
+  @override
+  State<_StreamTopicInput> createState() => _StreamTopicInputState();
+}
+
+class _StreamTopicInputState extends State<_StreamTopicInput> with PerAccountStoreAwareStateMixin<_StreamTopicInput> {
+  autocomplete.TopicAutocompleteView? model;
+
+  @override
+  void dispose() {
+    model?.dispose();
+    super.dispose();
+  }
+
+
+  @override
+  void onNewStore() {
+    _initModel(PerAccountStoreWidget.of(context));
+  }
+
+  void _initModel(PerAccountStore store)async  {
+    model = await autocomplete.TopicAutocompleteView.init(store: store, narrow: widget.narrow);
+    model!.addListener(_modelChanged);
+    model!.fetch();
+  }
+
+
+  void _modelChanged() {
+    setState(() {
+      // The actual state lives in the [StreamTopicsView] model.
+      // This method was called because that just changed.
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final zulipLocalizations = ZulipLocalizations.of(context);
+    final colorScheme = Theme.of(context).colorScheme;
+    return Autocomplete<Topic>(
+        optionsViewOpenDirection: OptionsViewOpenDirection.up,
+        optionsBuilder: (textEditingValue) => model?.results ?? [],
+        initialValue: widget.controller.value,
+        displayStringForOption: (option) {
+          return option.name;
+        },
+        onSelected: (option) => widget.controller.text = option.name,
+        fieldViewBuilder: (context, textEditingController, focusNode, onFieldSubmitted) => TextField(
+          controller: textEditingController,
+          onChanged: (value) {
+            widget.controller.text = value;
+            model?.query = autocomplete.TopicAutocompleteQuery(value);
+          },
+          focusNode: focusNode,
+          onSubmitted: (value) => onFieldSubmitted(),
+          onEditingComplete: onFieldSubmitted,
+          style: TextStyle(color: colorScheme.onSurface),
+          decoration: InputDecoration(hintText: zulipLocalizations.composeBoxTopicHintText),
+        ),
+      );
+  }
+}
+
 class _FixedDestinationContentInput extends StatelessWidget {
   const _FixedDestinationContentInput({
     required this.narrow,
@@ -881,16 +956,13 @@ class _StreamComposeBoxState extends State<_StreamComposeBox> implements Compose
 
   @override
   Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    final zulipLocalizations = ZulipLocalizations.of(context);
-
     return _ComposeBoxLayout(
       contentController: _contentController,
       contentFocusNode: _contentFocusNode,
-      topicInput: TextField(
+      topicInput: _StreamTopicInput(
+        narrow: widget.narrow,
         controller: _topicController,
-        style: TextStyle(color: colorScheme.onSurface),
-        decoration: InputDecoration(hintText: zulipLocalizations.composeBoxTopicHintText),
+        focusNode: _contentFocusNode,
       ),
       contentInput: _StreamContentInput(
         narrow: widget.narrow,