improve MESSAGE_UPDATE handling (hopefully)

10 files changed, 102 insertions, 57 deletions

diff --git a/abaddon.cpp b/abaddon.cpp
index 0fb189b..14fdcc0 100644
--- a/abaddon.cpp
+++ b/abaddon.cpp
@@ -125,7 +125,7 @@ void Abaddon::DiscordOnMessageDelete(Snowflake id, Snowflake channel_id) {
 }
 
 void Abaddon::DiscordOnMessageUpdate(Snowflake id, Snowflake channel_id) {
-    m_main_window->UpdateChatMessageEditContent(id, channel_id);
+    m_main_window->UpdateChatMessageUpdated(id, channel_id);
 }
 
 void Abaddon::DiscordOnGuildMemberListUpdate(Snowflake guild_id) {
diff --git a/components/chatmessage.cpp b/components/chatmessage.cpp
index 99f391b..e6e1949 100644
--- a/components/chatmessage.cpp
+++ b/components/chatmessage.cpp
@@ -85,11 +85,31 @@ void ChatMessageContainer::Update() {
     m_author->set_markup(md);
 }
 
+// returns index (1-based) of removed item
+int ChatMessageContainer::RemoveItem(Gtk::Widget *widget) {
+    auto children = m_content_box->get_children();
+    for (auto i = 0; i < children.size(); i++) {
+        if (widget == children[i]) {
+            m_content_box->remove(*widget);
+            return i;
+        }
+    }
+
+    return -1;
+}
+
 void ChatMessageContainer::AddNewContent(Gtk::Widget *widget, bool prepend) {
-    if (prepend)
-        m_content_box->pack_end(*widget);
-    else
-        m_content_box->pack_start(*widget);
+    if (prepend) {
+        m_content_box->add(*widget);
+        m_content_box->reorder_child(*widget, 1);
+    } else {
+        m_content_box->add(*widget);
+    }
+}
+
+void ChatMessageContainer::AddNewContentAtIndex(Gtk::Widget *widget, int index) {
+    m_content_box->add(*widget);
+    m_content_box->reorder_child(*widget, index); // this doesn't seem very reliable
 }
 
 ChatMessageItem::ChatMessageItem() {
@@ -156,8 +176,17 @@ void ChatMessageItem::AddMenuItem(Gtk::MenuItem *item) {
     m_menu.append(*item);
 }
 
+void ChatMessageItem::SetContainer(ChatMessageContainer *container) {
+    m_container = container;
+}
+
+ChatMessageContainer *ChatMessageItem::GetContainer() const {
+    return m_container;
+}
+
 ChatMessageTextItem::ChatMessageTextItem(const Message *data) {
     m_content = data->Content;
+    ID = data->ID;
 
     get_style_context()->add_class("message-text");
 
@@ -173,12 +202,8 @@ ChatMessageTextItem::ChatMessageTextItem(const Message *data) {
     m_menu_copy_content = Gtk::manage(new Gtk::MenuItem("Copy _Message", true));
     AddMenuItem(m_menu_copy_content);
     m_menu_copy_content->signal_activate().connect(sigc::mem_fun(*this, &ChatMessageTextItem::on_menu_copy_content));
-}
 
-void ChatMessageTextItem::EditContent(std::string content) {
-    m_content = content;
-    get_buffer()->set_text(content);
-    UpdateAttributes();
+    Update();
 }
 
 void ChatMessageTextItem::on_menu_copy_content() {
@@ -209,9 +234,12 @@ void ChatMessageTextItem::UpdateAttributes() {
 
 ChatMessageEmbedItem::ChatMessageEmbedItem(const Message *data) {
     m_embed = data->Embeds[0];
+    ID = data->ID;
 
     DoLayout();
     AttachMenuHandler(this);
+
+    Update();
 }
 
 void ChatMessageEmbedItem::DoLayout() {
diff --git a/components/chatmessage.hpp b/components/chatmessage.hpp
index 9365dd5..94428b3 100644
--- a/components/chatmessage.hpp
+++ b/components/chatmessage.hpp
@@ -19,8 +19,10 @@ public:
 
     ChatMessageContainer(const Message *data);
     void AddNewContent(Gtk::Widget *widget, bool prepend = false);
+    void AddNewContentAtIndex(Gtk::Widget *widget, int index);
     void SetAvatarFromPixbuf(Glib::RefPtr<Gdk::Pixbuf> pixbuf);
     void Update();
+    int RemoveItem(Gtk::Widget *widget);
 
 protected:
     Gtk::Box *m_main_box;
@@ -43,7 +45,12 @@ public:
     void AddMenuItem(Gtk::MenuItem *item);
     virtual void Update() = 0;
 
+    void SetContainer(ChatMessageContainer *container);
+    ChatMessageContainer *GetContainer() const;
+
 protected:
+    ChatMessageContainer *m_container = nullptr;
+
     void AttachMenuHandler(Gtk::Widget *widget);
     void on_menu_copy_id();
     void on_menu_message_delete();
diff --git a/components/chatwindow.cpp b/components/chatwindow.cpp
index 652844a..74c917b 100644
--- a/components/chatwindow.cpp
+++ b/components/chatwindow.cpp
@@ -7,7 +7,7 @@ ChatWindow::ChatWindow() {
     m_new_message_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::AddNewMessageInternal));
     m_new_history_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::AddNewHistoryInternal));
     m_message_delete_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::DeleteMessageInternal));
-    m_message_edit_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::UpdateMessageContentInternal));
+    m_message_edit_dispatch.connect(sigc::mem_fun(*this, &ChatWindow::UpdateMessageInternal));
 
     m_main = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
     m_listbox = Gtk::manage(new Gtk::ListBox);
