mautrix-discord/pkg/msgconv/from-discord.go

// mautrix-discord - A Matrix-Discord puppeting bridge.
// Copyright (C) 2024 Tulir Asokan
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package msgconv

import (
	"context"
	"fmt"
	"html"
	"strconv"
	"strings"
	"time"

	"github.com/bwmarrin/discordgo"
	"github.com/rs/zerolog"
	"go.mau.fi/mautrix-discord/pkg/connector"
	"maunium.net/go/mautrix/bridgev2"
	"maunium.net/go/mautrix/bridgev2/networkid"
	"maunium.net/go/mautrix/event"
	"maunium.net/go/mautrix/format"
)

func (mc *MessageConverter) ToMatrix(
	ctx context.Context,
	portal *bridgev2.Portal,
	intent bridgev2.MatrixAPI,
	source *bridgev2.UserLogin,
	msg *discordgo.Message,
) *bridgev2.ConvertedMessage {
	predictedLength := len(msg.Attachments) + len(msg.StickerItems)
	if msg.Content != "" {
		predictedLength++
	}
	parts := make([]*bridgev2.ConvertedMessagePart, 0, predictedLength)
	if textPart := mc.renderDiscordTextMessage(ctx, intent, portal, msg, source); textPart != nil {
		parts = append(parts, textPart)
	}

	log := zerolog.Ctx(ctx)
	handledIDs := make(map[string]struct{})

	for _, att := range msg.Attachments {
		if _, handled := handledIDs[att.ID]; handled {
			continue
		}
		handledIDs[att.ID] = struct{}{}

		log := log.With().Str("attachment_id", att.ID).Logger()
		if part := mc.renderDiscordAttachment(log.WithContext(ctx), intent, portal, att); part != nil {
			parts = append(parts, part)
		}
	}

	for _, sticker := range msg.StickerItems {
		if _, handled := handledIDs[sticker.ID]; handled {
			continue
		}
		handledIDs[sticker.ID] = struct{}{}

		log := log.With().Str("sticker_id", sticker.ID).Logger()
		if part := mc.renderDiscordSticker(log.WithContext(ctx), intent, sticker); part != nil {
			parts = append(parts, part)
		}
	}

	for i, embed := range msg.Embeds {
		// Ignore non-video embeds, they're handled in convertDiscordTextMessage
		if getEmbedType(msg, embed) != EmbedVideo {
			continue
		}
		// Discord deduplicates embeds by URL. It makes things easier for us too.
		if _, handled := handledIDs[embed.URL]; handled {
			continue
		}
		handledIDs[embed.URL] = struct{}{}

		log := log.With().
			Str("computed_embed_type", "video").
			Str("embed_type", string(embed.Type)).
			Int("embed_index", i).
			Logger()
		part := mc.renderDiscordVideoEmbed(log.WithContext(ctx), intent, portal, embed)
		if part != nil {
			parts = append(parts, part)
		}
	}

	if len(parts) == 0 && msg.Thread != nil {
		parts = append(parts, &bridgev2.ConvertedMessagePart{Type: event.EventMessage, Content: &event.MessageEventContent{
			MsgType: event.MsgText,
			Body:    fmt.Sprintf("Created a thread: %s", msg.Thread.Name),
		}})
	}

	// TODO(skip): Add extra metadata.
	// for _, part := range parts {
	// 	puppet.addWebhookMeta(part, msg)
	// 	puppet.addMemberMeta(part, msg)
	// }

	return &bridgev2.ConvertedMessage{Parts: parts}
}

const forwardTemplateHTML = `<blockquote>
<p>↷ Forwarded</p>
%s
<p>%s</p>
</blockquote>`

const msgInteractionTemplateHTML = `<blockquote>
<a href="https://matrix.to/#/%s">%s</a> used <font color="#3771bb">/%s</font>
</blockquote>`

const msgComponentTemplateHTML = `<p>This message contains interactive elements. Use the Discord app to interact with the message.</p>`

