arikawa/api/message.go

package api

import (
	"github.com/pkg/errors"

	"github.com/diamondburned/arikawa/v2/discord"
	"github.com/diamondburned/arikawa/v2/utils/httputil"
	"github.com/diamondburned/arikawa/v2/utils/json/option"
)

const (
	// the limit of max messages per request, as imposed by Discord
	maxMessageFetchLimit = 100
	// maxMessageDeleteLimit is the limit of max message that can be deleted
	// per bulk delete request, as imposed by Discord.
	maxMessageDeleteLimit = 100
)

// Messages returns a slice filled with the most recent messages sent in the
// channel with the passed ID. The method automatically paginates until it
// reaches the passed limit, or, if the limit is set to 0, has fetched all
// messages in the channel.
//
// As the underlying endpoint is capped at a maximum of 100 messages per
// request, at maximum a total of limit/100 rounded up requests will be made,
// although they may be less, if no more messages are available.
//
// When fetching the messages, those with the highest ID, will be fetched
// first.
// The returned slice will be sorted from latest to oldest.
func (c *Client) Messages(channelID discord.ChannelID, limit uint) ([]discord.Message, error) {
	// Since before is 0 it will be omitted by the http lib, which in turn
	// will lead discord to send us the most recent messages without having to
	// specify a Snowflake.
	return c.MessagesBefore(channelID, 0, limit)
}

// MessagesAround returns messages around the ID, with a limit of 100.
func (c *Client) MessagesAround(
	channelID discord.ChannelID, around discord.MessageID, limit uint) ([]discord.Message, error) {

	return c.messagesRange(channelID, 0, 0, around, limit)
}

// MessagesBefore returns a slice filled with the messages sent in the channel
// with the passed id. The method automatically paginates until it reaches the
// passed limit, or, if the limit is set to 0, has fetched all messages in the
// channel with an id smaller than before.
//
// As the underlying endpoint has a maximum of 100 messages per request, at
// maximum a total of limit/100 rounded up requests will be made, although they
// may be less, if no more messages are available.
//
// The returned slice will be sorted from latest to oldest.
func (c *Client) MessagesBefore(
	channelID discord.ChannelID, before discord.MessageID, limit uint) ([]discord.Message, error) {

	msgs := make([]discord.Message, 0, limit)

	fetch := uint(maxMessageFetchLimit)

	// Check if we are truly fetching unlimited messages to avoid confusion
	// later on, if the limit reaches 0.
	unlimited := limit == 0

	for limit > 0 || unlimited {
		if limit > 0 {
			// Only fetch as much as we need. Since limit gradually decreases,
			// we only need to fetch min(fetch, limit).
			fetch = uint(min(maxMessageFetchLimit, int(limit)))
			limit -= maxMessageFetchLimit
		}

		m, err := c.messagesRange(channelID, before, 0, 0, fetch)
		if err != nil {
			return msgs, err
		}
		// Append the older messages into the list of newer messages.
		msgs = append(msgs, m...)

		if len(m) < maxMessageFetchLimit {
			break
		}

		before = m[len(m)-1].ID
	}

	if len(msgs) == 0 {
		return nil, nil
	}

	return msgs, nil
}

// MessagesAfter returns a slice filled with the messages sent in the channel
// with the passed ID. The method automatically paginates until it reaches the
// passed limit, or, if the limit is set to 0, has fetched all messages in the
// channel with an id higher than after.
//
// As the underlying endpoint has a maximum of 100 messages per request, at
// maximum a total of limit/100 rounded up requests will be made, although they
// may be less, if no more messages are available.
//
// The returned slice will be sorted from latest to oldest.
func (c *Client) MessagesAfter(
	channelID discord.ChannelID, after discord.MessageID, limit uint) ([]discord.Message, error) {

	// 0 is uint's zero value and will lead to the after param getting omitted,
	// which in turn will lead to the most recent messages being returned.
	// Setting this to 1 will prevent that.
	if after == 0 {
		after = 1
	}

	var msgs []discord.Message

	fetch := uint(maxMessageFetchLimit)

	// Check if we are truly fetching unlimited messages to avoid confusion
	// later on, if the limit reaches 0.
	unlimited := limit == 0

	for limit > 0 || unlimited {
		if limit > 0 {
			// Only fetch as much as we need. Since limit gradually decreases,
			// we only need to fetch min(fetch, limit).
			fetch = uint(min(maxMessageFetchLimit, int(limit)))
			limit -= maxMessageFetchLimit
		}

		m, err := c.messagesRange(channelID, 0, after, 0, fetch)
		if err != nil {
			return msgs, err
		}
		// Prepend the older messages into the newly-fetched messages list.
		msgs = append(m, msgs...)

		if len(m) < maxMessageFetchLimit {
			break
		}

		after = m[0].ID
	}

	if len(msgs) == 0 {
		return nil, nil
	}

	return msgs, nil
}

