feat(chat): advance read pointers when opening chats

Signed-off-by: Brandon McAnsh <git@bmcreations.dev>

Author: bmc08gt

api/src/main/java/com/getcode/model/Chat.kt

@@ -39,8 +39,11 @@ data class Chat(
     fun resetUnreadCount() = copy(unreadCount = 0)
     fun toggleMute() = copy(isMuted = !isMuted)
 
+    val newestMessage: ChatMessage?
+        get() = messages.maxByOrNull { it.dateMillis }
+
     val lastMessageMillis: Long?
-        get() = messages.maxOfOrNull { it.dateMillis }
+        get() = newestMessage?.dateMillis
 }
 
 sealed interface Pointer {

api/src/main/java/com/getcode/network/HistoryController.kt

@@ -12,6 +12,7 @@ import com.getcode.model.ChatMessage
 import com.getcode.model.Cursor
 import com.getcode.model.ID
 import com.getcode.network.client.Client
+import com.getcode.network.client.advancePointer
 import com.getcode.network.client.fetchChats
 import com.getcode.network.client.fetchMessagesFor
 import com.getcode.network.client.setMuted
@@ -92,6 +93,27 @@ class HistoryController @Inject constructor(
         }
     }
 
+    suspend fun advanceReadPointer(chatId: ID) {
+        val owner = owner() ?: return
+
+        _chats.update {
+            it?.toMutableList()?.apply chats@{
+                indexOfFirst { chat -> chat.id == chatId }
+                    .takeIf { index -> index >= 0 }
+                    ?.let { index ->
+                        val chat = this[index]
+                        val newestMessage = chat.newestMessage
+                        if (newestMessage != null) {
+                            client.advancePointer(owner, chatId, newestMessage.id)
+                                .onSuccess {
+                                    this[index] = chat.resetUnreadCount()
+                                }
+                        }
+                    }
+            }?.toList()
+        }
+    }
+
     suspend fun setMuted(chatId: ID, muted: Boolean): Result<Boolean> {
         val owner = owner() ?: return Result.failure(Throwable("No owner detected"))
 

api/src/main/java/com/getcode/network/api/ChatApi.kt

@@ -2,8 +2,11 @@ package com.getcode.network.api
 
 import com.codeinc.gen.chat.v1.ChatGrpc
 import com.codeinc.gen.chat.v1.ChatService
+import com.codeinc.gen.chat.v1.ChatService.AdvancePointerRequest
+import com.codeinc.gen.chat.v1.ChatService.AdvancePointerResponse
 import com.codeinc.gen.chat.v1.ChatService.GetChatsRequest
 import com.codeinc.gen.chat.v1.ChatService.GetMessagesRequest
+import com.codeinc.gen.chat.v1.ChatService.Pointer.Kind
 import com.codeinc.gen.chat.v1.ChatService.SetMuteStateRequest
 import com.codeinc.gen.chat.v1.ChatService.SetMuteStateResponse
 import com.getcode.ed25519.Ed25519
@@ -65,6 +68,25 @@ class ChatApi @Inject constructor(
             .flowOn(Dispatchers.IO)
     }
 
+    fun advancePointer(owner: KeyPair, chatId: ID, to: ID): Flow<AdvancePointerResponse> {
+        val request = AdvancePointerRequest.newBuilder()
+            .setChatId(ChatService.ChatId.newBuilder()
+                .setValue(chatId.toByteArray().toByteString())
+                .build()
+            ).setPointer(ChatService.Pointer.newBuilder()
+                .setKindValue(Kind.READ_VALUE)
+                .setValue(ChatService.ChatMessageId.newBuilder()
+                    .setValue(to.toByteArray().toByteString())
+                )
+            ).setOwner(owner.publicKeyBytes.toSolanaAccount())
+            .setSignature(owner)
+            .build()
+
+        return api::advancePointer
+            .callAsCancellableFlow(request)
+            .flowOn(Dispatchers.IO)
+    }
+
     fun setMuteState(owner: KeyPair, chatId: ID, muted: Boolean): Flow<SetMuteStateResponse> {
         val request = SetMuteStateRequest.newBuilder()
             .setChatId(ChatService.ChatId.newBuilder()
@@ -81,23 +103,31 @@ class ChatApi @Inject constructor(
     }
 }
 
-fun GetChatsRequest.Builder.setSignature(owner: KeyPair): GetChatsRequest.Builder {
+private fun GetChatsRequest.Builder.setSignature(owner: KeyPair): GetChatsRequest.Builder {
+    val bos = ByteArrayOutputStream()
+    buildPartial().writeTo(bos)
+    setSignature(Ed25519.sign(bos.toByteArray(), owner).toSignature())
+
+    return this
+}
+
+private fun GetMessagesRequest.Builder.setSignature(owner: KeyPair): GetMessagesRequest.Builder {
     val bos = ByteArrayOutputStream()
     buildPartial().writeTo(bos)
     setSignature(Ed25519.sign(bos.toByteArray(), owner).toSignature())
 
     return this
 }
 
-fun GetMessagesRequest.Builder.setSignature(owner: KeyPair): GetMessagesRequest.Builder {
+private fun SetMuteStateRequest.Builder.setSignature(owner: KeyPair): SetMuteStateRequest.Builder {
     val bos = ByteArrayOutputStream()
     buildPartial().writeTo(bos)
     setSignature(Ed25519.sign(bos.toByteArray(), owner).toSignature())
 
     return this
 }
 
-fun SetMuteStateRequest.Builder.setSignature(owner: KeyPair): SetMuteStateRequest.Builder {
+private fun AdvancePointerRequest.Builder.setSignature(owner: KeyPair): AdvancePointerRequest.Builder {
     val bos = ByteArrayOutputStream()
     buildPartial().writeTo(bos)
     setSignature(Ed25519.sign(bos.toByteArray(), owner).toSignature())

api/src/main/java/com/getcode/network/client/Client_Chat.kt

@@ -29,4 +29,12 @@ suspend fun Client.fetchMessagesFor(owner: KeyPair, chatId: ID, cursor: Cursor?
         }.onFailure {
             Timber.e(t = it, "Failed fetching messages.")
         }
+}
+
+suspend fun Client.advancePointer(
+    owner: KeyPair,
+    chatId: ID,
+    to: ID,
+): Result<Unit> {
+    return chatService.advancePointer(owner, chatId, to)
 }

api/src/main/java/com/getcode/network/service/ChatService.kt

@@ -130,4 +130,39 @@ class ChatService @Inject constructor(
                 }
             }.first()
     }
+
+    suspend fun advancePointer(
+        owner: KeyPair,
+        chatId: ID,
+        to: ID,
+    ): Result<Unit> {
+        return networkOracle.managedRequest(api.advancePointer(owner, chatId, to))
+            .map { response ->
+                when (response.result) {
+                    ChatService.AdvancePointerResponse.Result.OK -> {
+                        Result.success(Unit)
+                    }
+                    ChatService.AdvancePointerResponse.Result.CHAT_NOT_FOUND -> {
+                        val error = Throwable("Error: chat not found $chatId")
+                        Timber.e(t = error)
+                        Result.failure(error)
+                    }
+                    ChatService.AdvancePointerResponse.Result.MESSAGE_NOT_FOUND -> {
+                        val error = Throwable("Error: message not found $to")
+                        Timber.e(t = error)
+                        Result.failure(error)
+                    }
+                    ChatService.AdvancePointerResponse.Result.UNRECOGNIZED -> {
+                        val error = Throwable("Error: Unrecognized request.")
+                        Timber.e(t = error)
+                        Result.failure(error)
+                    }
+                    else -> {
+                        val error = Throwable("Error: Unknown")
+                        Timber.e(t = error)
+                        Result.failure(error)
+                    }
+                }
+            }.first()
+    }
 }

app/src/main/java/com/getcode/view/main/chat/ChatViewModel.kt

@@ -77,6 +77,7 @@ class ChatViewModel @Inject constructor(
         stateFlow
             .map { it.chatId }
             .filterNotNull()
+            .onEach { historyController.advanceReadPointer(it) }
             .flatMapLatest { historyController.chats }
             .flowOn(Dispatchers.IO)
             .filterNotNull()