func (mc *MessageConverter) renderDiscordTextMessage(ctx context.Context, intent bridgev2.MatrixAPI, portal *bridgev2.Portal, msg *discordgo.Message, source *bridgev2.UserLogin) *bridgev2.ConvertedMessagePart {
	log := zerolog.Ctx(ctx)
	if msg.Type == discordgo.MessageTypeCall {
		return &bridgev2.ConvertedMessagePart{Type: event.EventMessage, Content: &event.MessageEventContent{
			MsgType: event.MsgEmote,
			Body:    "started a call",
		}}
	} else if msg.Type == discordgo.MessageTypeGuildMemberJoin {
		return &bridgev2.ConvertedMessagePart{Type: event.EventMessage, Content: &event.MessageEventContent{
			MsgType: event.MsgEmote,
			Body:    "joined the server",
		}}
	}

	var htmlParts []string

	if msg.Interaction != nil {
		ghost, err := mc.connector.Bridge.GetGhostByID(ctx, networkid.UserID(msg.Interaction.User.ID))
		// TODO(skip): Try doing ghost.UpdateInfoIfNecessary.
		if err == nil {
			htmlParts = append(htmlParts, fmt.Sprintf(msgInteractionTemplateHTML, ghost.Intent.GetMXID(), ghost.Name, msg.Interaction.Name))
		} else {
			log.Err(err).Msg("Couldn't get ghost by ID while bridging interaction")
		}
	}

	if msg.Content != "" && !isPlainGifMessage(msg) {
		// Bridge basic text messages.
		htmlParts = append(htmlParts, mc.renderDiscordMarkdownOnlyHTML(msg.Content, true))
	} else if msg.MessageReference != nil &&
		msg.MessageReference.Type == discordgo.MessageReferenceTypeForward &&
		len(msg.MessageSnapshots) > 0 &&
		msg.MessageSnapshots[0].Message != nil {
		// Bridge forwarded messages.

		forwardedHTML := mc.renderDiscordMarkdownOnlyHTMLNoUnwrap(msg.MessageSnapshots[0].Message.Content, true)
		msgTSText := msg.MessageSnapshots[0].Message.Timestamp.Format("2006-01-02 15:04 MST")
		origLink := fmt.Sprintf("unknown channel • %s", msgTSText)
		if forwardedFromPortal, err := mc.connector.Bridge.DB.Portal.GetByKey(ctx, connector.MakePortalKeyWithID(msg.MessageReference.ChannelID)); err == nil && forwardedFromPortal != nil {
			if origMessage, err := mc.connector.Bridge.DB.Message.GetFirstPartByID(ctx, source.ID, networkid.MessageID(msg.MessageReference.MessageID)); err == nil && origMessage != nil {
				// We've bridged the message that was forwarded, so we can link to it directly.
				origLink = fmt.Sprintf(
					`<a href="%s">#%s • %s</a>`,
					forwardedFromPortal.MXID.EventURI(origMessage.MXID, mc.connector.Bridge.Matrix.ServerName()),
					forwardedFromPortal.Name,
					msgTSText,
				)
			} else if err != nil {
				log.Err(err).Msg("Couldn't find corresponding message when bridging forwarded message")
			} else if forwardedFromPortal.MXID != "" {
				// We don't have the message but we have the portal, so link to that.
				origLink = fmt.Sprintf(
					`<a href="%s">#%s</a> • %s`,
					forwardedFromPortal.MXID.URI(mc.connector.Bridge.Matrix.ServerName()),
					forwardedFromPortal.Name,
					msgTSText,
				)
			} else if forwardedFromPortal.Name != "" {
				// We only have the name of the portal.
				origLink = fmt.Sprintf("%s • %s", forwardedFromPortal.Name, msgTSText)
			}
		} else {
			log.Err(err).Msg("Couldn't find corresponding portal when bridging forwarded message")
		}

		htmlParts = append(htmlParts, fmt.Sprintf(forwardTemplateHTML, forwardedHTML, origLink))
	}

	previews := make([]*event.BeeperLinkPreview, 0)
	for i, embed := range msg.Embeds {
		if i == 0 && msg.MessageReference == nil && isReplyEmbed(embed) {
			continue
		}

		with := log.With().
			Str("embed_type", string(embed.Type)).
			Int("embed_index", i)

		switch getEmbedType(msg, embed) {
		case EmbedRich:
			log := with.Str("computed_embed_type", "rich").Logger()
			htmlParts = append(htmlParts, mc.renderDiscordRichEmbed(log.WithContext(ctx), intent, portal, embed))
		case EmbedLinkPreview:
			log := with.Str("computed_embed_type", "link preview").Logger()
			previews = append(previews, mc.renderDiscordLinkEmbed(log.WithContext(ctx), intent, portal, embed))
		case EmbedVideo:
			// Video embeds are handled as separate messages via renderDiscordVideoEmbed.
		default:
			log := with.Logger()
			log.Warn().Msg("Unknown embed type in message")
		}
	}

	if len(msg.Components) > 0 {
		htmlParts = append(htmlParts, msgComponentTemplateHTML)
	}

	if len(htmlParts) == 0 {
		return nil
	}

	fullHTML := strings.Join(htmlParts, "\n")
	if !msg.MentionEveryone {
		fullHTML = strings.ReplaceAll(fullHTML, "@room", "@\u2063ro\u2063om")
	}

	content := format.HTMLToContent(fullHTML)
	extraContent := map[string]any{
		"com.beeper.linkpreviews": previews,
	}

	return &bridgev2.ConvertedMessagePart{Type: event.EventMessage, Content: &content, Extra: extraContent}
}

