setMessages method

void setMessages(
  1. List<Message> messages
)

Replaces all messages with messages.

The messages are sorted by Message.timestamp (using the custom sort callback for equal timestamps) and grouped. Messages with unparsable timestamps are placed last. Note that messages is sorted in place.

Implementation

void setMessages(List<Message> messages) {
  _messageGroups.clear();
  _unreadMessageIds.clear();
  _appearPendingIds.clear();

  // Parse each timestamp once, not on every comparison.
  final entries = [
    for (final message in messages)
      (message: message, date: DateTime.tryParse(message.timestamp)),
  ];
  entries.sort((ea, eb) {
    final a = ea.message;
    final b = eb.message;
    final aDate = ea.date;
    final bDate = eb.date;

    // Messages with unparsable timestamps sort last.
    if (aDate == null || bDate == null) {
      if (aDate == null && bDate == null) return 0;
      if (aDate == null) return 1;
      return -1;
    }

    // Compare by time first.
    final timeComparison = aDate.compareTo(bDate);

    // Different times: chronological order wins.
    if (timeComparison != 0) {
      return timeComparison;
    }

    // Same time: defer to the custom sort, if any.
    if (_customSortCallback != null) {
      return _customSortCallback(a, b);
    }
    return 0;
  });
  for (int i = 0; i < entries.length; i++) {
    messages[i] = entries[i].message;
  }

  // addMessage re-positions failed messages on every call; keep that exact behavior when any
  // are registered (rare during a full reload).
  if (_failedMessageEntries.isNotEmpty) {
    _suppressAppear = true; // loaded history, not new messages
    try {
      for (final message in messages) {
        addMessage(message);
      }
    } finally {
      _suppressAppear = false;
    }
    return;
  }

  // Group in a single pass over the sorted list. Equivalent to calling addMessage for each
  // message, without its per-message duplicate scan over every group and per-message notify.
  final positions = <String, ({MessageGroup group, int index})>{};
  for (final message in messages) {
    if (message.id.isNotEmpty) {
      final existing = positions[message.id];
      if (existing != null) {
        // Same id seen before: replace it in place, as addMessage does.
        existing.group.messages[existing.index] = message;
        continue;
      }
    }
    final MessageGroup group;
    if (_messageGroups.isEmpty ||
        !_canJoinGroup(_messageGroups.last, message)) {
      group = MessageGroup(
        name: message.name,
        isSender: message.isSender,
        timestamp: message.timestamp,
        messages: [message],
      );
      _messageGroups.add(group);
    } else {
      group = _messageGroups.last;
      group.messages.add(message);
    }
    if (message.id.isNotEmpty) {
      positions[message.id] = (group: group, index: group.messages.length - 1);
    }
    if (message.isRead == false) {
      _unreadMessageIds.add(message.id);
    } else if (message.isRead == true) {
      _unreadMessageIds.remove(message.id);
    }
  }
  _notifyMessagesChanged();
}