func (c *Client) messagesRange(
	channelID discord.ChannelID, before, after, around discord.MessageID, limit uint) ([]discord.Message, error) {

	switch {
	case limit == 0:
		limit = 50
	case limit > 100:
		limit = 100
	}

	var param struct {
		Before discord.MessageID `schema:"before,omitempty"`
		After  discord.MessageID `schema:"after,omitempty"`
		Around discord.MessageID `schema:"around,omitempty"`

		Limit uint `schema:"limit"`
	}

	param.Before = before
	param.After = after
	param.Around = around
	param.Limit = limit

	var msgs []discord.Message
	return msgs, c.RequestJSON(
		&msgs, "GET",
		EndpointChannels+channelID.String()+"/messages",
		httputil.WithSchema(c, param),
	)
}

// Message returns a specific message in the channel.
//
// If operating on a guild channel, this endpoint requires the
// READ_MESSAGE_HISTORY permission to be present on the current user.
func (c *Client) Message(channelID discord.ChannelID, messageID discord.MessageID) (*discord.Message, error) {
	var msg *discord.Message
	return msg, c.RequestJSON(&msg, "GET",
		EndpointChannels+channelID.String()+"/messages/"+messageID.String())
}

// SendText posts a only-text message to a guild text or DM channel.
//
// If operating on a guild channel, this endpoint requires the SEND_MESSAGES
// permission to be present on the current user.
//
// Fires a Message Create Gateway event.
func (c *Client) SendText(channelID discord.ChannelID, content string) (*discord.Message, error) {
	return c.SendMessageComplex(channelID, SendMessageData{
		Content: content,
	})
}

// SendEmbed posts an Embed to a guild text or DM channel.
//
// If operating on a guild channel, this endpoint requires the SEND_MESSAGES
// permission to be present on the current user.
//
// Fires a Message Create Gateway event.
func (c *Client) SendEmbed(
	channelID discord.ChannelID, e discord.Embed) (*discord.Message, error) {

	return c.SendMessageComplex(channelID, SendMessageData{
		Embed: &e,
	})
}

// SendMessage posts a message to a guild text or DM channel.
//
// If operating on a guild channel, this endpoint requires the SEND_MESSAGES
// permission to be present on the current user.
//
// Fires a Message Create Gateway event.
func (c *Client) SendMessage(
	channelID discord.ChannelID, content string, embed *discord.Embed) (*discord.Message, error) {

	return c.SendMessageComplex(channelID, SendMessageData{
		Content: content,
		Embed:   embed,
	})
}

// https://discord.com/developers/docs/resources/channel#edit-message-json-params
type EditMessageData struct {
	// Content is the new message contents (up to 2000 characters).
	Content option.NullableString `json:"content,omitempty"`
	// Embed contains embedded rich content.
	Embed *discord.Embed `json:"embed,omitempty"`
	// AllowedMentions are the allowed mentions for a message.
	AllowedMentions *AllowedMentions `json:"allowed_mentions,omitempty"`
	// Flags edits the flags of a message (only SUPPRESS_EMBEDS can currently
	// be set/unset)
	//
	// This field is nullable.
	Flags *discord.MessageFlags `json:"flags,omitempty"`
}

// EditText edits the contents of a previously sent message. For more
// documentation, refer to EditMessageComplex.
func (c *Client) EditText(
	channelID discord.ChannelID, messageID discord.MessageID, content string) (*discord.Message, error) {

	return c.EditMessageComplex(channelID, messageID, EditMessageData{
		Content: option.NewNullableString(content),
	})
}