func mediaFailedMessage(err error) *event.MessageEventContent {
	return &event.MessageEventContent{
		Body:    fmt.Sprintf("Failed to bridge media: %v", err),
		MsgType: event.MsgNotice,
	}
}

func (mc *MessageConverter) renderDiscordVideoEmbed(ctx context.Context, intent bridgev2.MatrixAPI, portal *bridgev2.Portal, embed *discordgo.MessageEmbed) *bridgev2.ConvertedMessagePart {
	var proxyURL string
	if embed.Video != nil {
		proxyURL = embed.Video.ProxyURL
	} else if embed.Thumbnail != nil {
		proxyURL = embed.Thumbnail.ProxyURL
	} else {
		zerolog.Ctx(ctx).Warn().Str("embed_url", embed.URL).Msg("No video or thumbnail proxy URL found in embed")
		return &bridgev2.ConvertedMessagePart{
			Type: event.EventMessage,
			Content: &event.MessageEventContent{
				Body:    "Failed to bridge media: no video or thumbnail proxy URL found in embed",
				MsgType: event.MsgNotice,
			},
		}
	}

	upload := connector.AttachmentReupload{
		DownloadingURL: proxyURL,
	}
	reupload, err := mc.connector.ReuploadMedia(ctx, intent, portal, upload)
	if err != nil {
		zerolog.Ctx(ctx).Err(err).Msg("Failed to copy video embed to Matrix")
		return &bridgev2.ConvertedMessagePart{
			Type:    event.EventMessage,
			Content: mediaFailedMessage(err),
		}
	}

	content := &event.MessageEventContent{
		Body: embed.URL,
		Info: &event.FileInfo{
			MimeType: reupload.MimeType,
			Size:     reupload.DownloadedSize,
		},
		File: &event.EncryptedFileInfo{
			EncryptedFile: reupload.EncryptedFile.EncryptedFile,
			URL:           reupload.MXC,
		},
	}

	if embed.Video != nil {
		content.MsgType = event.MsgVideo
		content.Info.Width = embed.Video.Width
		content.Info.Height = embed.Video.Height
	} else {
		content.MsgType = event.MsgImage
		content.Info.Width = embed.Thumbnail.Width
		content.Info.Height = embed.Thumbnail.Height
	}

	extra := map[string]any{}
	if content.MsgType == event.MsgVideo && embed.Type == discordgo.EmbedTypeGifv {
		extra["info"] = map[string]any{
			"fi.mau.discord.gifv":  true,
			"fi.mau.gif":           true,
			"fi.mau.loop":          true,
			"fi.mau.autoplay":      true,
			"fi.mau.hide_controls": true,
			"fi.mau.no_audio":      true,
		}
	}

	return &bridgev2.ConvertedMessagePart{
		Type:    event.EventMessage,
		Content: content,
		Extra:   extra,
	}
}

func (mc *MessageConverter) renderDiscordSticker(context context.Context, intent bridgev2.MatrixAPI, sticker *discordgo.StickerItem) *bridgev2.ConvertedMessagePart {
	panic("unimplemented")
}

