feat(chat): open @handle mentions in message bubbles (#1609)

* feat(chat): open @handle mentions in message bubbles

Ports code-ios-app#882. A `@handle` in a text or reply bubble is drawn
as a rounded pill and opens whoever it names.

Detection runs once per message in the mapper, beside the links, with
iOS's pattern. A handle inside a link (`x.com/@jeff`) stays the link's.
Mentions live on `ContentBubble.mentions`, outside card classification,
and `splitAroundLinkCard` rebases each into its own row.

A tap looks the handle up through `LinkCardResolver.lookUpUser`, which
shares the person card's lookup and memory, so a handle already
resolved opens without a round trip. Where it lands:

- the viewer's own handle: the You tab, as a person card to yourself does
- the open DM's counterpart: their profile as the title opens it, with
  Mute and without Message
- anyone else: their profile with Message and Send Cash and no Mute
  (`ProfileOrigin.Mention`)
- unclaimed: "No Such Account"; any other failure: "Couldn't Open
  Profile"

The pill uses iOS's values: white at 14%, 6dp radius, 6dp padding and
a 3dp gap, drawn per line when the handle wraps. The room either side
comes from inline placeholders, since Compose has no per-character
kerning.

* fix(chat): size text bubbles to their widest line and unstyle mentions

A Compose Text that wraps reports the full width it was offered, so a
wrapped message stretched its bubble to the maximum width. A mention
pill wrapping onto its own line left most of the bubble empty. The body
now measures itself once at the offered width and takes the width of
its widest line, as SwiftUI text does on iOS.

A clickable span with no style is drawn as a web link, so mentions came
out purple and underlined over their pills. They now take the body's
colour with no underline.

Author: bmc08gt

apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/chat/ChatStep.kt

@@ -75,7 +75,10 @@ sealed interface ChatStep : FlowStep, Parcelable {
 
     @Parcelize
     @Serializable
-    data class Profile(val contact: ChatParticipant): ChatStep
+    data class Profile(
+        val contact: ChatParticipant,
+        val origin: ProfileOrigin = ProfileOrigin.Chat,
+    ): ChatStep
 
     /**
      * The group's own profile — the counterpart of [Profile] for a chat that has no counterparty.
@@ -138,3 +141,20 @@ sealed interface ChatStep : FlowStep, Parcelable {
     @Serializable
     data class Reactors(val chatId: ChatId, val messageId: Long) : ChatStep, Sheet, HalfSheet
 }
+
+/** What opened a [ChatStep.Profile], which decides the actions it offers. */
+@Serializable
+enum class ProfileOrigin {
+    /**
+     * The chat's own title, or a member's picture or reactor row. The chat decides: a tip DM's
+     * profile is the other person in it, so it offers Mute and not Message.
+     */
+    Chat,
+
+    /**
+     * A tapped `@handle` naming someone other than the DM's counterpart. That person is not who
+     * the chat is with, so Mute would act on the wrong chat and Message and Send Cash have
+     * somewhere new to go. iOS's `UserProfileOrigin.mention`.
+     */
+    Mention,
+}

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/ChatFlowScreen.kt

@@ -19,6 +19,7 @@ import com.flipcash.app.core.chat.ChatIdentifier
 import com.flipcash.app.core.chat.ChatParticipant
 import com.flipcash.app.core.chat.ChatSendResult
 import com.flipcash.app.core.chat.ChatStep
+import com.flipcash.app.core.chat.ProfileOrigin
 import com.flipcash.app.core.chat.GroupInviteResult
 import com.flipcash.app.core.extensions.openAsSheet
 import com.flipcash.app.messenger.internal.ChatSubject
@@ -110,7 +111,7 @@ private fun chatEntryProvider(
     }
 
     annotatedEntry<ChatStep.Profile> { step ->
-        FlowChatProfileScreen(step.contact)
+        FlowChatProfileScreen(step.contact, step.origin)
     }
     annotatedEntry<ChatStep.GroupProfile> {
         FlowGroupProfileScreen()
@@ -310,15 +311,15 @@ private fun FlowGroupInviteSheet() {
 }
 
 @Composable
-private fun FlowChatProfileScreen(participant: ChatParticipant) {
+private fun FlowChatProfileScreen(participant: ChatParticipant, origin: ProfileOrigin) {
     val viewModel = flowSharedViewModel<ChatProfileViewModel>()
     val flowNavigator = rememberFlowNavigator<ChatStep, Parcelable>()
 
     LaunchedEffect(viewModel, participant) {
         viewModel.dispatchEvent(ChatProfileViewModel.Event.OnParticipantSet(participant))
     }
 
-    ChatProfileScreen(viewModel, flowSharedViewModel<ChatViewModel>())
+    ChatProfileScreen(viewModel, flowSharedViewModel<ChatViewModel>(), origin)
 
     LaunchedEffect(viewModel) {
         viewModel.eventFlow

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt

@@ -101,6 +101,7 @@ import com.flipcash.shared.chat.reactions.ReactionStripComposer
 import com.flipcash.shared.chat.reactions.SelfReaction
 import com.flipcash.shared.chat.readOnly
 import com.flipcash.shared.chat.resolveCapabilities
+import com.flipcash.shared.chat.ui.detectMentions
 import com.flipcash.shared.chat.ui.detectUrls
 import com.flipcash.shared.chat.ui.linkableText
 import com.flipcash.shared.chat.withinWindows
@@ -581,6 +582,15 @@ internal class ChatViewModel @Inject constructor(
         data object NavigateToInitPayment : Event
         data object PresentDepositOptions : Event
         data class OpenScreen(val route: AppRoute, val asSheet: Boolean = false): Event
+
+        /** The reader tapped a mention of [username] in the transcript. */
+        data class MentionTapped(val username: String) : Event
+
+        /**
+         * Where a tapped mention resolved to, for the screen to open. Only the destinations that
+         * open something: an unclaimed handle or a failed lookup is a dialog raised here.
+         */
+        data class OpenMention(val destination: MentionDestination) : Event
         data object OnConfirmRequested : Event
 
         /** Confirm the DM-opening fee. The amount comes from the fee, not from the keypad. */
@@ -850,8 +860,13 @@ internal class ChatViewModel @Inject constructor(
                     // which meant a chat painted nothing until every link in the first window had
                     // been round-tripped, and that every link in every mapped message was queried
                     // whether or not the reader ever scrolled to it.
-                    val linkCard = enriched.linkableText()
-                        ?.let { text -> linkCardClassifier.firstCard(detectUrls(text)) }
+                    val linkableText = enriched.linkableText()
+                    val links = linkableText?.let(::detectUrls).orEmpty()
+                    val linkCard = linkCardClassifier.firstCard(links)
+
+                    // Detected over the whole text, beside the links, so a handle inside a link
+                    // stays the link's. Nothing is looked up until one is tapped.
+                    val mentions = linkableText?.let { detectMentions(it, links) }.orEmpty()
 
                     // Noted while the voucher and the message it came on are in the same hand;
                     // see [ClaimReplyTargets]. Skipped for the reader's own messages, which is what
@@ -917,6 +932,7 @@ internal class ChatViewModel @Inject constructor(
                         // after the first page does.
                         senderId = message.senderId?.takeIf { !message.isFromSelf },
                         linkCard = linkCard,
+                        mentions = mentions,
                         // `splitAroundLinkCard` keeps these pills on the last row only.
                         reactionPills = storedReactions.pills,
                         selfReactions = storedReactions.selfReactions,
@@ -1152,6 +1168,7 @@ internal class ChatViewModel @Inject constructor(
         initChatHandlers()
         initLinkCardFreshness()
         initClaimReplies()
+        initMentionHandlers()
         initDraftHandlers()
         initGroupAnalytics()
 
@@ -1248,6 +1265,33 @@ internal class ChatViewModel @Inject constructor(
             .launchIn(viewModelScope)
     }
 
+    /**
+     * Opens where a tapped `@handle` leads. Looked up through [linkCardResolver], so a handle a
+     * person card or an earlier tap already resolved opens without a round trip.
+     *
+     * An unclaimed handle and a failed lookup get different dialogs: one is an answer, the other
+     * is worth trying again.
+     */
+    private fun initMentionHandlers() {
+        eventFlow.filterIsInstance<Event.MentionTapped>()
+            .onEach { event ->
+                val lookup = linkCardResolver.lookUpUser(LinkCard.User.Identity.ByUsername(event.username))
+                val counterpart = (stateFlow.value.participant as? ChatParticipant.TipUser)?.userId
+                when (val destination = mentionDestination(event.username, lookup, counterpart)) {
+                    is MentionDestination.NoSuchAccount -> BottomBarManager.showInfo(
+                        title = resources.getString(R.string.error_title_usernameNotFound),
+                        message = resources.getString(R.string.error_description_usernameNotFound, destination.username),
+                    )
+                    MentionDestination.LookupFailed -> BottomBarManager.showError(
+                        title = resources.getString(R.string.error_title_profileUnavailable),
+                        message = resources.getString(R.string.error_description_profileUnavailable),
+                    )
+                    else -> dispatchEvent(Event.OpenMention(destination))
+                }
+            }
+            .launchIn(viewModelScope)
+    }
+
     /**
      * Replies to the voucher with a thank-you, once a link tapped here has actually been collected.
      *
@@ -2636,6 +2680,8 @@ internal class ChatViewModel @Inject constructor(
                 Event.NavigateToInitPayment -> { state -> state.copy(sendProgress = LoadingSuccessState()) }
                 is Event.PresentDepositOptions -> { state -> state }
                 is Event.OpenScreen -> { state -> state }
+                is Event.MentionTapped -> { state -> state }
+                is Event.OpenMention -> { state -> state }
                 is Event.OnConfirmRequested -> { state -> state }
                 is Event.OnInitPaymentConfirmed -> { state -> state }
                 is Event.OnSendRequested -> { state -> state }

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/MentionDestination.kt

@@ -0,0 +1,61 @@
+package com.flipcash.app.messenger.internal
+
+import com.flipcash.app.core.chat.ChatParticipant
+import com.flipcash.app.core.chat.ProfileOrigin
+import com.flipcash.app.messenger.internal.link.UserLinkLookup
+import com.flipcash.services.models.GetUserProfileError
+import com.flipcash.shared.chat.models.LinkCard
+import com.getcode.opencode.model.core.ID
+
+/** Where a tapped `@handle` lands, once the handle has been looked up. iOS's `MentionDestination`. */
+internal sealed interface MentionDestination {
+    /** The handle is the viewer's own. Matches a person card linking to the viewer. */
+    data object OwnTipCard : MentionDestination
+
+    data class Profile(
+        val participant: ChatParticipant.TipUser,
+        val origin: ProfileOrigin,
+    ) : MentionDestination
+
+    /** Nobody has claimed [username]. */
+    data class NoSuchAccount(val username: String) : MentionDestination
+
+    /** The lookup never got an answer. */
+    data object LookupFailed : MentionDestination
+}
+
+/**
+ * Where a mention of [username] lands, given its [lookup] and the person the open DM is with, if
+ * any.
+ *
+ * The counterpart opens the way the DM's own title does, with Mute and without Message, since
+ * Message would lead straight back here. Anyone else gets the shortcuts and no Mute.
+ */
+internal fun mentionDestination(
+    username: String,
+    lookup: Result<LinkCard.User.State.Resolved>,
+    counterpart: ID?,
+): MentionDestination = lookup.fold(
+    onSuccess = { found ->
+        if (found.isOwn) {
+            MentionDestination.OwnTipCard
+        } else {
+            MentionDestination.Profile(
+                participant = ChatParticipant.TipUser(found.userId, found.profile),
+                origin = if (found.userId == counterpart) ProfileOrigin.Chat else ProfileOrigin.Mention,
+            )
+        }
+    },
+    onFailure = { error ->
+        if (error.meansUnclaimed()) {
+            MentionDestination.NoSuchAccount(username)
+        } else {
+            MentionDestination.LookupFailed
+        }
+    },
+)
+
+// The server answers an unclaimed handle with an id-less profile, which the lookup fails as
+// `NoSuchAccount`; `NotFound` is the same answer if it ever comes back as an error instead.
+private fun Throwable.meansUnclaimed(): Boolean =
+    this is UserLinkLookup.NoSuchAccount || this is GetUserProfileError.NotFound

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/link/LinkCardResolver.kt

@@ -111,6 +111,22 @@ internal class LinkCardResolver(
         is LinkCard.User -> card.copy(state = userState(card.identity))
     }
 
+    /**
+     * The person [identity] names, for a tapped `@handle`: the same lookup and the same stored
+     * answers a person card for `flipcash.com/<handle>` uses, so a handle a card or an earlier tap
+     * already resolved opens without a round trip.
+     *
+     * Unlike [resolve], the failure comes back whole. A card draws an unclaimed handle and a
+     * dropped connection alike, but a tap has to tell the reader which one happened. A stored
+     * answer does not outlive the server saying the handle names nobody.
+     */
+    suspend fun lookUpUser(identity: LinkCard.User.Identity): Result<LinkCard.User.State.Resolved> {
+        userAnswers[identity]?.let { return Result.success(it) }
+        return user(identity)
+            .onSuccess { memory.putUser(identity, it) }
+            .onFailure { if (it.meansLinkIsGone()) memory.removeUser(identity) }
+    }
+
     /**
      * Drops what is held about [entropy] and tells the cards on screen to ask again.
      *

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/MessengerScreen.kt

@@ -9,6 +9,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.imePadding
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -36,6 +37,7 @@ import com.flipcash.app.core.links.ExternalLinkUriHandler
 import com.flipcash.app.core.tokens.TokenInfoEntry
 import com.flipcash.app.messenger.internal.ChatSubject
 import com.flipcash.app.messenger.internal.ChatViewModel
+import com.flipcash.app.messenger.internal.MentionDestination
 import com.flipcash.app.messenger.internal.link.CashCardTap
 import com.flipcash.app.messenger.internal.screens.components.ChatTopBar
 import com.flipcash.app.messenger.internal.screens.components.ChatTopEdge
@@ -50,6 +52,7 @@ import com.getcode.ui.theme.ScaffoldBarPlacement
 import com.getcode.ui.utils.rememberKeyboardController
 import dev.chrisbanes.haze.hazeSource
 import dev.chrisbanes.haze.rememberHazeState
+import kotlinx.coroutines.flow.filterIsInstance
 
 @Composable
 internal fun MessengerScreen(viewModel: ChatViewModel) {
@@ -71,6 +74,27 @@ internal fun MessengerScreen(viewModel: ChatViewModel) {
     var barHeight by remember { mutableStateOf(0.dp) }
     val keyboard = rememberKeyboardController()
 
+    // Here rather than in the action handler because the lookup comes first: the tap only knows a
+    // handle, and where it leads is the view model's to decide once the handle has an answer.
+    LaunchedEffect(viewModel) {
+        viewModel.eventFlow
+            .filterIsInstance<ChatViewModel.Event.OpenMention>()
+            .collect { (destination) ->
+                keyboard.hideIfVisible {
+                    when (destination) {
+                        // As a person card linking to the viewer does: their card is on the You tab.
+                        MentionDestination.OwnTipCard ->
+                            navigator.rootNavigator.navigateAll(listOf(AppRoute.Tabs.Menu))
+                        is MentionDestination.Profile ->
+                            navigator.push(ChatStep.Profile(destination.participant, destination.origin))
+                        // Raised as dialogs by the view model; they never reach here.
+                        is MentionDestination.NoSuchAccount,
+                        MentionDestination.LookupFailed -> Unit
+                    }
+                }
+            }
+    }
+
     val chatActionHandler = { action: ChatAction ->
         when (action) {
             is ChatAction.AdvanceReadPointer -> {
@@ -159,6 +183,10 @@ internal fun MessengerScreen(viewModel: ChatViewModel) {
                 }
             }
 
+            is ChatAction.OpenMention -> {
+                viewModel.dispatchEvent(ChatViewModel.Event.MentionTapped(action.username))
+            }
+
             is ChatAction.ToggleSelection -> {
                 viewModel.dispatchEvent(ChatViewModel.Event.ToggleMessageSelection(action.bubble))
             }

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/ChatProfileScreen.kt

@@ -23,6 +23,7 @@ import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.flipcash.app.core.chat.ChatParticipant
 import com.flipcash.app.core.chat.ChatStep
+import com.flipcash.app.core.chat.ProfileOrigin
 import com.flipcash.app.core.chat.ReportSubject
 import com.flipcash.app.core.AppRoute
 import com.getcode.navigation.core.LocalCodeNavigator
@@ -66,18 +67,24 @@ import kotlin.time.Instant
  * The Message and Send Cash shortcuts follow the same split, the other way round: they show on a
  * group member's profile and not on a tip DM's, where they would only reopen the chat behind it.
  * [profileShortcutRecipient] has the whole rule. Share shows on every person's profile.
+ *
+ * A tapped `@handle` naming someone other than a tip DM's counterpart opens with
+ * [ProfileOrigin.Mention]. That person is not who the chat is with, so the screen leaves the chat
+ * out, as a `flipcash.com` link's profile does: no Mute, and Message shows.
  */
 @Composable
 internal fun ChatProfileScreen(
     viewModel: ChatProfileViewModel,
     chatViewModel: ChatViewModel,
+    origin: ProfileOrigin = ProfileOrigin.Chat,
 ) {
     val flowNavigator = rememberFlowNavigator<ChatStep, Parcelable>()
     val chatState by chatViewModel.stateFlow.collectAsStateWithLifecycle()
 
     PersonProfileScreen(
         viewModel = viewModel,
-        chat = ProfileChat(
+        chat = profileChat(
+            origin = origin,
             chatId = chatState.chatId,
             chatType = chatState.chatType,
             viewerState = chatState.viewerState,
@@ -87,6 +94,20 @@ internal fun ChatProfileScreen(
     )
 }
 
+/**
+ * The chat behind a profile opened from inside it, or null for a mention, whose person the chat is
+ * not with.
+ */
+internal fun profileChat(
+    origin: ProfileOrigin,
+    chatId: ChatId?,
+    chatType: ChatType,
+    viewerState: ViewerState?,
+): ProfileChat? = when (origin) {
+    ProfileOrigin.Chat -> ProfileChat(chatId, chatType, viewerState)
+    ProfileOrigin.Mention -> null
+}
+
 /**
  * The conversation a person's profile was opened from, for the parts of the screen that act on the
  * chat rather than the person: the mute row and the muted chip.