fix(chat): don't skip the initial backlog fetch on a stale lastMessage

loadInitialMessages skipped the network fetch entirely whenever the
local chat block already reached conversationModel.lastMessage.id,
trusting that value as proof we were caught up with the server. That
field is only as fresh as the last room list sync, though: a message
sent while the app had the conversation list open but the chat closed
(and no push-triggered catch-up ran, e.g. on flavors without FCM)
never updates it. Opening the chat then wrongly concluded there was
nothing to fetch, leaving the newest message missing until whatever
live-update mechanism happened to be active caught up on its own.

Always close the backlog from the newest locally known message
instead of gating on the conversation's cached lastMessage. closeBacklog
is a single cheap request when there is genuinely nothing new, so
there is no upside to trusting a value that isn't guaranteed current.

Drop ChatMessageSyncer.seedHttpSyncedMessageId with it: it existed
only to seed the insurance anchor from that same stale field for the
now-removed branch, and has no other caller.

Assisted-by: Claude Sonnet 5 <noreply@anthropic.com>
Signed-off-by: Marcel Hibbe <dev@mhibbe.de>

Author: mahibi

app/src/main/java/com/nextcloud/talk/chat/data/network/ChatMessageSyncer.kt

@@ -291,20 +291,11 @@ class ChatMessageSyncer @Inject constructor(
 
     /**
      * The newest message id of the conversation/thread confirmed via HTTP sync, or null when no
-     * sync happened yet (and [seedHttpSyncedMessageId] was never called) since app start.
+     * sync happened yet since app start.
      */
     fun lastHttpSyncedMessageId(internalConversationId: String, threadId: Long?): Long? =
         lastHttpSyncedMessageIds[syncStateKey(internalConversationId, threadId)]
 
-    /**
-     * Seeds the HTTP-synced anchor without a fetch. Only call with ids whose coverage is proven by
-     * HTTP-derived data — e.g. the conversation's lastMessage from the room list sync when the
-     * local chat block already reaches it. The anchor only ever moves forward.
-     */
-    fun seedHttpSyncedMessageId(internalConversationId: String, threadId: Long?, messageId: Long) {
-        lastHttpSyncedMessageIds.merge(syncStateKey(internalConversationId, threadId), messageId, ::maxOf)
-    }
-
     private fun recordHttpSyncedMessageId(target: SyncTarget, messageId: Long) {
         lastHttpSyncedMessageIds.merge(syncStateKey(target.internalConversationId, target.threadId), messageId, ::maxOf)
     }

app/src/main/java/com/nextcloud/talk/chat/data/network/OfflineFirstChatRepository.kt

@@ -188,33 +188,10 @@ class OfflineFirstChatRepository @Inject constructor(
         val weAlreadyHaveSomeOfflineMessages = newestMessageIdFromDb > 0
 
         val weHaveAtLeastTheLastReadMessage = newestMessageIdFromDb >= conversationModel.lastReadMessage.toLong()
-        val lastMessageIdFromServer = conversationModel.lastMessage?.id ?: 0
-        val weHaveTheLastMessage = newestMessageIdFromDb >= lastMessageIdFromServer
         Log.d(TAG, "weAlreadyHaveSomeOfflineMessages:$weAlreadyHaveSomeOfflineMessages")
         Log.d(TAG, "weHaveAtLeastTheLastReadMessage:$weHaveAtLeastTheLastReadMessage")
-        Log.d(TAG, "weHaveTheLastMessage:$weHaveTheLastMessage (lastMessageIdFromServer:$lastMessageIdFromServer)")
 
         when {
-            weAlreadyHaveSomeOfflineMessages && weHaveTheLastMessage -> {
-                // The offline messages already reach the conversation's last message (e.g. because
-                // the room list sync prefetched them), so no initial request is needed at all —
-                // regardless of the live-update mode. Anything newer is handled by long polling,
-                // the chat relay or the insurance requests.
-                Log.d(
-                    TAG,
-                    "Initial online request is skipped because offline messages are up to date" +
-                        " until the conversation's last message"
-                )
-
-                // No HTTP fetch happens in this branch, so seed the insurance anchor explicitly:
-                // lastMessage came from the room list sync (HTTP) and the local chat block reaches
-                // it, so it is a valid HTTP-synced anchor. Without the seed, the first insurance
-                // request of this session would query with lastKnownMessageId=0.
-                conversationModel.lastMessage?.id?.let {
-                    syncer.seedHttpSyncedMessageId(internalConversationId, threadId, it)
-                }
-            }
-
             weAlreadyHaveSomeOfflineMessages && weHaveAtLeastTheLastReadMessage -> {
                 // Close the backlog since the newest offline message. This is required on
                 // chat-relay servers (the relay cannot deliver messages that arrived while the
@@ -223,6 +200,12 @@ class OfflineFirstChatRepository @Inject constructor(
                 // initial load never has to know the live-update mode, i.e. it must not wait for
                 // the websocket. closeBacklog loops until the backlog is fully closed — a single
                 // capped fetch could leave a permanent gap on chat-relay servers.
+                //
+                // This request is always made, even if the conversation's cached lastMessage
+                // suggests we are already caught up: that value is only as fresh as the last room
+                // list sync and can already be behind the server by the time the chat is opened.
+                // closeBacklog is cheap when there is truly nothing new (a single request coming
+                // back empty), so there is no good reason to trust the stale value instead.
                 Log.d(TAG, "Closing the backlog from the newest offline message for initial loading")
 
                 syncer.closeBacklog(

app/src/test/java/com/nextcloud/talk/chat/data/network/ChatMessageSyncerTest.kt

@@ -402,16 +402,6 @@ class ChatMessageSyncerTest {
             assertEquals(42L, syncer.lastHttpSyncedMessageId(INTERNAL_CONVERSATION_ID, null))
         }
 
-    @Test
-    fun `seeded insurance anchor only moves forward`() {
-        assertNull(syncer.lastHttpSyncedMessageId(INTERNAL_CONVERSATION_ID, null))
-
-        syncer.seedHttpSyncedMessageId(INTERNAL_CONVERSATION_ID, null, 44L)
-        syncer.seedHttpSyncedMessageId(INTERNAL_CONVERSATION_ID, null, 10L)
-
-        assertEquals(44L, syncer.lastHttpSyncedMessageId(INTERNAL_CONVERSATION_ID, null))
-    }
-
     @Test
     fun `cleanupExpiredMessages trims block boundaries and deletes empty blocks`() =
         runTest {