@@ -91,6 +91,29 @@ ChatDisplayType ChatWindow::GetMessageDisplayType(const Message *data) {
     return ChatDisplayType::Unknown;
 }
 
+ChatMessageItem *ChatWindow::CreateMessageComponent(const Message *data) {
+    auto type = GetMessageDisplayType(data);
+    ChatMessageItem *widget = nullptr;
+
+    if (type == ChatDisplayType::Text) {
+        widget = Gtk::manage(new ChatMessageTextItem(data));
+
+        widget->signal_action_message_delete().connect([this](Snowflake channel_id, Snowflake id) {
+            m_signal_action_message_delete.emit(channel_id, id);
+        });
+        widget->signal_action_message_edit().connect([this](Snowflake channel_id, Snowflake id) {
+            m_signal_action_message_edit.emit(channel_id, id);
+        });
+    } else if (type == ChatDisplayType::Embed) {
+        widget = Gtk::manage(new ChatMessageEmbedItem(data));
+    }
+
+    if (widget == nullptr) return nullptr;
+    widget->ChannelID = m_active_channel;
+    m_id_to_widget[data->ID] = widget;
+    return widget;
+}
+
 void ChatWindow::ProcessMessage(const Message *data, bool prepend) {
     if (!Abaddon::Get().GetDiscordClient().IsStarted()) return;
 
@@ -107,8 +130,6 @@ void ChatWindow::ProcessMessage(const Message *data, bool prepend) {
         }
     }
 
