Improve reply popup after thread update

src/controllers/commands/CommandController.cpp

@@ -1563,20 +1563,16 @@ void CommandController::initialize(Settings &, Paths &paths)
                 const auto &msg = *it;
                 if (msg->loginName.compare(username, Qt::CaseInsensitive) == 0)
                 {
-                    std::shared_ptr<MessageThread> thread;
                     // found most recent message by user
                     if (msg->replyThread == nullptr)
                     {
-                        thread = std::make_shared<MessageThread>(msg);
+                        // prepare thread if one does not exist
+                        auto thread = std::make_shared<MessageThread>(msg);
                         twitchChannel->addReplyThread(thread);
                     }
-                    else
-                    {
-                        thread = msg->replyThread;
-                    }
 
                     QString reply = words.mid(2).join(" ");
-                    twitchChannel->sendReply(reply, thread->rootId());
+                    twitchChannel->sendReply(reply, msg->id);
                     return "";
                 }
             }

src/messages/Message.hpp

@@ -88,6 +88,7 @@ struct Message {
     // the reply thread will be cleaned up by the TwitchChannel.
     // The root of the thread does not have replyThread set.
     std::shared_ptr<MessageThread> replyThread;
+    std::shared_ptr<const Message> replyParent;
     uint32_t count = 1;
     std::vector<std::unique_ptr<MessageElement>> elements;
 

src/providers/twitch/IrcMessageHandler.cpp

@@ -453,10 +453,11 @@ void IrcMessageHandler::populateReply(
     const std::vector<MessagePtr> &otherLoaded, TwitchMessageBuilder &builder)
 {
     const auto &tags = message->tags();
-    if (const auto it = tags.find("reply-parent-msg-id"); it != tags.end())
+    if (const auto it = tags.find("reply-thread-parent-msg-id"); it != tags.end())
     {
         const QString replyID = it.value().toString();
         auto threadIt = channel->threads_.find(replyID);
+        std::shared_ptr<MessageThread> rootThread;
         if (threadIt != channel->threads_.end())
         {
             auto owned = threadIt->second.lock();
@@ -466,43 +467,73 @@ void IrcMessageHandler::populateReply(
                 updateReplyParticipatedStatus(tags, message->nick(), builder,
                                               owned, false);
                 builder.setThread(owned);
-                return;
+                rootThread = owned;
             }
         }
 
-        MessagePtr foundMessage;
-
-        // Thread does not yet exist, find root reply and create thread.
-        // Linear search is justified by the infrequent use of replies
-        for (auto &otherMsg : otherLoaded)
+        if (!rootThread)
         {
-            if (otherMsg->id == replyID)
+            MessagePtr foundMessage;
+
+            // Thread does not yet exist, find root reply and create thread.
+            // Linear search is justified by the infrequent use of replies
+            for (auto &otherMsg : otherLoaded)
             {
-                // Found root reply message
-                foundMessage = otherMsg;
-                break;
+                if (otherMsg->id == replyID)
+                {
+                    // Found root reply message
+                    foundMessage = otherMsg;
+                    break;
+                }
             }
-        }
 
-        if (!foundMessage)
-        {
-            // We didn't find the reply root message in the otherLoaded messages
-            // which are typically the already-parsed recent messages from the
-            // Recent Messages API. We could have a really old message that
-            // still exists being replied to, so check for that here.
-            foundMessage = channel->findMessage(replyID);
+            if (!foundMessage)
+            {
+                // We didn't find the reply root message in the otherLoaded messages
+                // which are typically the already-parsed recent messages from the
+                // Recent Messages API. We could have a really old message that
+                // still exists being replied to, so check for that here.
+                foundMessage = channel->findMessage(replyID);
+            }
+
+            if (foundMessage)
+            {
+                std::shared_ptr<MessageThread> newThread =
+                        std::make_shared<MessageThread>(foundMessage);
+                updateReplyParticipatedStatus(tags, message->nick(), builder,
+                                              newThread, true);
+
+                builder.setThread(newThread);
+                rootThread = newThread;
+                // Store weak reference to thread in channel
+                channel->addReplyThread(newThread);
+            }
         }
 
-        if (foundMessage)
+        if (const auto parentIt = tags.find("reply-parent-msg-id"); parentIt != tags.end())
         {
-            std::shared_ptr<MessageThread> newThread =
-                std::make_shared<MessageThread>(foundMessage);
-            updateReplyParticipatedStatus(tags, message->nick(), builder,
-                                          newThread, true);
-
-            builder.setThread(newThread);
-            // Store weak reference to thread in channel
-            channel->addReplyThread(newThread);
+            const QString parentID = parentIt.value().toString();
+            std::shared_ptr<const Message> parent;
+            if (replyID == parentID)
+            {
+                if (rootThread)
+                {
+                    parent = rootThread->root();
+                }
+            }
+            else
+            {
+                auto parentThreadIt = channel->threads_.find(parentID);
+                if (parentThreadIt != channel->threads_.end() && !parentThreadIt->second.expired())
+                {
+                    parent = parentThreadIt->second.lock()->root();
+                }
+                else
+                {
+                    parent = channel->findMessage(parentID);
+                }
+            }
+            builder.setParent(parent);
         }
     }
 }
@@ -570,17 +601,19 @@ void IrcMessageHandler::addMessage(Communi::IrcMessage *_message,
     TwitchMessageBuilder builder(chan.get(), _message, args, content, isAction);
     builder.setMessageOffset(messageOffset);
 
-    if (const auto it = tags.find("reply-parent-msg-id"); it != tags.end())
+    if (const auto it = tags.find("reply-thread-parent-msg-id"); it != tags.end())
     {
         const QString replyID = it.value().toString();
         auto threadIt = channel->threads_.find(replyID);
+        std::shared_ptr<MessageThread> rootThread;
         if (threadIt != channel->threads_.end() && !threadIt->second.expired())
         {
             // Thread already exists (has a reply)
             auto thread = threadIt->second.lock();
             updateReplyParticipatedStatus(tags, _message->nick(), builder,
                                           thread, false);
             builder.setThread(thread);
+            rootThread = thread;
         }
         else
         {
@@ -594,10 +627,37 @@ void IrcMessageHandler::addMessage(Communi::IrcMessage *_message,
                                               newThread, true);
 
                 builder.setThread(newThread);
+                rootThread = newThread;
                 // Store weak reference to thread in channel
                 channel->addReplyThread(newThread);
             }
         }
+
+        if (const auto parentIt = tags.find("reply-parent-msg-id"); parentIt != tags.end())
+        {
+            const QString parentID = parentIt.value().toString();
+            std::shared_ptr<const Message> parent;
+            if (replyID == parentID)
+            {
+                if (rootThread)
+                {
+                    parent = rootThread->root();
+                }
+            }
+            else
+            {
+                auto parentThreadIt = channel->threads_.find(parentID);
+                if (parentThreadIt != channel->threads_.end() && !parentThreadIt->second.expired())
+                {
+                    parent = parentThreadIt->second.lock()->root();
+                }
+                else
+                {
+                    parent = channel->findMessage(parentID);
+                }
+            }
+            builder.setParent(parent);
+        }
     }
 
     if (isSub || !builder.isIgnored())

src/providers/twitch/TwitchMessageBuilder.cpp

@@ -623,15 +623,21 @@ void TwitchMessageBuilder::parseThread()
     {
         // set references
         this->message().replyThread = this->thread_;
+        this->message().replyParent = this->parent_;
         this->thread_->addToThread(this->weakOf());
 
         // enable reply flag
         this->message().flags.set(MessageFlag::ReplyMessage);
 
-        const auto &threadRoot = this->thread_->root();
+        std::shared_ptr<const Message> threadRoot;
+        if (!this->parent_) {
+            threadRoot = this->thread_->root();
+        } else {
+            threadRoot = this->parent_;
+        }
 
         QString usernameText = SharedMessageBuilder::stylizeUsername(
-            threadRoot->loginName, *threadRoot.get());
+            threadRoot->loginName, *threadRoot);
 
         this->emplace<ReplyCurveElement>();
 
@@ -1811,6 +1817,11 @@ void TwitchMessageBuilder::setThread(std::shared_ptr<MessageThread> thread)
     this->thread_ = std::move(thread);
 }
 
