Add Unreplied tab to the RS comments list (#23133)

* Add Unreplied tab to the RS comments list

Ports the legacy Unreplied filter to the wordpress-rs comments list without
FluxC. A new UNREPLIED tab fetches status=all and is threaded client-side to
keep only top-level comments the current user hasn't replied to.

RsComment now carries authorId/parentId (view context has no author email, so
"mine" is a user-id comparison); the current user id is read from the same
cached retrieveMeWithEditContext fetch that backs the moderate capability.

* Simplify Unreplied over-fetch: named val instead of .let

* Fix review findings in the Unreplied tab

- Seed the swipe session without a cursor for Unreplied so the detail pager
  can't page the raw stream into the replied-to/own comments the tab hides.
- Auto-advance past a filtered-empty first page (and after a re-thread empties
  one) so unreplied matches on later pages aren't stranded behind a false
  empty state; also closes the cold-start race where currentUserId resolves
  after the first page applies.
- Carry over resolved post titles when rebuilding rows so load-more no longer
  flashes titles and the re-thread no longer loses them permanently.
- Prune the selection to still-visible rows after a re-thread.

* Auto-advance Unreplied paging when a page shrinks the list to empty

A load-more page can carry the user's reply to the last visible unreplied
comment, dropping the visible count to zero. Widen the auto-advance guard from
== to <= sizeBefore so paging continues instead of stranding a false empty
state (there's no scroll trigger left once the list is empty).

Author: nbradbury

WordPress/src/main/java/org/wordpress/android/ui/comments/unified/CommentsRsDataSource.kt

@@ -51,6 +51,11 @@ class CommentsRsDataSource @Inject constructor(
     /** A comment mapped from [CommentWithViewContext], shared by the detail and list screens. */
     data class RsComment(
         val remoteCommentId: Long,
+        // The commenter's WP user id (0 when anonymous), and the parent comment id (0 when
+        // top-level). Both feed the Unreplied tab's client-side threading — the view context has
+        // no author email, so "is this reply mine?" is a user-id comparison.
+        val authorId: Long = 0,
+        val parentId: Long = 0,
         val authorName: String,
         val authorAvatarUrl: String,
         val dateGmt: Date,
@@ -320,6 +325,8 @@ class CommentsRsDataSource @Inject constructor(
 
 internal fun CommentWithViewContext.toRsComment() = CommentsRsDataSource.RsComment(
     remoteCommentId = id,
+    authorId = author,
+    parentId = parent,
     authorName = authorName,
     authorAvatarUrl = pickAvatarUrl(),
     // dateGmt is a UTC java.util.Date (an absolute instant), so relative-time formatting is

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/CommentsRsListTab.kt

@@ -5,15 +5,17 @@ import org.wordpress.android.R
 import uniffi.wp_api.CommentStatus as RsCommentStatus
 
 /**
- * Filter tabs for the rs comments list, matching the legacy unified list minus Unreplied
- * (deferred; it needs client-side threading of ~100 comments).
+ * Filter tabs for the rs comments list, matching the legacy unified list.
  *
- * [queryStatus] is the `status` query param for `/wp/v2/comments`. Two tabs use
+ * [queryStatus] is the `status` query param for `/wp/v2/comments`. Three tabs use
  * [RsCommentStatus.Custom] because `WP_Comment_Query` only recognises the literal values
  * `approve` and `all` — wordpress-rs serialises [RsCommentStatus.Approved] as `approved`,
  * which WordPress core treats as an unknown status and returns nothing for (wordpress-rs
  * `comments.rs` serialisation test asserts `status=approved`). `all` means approved+hold,
  * matching the legacy ALL filter (APPROVED+UNAPPROVED).
+ *
+ * [UNREPLIED] has no server status: it queries `all` (like [ALL]) and is threaded client-side by
+ * [filterUnreplied] to keep only top-level comments the user hasn't replied to, mirroring legacy.
  */
 enum class CommentsRsListTab(
     @StringRes val labelResId: Int,
@@ -34,6 +36,12 @@ enum class CommentsRsListTab(
         R.string.comment_tracker_label_pending,
         RsCommentStatus.Hold
     ),
+    UNREPLIED(
+        R.string.comment_status_unreplied,
+        R.string.comments_empty_list_filtered_unreplied,
+        R.string.comment_tracker_label_unreplied,
+        RsCommentStatus.Custom("all")
+    ),
     APPROVED(
         R.string.comment_status_approved,
         R.string.comments_empty_list_filtered_approved,

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/CommentsRsListUiState.kt

@@ -109,6 +109,13 @@ internal fun CommentsRsListTab.batchActions(): List<CommentsRsBatchAction> = whe
         CommentsRsBatchAction.SPAM,
         CommentsRsBatchAction.TRASH
     )
+    // Unreplied rows are approved or pending comments, so offer the same actions as ALL.
+    CommentsRsListTab.UNREPLIED -> listOf(
+        CommentsRsBatchAction.APPROVE,
+        CommentsRsBatchAction.UNAPPROVE,
+        CommentsRsBatchAction.SPAM,
+        CommentsRsBatchAction.TRASH
+    )
     CommentsRsListTab.APPROVED -> listOf(
         CommentsRsBatchAction.UNAPPROVE,
         CommentsRsBatchAction.SPAM,

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/CommentsRsListViewModel.kt

@@ -103,6 +103,16 @@ class CommentsRsListViewModel @Inject constructor(
     private val _canModerate = MutableStateFlow(false)
     val canModerate: StateFlow<Boolean> = _canModerate.asStateFlow()
 
+    // The current user's WP user id, resolved once on init (from the same "me" fetch as
+    // canModerate); null until then, or if it couldn't be fetched. Used only to tell the user's
+    // own replies apart when threading the Unreplied tab. Read and written only on the main thread.
+    private var currentUserId: Long? = null
+
+    // Raw comments fetched per tab, accumulated across pages. The Unreplied tab derives its
+    // displayed rows from this via client-side threading, so a reply and the parent it answers can
+    // arrive on different pages and still be matched.
+    private val rawComments = mutableMapOf<CommentsRsListTab, List<RsComment>>()
+
     // Pagination cursors: the next-page params returned with each fetched page, per tab.
     private val nextPageParams = mutableMapOf<CommentsRsListTab, CommentListParams?>()
 
@@ -142,7 +152,12 @@ class CommentsRsListViewModel @Inject constructor(
             _events.trySend(CommentsRsListEvent.Finish)
         } else {
             viewModelScope.launch {
+                // Both values come from the same cached "me" fetch inside SiteCapabilityChecker.
                 _canModerate.value = withContext(bgDispatcher) { siteCapabilityChecker.canModerateComments(site) }
+                currentUserId = withContext(bgDispatcher) { siteCapabilityChecker.currentUserId(site) }
+                // If the Unreplied tab loaded before the id resolved, re-thread it now that the
+                // user's own replies can be identified.
+                rethreadUnreplied()
             }
             @OptIn(FlowPreview::class)
             viewModelScope.launch {
@@ -220,6 +235,7 @@ class CommentsRsListViewModel @Inject constructor(
         loadMoreJobs.clear()
         resolveTitleJobs.values.forEach { it.cancel() }
         resolveTitleJobs.clear()
+        rawComments.clear()
         nextPageParams.clear()
         pageGenerations.clear()
         _tabStates.value = emptyMap()
@@ -313,12 +329,14 @@ class CommentsRsListViewModel @Inject constructor(
                 is RsCommentsPageResult.Success -> {
                     val sizeBefore = getTabUiState(tab).comments.size
                     applyPage(tab, result, append = true)
-                    // When a page adds no rows (it deduped away after a server-side shift, or
-                    // came back empty mid-shrink), the scroll position hasn't changed so the
-                    // load-more trigger won't re-fire; advance to the next page directly. The
-                    // depth cap keeps a pathological cursor chain (e.g. a proxy ignoring the
+                    // When a page doesn't grow the visible list, the scroll position hasn't moved
+                    // so the load-more trigger won't re-fire; advance to the next page directly.
+                    // `<=` (not `==`) also covers the shrink-to-empty case: an Unreplied page can
+                    // carry the user's reply to the last visible comment, dropping the visible
+                    // count to zero — with no rows there's no scroll trigger left to resume paging.
+                    // The depth cap keeps a pathological cursor chain (e.g. a proxy ignoring the
                     // page param) from firing unbounded unattended requests.
-                    if (getTabUiState(tab).comments.size == sizeBefore &&
+                    if (getTabUiState(tab).comments.size <= sizeBefore &&
                         nextPageParams[tab] != null &&
                         autoAdvanceDepth < CommentBrowsingSession.MAX_AUTO_ADVANCE_PAGES
                     ) {
@@ -349,7 +367,11 @@ class CommentsRsListViewModel @Inject constructor(
             // it can swipe between them and keep loading more (the cursor can't cross an Intent).
             val tab = currentTab ?: CommentsRsListTab.ALL
             val ids = _tabStates.value[tab]?.comments?.map { it.remoteCommentId } ?: listOf(remoteCommentId)
-            commentBrowsingSession.start(site, ids, nextPageParams[tab])
+            // Unreplied's rows are a client-side-threaded subset of the raw stream; the session
+            // pages the raw stream, so handing it the cursor would let the pager swipe into the
+            // replied-to and own comments the tab hides. Seed only the visible ids, no cursor.
+            val cursor = if (tab == CommentsRsListTab.UNREPLIED) null else nextPageParams[tab]
+            commentBrowsingSession.start(site, ids, cursor)
             _events.trySend(CommentsRsListEvent.OpenCommentDetail(site, remoteCommentId))
         }
     }
@@ -492,13 +514,19 @@ class CommentsRsListViewModel @Inject constructor(
     private fun fetchFirstPage(tab: CommentsRsListTab, showErrorSnackbar: Boolean = true) {
         // Callers (initTab, refreshTab) guard against a null site, so the site getter below is safe.
         firstPageJobs[tab] = viewModelScope.launch {
-            val params = commentsRsDataSource.firstPageParams(
+            val base = commentsRsDataSource.firstPageParams(
                 status = tab.queryStatus,
                 search = _searchQuery.value.trim().ifBlank { null }
             )
+            // Unreplied over-fetches (like the legacy list) since client-side threading discards
+            // most of each page, so a single page still yields visible rows.
+            val params = if (tab == CommentsRsListTab.UNREPLIED) base.copy(perPage = UNREPLIED_PAGE_SIZE) else base
             val result = withContext(bgDispatcher) { commentsRsDataSource.fetchCommentsPage(site, params) }
             when (result) {
-                is RsCommentsPageResult.Success -> applyPage(tab, result, append = false)
+                is RsCommentsPageResult.Success -> {
+                    applyPage(tab, result, append = false)
+                    advanceIfFilteredEmpty(tab)
+                }
                 is RsCommentsPageResult.Error -> onFirstPageError(tab, result.message, showErrorSnackbar)
             }
         }
@@ -512,12 +540,18 @@ class CommentsRsListViewModel @Inject constructor(
     private fun applyPage(tab: CommentsRsListTab, result: RsCommentsPageResult.Success, append: Boolean) {
         if (!append) pageGenerations[tab] = (pageGenerations[tab] ?: 0) + 1
         nextPageParams[tab] = result.nextPageParams
-        val newRows = result.comments.map { it.toUiModel() }
+        // A comment can shift pages if the list changed server-side between requests, so dedupe
+        // the accumulated raw set on append. Displayed rows are always derived from this raw set,
+        // which lets Unreplied thread a reply against a parent fetched on an earlier page.
+        val raw = if (append) {
+            (rawComments[tab].orEmpty() + result.comments).distinctBy { it.remoteCommentId }
+        } else {
+            result.comments
+        }
+        rawComments[tab] = raw
         updateTabUiState(tab) {
             copy(
-                // A comment can shift pages if the list changed server-side between requests,
-                // so dedupe on append.
-                comments = if (append) (comments + newRows).distinctBy { it.remoteCommentId } else newRows,
+                comments = displayRows(tab, raw),
                 isLoading = false,
                 isRefreshing = false,
                 // A replacing page must clear isLoadingMore too: a load-more in flight when the
@@ -531,6 +565,50 @@ class CommentsRsListViewModel @Inject constructor(
         resolvePostTitles(tab)
     }
 
+    /**
+     * Maps a tab's accumulated raw comments to displayed rows. The Unreplied tab is threaded
+     * client-side to only the comments the user hasn't replied to; every other tab shows its
+     * comments as-is.
+     */
+    private fun displayRows(tab: CommentsRsListTab, raw: List<RsComment>): List<CommentRsUiModel> {
+        // Rows are rebuilt from title-less RsComments, so carry over any post titles already
+        // resolved for the tab (keyed by post — a title is the same for every comment on a post).
+        // Without this, each rebuild (load-more, re-thread) would blank titles until resolvePostTitles
+        // re-fetches them, and re-thread — which never re-resolves — would lose them for good.
+        val knownTitles = getTabUiState(tab).comments
+            .filter { it.postTitle != null }
+            .associate { it.postId to it.postTitle }
+        val visible = if (tab == CommentsRsListTab.UNREPLIED) filterUnreplied(raw, currentUserId) else raw
+        return visible.map { it.toUiModel().copy(postTitle = knownTitles[it.postId]) }
+    }
+
+    /** Re-derives the Unreplied tab's rows from its raw comments (e.g. once [currentUserId] resolves). */
+    private fun rethreadUnreplied() {
+        val tab = CommentsRsListTab.UNREPLIED
+        val raw = rawComments[tab] ?: return
+        val rows = displayRows(tab, raw)
+        updateTabUiState(tab) { copy(comments = rows) }
+        // Re-threading can drop rows that were over-reported while currentUserId was still null;
+        // clear any selection for comments no longer shown so an off-screen id can't intercept
+        // back presses or target a batch action (the same hazard refreshTab guards against).
+        val visibleIds = rows.mapTo(mutableSetOf()) { it.remoteCommentId }
+        _selectedIds.update { it intersect visibleIds }
+        // Re-threading with the now-known id can empty a page that previously over-reported, so
+        // keep paging rather than stranding matches behind a false empty state.
+        advanceIfFilteredEmpty(tab)
+    }
+
+    /**
+     * Keeps paging while a filtered tab (Unreplied) shows no rows but the raw stream has more:
+     * a full page can thread away to nothing, and the list's load-more trigger only fires once
+     * rows are on screen. Bounded by the same auto-advance cap as load-more.
+     */
+    private fun advanceIfFilteredEmpty(tab: CommentsRsListTab) {
+        if (getTabUiState(tab).comments.isEmpty() && nextPageParams[tab] != null) {
+            loadMoreInternal(tab, autoAdvanceDepth = 0)
+        }
+    }
+
     /**
      * First-page failure: when the tab already shows comments keep them and offer a retry
      * snackbar; when it's empty, show the full-screen error state. Silent refreshes (returning
@@ -610,5 +688,9 @@ class CommentsRsListViewModel @Inject constructor(
 
         private const val SEARCH_DEBOUNCE_MS = 250L
         private const val MIN_SEARCH_QUERY_LENGTH = 3
+
+        // Larger page for the Unreplied tab (matching the legacy list) to offset the rows that
+        // client-side threading filters out.
+        private const val UNREPLIED_PAGE_SIZE = 100u
     }
 }

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/CommentsRsUnrepliedFilter.kt

@@ -0,0 +1,33 @@
+package org.wordpress.android.ui.commentsrs
+
+import org.wordpress.android.ui.comments.unified.CommentsRsDataSource.RsComment
+
+/**
+ * Client-side "Unreplied" filter for the rs comments list, mirroring the legacy
+ * `UnrepliedCommentsUtils`. A comment is unreplied when it is a top-level comment
+ * ([RsComment.parentId] == 0) that the current user did not write and that has no direct reply
+ * written by the current user.
+ *
+ * Threading is computed over whatever comments have been loaded so far, so — exactly like the
+ * legacy list — a reply that lives on a not-yet-loaded page can briefly leave its parent showing
+ * as unreplied until that page arrives.
+ *
+ * "Mine" is a user-id comparison ([RsComment.authorId] == [myUserId]) because the view context
+ * carries no author email. When [myUserId] is null (the "me" fetch failed), nothing counts as
+ * mine and the filter over-reports rather than hiding comments — the same fallback the legacy
+ * util has when it can't resolve the account email.
+ */
+internal fun filterUnreplied(comments: List<RsComment>, myUserId: Long?): List<RsComment> {
+    val myReplyParentIds = comments
+        .filter { it.parentId != 0L && isMine(it, myUserId) }
+        .map { it.parentId }
+        .toSet()
+    return comments.filter { comment ->
+        comment.parentId == 0L &&
+                !isMine(comment, myUserId) &&
+                comment.remoteCommentId !in myReplyParentIds
+    }
+}
+
+private fun isMine(comment: RsComment, myUserId: Long?): Boolean =
+    myUserId != null && comment.authorId == myUserId

WordPress/src/main/java/org/wordpress/android/ui/commentsrs/screens/CommentsRsListScreen.kt

@@ -110,6 +110,7 @@ fun CommentsRsListScreen(
     val listStates = mapOf(
         CommentsRsListTab.ALL to rememberLazyListState(),
         CommentsRsListTab.PENDING to rememberLazyListState(),
+        CommentsRsListTab.UNREPLIED to rememberLazyListState(),
         CommentsRsListTab.APPROVED to rememberLazyListState(),
         CommentsRsListTab.SPAM to rememberLazyListState(),
         CommentsRsListTab.TRASHED to rememberLazyListState()

WordPress/src/main/java/org/wordpress/android/ui/mysite/items/listitem/SiteCapabilityChecker.kt

@@ -42,6 +42,14 @@ class SiteCapabilityChecker @Inject constructor(
     suspend fun canModerateComments(site: SiteModel): Boolean =
         capabilities(site).canModerateComments
 
+    /**
+     * The current user's WP user id for the given site, or null if it couldn't be resolved. Read
+     * from the same "me" fetch as the capabilities above (no extra request). The rs comments list
+     * uses it to tell the user's own replies apart when computing the Unreplied filter.
+     */
+    suspend fun currentUserId(site: SiteModel): Long? =
+        capabilities(site).currentUserId
+
     private suspend fun capabilities(site: SiteModel): CapabilityCache {
         capabilityCache[site.id]?.let { return it }
         // Only a successful fetch is cached. On failure fall back to a fail-closed value for this
@@ -59,10 +67,11 @@ class SiteCapabilityChecker @Inject constructor(
             }
             when (response) {
                 is WpRequestResult.Success -> {
-                    val capabilities = response.response.data.capabilities
+                    val user = response.response.data
                     CapabilityCache(
-                        hasEditThemeOptions = capabilities.hasCap(UserCapability.EditThemeOptions),
-                        canModerateComments = capabilities.hasCap(UserCapability.ModerateComments)
+                        hasEditThemeOptions = user.capabilities.hasCap(UserCapability.EditThemeOptions),
+                        canModerateComments = user.capabilities.hasCap(UserCapability.ModerateComments),
+                        currentUserId = user.id
                     )
                 }
                 // Return null (not cached) so the next call retries rather than locking in a
@@ -84,6 +93,7 @@ class SiteCapabilityChecker @Inject constructor(
 
     private data class CapabilityCache(
         val hasEditThemeOptions: Boolean = false,
-        val canModerateComments: Boolean = false
+        val canModerateComments: Boolean = false,
+        val currentUserId: Long? = null
     )
 }

WordPress/src/test/java/org/wordpress/android/ui/comments/unified/CommentsRsListMappingTest.kt

@@ -20,6 +20,8 @@ class CommentsRsListMappingTest {
         val item = rsComment().toRsComment()
 
         assertThat(item.remoteCommentId).isEqualTo(COMMENT_ID)
+        assertThat(item.authorId).isEqualTo(7L)
+        assertThat(item.parentId).isEqualTo(0L)
         assertThat(item.authorName).isEqualTo("Jane")
         assertThat(item.authorAvatarUrl).isEqualTo("https://example.com/avatar96.png")
         assertThat(item.dateGmt).isEqualTo(DATE_GMT)
@@ -29,6 +31,11 @@ class CommentsRsListMappingTest {
         assertThat(item.status).isEqualTo(APPROVED)
     }
 
+    @Test
+    fun `toRsComment carries the parent id used for Unreplied threading`() {
+        assertThat(rsComment(parent = 42L).toRsComment().parentId).isEqualTo(42L)
+    }
+
     @Test
     fun `pickAvatarUrl prefers size 96`() {
         val comment = rsComment(
@@ -73,6 +80,7 @@ class CommentsRsListMappingTest {
 
     private fun rsComment(
         status: RsCommentStatus = RsCommentStatus.Approved,
+        parent: Long = 0L,
         avatarUrls: Map<UserAvatarSize, String> = mapOf(
             UserAvatarSize.Size96 to "https://example.com/avatar96.png"
         )
@@ -85,7 +93,7 @@ class CommentsRsListMappingTest {
         date = "2026-07-01T12:00:00",
         dateGmt = DATE_GMT,
         link = "https://example.com/post/#comment-42",
-        parent = 0L,
+        parent = parent,
         post = POST_ID,
         status = status,
         commentType = CommentType.Comment,