-    auto type = GetMessageDisplayType(data);
-
     ChatMessageContainer *container;
     if (should_attach) {
         container = last_row;
@@ -137,27 +158,11 @@ void ChatWindow::ProcessMessage(const Message *data, bool prepend) {
         m_num_rows++;
     }
 
-    // actual content
-    if (type == ChatDisplayType::Text) {
-        auto *text = Gtk::manage(new ChatMessageTextItem(data));
-        text->ID = data->ID;
-        text->ChannelID = m_active_channel;
-        text->signal_action_message_delete().connect([this](Snowflake channel_id, Snowflake id) {
-            m_signal_action_message_delete.emit(channel_id, id);
-        });
-        text->signal_action_message_edit().connect([this](Snowflake channel_id, Snowflake id) {
-            m_signal_action_message_edit.emit(channel_id, id);
-        });
-        text->Update();
-        container->AddNewContent(text, prepend);
-        m_id_to_widget[data->ID] = text;
-    } else if (type == ChatDisplayType::Embed) {
-        auto *widget = Gtk::manage(new ChatMessageEmbedItem(data));
-        widget->ID = data->ID;
-        widget->ChannelID = m_active_channel;
-        widget->Update();
-        container->AddNewContent(widget, prepend);
-        m_id_to_widget[data->ID] = widget;
+    ChatMessageItem *widget = CreateMessageComponent(data);
+
+    if (widget != nullptr) {
+        widget->SetContainer(container);
+        container->AddNewContent(dynamic_cast<Gtk::Widget *>(widget), prepend);
     }
 
     container->set_margin_left(5);
@@ -218,7 +223,7 @@ void ChatWindow::DeleteMessage(Snowflake id) {
     m_message_delete_dispatch.emit();
 }
 
-void ChatWindow::UpdateMessageContent(Snowflake id) {
+void ChatWindow::UpdateMessage(Snowflake id) {
     std::scoped_lock<std::mutex> guard(m_update_mutex);
     m_message_edit_queue.push(id);
     m_message_edit_dispatch.emit();
@@ -240,7 +245,7 @@ void ChatWindow::InsertChatInput(std::string text) {
 Snowflake ChatWindow::GetOldestListedMessage() {
     Snowflake m;
 
-    for (const auto& [id, widget] : m_id_to_widget) {
+    for (const auto &[id, widget] : m_id_to_widget) {
         if (id < m)
             m = id;
     }
@@ -301,7 +306,7 @@ void ChatWindow::DeleteMessageInternal() {
     item->Update();
 }
 
-void ChatWindow::UpdateMessageContentInternal() {
+void ChatWindow::UpdateMessageInternal() {
     Snowflake id;
     {
         std::scoped_lock<std::mutex> guard(m_update_mutex);
@@ -312,11 +317,16 @@ void ChatWindow::UpdateMessageContentInternal() {
     if (m_id_to_widget.find(id) == m_id_to_widget.end())
         return;
 
+    // GetMessage should give us the new object at this point
     auto *msg = Abaddon::Get().GetDiscordClient().GetMessage(id);
-    auto *item = dynamic_cast<ChatMessageTextItem *>(m_id_to_widget.at(id));
+    auto *item = dynamic_cast<Gtk::Widget *>(m_id_to_widget.at(id));
     if (item != nullptr) {
-        item->EditContent(msg->Content);
-        item->Update();
+        ChatMessageContainer *container = dynamic_cast<ChatMessageItem *>(item)->GetContainer();
+        int idx = container->RemoveItem(item);
+        if (idx == -1) return;
+        auto *new_widget = CreateMessageComponent(msg);
+        new_widget->SetContainer(container);
+        container->AddNewContentAtIndex(dynamic_cast<Gtk::Widget *>(new_widget), idx);
     }
 }
 
diff --git a/components/chatwindow.hpp b/components/chatwindow.hpp
index ba71d2b..570299d 100644
--- a/components/chatwindow.hpp
+++ b/components/chatwindow.hpp
@@ -18,7 +18,7 @@ public:
     void AddNewMessage(Snowflake id);
     void AddNewHistory(const std::vector<Snowflake> &msgs);
     void DeleteMessage(Snowflake id);
-    void UpdateMessageContent(Snowflake id);
+    void UpdateMessage(Snowflake id);
     void Clear();
     void InsertChatInput(std::string text);
     Snowflake GetOldestListedMessage();
@@ -29,8 +29,9 @@ protected:
     void AddNewMessageInternal();
     void AddNewHistoryInternal();
     void DeleteMessageInternal();
-    void UpdateMessageContentInternal();
+    void UpdateMessageInternal();
     ChatDisplayType GetMessageDisplayType(const Message *data);
+    ChatMessageItem *CreateMessageComponent(const Message *data);
     void ProcessMessage(const Message *data, bool prepend = false);
     int m_num_rows = 0; // youd think thered be a Gtk::ListBox::get_row_count or something but nope
     std::unordered_map<Snowflake, ChatMessageItem *> m_id_to_widget;
diff --git a/discord/discord.cpp b/discord/discord.cpp
index 8e81e7f..e16e764 100644
--- a/discord/discord.cpp
+++ b/discord/discord.cpp
@@ -387,18 +387,16 @@ void DiscordClient::HandleGatewayMessageDelete(const GatewayMessage &msg) {
 }
 
 void DiscordClient::HandleGatewayMessageUpdate(const GatewayMessage &msg) {
-    // less than stellar way of doing this probably
-    Message data;
-    data.from_json_edited(msg.Data);
+    Snowflake id = msg.Data.at("id");
 
-    auto *current = m_store.GetMessage(data.ID);
+    auto *current = m_store.GetMessage(id);
     if (current == nullptr)
         return;
 
-    if (data.Content != current->Content) {
-        current->SetEdited(data.Content);
-        m_signal_message_update.emit(data.ID, data.ChannelID);
-    }
+    current->from_json_edited(msg.Data);
+
+    current->SetEdited();
+    m_signal_message_update.emit(id, current->ChannelID);
 }
 
 void DiscordClient::HandleGatewayGuildMemberListUpdate(const GatewayMessage &msg) {
diff --git a/discord/message.cpp b/discord/message.cpp
index 044c2e5..4134435 100644
--- a/discord/message.cpp
+++ b/discord/message.cpp
@@ -79,6 +79,8 @@ void from_json(const nlohmann::json &j, Message &m) {
     JS_D("content", m.Content);
     JS_D("timestamp", m.Timestamp);
     JS_N("edited_timestamp", m.EditedTimestamp);
+    if (!j.at("edited_timestamp").is_null())
+        m.SetEdited();
     JS_D("tts", m.IsTTS);
     JS_D("mention_everyone", m.DoesMentionEveryone);
     JS_D("mentions", m.Mentions);
@@ -97,7 +99,6 @@ void from_json(const nlohmann::json &j, Message &m) {
     JS_O("flags", m.Flags);
 }
 
-// probably gonna need to return present keys
 void Message::from_json_edited(const nlohmann::json &j) {
     JS_D("id", ID);
     JS_D("channel_id", ChannelID);
@@ -109,6 +110,7 @@ void Message::from_json_edited(const nlohmann::json &j) {
     JS_O("tts", IsTTS);
     JS_O("mention_everyone", DoesMentionEveryone);
     JS_O("mentions", Mentions);
+    JS_O("embeds", Embeds);
     JS_O("nonce", Nonce);
     JS_O("pinned", IsPinned);
     JS_O("webhook_id", WebhookID);
@@ -120,9 +122,8 @@ void Message::SetDeleted() {
     m_deleted = true;
 }
 
-void Message::SetEdited(std::string new_content) {
+void Message::SetEdited() {
     m_edited = true;
-    Content = new_content;
 }
 
 bool Message::IsDeleted() const {
diff --git a/discord/message.hpp b/discord/message.hpp
index 2c8fc3d..ab55516 100644
--- a/discord/message.hpp
+++ b/discord/message.hpp
@@ -150,7 +150,7 @@ struct Message {
 
     // custom fields to track changes
     void SetDeleted();
-    void SetEdited(std::string new_content);
+    void SetEdited();
     bool IsDeleted() const;
     bool IsEdited() const;
 
diff --git a/windows/mainwindow.cpp b/windows/mainwindow.cpp
index 8dde16f..5e85c98 100644
--- a/windows/mainwindow.cpp
+++ b/windows/mainwindow.cpp
@@ -146,9 +146,9 @@ void MainWindow::UpdateChatMessageDeleted(Snowflake id, Snowflake channel_id) {
         m_chat.DeleteMessage(id);
 }
 
-void MainWindow::UpdateChatMessageEditContent(Snowflake id, Snowflake channel_id) {
+void MainWindow::UpdateChatMessageUpdated(Snowflake id, Snowflake channel_id) {
     if (channel_id == GetChatActiveChannel())
-        m_chat.UpdateMessageContent(id);
+        m_chat.UpdateMessage(id);
 }
 
 void MainWindow::UpdateChatPrependHistory(const std::vector<Snowflake> &msgs) {
diff --git a/windows/mainwindow.hpp b/windows/mainwindow.hpp
index 7480346..33308ce 100644
--- a/windows/mainwindow.hpp
+++ b/windows/mainwindow.hpp
@@ -16,7 +16,7 @@ public:
     Snowflake GetChatActiveChannel() const;
     void UpdateChatNewMessage(Snowflake id);
     void UpdateChatMessageDeleted(Snowflake id, Snowflake channel_id);
-    void UpdateChatMessageEditContent(Snowflake id, Snowflake channel_id);
+    void UpdateChatMessageUpdated(Snowflake id, Snowflake channel_id);
     void UpdateChatPrependHistory(const std::vector<Snowflake> &msgs);
     void InsertChatInput(std::string text);
     Snowflake GetChatOldestListedMessage();