func (mc *MessageConverter) renderDiscordMarkdownOnlyHTML(text string, allowInlineLinks bool) string {
	panic("unimplemented")
}

func (mc *MessageConverter) renderDiscordMarkdownOnlyHTMLNoUnwrap(text string, allowInlineLinks bool) string {
	panic("unimplemented")
}

const (
	embedHTMLWrapper         = `<blockquote class="discord-embed">%s</blockquote>`
	embedHTMLWrapperColor    = `<blockquote class="discord-embed" background-color="#%06X">%s</blockquote>`
	embedHTMLAuthorWithImage = `<p class="discord-embed-author"><img data-mx-emoticon height="24" src="%s" title="Author icon" alt="">&nbsp;<span>%s</span></p>`
	embedHTMLAuthorPlain     = `<p class="discord-embed-author"><span>%s</span></p>`
	embedHTMLAuthorLink      = `<a href="%s">%s</a>`
	embedHTMLTitleWithLink   = `<p class="discord-embed-title"><a href="%s"><strong>%s</strong></a></p>`
	embedHTMLTitlePlain      = `<p class="discord-embed-title"><strong>%s</strong></p>`
	embedHTMLDescription     = `<p class="discord-embed-description">%s</p>`
	embedHTMLFieldName       = `<th>%s</th>`
	embedHTMLFieldValue      = `<td>%s</td>`
	embedHTMLFields          = `<table class="discord-embed-fields"><tr>%s</tr><tr>%s</tr></table>`
	embedHTMLLinearField     = `<p class="discord-embed-field" x-inline="%s"><strong>%s</strong><br><span>%s</span></p>`
	embedHTMLImage           = `<p class="discord-embed-image"><img src="%s" alt="" title="Embed image"></p>`
	embedHTMLFooterWithImage = `<p class="discord-embed-footer"><sub><img data-mx-emoticon height="20" src="%s" title="Footer icon" alt="">&nbsp;<span>%s</span>%s</sub></p>`
	embedHTMLFooterPlain     = `<p class="discord-embed-footer"><sub><span>%s</span>%s</sub></p>`
	embedHTMLFooterOnlyDate  = `<p class="discord-embed-footer"><sub>%s</sub></p>`
	embedHTMLDate            = `<time datetime="%s">%s</time>`
	embedFooterDateSeparator = ` • `
)

