wip; Support outbox messages in message list

TODOs

- Perhaps make senderFullName available on OutboxMessage
- Add tests.

Author: PIG208

lib/model/message_list.dart

@@ -10,6 +10,7 @@ import '../api/route/messages.dart';
 import 'algorithms.dart';
 import 'channel.dart';
 import 'content.dart';
+import 'message.dart';
 import 'narrow.dart';
 import 'store.dart';
 
@@ -36,20 +37,47 @@ class MessageListDateSeparatorItem extends MessageListItem {
 }
 
 /// A message to show in the message list.
-class MessageListMessageItem extends MessageListItem {
-  final Message message;
-  ZulipMessageContent content;
+sealed class MessageListDisplayableMessageItem extends MessageListItem {
+  DisplayableMessage get message;
+  ZulipMessageContent get content;
   bool showSender;
   bool isLastInBlock;
 
+  MessageListDisplayableMessageItem({
+    required this.showSender,
+    required this.isLastInBlock,
+  });
+}
+
+class MessageListMessageItem extends MessageListDisplayableMessageItem {
+  @override
+  final Message message;
+  @override
+  ZulipMessageContent content;
+
   MessageListMessageItem(
     this.message,
     this.content, {
-    required this.showSender,
-    required this.isLastInBlock,
+    required super.showSender,
+    required super.isLastInBlock,
   });
 }
 
+class MessageListOutboxMessageItem extends MessageListDisplayableMessageItem {
+  @override
+  final OutboxMessage message;
+  @override
+  final ZulipContent content;
+
+  MessageListOutboxMessageItem(
+    this.message, {
+    required super.showSender,
+    required super.isLastInBlock,
+  }) : content = ZulipContent(nodes: [
+    ParagraphNode(links: [], nodes: [TextNode(message.content)]),
+  ]);
+}
+
 /// Indicates the app is loading more messages at the top.
 // TODO(#80): or loading at the bottom, by adding a [MessageListDirection.newer]
 class MessageListLoadingItem extends MessageListItem {
@@ -77,6 +105,13 @@ mixin _MessageSequence {
   /// See also [contents] and [items].
   final List<Message> messages = [];
 
+  /// The messages sent by the self-user.
+  ///
+  /// See also [items].
+  // Usually this should not have that many items, so we do not anticipate
+  // performance issues with unoptimized O(N) iterations through this list.
+  final List<OutboxMessage> outboxMessages = [];
+
   /// Whether [messages] and [items] represent the results of a fetch.
   ///
   /// This allows the UI to distinguish "still working on fetching messages"
@@ -129,11 +164,12 @@ mixin _MessageSequence {
   /// The messages and their siblings in the UI, in order.
   ///
   /// This has a [MessageListMessageItem] corresponding to each element
-  /// of [messages], in order.  It may have additional items interspersed
-  /// before, between, or after the messages.
+  /// of [messages], followed by each element in [outboxMessages] in order.
+  /// It may have additional items interspersed before, between, or after the
+  /// messages.
   ///
-  /// This information is completely derived from [messages] and
-  /// the flags [haveOldest], [fetchingOlder] and [fetchOlderCoolingDown].
+  /// This information is completely derived from [messages], [outboxMessages]
+  /// and the flags [haveOldest], [fetchingOlder] and [fetchOlderCoolingDown].
   /// It exists as an optimization, to memoize that computation.
   final QueueList<MessageListItem> items = QueueList();
 
@@ -157,6 +193,7 @@ mixin _MessageSequence {
       case MessageListDateSeparatorItem(:var message):
         return message.id != null && message.id! <= messageId ? -1 : 1;
       case MessageListMessageItem(:var message): return message.id.compareTo(messageId);
+      case MessageListOutboxMessageItem():       return 1;
     }
   }
 
@@ -264,6 +301,7 @@ mixin _MessageSequence {
   void _reset() {
     generation += 1;
     messages.clear();
+    outboxMessages.clear();
     _fetched = false;
     _haveOldest = false;
     _fetchingOlder = false;
@@ -282,17 +320,18 @@ mixin _MessageSequence {
     _reprocessAll();
   }
 
-  /// Prepare [items] before a [MessageListMessageItem] can be appended.
+  /// Prepare [items] before a [MessageListDisplayableMessageItem] can be appended.
   ///
   /// Returns whether the sender can be shared between the items for both
-  /// messages, as in the negation of [MessageListMessageItem.showSender].
-  bool _prepareTailForMessage(Message message, {required Message? prevMessage}) {
+  /// messages, as in the negation of [MessageListDisplayableMessageItem.showSender].
+  bool _prepareTailForMessage(DisplayableMessage message, {
+    required DisplayableMessage? prevMessage,
+  }) {
     if (prevMessage == null || !haveSameRecipient(prevMessage, message)) {
       items.add(MessageListRecipientHeaderItem(message));
       return false;
     } else {
-      assert(items.last is MessageListMessageItem);
-      final prevMessageItem = items.last as MessageListMessageItem;
+      final prevMessageItem = items.last as MessageListDisplayableMessageItem;
       assert(identical(prevMessageItem.message, prevMessage));
       assert(prevMessageItem.isLastInBlock);
       prevMessageItem.isLastInBlock = false;
@@ -320,6 +359,28 @@ mixin _MessageSequence {
       showSender: !canShareSender, isLastInBlock: true));
   }
 
+  void _processOutboxMessage(int index) {
+    final prevMessage = index == 0 ? messages.last : outboxMessages[index - 1];
+    final message = outboxMessages[index];
+
+    final canShareSender = _prepareTailForMessage(message, prevMessage: prevMessage);
+    items.add(MessageListOutboxMessageItem(message,
+      showSender: !canShareSender, isLastInBlock: true));
+  }
+
+  /// Remove from [items] the ones associated with [outboxMessages].
+  void _removeOutboxMessageItems() {
+    while (items.isNotEmpty && items.last is! MessageListMessageItem) {
+      items.removeLast();
+    }
+    final lastMessageItem = items.lastOrNull;
+    assert(items.none((e) => e is MessageListOutboxMessageItem));
+    if (lastMessageItem is MessageListDisplayableMessageItem) {
+      assert(lastMessageItem is MessageListMessageItem);
+      lastMessageItem.isLastInBlock = true;
+    }
+  }
+
   /// Update [items] to include markers at start and end as appropriate.
   void _updateEndMarkers() {
     assert(fetched);
@@ -344,23 +405,27 @@ mixin _MessageSequence {
     }
   }
 
-  /// Recompute [items] from scratch, based on [messages], [contents], and flags.
+  /// Recompute [items] from scratch, based on [messages], [contents],
+  /// [outboxMessages] and flags.
   void _reprocessAll() {
     items.clear();
     for (var i = 0; i < messages.length; i++) {
       _processMessage(i);
     }
+    for (var i = 0; i < outboxMessages.length; i++) {
+      _processOutboxMessage(i);
+    }
     _updateEndMarkers();
   }
 }
 
 @visibleForTesting
-bool haveSameRecipient(Message prevMessage, Message message) {
-  if (prevMessage is StreamMessage && message is StreamMessage) {
-    if (prevMessage.streamId != message.streamId) return false;
-    if (prevMessage.topic.canonicalize() != message.topic.canonicalize()) return false;
-  } else if (prevMessage is DmMessage && message is DmMessage) {
-    if (!_equalIdSequences(prevMessage.allRecipientIds, message.allRecipientIds)) {
+bool haveSameRecipient(DisplayableMessage prevMessage, DisplayableMessage message) {
+  if (prevMessage is DisplayableMessage<StreamDestination> && message is DisplayableMessage<StreamDestination>) {
+    if (prevMessage.destination.streamId != message.destination.streamId) return false;
+    if (prevMessage.destination.topic.canonicalize() != message.destination.topic.canonicalize()) return false;
+  } else if (prevMessage is DisplayableMessage<DmDestination> && message is DisplayableMessage<DmDestination>) {
+    if (!_equalIdSequences(prevMessage.destination.userIds, message.destination.userIds)) {
       return false;
     }
   } else {
@@ -379,7 +444,7 @@ bool haveSameRecipient(Message prevMessage, Message message) {
 }
 
 @visibleForTesting
-bool messagesSameDay(Message prevMessage, Message message) {
+bool messagesSameDay(DisplayableMessage prevMessage, DisplayableMessage message) {
   // TODO memoize [DateTime]s... also use memoized for showing date/time in msglist
   final prevTime = DateTime.fromMillisecondsSinceEpoch(prevMessage.timestamp * 1000);
   final time = DateTime.fromMillisecondsSinceEpoch(message.timestamp * 1000);
@@ -444,19 +509,20 @@ class MessageListView with ChangeNotifier, _MessageSequence {
   /// one way or another.
   ///
   /// See also [_allMessagesVisible].
-  bool _messageVisible(Message message) {
+  bool _messageVisible(DisplayableMessage message) {
     switch (narrow) {
       case CombinedFeedNarrow():
-        return switch (message) {
-          StreamMessage() =>
-            store.isTopicVisible(message.streamId, message.topic),
-          DmMessage() => true,
+        return switch (message.destination) {
+          StreamDestination(:final streamId, :final topic) =>
+            store.isTopicVisible(streamId, topic),
+          DmDestination() => true,
         };
 
       case ChannelNarrow(:final streamId):
-        assert(message is StreamMessage && message.streamId == streamId);
-        if (message is! StreamMessage) return false;
-        return store.isTopicVisibleInStream(streamId, message.topic);
+        assert(message is DisplayableMessage<StreamDestination>
+               && message.destination.streamId == streamId);
+        if (message is! DisplayableMessage<StreamDestination>) return false;
+        return store.isTopicVisibleInStream(streamId, message.destination.topic);
 
       case TopicNarrow():
       case DmNarrow():
@@ -525,6 +591,9 @@ class MessageListView with ChangeNotifier, _MessageSequence {
         _addMessage(message);
       }
     }
+    for (final outboxMessage in store.outboxMessages.values) {
+      handleOutboxMessage(outboxMessage);
+    }
     _fetched = true;
     _haveOldest = result.foundOldest;
     _updateEndMarkers();
@@ -631,6 +700,19 @@ class MessageListView with ChangeNotifier, _MessageSequence {
     }
   }
 
+  void handleOutboxMessage(OutboxMessage outboxMessage) {
+    if (outboxMessage.hidden) return;
+    if (narrow.containsMessage(outboxMessage) && _messageVisible(outboxMessage)) {
+      outboxMessages.add(outboxMessage);
+      _processOutboxMessage(outboxMessages.length - 1);
+      notifyListeners();
+    }
+  }
+
+  void handleUpdateOutboxMessage(int localMessageId) {
+    notifyListenersIfOutboxMessagePresent(localMessageId);
+  }
+
   void handleUserTopicEvent(UserTopicEvent event) {
     switch (_canAffectVisibility(event)) {
       case VisibilityEffect.none:
@@ -666,14 +748,26 @@ class MessageListView with ChangeNotifier, _MessageSequence {
   void handleMessageEvent(MessageEvent event) {
     final message = event.message;
     if (!narrow.containsMessage(message) || !_messageVisible(message)) {
+      assert(event.localMessageId == null
+             || outboxMessages.every((message) =>
+                  message.localMessageId != event.localMessageId!));
       return;
     }
     if (!_fetched) {
       // TODO mitigate this fetch/event race: save message to add to list later
       return;
     }
+    _removeOutboxMessageItems();
     // TODO insert in middle instead, when appropriate
     _addMessage(message);
+    final localMessageId = event.localMessageId;
+    if (localMessageId != null) {
+      outboxMessages.removeWhere(
+        (message) => message.localMessageId == localMessageId);
+      for (int i = 0; i < outboxMessages.length; i++) {
+        _processOutboxMessage(i);
+      }
+    }
     notifyListeners();
   }
 
@@ -792,6 +886,15 @@ class MessageListView with ChangeNotifier, _MessageSequence {
     }
   }
 
+  /// Notify listeners if the given outbox message is present in this view.
+  void notifyListenersIfOutboxMessagePresent(int localMessageId) {
+    final isAnyPresent =
+      outboxMessages.any((message) => message.localMessageId == localMessageId);
+    if (isAnyPresent) {
+      notifyListeners();
+    }
+  }
+
   /// Called when the app is reassembled during debugging, e.g. for hot reload.
   ///
   /// This will redo from scratch any computations we can, such as parsing