From b036b20b37ddaadfa729cfedc9a7c5f0a3c0a1bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Florian=20Spie=C3=9F?= <business@minn.dev>
Date: Sat, 5 Oct 2024 11:24:21 +0200
Subject: [PATCH] Add support for message forwarding (#2744)

---
 .../net/dv8tion/jda/api/entities/Message.java |  50 ++++
 .../jda/api/entities/MessageReference.java    |  74 +++++-
 .../entities/messages/MessageSnapshot.java    | 231 ++++++++++++++++++
 .../jda/api/requests/ErrorResponse.java       |   2 +
 .../restaction/MessageCreateAction.java       | 139 +++++++++++
 .../messages/AbstractMessageBuilder.java      |  10 +
 .../jda/internal/entities/EntityBuilder.java  |  74 ++++--
 .../internal/entities/ReceivedMessage.java    |  13 +-
 .../restaction/MessageCreateActionImpl.java   |  94 +++++--
 .../restaction/MessageCreateActionTest.java   |  62 ++++-
 10 files changed, 706 insertions(+), 43 deletions(-)
 create mode 100644 src/main/java/net/dv8tion/jda/api/entities/messages/MessageSnapshot.java

diff --git a/src/main/java/net/dv8tion/jda/api/entities/Message.java b/src/main/java/net/dv8tion/jda/api/entities/Message.java
index 7b8f73f804..2932f9c7d2 100644
--- a/src/main/java/net/dv8tion/jda/api/entities/Message.java
+++ b/src/main/java/net/dv8tion/jda/api/entities/Message.java
@@ -30,6 +30,7 @@
 import net.dv8tion.jda.api.entities.emoji.Emoji;
 import net.dv8tion.jda.api.entities.emoji.RichCustomEmoji;
 import net.dv8tion.jda.api.entities.messages.MessagePoll;
+import net.dv8tion.jda.api.entities.messages.MessageSnapshot;
 import net.dv8tion.jda.api.entities.sticker.GuildSticker;
 import net.dv8tion.jda.api.entities.sticker.Sticker;
 import net.dv8tion.jda.api.entities.sticker.StickerItem;
@@ -57,6 +58,8 @@
 import net.dv8tion.jda.api.utils.messages.MessageRequest;
 import net.dv8tion.jda.internal.JDAImpl;
 import net.dv8tion.jda.internal.entities.ReceivedMessage;
+import net.dv8tion.jda.internal.entities.channel.mixin.middleman.MessageChannelMixin;
+import net.dv8tion.jda.internal.requests.restaction.MessageCreateActionImpl;
 import net.dv8tion.jda.internal.requests.restaction.pagination.PollVotersPaginationActionImpl;
 import net.dv8tion.jda.internal.utils.Checks;
 import net.dv8tion.jda.internal.utils.Helpers;
@@ -821,6 +824,19 @@ default List<Button> getButtonsByLabel(@Nonnull String label, boolean ignoreCase
     @Unmodifiable
     List<StickerItem> getStickers();
 
+    /**
+     * The {@link MessageSnapshot MessageSnaphots} attached to this message.
+     *
+     * <p>This is used primarily for message forwarding.
+     * The content of the forwarded message is provided as a snapshot at the time of forwarding.
+     * When the message is edited or deleted, this snapshot remains unchanged.
+     *
+     * @return Immutable {@link List} of {@link MessageSnapshot}
+     */
+    @Nonnull
+    @Unmodifiable
+    List<MessageSnapshot> getMessageSnapshots();
+
     /**
      * Defines whether or not this Message triggers TTS (Text-To-Speech).
      *
@@ -1674,6 +1690,40 @@ default MessageCreateAction replyFiles(@Nonnull Collection<? extends FileUpload>
         return getChannel().sendFiles(files).setMessageReference(this);
     }
 
+    /**
+     * Forwards this message into the provided channel.
+     *
+     * <p><b>A message forward request cannot contain additional content.</b>
+     *
+     * <p>Possible {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} from forwarding include:
+     * <ul>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#REFERENCED_MESSSAGE_NOT_FOUND REFERENCED_MESSSAGE_NOT_FOUND}
+     *     <br>If the provided reference cannot be resolved to a message</li>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#FORWARD_CANNOT_HAVE_CONTENT FORWARD_CANNOT_HAVE_CONTENT}
+     *     <br>If additional content is sent alongside a forwarded message</li>
+     * </ul>
+     *
+     * @param  channel
+     *         The target channel to forward to
+     *
+     * @throws InsufficientPermissionException
+     *         If the bot is missing {@link Permission#MESSAGE_SEND} in the target channel
+     * @throws IllegalArgumentException
+     *         If the target channel is null
+     *
+     * @return {@link MessageCreateAction}
+     */
+    @Nonnull
+    @CheckReturnValue
+    default MessageCreateAction forwardTo(@Nonnull MessageChannel channel)
+    {
+        Checks.notNull(channel, "Target channel");
+        if (channel instanceof MessageChannelMixin)
+            ((MessageChannelMixin<?>) channel).checkCanSendMessage();
+        return new MessageCreateActionImpl(channel)
+                .setMessageReference(MessageReference.MessageReferenceType.FORWARD, this);
+    }
+
     /**
      * Deletes this Message from Discord.
      * <br>If this Message was not sent by the currently logged in account, then this will fail unless the Message is from
diff --git a/src/main/java/net/dv8tion/jda/api/entities/MessageReference.java b/src/main/java/net/dv8tion/jda/api/entities/MessageReference.java
index 2dfe6b8b08..b4e1b58be3 100644
--- a/src/main/java/net/dv8tion/jda/api/entities/MessageReference.java
+++ b/src/main/java/net/dv8tion/jda/api/entities/MessageReference.java
@@ -38,6 +38,7 @@
  */
 public class MessageReference
 {
+    private final int type;
     private final long messageId;
     private final long channelId;
     private final long guildId;
@@ -47,8 +48,9 @@ public class MessageReference
     private final Guild guild;
     private Message referencedMessage;
 
-    public MessageReference(long messageId, long channelId, long guildId, @Nullable Message referencedMessage, JDA api)
+    public MessageReference(int type, long messageId, long channelId, long guildId, @Nullable Message referencedMessage, JDA api)
     {
+        this.type = type;
         this.messageId = messageId;
         this.channelId = channelId;
         this.guildId = guildId;
@@ -213,6 +215,27 @@ public Guild getGuild()
         return guild;
     }
 
+    /**
+     * The message reference type id
+     *
+     * @return The raw type id
+     */
+    public int getTypeRaw()
+    {
+        return type;
+    }
+
+    /**
+     * The type of this message reference
+     *
+     * @return The {@link MessageReferenceType} or {@link MessageReferenceType#UNKNOWN}
+     */
+    @Nonnull
+    public MessageReferenceType getType()
+    {
+        return MessageReferenceType.fromId(type);
+    }
+
     /**
      * Returns the message id for this reference, or 0 if no message id was provided.
      *
@@ -298,4 +321,53 @@ private void checkPermission(Permission permission)
         if (!selfMember.hasPermission(guildChannel, permission))
             throw new InsufficientPermissionException(guildChannel, permission);
     }
+
+    /**
+     * The type of message reference
+     */
+    public enum MessageReferenceType
+    {
+        /** This message reference indicates a replied to message */
+        DEFAULT(0),
+        /** This message reference indicates a forwarded message */
+        FORWARD(1),
+
+        UNKNOWN(-1);
+
+        private final int id;
+
+        MessageReferenceType(int id)
+        {
+            this.id = id;
+        }
+
+        /**
+         * Convert the raw type id to the message reference type enum
+         *
+         * @param  id
+         *         Raw type id
+         *
+         * @return Enum constant of the reference type or {@link #UNKNOWN}
+         */
+        @Nonnull
+        public static MessageReferenceType fromId(int id)
+        {
+            for (MessageReferenceType type : values())
+            {
+                if (type.id == id)
+                    return type;
+            }
+            return UNKNOWN;
+        }
+
+        /**
+         * The raw type id used in the API.
+         *
+         * @return The raw type id
+         */
+        public int getId()
+        {
+            return id;
+        }
+    }
 }
diff --git a/src/main/java/net/dv8tion/jda/api/entities/messages/MessageSnapshot.java b/src/main/java/net/dv8tion/jda/api/entities/messages/MessageSnapshot.java
new file mode 100644
index 0000000000..1ab881b2f0
--- /dev/null
+++ b/src/main/java/net/dv8tion/jda/api/entities/messages/MessageSnapshot.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright 2015 Austin Keener, Michael Ritter, Florian Spieß, and the JDA contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.dv8tion.jda.api.entities.messages;
+
+import net.dv8tion.jda.api.entities.Mentions;
+import net.dv8tion.jda.api.entities.Message.Attachment;
+import net.dv8tion.jda.api.entities.Message.MessageFlag;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.MessageType;
+import net.dv8tion.jda.api.entities.sticker.StickerItem;
+import net.dv8tion.jda.api.interactions.components.LayoutComponent;
+import org.jetbrains.annotations.Unmodifiable;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.time.OffsetDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.regex.Matcher;
+
+import static net.dv8tion.jda.api.entities.Message.INVITE_PATTERN;
+
+/**
+ * Snapshot of a forwarded message.
+ */
+public class MessageSnapshot
+{
+    private final Object mutex = new Object();
+
+    private final MessageType type;
+    private final Mentions mentions;
+    private final OffsetDateTime editTime;
+    private final String content;
+    private final List<Attachment> attachments;
+    private final List<MessageEmbed> embeds;
+    private final List<LayoutComponent> components;
+    private final List<StickerItem> stickers;
+    private final long flags;
+
+    private List<String> invites;
+
+    public MessageSnapshot(
+        MessageType type, Mentions mentions, OffsetDateTime editTime, String content,
+        List<Attachment> attachments,
+        List<MessageEmbed> embeds, List<LayoutComponent> components,
+        List<StickerItem> stickers, long flags
+    ) {
+        this.type = type;
+        this.mentions = mentions;
+        this.editTime = editTime;
+        this.content = content;
+        this.attachments = Collections.unmodifiableList(attachments);
+        this.embeds =  Collections.unmodifiableList(embeds);
+        this.components =  Collections.unmodifiableList(components);
+        this.stickers = Collections.unmodifiableList(stickers);
+        this.flags = flags;
+    }
+
+    /**
+     * The {@link MessageType} of the forwarded message.
+     *
+     * @return The {@link MessageType}
+     */
+    @Nonnull
+    public MessageType getType()
+    {
+        return type;
+    }
+
+    /**
+     * The mentions of the forwarded message.
+     *
+     * <p>Mentions are only used for resolving users and roles in a forwarded message.
+     * Mentions for cross-guild forwarded messages are usually not resolved.
+     *
+     * @return {@link Mentions}
+     */
+    @Nonnull
+    public Mentions getMentions()
+    {
+        return mentions;
+    }
+
+    /**
+     * Whether the forwarded message was edited.
+     *
+     * <p>Since this is a snapshot, the edited timestamp is only relevant to the time it was forwarded.
+     * If the message is edited after the fact, this is not updated.
+     *
+     * @return True, if the message was edited when it was forwarded
+     */
+    public boolean isEdited()
+    {
+        return editTime != null;
+    }
+
+    /**
+     * The last time the forwarded message was edited before being forwarded.
+     *
+     * <p>Since this is a snapshot, the edited timestamp is only relevant to the time it was forwarded.
+     * If the message is edited after the fact, this is not updated.
+     *
+     * @return {@link OffsetDateTime} when the message was edited (up to the time it was forwarded)
+     */
+    @Nullable
+    public OffsetDateTime getTimeEdited()
+    {
+        return editTime;
+    }
+
+    /**
+     * The raw content of the message, including markdown and mentions.
+     *
+     * @return The raw message content.
+     */
+    @Nonnull
+    public String getContentRaw()
+    {
+        return content;
+    }
+
+    /**
+     * Invite codes found in the message content.
+     *
+     * @return The invite codes
+     */
+    @Nonnull
+    @Unmodifiable
+    public List<String> getInvites()
+    {
+        if (invites != null)
+            return invites;
+        synchronized (mutex)
+        {
+            if (invites != null)
+                return invites;
+            invites = new ArrayList<>();
+            Matcher m = INVITE_PATTERN.matcher(getContentRaw());
+            while (m.find())
+                invites.add(m.group(1));
+            return invites = Collections.unmodifiableList(invites);
+        }
+    }
+
+    /**
+     * Message attachments of the forwarded message.
+     *
+     * @return Immutable {@link List} of {@link Attachment}
+     */
+    @Nonnull
+    @Unmodifiable
+    public List<Attachment> getAttachments()
+    {
+        return attachments;
+    }
+
+    /**
+     * Message embeds of the forwarded message.
+     *
+     * @return Immutable {@link List} of {@link MessageEmbed}
+     */
+    @Nonnull
+    @Unmodifiable
+    public List<MessageEmbed> getEmbeds()
+    {
+        return embeds;
+    }
+
+    /**
+     * Components of the forwarded message.
+     *
+     * <p>Buttons and other interactive components are non-functional in forwarded messages.
+     *
+     * @return Immutable {@link List} of {@link LayoutComponent}
+     */
+    @Nonnull
+    @Unmodifiable
+    public List<LayoutComponent> getComponents()
+    {
+        return components;
+    }
+
+    /**
+     * Stickers of the forwarded message.
+     *
+     * @return Immutable {@link List} of {@link StickerItem}
+     */
+    @Nonnull
+    @Unmodifiable
+    public List<StickerItem> getStickers()
+    {
+        return stickers;
+    }
+
+    /**
+     * The raw message flags of the forwarded message.
+     *
+     * @return The message flags
+     */
+    public long getFlagsRaw()
+    {
+        return flags;
+    }
+
+    /**
+     * The message flags fo the forwarded message.
+     *
+     * @return {@link EnumSet} of {@link MessageFlag}
+     */
+    @Nonnull
+    public EnumSet<MessageFlag> getFlags()
+    {
+        return MessageFlag.fromBitField((int) getFlagsRaw());
+    }
+}
diff --git a/src/main/java/net/dv8tion/jda/api/requests/ErrorResponse.java b/src/main/java/net/dv8tion/jda/api/requests/ErrorResponse.java
index ec98832255..024829c5a0 100644
--- a/src/main/java/net/dv8tion/jda/api/requests/ErrorResponse.java
+++ b/src/main/java/net/dv8tion/jda/api/requests/ErrorResponse.java
@@ -218,6 +218,8 @@ public enum ErrorResponse
     THREAD_LOCKED(                            160005, "Thread is locked"),
     MAX_ACTIVE_THREADS(                       160006, "Maximum number of active threads reached"),
     MAX_ANNOUNCEMENT_THREADS(                 160007, "Maximum number of active announcement threads reached"),
+    REFERENCED_MESSSAGE_NOT_FOUND(            160008, "Message could not be found"),
+    FORWARD_CANNOT_HAVE_CONTENT(              160011, "Forward messages cannot have additional content"),
     INVALID_LOTTIE_JSON(                      170001, "Invalid JSON for uploaded Lottie file"),
     LOTTIE_CANNOT_CONTAIN_RASTERIZED_IMAGE(   170002, "Uploaded Lotties cannot contain rasterized images such as PNG or JPEG"),
     MAX_STICKER_FPS(                          170003, "Sticker maximum framerate exceeded"),
diff --git a/src/main/java/net/dv8tion/jda/api/requests/restaction/MessageCreateAction.java b/src/main/java/net/dv8tion/jda/api/requests/restaction/MessageCreateAction.java
index b60895186d..21f6540fe8 100644
--- a/src/main/java/net/dv8tion/jda/api/requests/restaction/MessageCreateAction.java
+++ b/src/main/java/net/dv8tion/jda/api/requests/restaction/MessageCreateAction.java
@@ -17,6 +17,7 @@
 package net.dv8tion.jda.api.requests.restaction;
 
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageReference.MessageReferenceType;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import net.dv8tion.jda.api.entities.sticker.GuildSticker;
 import net.dv8tion.jda.api.entities.sticker.Sticker;
@@ -74,6 +75,144 @@ static void setDefaultFailOnInvalidReply(boolean fail)
     @Nonnull
     MessageCreateAction setNonce(@Nullable String nonce);
 
+    /**
+     * Message reference used for a reply or forwarded message.
+     *
+     * <p><b>{@link MessageReferenceType#DEFAULT Default Type}</b>
+     *
+     * <p>You can only reply to messages from the same channel.
+     * By default, this will mention the author of the target message, this can be disabled using {@link #mentionRepliedUser(boolean)}.
+     *
+     * <p>This also requires {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY} in the channel.
+     * If this permission is missing, you receive {@link net.dv8tion.jda.api.requests.ErrorResponse#REPLY_FAILED_MISSING_MESSAGE_HISTORY_PERM ErrorResponse.REPLY_FAILED_MISSING_MESSAGE_HISTORY_PERM}.
+     *
+     * <p>If the target message does not exist, this will result in {@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE ErrorResponse.UNKNOWN_MESSAGE}.
+     * You can use {@link #failOnInvalidReply(boolean)} to allow unknown or deleted messages.
+     *
+     * <p><b>{@link MessageReferenceType#FORWARD Forward Type}</b>
+     *
+     * <p>Creates a snapshot of the referenced message at the current time and sends it in this channel.
+     *
+     * <p>You cannot forward messages from channels you do not have access to.
+     *
+     * <p>Possible {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} from forwarding include:
+     * <ul>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#REFERENCED_MESSSAGE_NOT_FOUND REFERENCED_MESSSAGE_NOT_FOUND}
+     *     <br>If the provided reference cannot be resolved to a message</li>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#FORWARD_CANNOT_HAVE_CONTENT FORWARD_CANNOT_HAVE_CONTENT}
+     *     <br>If additional content is sent alongside a forwarded message</li>
+     * </ul>
+     *
+     * @param  type
+     *         The type of message reference
+     * @param  guildId
+     *         The guild id the forwarded message comes from, or null if it is not from a guild
+     * @param  channelId
+     *         The channel id the forwarded message comes from
+     * @param  messageId
+     *         The target message id
+     *
+     * @throws IllegalArgumentException
+     *         If null or an invalid snowflake is passed or the reference type is {@link MessageReferenceType#UNKNOWN}
+     *
+     * @return The same instance for chaining
+     */
+    @Nonnull
+    MessageCreateAction setMessageReference(@Nonnull MessageReferenceType type, @Nullable String guildId, @Nonnull String channelId, @Nonnull String messageId);
+
+    /**
+     * Message reference used for a reply or forwarded message.
+     *
+     * <p><b>{@link MessageReferenceType#DEFAULT Default Type}</b>
+     *
+     * <p>You can only reply to messages from the same channel.
+     * By default, this will mention the author of the target message, this can be disabled using {@link #mentionRepliedUser(boolean)}.
+     *
+     * <p>This also requires {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY} in the channel.
+     * If this permission is missing, you receive {@link net.dv8tion.jda.api.requests.ErrorResponse#REPLY_FAILED_MISSING_MESSAGE_HISTORY_PERM ErrorResponse.REPLY_FAILED_MISSING_MESSAGE_HISTORY_PERM}.
+     *
+     * <p>If the target message does not exist, this will result in {@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE ErrorResponse.UNKNOWN_MESSAGE}.
+     * You can use {@link #failOnInvalidReply(boolean)} to allow unknown or deleted messages.
+     *
+     * <p><b>{@link MessageReferenceType#FORWARD Forward Type}</b>
+     *
+     * <p>Creates a snapshot of the referenced message at the current time and sends it in this channel.
+     *
+     * <p>You cannot forward messages from channels you do not have access to.
+     *
+     * <p>Possible {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} from forwarding include:
+     * <ul>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#REFERENCED_MESSSAGE_NOT_FOUND REFERENCED_MESSSAGE_NOT_FOUND}
+     *     <br>If the provided reference cannot be resolved to a message</li>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#FORWARD_CANNOT_HAVE_CONTENT FORWARD_CANNOT_HAVE_CONTENT}
+     *     <br>If additional content is sent alongside a forwarded message</li>
+     * </ul>
+     *
+     * @param  type
+     *         The type of message reference
+     * @param  guildId
+     *         The guild id the forwarded message comes from, or 0 if it is not from a guild
+     * @param  channelId
+     *         The channel id the forwarded message comes from
+     * @param  messageId
+     *         The target message id
+     *
+     * @throws IllegalArgumentException
+     *         If the reference type is null or {@link MessageReferenceType#UNKNOWN}
+     *
+     * @return The same instance for chaining
+     */
+    @Nonnull
+    default MessageCreateAction setMessageReference(@Nonnull MessageReferenceType type, long guildId, long channelId, long messageId)
+    {
+        return setMessageReference(type, Long.toUnsignedString(guildId), Long.toUnsignedString(channelId), Long.toUnsignedString(messageId));
+    }
+
+    /**
+     * Message reference used for a reply or forwarded message.
+     *
+     * <p><b>{@link MessageReferenceType#DEFAULT Default Type}</b>
+     *
+     * <p>You can only reply to messages from the same channel.
+     * By default, this will mention the author of the target message, this can be disabled using {@link #mentionRepliedUser(boolean)}.
+     *
+     * <p>This also requires {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY} in the channel.
+     * If this permission is missing, you receive {@link net.dv8tion.jda.api.requests.ErrorResponse#REPLY_FAILED_MISSING_MESSAGE_HISTORY_PERM ErrorResponse.REPLY_FAILED_MISSING_MESSAGE_HISTORY_PERM}.
+     *
+     * <p>If the target message does not exist, this will result in {@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE ErrorResponse.UNKNOWN_MESSAGE}.
+     * You can use {@link #failOnInvalidReply(boolean)} to allow unknown or deleted messages.
+     *
+     * <p><b>{@link MessageReferenceType#FORWARD Forward Type}</b>
+     *
+     * <p>Creates a snapshot of the referenced message at the current time and sends it in this channel.
+     *
+     * <p>You cannot forward messages from channels you do not have access to.
+     *
+     * <p>Possible {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} from forwarding include:
+     * <ul>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#REFERENCED_MESSSAGE_NOT_FOUND REFERENCED_MESSSAGE_NOT_FOUND}
+     *     <br>If the provided reference cannot be resolved to a message</li>
+     *     <li>{@link net.dv8tion.jda.api.requests.ErrorResponse#FORWARD_CANNOT_HAVE_CONTENT FORWARD_CANNOT_HAVE_CONTENT}
+     *     <br>If additional content is sent alongside a forwarded message</li>
+     * </ul>
+     *
+     * @param  type
+     *         The type of message reference
+     * @param  message
+     *         The target message
+     *
+     * @throws IllegalArgumentException
+     *         If null is provided or the reference type is {@link MessageReferenceType#UNKNOWN}
+     *
+     * @return The same instance for chaining
+     */
+    @Nonnull
+    default MessageCreateAction setMessageReference(@Nonnull MessageReferenceType type, @Nonnull Message message)
+    {
+        Checks.notNull(message, "Message");
+        return setMessageReference(type, message.getGuildId(), message.getChannel().getId(), message.getId());
+    }
+
     /**
      * Message reference used for a reply.
      * <br>The client will show this message as a reply to the target message.
diff --git a/src/main/java/net/dv8tion/jda/api/utils/messages/AbstractMessageBuilder.java b/src/main/java/net/dv8tion/jda/api/utils/messages/AbstractMessageBuilder.java
index 9d794a6883..78e7d2dcd4 100644
--- a/src/main/java/net/dv8tion/jda/api/utils/messages/AbstractMessageBuilder.java
+++ b/src/main/java/net/dv8tion/jda/api/utils/messages/AbstractMessageBuilder.java
@@ -199,6 +199,16 @@ public boolean isSuppressEmbeds()
         return (this.messageFlags & Message.MessageFlag.EMBEDS_SUPPRESSED.getValue()) != 0;
     }
 
+    /**
+     * The flags set on this message.
+     *
+     * @return The currently set message flags
+     */
+    public long getMessageFlagsRaw()
+    {
+        return messageFlags;
+    }
+
     /**
      * Whether this builder is considered empty, this checks for all <em>required</em> fields of the request type.
      * <br>On a create request, this checks for {@link #setContent(String) content}, {@link #setEmbeds(Collection) embeds}, {@link #setComponents(Collection) components}, and {@link #setFiles(Collection) files}.
diff --git a/src/main/java/net/dv8tion/jda/internal/entities/EntityBuilder.java b/src/main/java/net/dv8tion/jda/internal/entities/EntityBuilder.java
index 687b1df795..4de5e84698 100644
--- a/src/main/java/net/dv8tion/jda/internal/entities/EntityBuilder.java
+++ b/src/main/java/net/dv8tion/jda/internal/entities/EntityBuilder.java
@@ -43,6 +43,7 @@
 import net.dv8tion.jda.api.entities.emoji.EmojiUnion;
 import net.dv8tion.jda.api.entities.emoji.RichCustomEmoji;
 import net.dv8tion.jda.api.entities.messages.MessagePoll;
+import net.dv8tion.jda.api.entities.messages.MessageSnapshot;
 import net.dv8tion.jda.api.entities.sticker.*;
 import net.dv8tion.jda.api.entities.templates.Template;
 import net.dv8tion.jda.api.entities.templates.TemplateChannel;
@@ -55,6 +56,7 @@
 import net.dv8tion.jda.api.exceptions.ParsingException;
 import net.dv8tion.jda.api.interactions.DiscordLocale;
 import net.dv8tion.jda.api.interactions.components.ActionRow;
+import net.dv8tion.jda.api.interactions.components.LayoutComponent;
 import net.dv8tion.jda.api.utils.cache.CacheFlag;
 import net.dv8tion.jda.api.utils.cache.CacheView;
 import net.dv8tion.jda.api.utils.data.DataArray;
@@ -89,6 +91,7 @@
 import java.time.temporal.TemporalAccessor;
 import java.util.*;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -1758,6 +1761,9 @@ private ReceivedMessage createMessage0(DataObject jsonObject, @Nullable MessageC
         final List<MessageEmbed>       embeds      = map(jsonObject, "embeds",        this::createMessageEmbed);
         final List<MessageReaction>    reactions   = map(jsonObject, "reactions",     (obj) -> createMessageReaction(tmpChannel, channelId, id, obj));
         final List<StickerItem>        stickers    = map(jsonObject, "sticker_items", this::createStickerItem);
+        final List<LayoutComponent>    components  = map(jsonObject, "components",    ActionRow::fromData, obj -> obj.getInt("type", -1) == 1);
+
+        MessagePoll poll = jsonObject.optObject("poll").map(EntityBuilder::createMessagePoll).orElse(null);
 
         // Message activity (for game invites/spotify)
         MessageActivity activity = null;
@@ -1825,32 +1831,24 @@ else if (MISSING_CHANNEL.equals(ex.getMessage()))
             }
         }
 
+        List<MessageSnapshot> snapshots = Collections.emptyList();
         MessageReference messageReference = null;
         if (!jsonObject.isNull("message_reference")) // always contains the channel + message id for a referenced message
         {                                                // used for when referenced_message is not provided
             DataObject messageReferenceJson = jsonObject.getObject("message_reference");
 
             messageReference = new MessageReference(
+                    messageReferenceJson.getInt("type", -1),
                     messageReferenceJson.getLong("message_id", 0),
                     messageReferenceJson.getLong("channel_id", 0),
                     messageReferenceJson.getLong("guild_id", 0),
                     referencedMessage,
                     api
             );
-        }
 
-        MessagePoll poll = jsonObject.optObject("poll").map(EntityBuilder::createMessagePoll).orElse(null);
 
-        // Message Components
-        List<ActionRow> components = Collections.emptyList();
-        Optional<DataArray> componentsArrayOpt = jsonObject.optArray("components");
-        if (componentsArrayOpt.isPresent())
-        {
-            DataArray array = componentsArrayOpt.get();
-            components = array.stream(DataArray::getObject)
-                    .filter(it -> it.getInt("type", 0) == 1)
-                    .map(ActionRow::fromData)
-                    .collect(Collectors.toList());
+            MessageReference finalReference = messageReference;
+            snapshots = map(jsonObject, "message_snapshots", (obj) -> createMessageSnapshot(finalReference, obj.getObject("message")));
         }
 
         // Application command and component replies
@@ -1871,8 +1869,8 @@ else if (MISSING_CHANNEL.equals(ex.getMessage()))
         int position = jsonObject.getInt("position", -1);
 
         return new ReceivedMessage(id, channelId, guildId, api, guild, channel, type, messageReference, fromWebhook, applicationId, tts, pinned,
-                content, nonce, user, member, activity, poll, editTime, mentions, reactions, attachments, embeds, stickers, components, flags,
-                messageInteraction, startedThread, position);
+                content, nonce, user, member, activity, poll, editTime, mentions, reactions, attachments, embeds, stickers, components, snapshots,
+                flags, messageInteraction, startedThread, position);
     }
 
     private static MessageActivity createMessageActivity(DataObject jsonObject)
@@ -2179,6 +2177,34 @@ public Message.Interaction createMessageInteraction(GuildImpl guildImpl, DataObj
         return new Message.Interaction(id, type, name, user, member);
     }
 
+    public MessageSnapshot createMessageSnapshot(MessageReference messageReference, DataObject jsonObject)
+    {
+        MessageType type = MessageType.fromId(jsonObject.getInt("type"));
+
+        String content = jsonObject.getString("content", "");
+        OffsetDateTime editTime = jsonObject.isNull("edited_timestamp") ? null : OffsetDateTime.parse(jsonObject.getString("edited_timestamp"));
+        int flags = jsonObject.getInt("flags", 0);
+        boolean mentionsEveryone = jsonObject.getBoolean("mention_everyone");
+
+        List<Message.Attachment> attachments = map(jsonObject, "attachments",   this::createMessageAttachment);
+        List<MessageEmbed>       embeds      = map(jsonObject, "embeds",        this::createMessageEmbed);
+        List<StickerItem>        stickers    = map(jsonObject, "sticker_items", this::createStickerItem);
+        List<LayoutComponent>    components  = map(jsonObject, "components",    ActionRow::fromData, obj -> obj.getInt("type", -1) == 1);
+
+        Guild guild = messageReference.getGuild();
+        // Lazy Mention parsing and caching (includes reply mentions)
+        // This only works if the message is from the same guild
+        Mentions mentions = new MessageMentionsImpl(
+            api, guild instanceof GuildImpl ? (GuildImpl) guild : null, content, mentionsEveryone,
+            jsonObject.getArray("mentions"),
+            jsonObject.optArray("mention_roles").orElseGet(DataArray::empty)
+        );
+
+        return new MessageSnapshot(
+            type, mentions, editTime, content, attachments, embeds, components, stickers, flags
+        );
+    }
+
     @Nullable
     public PermissionOverride createPermissionOverride(DataObject override, IPermissionContainerMixin<?> chan)
     {
@@ -2629,6 +2655,11 @@ private Map<String, AuditLogChange> changeToMap(Set<AuditLogChange> changesList)
     }
 
     private <T> List<T> map(DataObject jsonObject, String key, Function<DataObject, T> convert)
+    {
+        return map(jsonObject, key, convert, (ignored) -> true);
+    }
+
+    private <T> List<T> map(DataObject jsonObject, String key, Function<DataObject, T> convert, Predicate<DataObject> filter)
     {
         if (jsonObject.isNull(key))
             return Collections.emptyList();
@@ -2638,9 +2669,18 @@ private <T> List<T> map(DataObject jsonObject, String key, Function<DataObject,
         for (int i = 0; i < arr.length(); i++)
         {
             DataObject obj = arr.getObject(i);
-            T result = convert.apply(obj);
-            if (result != null)
-                mappedObjects.add(result);
+            try
+            {
+                if (!filter.test(obj))
+                    continue;
+                T result = convert.apply(obj);
+                if (result != null)
+                    mappedObjects.add(result);
+            }
+            catch (Exception e)
+            {
+                LOG.error("Failed to parse element in {} with content {}", key, obj, e);
+            }
         }
 
         return mappedObjects;
diff --git a/src/main/java/net/dv8tion/jda/internal/entities/ReceivedMessage.java b/src/main/java/net/dv8tion/jda/internal/entities/ReceivedMessage.java
index 5e2c467da5..b93b610b8a 100644
--- a/src/main/java/net/dv8tion/jda/internal/entities/ReceivedMessage.java
+++ b/src/main/java/net/dv8tion/jda/internal/entities/ReceivedMessage.java
@@ -34,11 +34,11 @@
 import net.dv8tion.jda.api.entities.emoji.Emoji;
 import net.dv8tion.jda.api.entities.emoji.RichCustomEmoji;
 import net.dv8tion.jda.api.entities.messages.MessagePoll;
+import net.dv8tion.jda.api.entities.messages.MessageSnapshot;
 import net.dv8tion.jda.api.entities.sticker.StickerItem;
 import net.dv8tion.jda.api.exceptions.InsufficientPermissionException;
 import net.dv8tion.jda.api.exceptions.PermissionException;
 import net.dv8tion.jda.api.interactions.InteractionHook;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
 import net.dv8tion.jda.api.interactions.components.LayoutComponent;
 import net.dv8tion.jda.api.requests.ErrorResponse;
 import net.dv8tion.jda.api.requests.GatewayIntent;
@@ -108,6 +108,7 @@ public class ReceivedMessage implements Message
     protected final List<MessageEmbed> embeds;
     protected final List<StickerItem> stickers;
     protected final List<LayoutComponent> components;
+    protected final List<MessageSnapshot> messageSnapshots;
 
     protected WebhookClient<Message> webhook;
 
@@ -122,7 +123,7 @@ public ReceivedMessage(
             boolean fromWebhook, long applicationId, boolean  tts, boolean pinned,
             String content, String nonce, User author, Member member, MessageActivity activity, MessagePoll poll, OffsetDateTime editTime,
             Mentions mentions, List<MessageReaction> reactions, List<Attachment> attachments, List<MessageEmbed> embeds,
-            List<StickerItem> stickers, List<ActionRow> components,
+            List<StickerItem> stickers, List<LayoutComponent> components, List<MessageSnapshot> messageSnapshots,
             int flags, Message.Interaction interaction, ThreadChannel startedThread, int position)
     {
         this.id = id;
@@ -149,6 +150,7 @@ public ReceivedMessage(
         this.embeds = Collections.unmodifiableList(embeds);
         this.stickers = Collections.unmodifiableList(stickers);
         this.components = Collections.unmodifiableList(components);
+        this.messageSnapshots = Collections.unmodifiableList(messageSnapshots);
         this.flags = flags;
         this.interaction = interaction;
         this.startedThread = startedThread;
@@ -660,6 +662,13 @@ public List<StickerItem> getStickers()
         return this.stickers;
     }
 
+    @Nonnull
+    @Override
+    public List<MessageSnapshot> getMessageSnapshots()
+    {
+        return messageSnapshots;
+    }
+
     @Override
     public boolean isWebhookMessage()
     {
diff --git a/src/main/java/net/dv8tion/jda/internal/requests/restaction/MessageCreateActionImpl.java b/src/main/java/net/dv8tion/jda/internal/requests/restaction/MessageCreateActionImpl.java
index 6e76e56a5b..57e6dd3a5a 100644
--- a/src/main/java/net/dv8tion/jda/internal/requests/restaction/MessageCreateActionImpl.java
+++ b/src/main/java/net/dv8tion/jda/internal/requests/restaction/MessageCreateActionImpl.java
@@ -17,6 +17,7 @@
 package net.dv8tion.jda.internal.requests.restaction;
 
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageReference;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import net.dv8tion.jda.api.entities.sticker.GuildSticker;
@@ -26,6 +27,7 @@
 import net.dv8tion.jda.api.requests.Route;
 import net.dv8tion.jda.api.requests.restaction.MessageCreateAction;
 import net.dv8tion.jda.api.utils.data.DataObject;
+import net.dv8tion.jda.api.utils.data.SerializableData;
 import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder;
 import net.dv8tion.jda.api.utils.messages.MessageCreateData;
 import net.dv8tion.jda.internal.requests.RestActionImpl;
@@ -51,7 +53,7 @@ public class MessageCreateActionImpl extends RestActionImpl<Message> implements
     private final MessageCreateBuilder builder = new MessageCreateBuilder();
     private final List<String> stickers = new ArrayList<>();
     private String nonce;
-    private String messageReferenceId;
+    private MessageReferenceData messageReference;
     private boolean failOnInvalidReply = defaultFailOnInvalidReply;
 
     public static void setDefaultFailOnInvalidReply(boolean fail)
@@ -77,34 +79,42 @@ protected RequestBody finalizeData()
     {
         if (builder.isEmpty())
         {
-            if (!stickers.isEmpty())
-                return getRequestBody(DataObject.empty().put("sticker_ids", stickers));
+            // Special cases where builder is empty but can still send message on this endpoint
+            DataObject body = DataObject.empty().put("flags", builder.getMessageFlagsRaw());
+            populateBody(body);
+
+            if (!stickers.isEmpty() || messageReference != null && messageReference.type == MessageReference.MessageReferenceType.FORWARD)
+                return getRequestBody(body);
+
             throw new IllegalStateException("Cannot build empty messages! Must provide at least one of: content, embed, file, poll, or stickers");
         }
 
         try (MessageCreateData data = builder.build())
         {
             DataObject json = data.toData();
-            json.put("enforce_nonce", true);
-            if (nonce != null && !nonce.isEmpty())
-                json.put("nonce", nonce);
-            else
-                json.put("nonce", Long.toUnsignedString(nonceGenerator.nextLong()));
-            if (stickers != null && !stickers.isEmpty())
-                json.put("sticker_ids", stickers);
-            if (messageReferenceId != null)
-            {
-                json.put("message_reference", DataObject.empty()
-                        .put("channel_id", channel.getId())
-                        .put("message_id", messageReferenceId)
-                        .put("fail_if_not_exists", failOnInvalidReply)
-                );
-            }
+            populateBody(json);
 
             return getMultipartBody(data.getFiles(), json);
         }
     }
 
+    private void populateBody(DataObject json)
+    {
+        json.put("enforce_nonce", true);
+        if (nonce != null && !nonce.isEmpty())
+            json.put("nonce", nonce);
+        else
+            json.put("nonce", Long.toUnsignedString(nonceGenerator.nextLong()));
+        if (stickers != null && !stickers.isEmpty())
+            json.put("sticker_ids", stickers);
+        if (messageReference != null)
+        {
+            json.put("message_reference", messageReference.toData()
+                .put("fail_if_not_exists", failOnInvalidReply)
+            );
+        }
+    }
+
     @Override
     protected void handleSuccess(Response response, Request<Message> request)
     {
@@ -121,13 +131,30 @@ public MessageCreateAction setNonce(@Nullable String nonce)
         return this;
     }
 
+    @Nonnull
+    @Override
+    public MessageCreateAction setMessageReference(@Nonnull MessageReference.MessageReferenceType type, @Nullable String guildId, @Nonnull String channelId, @Nonnull String messageId)
+    {
+        Checks.notNull(type, "Type");
+        if (guildId != null)
+            Checks.isSnowflake(guildId, "Guild ID");
+        Checks.isSnowflake(channelId, "Channel ID");
+        Checks.isSnowflake(messageId, "Message ID");
+        Checks.check(type != MessageReference.MessageReferenceType.UNKNOWN, "Cannot create a message reference of UNKNOWN type");
+        this.messageReference = new MessageReferenceData(type, guildId, channelId, messageId);
+        return this;
+    }
+
     @Nonnull
     @Override
     public MessageCreateAction setMessageReference(@Nullable String messageId)
     {
         if (messageId != null)
             Checks.isSnowflake(messageId);
-        this.messageReferenceId = messageId;
+        String guildId = null;
+        if (channel instanceof GuildChannel)
+            guildId = ((GuildChannel) channel).getGuild().getId();
+        this.messageReference = new MessageReferenceData(MessageReference.MessageReferenceType.DEFAULT, guildId, channel.getId(), messageId);
         return this;
     }
 
@@ -184,4 +211,33 @@ public MessageCreateAction deadline(long timestamp)
     {
         return (MessageCreateAction) super.deadline(timestamp);
     }
+
+    private class MessageReferenceData implements SerializableData
+    {
+        private final MessageReference.MessageReferenceType type;
+        private final String messageId;
+        private final String channelId;
+        private final String guildId;
+
+        private MessageReferenceData(MessageReference.MessageReferenceType type, String guildId, String channelId, String messageId)
+        {
+            this.type = type;
+            this.messageId = messageId;
+            this.guildId = guildId;
+            this.channelId = channelId;
+        }
+
+        @Nonnull
+        @Override
+        public DataObject toData()
+        {
+            DataObject data = DataObject.empty()
+                    .put("type", type.getId())
+                    .put("message_id", messageId)
+                    .put("channel_id", channelId);
+            if (guildId != null)
+                data.put("guild_id", guildId);
+            return data;
+        }
+    }
 }
diff --git a/src/test/java/net/dv8tion/jda/test/restaction/MessageCreateActionTest.java b/src/test/java/net/dv8tion/jda/test/restaction/MessageCreateActionTest.java
index 591cbb4c37..48b0aaff5b 100644
--- a/src/test/java/net/dv8tion/jda/test/restaction/MessageCreateActionTest.java
+++ b/src/test/java/net/dv8tion/jda/test/restaction/MessageCreateActionTest.java
@@ -19,6 +19,7 @@
 import net.dv8tion.jda.api.EmbedBuilder;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.MessageReference;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import net.dv8tion.jda.api.entities.emoji.Emoji;
 import net.dv8tion.jda.api.interactions.components.ActionRow;
@@ -32,6 +33,7 @@
 import net.dv8tion.jda.api.utils.messages.MessagePollBuilder;
 import net.dv8tion.jda.api.utils.messages.MessagePollData;
 import net.dv8tion.jda.internal.requests.restaction.MessageCreateActionImpl;
+import net.dv8tion.jda.test.Constants;
 import net.dv8tion.jda.test.IntegrationTest;
 import okhttp3.MediaType;
 import org.junit.jupiter.api.BeforeEach;
@@ -64,9 +66,16 @@ public class MessageCreateActionTest extends IntegrationTest
     @Mock
     protected MessageChannel channel;
 
-    private static DataObject defaultMessageRequest()
+    private static DataObject minimalMessageRequest()
     {
         return DataObject.empty()
+            .put("enforce_nonce", true)
+            .put("flags", 0)
+            .put("nonce", FIXED_NONCE);
+    }
+    private static DataObject defaultMessageRequest()
+    {
+        return minimalMessageRequest()
                 .put("allowed_mentions", DataObject.empty()
                     .put("parse", DataArray.empty()
                         .add("users")
@@ -77,9 +86,6 @@ private static DataObject defaultMessageRequest()
                 .put("content", "")
                 .put("embeds", DataArray.empty())
                 .put("poll", null)
-                .put("enforce_nonce", true)
-                .put("flags", 0)
-                .put("nonce", FIXED_NONCE)
                 .put("tts", false);
     }
 
@@ -193,6 +199,54 @@ void testSuppressVoiceMessage()
             ).whenQueueCalled();
     }
 
+    @Test
+    void testReplyWithContent()
+    {
+        MessageCreateActionImpl action = new MessageCreateActionImpl(channel);
+
+        long messageId = random.nextLong();
+        action.setMessageReference(messageId);
+        action.setContent("test content");
+        action.failOnInvalidReply(true);
+
+        assertThatRequestFrom(action)
+            .hasBodyEqualTo(defaultMessageRequest()
+                .put("content", "test content")
+                .put("message_reference", DataObject.empty()
+                    .put("type", 0)
+                    .put("channel_id", channel.getId())
+                    .put("message_id", Long.toUnsignedString(messageId))
+                    .put("fail_if_not_exists", true)))
+            .whenQueueCalled();
+    }
+
+    @Test
+    void testForwardWithFlags()
+    {
+        MessageCreateActionImpl action = new MessageCreateActionImpl(channel);
+
+        long messageId = random.nextLong();
+        action.setMessageReference(
+            MessageReference.MessageReferenceType.FORWARD,
+            Constants.GUILD_ID,
+            Constants.CHANNEL_ID,
+            messageId
+        );
+
+        action.setSuppressedNotifications(true);
+
+        assertThatRequestFrom(action)
+            .hasBodyEqualTo(minimalMessageRequest()
+                .put("flags", 1 << 12)
+                .put("message_reference", DataObject.empty()
+                    .put("type", 1)
+                    .put("guild_id", Long.toUnsignedString(Constants.GUILD_ID))
+                    .put("channel_id", Long.toUnsignedString(Constants.CHANNEL_ID))
+                    .put("message_id", Long.toUnsignedString(messageId))
+                    .put("fail_if_not_exists", false)))
+            .whenQueueCalled();
+    }
+
     @Test
     void testFullFromBuilder()
     {