func (mc *MessageConverter) renderDiscordRichEmbed(ctx context.Context, intent bridgev2.MatrixAPI, portal *bridgev2.Portal, embed *discordgo.MessageEmbed) string {
	log := zerolog.Ctx(ctx)
	var htmlParts []string
	if embed.Author != nil {
		var authorHTML string
		authorNameHTML := html.EscapeString(embed.Author.Name)
		if embed.Author.URL != "" {
			authorNameHTML = fmt.Sprintf(embedHTMLAuthorLink, embed.Author.URL, authorNameHTML)
		}
		authorHTML = fmt.Sprintf(embedHTMLAuthorPlain, authorNameHTML)
		if embed.Author.ProxyIconURL != "" {
			reupload, err := mc.connector.ReuploadMedia(ctx, intent, portal, connector.AttachmentReupload{
				DownloadingURL: embed.Author.ProxyIconURL,
			})

			if err != nil {
				log.Warn().Err(err).Msg("Failed to reupload author icon in embed")
			} else {
				authorHTML = fmt.Sprintf(embedHTMLAuthorWithImage, reupload.MXC, authorNameHTML)
			}
		}
		htmlParts = append(htmlParts, authorHTML)
	}

	if embed.Title != "" {
		var titleHTML string
		baseTitleHTML := mc.renderDiscordMarkdownOnlyHTML(embed.Title, false)
		if embed.URL != "" {
			titleHTML = fmt.Sprintf(embedHTMLTitleWithLink, html.EscapeString(embed.URL), baseTitleHTML)
		} else {
			titleHTML = fmt.Sprintf(embedHTMLTitlePlain, baseTitleHTML)
		}
		htmlParts = append(htmlParts, titleHTML)
	}

	if embed.Description != "" {
		htmlParts = append(htmlParts, fmt.Sprintf(embedHTMLDescription, mc.renderDiscordMarkdownOnlyHTML(embed.Description, true)))
	}

	for i := 0; i < len(embed.Fields); i++ {
		item := embed.Fields[i]
		// TODO(skip): Port EmbedFieldsAsTables.
		if false {
			splitItems := []*discordgo.MessageEmbedField{item}
			if item.Inline && len(embed.Fields) > i+1 && embed.Fields[i+1].Inline {
				splitItems = append(splitItems, embed.Fields[i+1])
				i++
				if len(embed.Fields) > i+1 && embed.Fields[i+1].Inline {
					splitItems = append(splitItems, embed.Fields[i+1])
					i++
				}
			}
			headerParts := make([]string, len(splitItems))
			contentParts := make([]string, len(splitItems))
			for j, splitItem := range splitItems {
				headerParts[j] = fmt.Sprintf(embedHTMLFieldName, mc.renderDiscordMarkdownOnlyHTML(splitItem.Name, false))
				contentParts[j] = fmt.Sprintf(embedHTMLFieldValue, mc.renderDiscordMarkdownOnlyHTML(splitItem.Value, true))
			}
			htmlParts = append(htmlParts, fmt.Sprintf(embedHTMLFields, strings.Join(headerParts, ""), strings.Join(contentParts, "")))
		} else {
			htmlParts = append(htmlParts, fmt.Sprintf(embedHTMLLinearField,
				strconv.FormatBool(item.Inline),
				mc.renderDiscordMarkdownOnlyHTML(item.Name, false),
				mc.renderDiscordMarkdownOnlyHTML(item.Value, true),
			))
		}
	}

	if embed.Image != nil {
		reupload, err := mc.connector.ReuploadMedia(ctx, intent, portal, connector.AttachmentReupload{
			DownloadingURL: embed.Image.ProxyURL,
		})
		if err != nil {
			log.Warn().Err(err).Msg("Failed to reupload image in embed")
		} else {
			htmlParts = append(htmlParts, fmt.Sprintf(embedHTMLImage, reupload.MXC))
		}
	}

	var embedDateHTML string
	if embed.Timestamp != "" {
		formattedTime := embed.Timestamp
		parsedTS, err := time.Parse(time.RFC3339, embed.Timestamp)
		if err != nil {
			log.Warn().Err(err).Msg("Failed to parse timestamp in embed")
		} else {
			formattedTime = parsedTS.Format(discordTimestampStyle('F').Format())
		}
		embedDateHTML = fmt.Sprintf(embedHTMLDate, embed.Timestamp, formattedTime)
	}

	if embed.Footer != nil {
		var footerHTML string
		var datePart string
		if embedDateHTML != "" {
			datePart = embedFooterDateSeparator + embedDateHTML
		}
		footerHTML = fmt.Sprintf(embedHTMLFooterPlain, html.EscapeString(embed.Footer.Text), datePart)
		if embed.Footer.ProxyIconURL != "" {
			reupload, err := mc.connector.ReuploadMedia(ctx, intent, portal, connector.AttachmentReupload{
				DownloadingURL: embed.Footer.ProxyIconURL,
			})

			if err != nil {
				log.Warn().Err(err).Msg("Failed to reupload footer icon in embed")
			} else {
				footerHTML = fmt.Sprintf(embedHTMLFooterWithImage, reupload.MXC, html.EscapeString(embed.Footer.Text), datePart)
			}
		}
		htmlParts = append(htmlParts, footerHTML)
	} else if embed.Timestamp != "" {
		htmlParts = append(htmlParts, fmt.Sprintf(embedHTMLFooterOnlyDate, embedDateHTML))
	}

	if len(htmlParts) == 0 {
		return ""
	}

	compiledHTML := strings.Join(htmlParts, "")
	if embed.Color != 0 {
		compiledHTML = fmt.Sprintf(embedHTMLWrapperColor, embed.Color, compiledHTML)
	} else {
		compiledHTML = fmt.Sprintf(embedHTMLWrapper, compiledHTML)
	}
	return compiledHTML
}