// EditEmbed edits the embed of a previously sent message. For more
// documentation, refer to EditMessageComplex.
func (c *Client) EditEmbed(
	channelID discord.ChannelID, messageID discord.MessageID, embed discord.Embed) (*discord.Message, error) {

	return c.EditMessageComplex(channelID, messageID, EditMessageData{
		Embed: &embed,
	})
}

// EditMessage edits a previously sent message. For more documentation, refer to
// EditMessageComplex.
func (c *Client) EditMessage(
	channelID discord.ChannelID, messageID discord.MessageID, content string,
	embed *discord.Embed, suppressEmbeds bool) (*discord.Message, error) {

	var data = EditMessageData{
		Content: option.NewNullableString(content),
		Embed:   embed,
	}
	if suppressEmbeds {
		data.Flags = &discord.SuppressEmbeds
	}

	return c.EditMessageComplex(channelID, messageID, data)
}

// EditMessageComplex edits a previously sent message. The fields Content,
// Embed, AllowedMentions and Flags can be edited by the original message
// author. Other users can only edit flags and only if they have the
// MANAGE_MESSAGES permission in the corresponding channel. When specifying
// flags, ensure to include all previously set flags/bits in addition to ones
// that you are modifying. Only flags documented in EditMessageData may be
// modified by users (unsupported flag changes are currently ignored without
// error).
//
// Fires a Message Update Gateway event.
func (c *Client) EditMessageComplex(
	channelID discord.ChannelID, messageID discord.MessageID, data EditMessageData) (*discord.Message, error) {

	if data.AllowedMentions != nil {
		if err := data.AllowedMentions.Verify(); err != nil {
			return nil, errors.Wrap(err, "allowedMentions error")
		}
	}

	if data.Embed != nil {
		if err := data.Embed.Validate(); err != nil {
			return nil, errors.Wrap(err, "embed error")
		}
	}

	var msg *discord.Message
	return msg, c.RequestJSON(
		&msg, "PATCH",
		EndpointChannels+channelID.String()+"/messages/"+messageID.String(),
		httputil.WithJSONBody(data),
	)
}

// DeleteMessage delete a message. If operating on a guild channel and trying
// to delete a message that was not sent by the current user, this endpoint
// requires the MANAGE_MESSAGES permission.
func (c *Client) DeleteMessage(channelID discord.ChannelID, messageID discord.MessageID) error {
	return c.FastRequest("DELETE", EndpointChannels+channelID.String()+
		"/messages/"+messageID.String())
}

// DeleteMessages deletes multiple messages in a single request. This endpoint
// can only be used on guild channels and requires the MANAGE_MESSAGES
// permission. This endpoint only works for bots.
//
// This endpoint will not delete messages older than 2 weeks, and will fail if
// any message provided is older than that or if any duplicate message IDs are
// provided.
//
// Because the underlying endpoint only supports a maximum of 100 message IDs
// per request, DeleteMessages will make a total of messageIDs/100 rounded up
// requests.
//
// Fires a Message Delete Bulk Gateway event.
func (c *Client) DeleteMessages(channelID discord.ChannelID, messageIDs []discord.MessageID) error {
	switch {
	case len(messageIDs) == 0:
		return nil
	case len(messageIDs) == 1:
		return c.DeleteMessage(channelID, messageIDs[0])
	case len(messageIDs) <= maxMessageDeleteLimit: // Fast path
		return c.deleteMessages(channelID, messageIDs)
	}

	// If the number of messages to be deleted exceeds the amount discord is willing
	// to accept at one time then batches of messages will be deleted
	for start := 0; start < len(messageIDs); start += maxMessageDeleteLimit {
		end := min(len(messageIDs), start+maxMessageDeleteLimit)
		err := c.deleteMessages(channelID, messageIDs[start:end])
		if err != nil {
			return err
		}
	}

	return nil
}

func (c *Client) deleteMessages(channelID discord.ChannelID, messageIDs []discord.MessageID) error {
	var param struct {
		Messages []discord.MessageID `json:"messages"`
	}

	param.Messages = messageIDs

	return c.FastRequest(
		"POST",
		EndpointChannels+channelID.String()+"/messages/bulk-delete",
		httputil.WithJSONBody(param),
	)
}