+void TwitchMessageBuilder::setParent(std::shared_ptr<const Message> parent)
+{
+    this->parent_ = std::move(parent);
+}
+
 void TwitchMessageBuilder::setMessageOffset(int offset)
 {
     this->messageOffset_ = offset;

src/providers/twitch/TwitchMessageBuilder.hpp

@@ -58,6 +58,7 @@ class TwitchMessageBuilder : public SharedMessageBuilder
     MessagePtr build() override;
 
     void setThread(std::shared_ptr<MessageThread> thread);
+    void setParent(std::shared_ptr<const Message> parent);
     void setMessageOffset(int offset);
 
     static void appendChannelPointRewardMessage(
@@ -131,6 +132,7 @@ class TwitchMessageBuilder : public SharedMessageBuilder
     bool bitsStacked = false;
     bool historicalMessage_ = false;
     std::shared_ptr<MessageThread> thread_;
+    std::shared_ptr<const Message> parent_;
 
     /**
      * Starting offset to be used on index-based operations on `originalMessage_`.

src/singletons/helper/LoggingChannel.cpp

@@ -132,8 +132,7 @@ void LoggingChannel::addMessage(MessagePtr message)
         qsizetype colonIndex = messageText.indexOf(':');
         if (colonIndex != -1)
         {
-            QString rootMessageChatter =
-                message->replyThread->root()->loginName;
+            QString rootMessageChatter = message->replyParent->loginName;
             messageText.insert(colonIndex + 1, " @" + rootMessageChatter);
         }
     }

src/widgets/dialogs/ReplyThreadPopup.cpp

@@ -189,7 +189,7 @@ ReplyThreadPopup::ReplyThreadPopup(bool closeAutomatically, QWidget *parent,
 void ReplyThreadPopup::setThread(std::shared_ptr<MessageThread> thread)
 {
     this->thread_ = std::move(thread);
-    this->ui_.replyInput->setReply(this->thread_);
+    this->ui_.replyInput->setReply(this->thread_->root());
     this->addMessagesFromThread();
     this->updateInputUI();
 

src/widgets/helper/ChannelView.cpp

@@ -2830,10 +2830,9 @@ void ChannelView::setInputReply(const MessagePtr &message)
         return;
     }
 
-    std::shared_ptr<MessageThread> thread;
-
     if (message->replyThread == nullptr)
     {
+        // Create thread if one does not exist
         auto getThread = [&](TwitchChannel *tc) {
             auto threadIt = tc->threads().find(message->id);
             if (threadIt != tc->threads().end() && !threadIt->second.expired())
@@ -2851,26 +2850,15 @@ void ChannelView::setInputReply(const MessagePtr &message)
         if (auto tc =
                 dynamic_cast<TwitchChannel *>(this->underlyingChannel_.get()))
         {
-            thread = getThread(tc);
+            getThread(tc);
         }
         else if (auto tc = dynamic_cast<TwitchChannel *>(this->channel_.get()))
         {
-            thread = getThread(tc);
-        }
-        else
-        {
-            qCWarning(chatterinoCommon) << "Failed to create new reply thread";
-            // Unable to create new reply thread.
-            // TODO(dnsge): Should probably notify user?
-            return;
+            getThread(tc);
         }
     }
-    else
-    {
-        thread = message->replyThread;
-    }
 
-    this->split_->setInputReply(thread);
+    this->split_->setInputReply(message);
 }
 
 void ChannelView::showReplyThreadPopup(const MessagePtr &message)

src/widgets/splits/Split.cpp

@@ -1542,7 +1542,7 @@ void Split::drag()
     stopDraggingSplit();
 }
 
-void Split::setInputReply(const std::shared_ptr<MessageThread> &reply)
+void Split::setInputReply(const std::shared_ptr<const Message> &reply)
 {
     this->input_->setReply(reply);
 }

src/widgets/splits/Split.hpp

@@ -15,7 +15,6 @@
 namespace chatterino {
 
 class ChannelView;
-class MessageThread;
 class SplitHeader;
 class SplitInput;
 class SplitContainer;
@@ -75,7 +74,7 @@ class Split : public BaseWidget
 
     void setContainer(SplitContainer *container);
 
-    void setInputReply(const std::shared_ptr<MessageThread> &reply);
+    void setInputReply(const std::shared_ptr<const Message> &reply);
 
     static pajlada::Signals::Signal<Qt::KeyboardModifiers>
         modifierStatusChanged;

src/widgets/splits/SplitInput.cpp

@@ -359,7 +359,7 @@ QString SplitInput::handleSendMessage(std::vector<QString> &arguments)
         if (this->enableInlineReplying_)
         {
             // Remove @username prefix that is inserted when doing inline replies
-            message.remove(0, this->replyThread_->root()->displayName.length() +
+            message.remove(0, this->replyThread_->displayName.length() +
                                   1);  // remove "@username"
 
             if (!message.isEmpty() && message.at(0) == ' ')
@@ -373,7 +373,7 @@ QString SplitInput::handleSendMessage(std::vector<QString> &arguments)
             getApp()->commands->execCommand(message, c, false);
 
         // Reply within TwitchChannel
-        tc->sendReply(sendMessage, this->replyThread_->rootId());
+        tc->sendReply(sendMessage, this->replyThread_->id);
 
         this->postMessageSend(message, arguments);
         return "";
@@ -992,7 +992,7 @@ void SplitInput::editTextChanged()
             // We need to verify that
             // 1. the @username prefix exists and
             // 2. if a character exists after the @username, it is a space
-            QString replyPrefix = "@" + this->replyThread_->root()->displayName;
+            QString replyPrefix = "@" + this->replyThread_->displayName;
             if (!text.startsWith(replyPrefix) ||
                 (text.length() > replyPrefix.length() &&
                  text.at(replyPrefix.length()) != ' '))
@@ -1065,15 +1065,15 @@ void SplitInput::giveFocus(Qt::FocusReason reason)
     this->ui_.textEdit->setFocus(reason);
 }
 
-void SplitInput::setReply(std::shared_ptr<MessageThread> reply,
+void SplitInput::setReply(std::shared_ptr<const Message> reply,
                           bool showReplyingLabel)
 {
     this->replyThread_ = std::move(reply);
 
     if (this->enableInlineReplying_)
     {
         // Only enable reply label if inline replying
-        auto replyPrefix = "@" + this->replyThread_->root()->displayName;
+        auto replyPrefix = "@" + this->replyThread_->displayName;
         auto plainText = this->ui_.textEdit->toPlainText().trimmed();
         if (!plainText.startsWith(replyPrefix))
         {
@@ -1086,7 +1086,7 @@ void SplitInput::setReply(std::shared_ptr<MessageThread> reply,
             this->ui_.textEdit->resetCompletion();
         }
         this->ui_.replyLabel->setText("Replying to @" +
-                                      this->replyThread_->root()->displayName);
+                                      this->replyThread_->displayName);
     }
 }