func (mc *MessageConverter) renderDiscordLinkEmbedImage(ctx context.Context, intent bridgev2.MatrixAPI, portal *bridgev2.Portal, url string, width, height int, preview *event.BeeperLinkPreview) {
	reupload, err := mc.connector.ReuploadMedia(ctx, intent, portal, connector.AttachmentReupload{
		DownloadingURL: url,
	})
	if err != nil {
		zerolog.Ctx(ctx).Warn().Err(err).Msg("Failed to reupload image in URL preview, ignoring")
		return
	}

	if width != 0 || height != 0 {
		preview.ImageWidth = event.IntOrString(width)
		preview.ImageHeight = event.IntOrString(height)
	}
	preview.ImageSize = event.IntOrString(reupload.DownloadedSize)
	preview.ImageType = reupload.MimeType
	preview.ImageEncryption = &event.EncryptedFileInfo{
		EncryptedFile: reupload.EncryptedFile.EncryptedFile,
		URL:           reupload.MXC,
	}
}

func (mc *MessageConverter) renderDiscordLinkEmbed(ctx context.Context, intent bridgev2.MatrixAPI, portal *bridgev2.Portal, embed *discordgo.MessageEmbed) *event.BeeperLinkPreview {
	var preview event.BeeperLinkPreview
	preview.MatchedURL = embed.URL
	preview.Title = embed.Title
	preview.Description = embed.Description
	if embed.Image != nil {
		mc.renderDiscordLinkEmbedImage(ctx, intent, portal, embed.Image.ProxyURL, embed.Image.Width, embed.Image.Height, &preview)
	} else if embed.Thumbnail != nil {
		mc.renderDiscordLinkEmbedImage(ctx, intent, portal, embed.Thumbnail.ProxyURL, embed.Thumbnail.Width, embed.Thumbnail.Height, &preview)
	}
	return &preview
}

func (mc *MessageConverter) renderDiscordAttachment(ctx context.Context, intent bridgev2.MatrixAPI, portal *bridgev2.Portal, att *discordgo.MessageAttachment) *bridgev2.ConvertedMessagePart {
	content := &event.MessageEventContent{
		Body: att.Filename,
		Info: &event.FileInfo{
			Width:    att.Width,
			Height:   att.Height,
			MimeType: att.ContentType,

			// This gets overwritten later after the file is uploaded to the homeserver
			Size: att.Size,
		},
	}

	var extra = make(map[string]any)

	if strings.HasPrefix(att.Filename, "SPOILER_") {
		extra["page.codeberg.everypizza.msc4193.spoiler"] = true
	}

	if att.Description != "" {
		content.Body = att.Description
		content.FileName = att.Filename
	}

	switch strings.ToLower(strings.Split(att.ContentType, "/")[0]) {
	case "audio":
		content.MsgType = event.MsgAudio
		if att.Waveform != nil {
			// Bridge a voice message.

			// TODO convert waveform
			extra["org.matrix.msc1767.audio"] = map[string]any{
				"duration": int(att.DurationSeconds * 1000),
			}
			extra["org.matrix.msc3245.voice"] = map[string]any{}
		}
	case "image":
		content.MsgType = event.MsgImage
	case "video":
		content.MsgType = event.MsgVideo
	default:
		content.MsgType = event.MsgFile
	}

	// TODO(skip): Support direct media.
	reupload, err := mc.connector.ReuploadMedia(ctx, intent, portal, connector.AttachmentReupload{
		DownloadingURL: att.URL,
	})
	if err != nil {
		zerolog.Ctx(ctx).Err(err).Msg("Failed to copy attachment to Matrix")
		return &bridgev2.ConvertedMessagePart{
			Type:    event.EventMessage,
			Content: mediaFailedMessage(err),
		}
	}

	content.Info.Size = reupload.DownloadedSize
	if content.Info.Width == 0 && content.Info.Height == 0 {
		content.Info.Width = att.Width
		content.Info.Height = att.Height
	}
	content.File = &event.EncryptedFileInfo{
		EncryptedFile: reupload.EncryptedFile.EncryptedFile,
		URL:           reupload.MXC,
	}

	return &bridgev2.ConvertedMessagePart{
		Type:    event.EventMessage,
		Content: content,
		Extra:   extra,
	}
}