portal.go

// mautrix-slack - A Matrix-Slack puppeting bridge.
// Copyright (C) 2022 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 main

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"time"

	"golang.org/x/exp/slices"
	log "maunium.net/go/maulogger/v2"

	"github.com/slack-go/slack"

	"maunium.net/go/mautrix"
	"maunium.net/go/mautrix/appservice"
	"maunium.net/go/mautrix/bridge"
	"maunium.net/go/mautrix/bridge/bridgeconfig"
	"maunium.net/go/mautrix/event"
	"maunium.net/go/mautrix/id"
	"maunium.net/go/mautrix/util/dbutil"

	"go.mau.fi/mautrix-slack/config"
	"go.mau.fi/mautrix-slack/database"
)

type portalMatrixMessage struct {
	evt        *event.Event
	user       *User
	receivedAt time.Time
}

type Portal struct {
	*database.Portal

	bridge *SlackBridge
	log    log.Logger

	roomCreateLock          sync.Mutex
	encryptLock             sync.Mutex
	backfillLock            sync.Mutex
	latestEventBackfillLock sync.Mutex

	matrixMessages chan portalMatrixMessage

	slackMessageLock sync.Mutex

	currentlyTyping     []id.UserID
	currentlyTypingLock sync.Mutex
}

var (
	_ bridge.Portal                    = (*Portal)(nil)
	_ bridge.ReadReceiptHandlingPortal = (*Portal)(nil)
	_ bridge.TypingPortal              = (*Portal)(nil)
	//_ bridge.MembershipHandlingPortal = (*Portal)(nil)
	//_ bridge.MetaHandlingPortal = (*Portal)(nil)
	//_ bridge.DisappearingPortal = (*Portal)(nil)
)

func (portal *Portal) IsEncrypted() bool {
	return portal.Encrypted
}

func (portal *Portal) MarkEncrypted() {
	portal.Encrypted = true
	portal.Update(nil)
}

func (portal *Portal) shouldSetDMRoomMetadata() bool {
	return !portal.IsPrivateChat() ||
		portal.bridge.Config.Bridge.PrivateChatPortalMeta == "always" ||
		(portal.IsEncrypted() && portal.bridge.Config.Bridge.PrivateChatPortalMeta != "never")
}

func (portal *Portal) ReceiveMatrixEvent(user bridge.User, evt *event.Event) {
	if user.GetPermissionLevel() >= bridgeconfig.PermissionLevelUser /*|| portal.HasRelaybot()*/ {
		portal.matrixMessages <- portalMatrixMessage{user: user.(*User), evt: evt, receivedAt: time.Now()}
	}
}

func (portal *Portal) HandleMatrixReadReceipt(sender bridge.User, eventID id.EventID, receipt event.ReadReceipt) {
	//portal.handleMatrixReadReceipt(sender.(*User), eventID, receiptTimestamp, true)
	userTeam := sender.(*User).GetUserTeam(portal.Key.TeamID)

	portal.markSlackRead(sender.(*User), userTeam, eventID)
}

func (portal *Portal) markSlackRead(user *User, userTeam *database.UserTeam, eventID id.EventID) {
	if !userTeam.IsConnected() {
		portal.log.Debugfln("Not marking Slack conversation %s as read by %s: not connected to Slack", portal.Key, user.MXID)
		return
	}

	message := portal.bridge.DB.Message.GetByMatrixID(portal.Key, eventID)
	if message == nil {
		portal.log.Debugfln("Not marking Slack channel for portal %s as read: unknown message", portal.Key)
		return
	}

	userTeam.Client.MarkConversation(portal.Key.ChannelID, message.SlackID)
	portal.log.Debugfln("Marked message %s as read by %s in portal %s", message.SlackID, user.MXID, portal.Key)
}

var (
	portalCreationDummyEvent = event.Type{Type: "fi.mau.dummy.portal_created", Class: event.MessageEventType}
)

func (br *SlackBridge) loadPortal(dbPortal *database.Portal, key *database.PortalKey) *Portal {
	// If we weren't given a portal we'll attempt to create it if a key was
	// provided.
	if dbPortal == nil {
		if key == nil {
			return nil
		}

		dbPortal = br.DB.Portal.New()
		dbPortal.Key = *key
		dbPortal.Insert()
	}

	portal := br.NewPortal(dbPortal)

	// No need to lock, it is assumed that our callers have already acquired
	// the lock.
	br.portalsByID[portal.Key] = portal
	if portal.MXID != "" {
		br.portalsByMXID[portal.MXID] = portal
	}

	return portal
}

func (br *SlackBridge) GetPortalByMXID(mxid id.RoomID) *Portal {
	br.portalsLock.Lock()
	defer br.portalsLock.Unlock()

	portal, ok := br.portalsByMXID[mxid]
	if !ok {
		return br.loadPortal(br.DB.Portal.GetByMXID(mxid), nil)
	}

	return portal
}

func (br *SlackBridge) GetPortalByID(key database.PortalKey) *Portal {
	br.portalsLock.Lock()
	defer br.portalsLock.Unlock()

	portal, ok := br.portalsByID[key]
	if !ok {
		return br.loadPortal(br.DB.Portal.GetByID(key), &key)
	}

	return portal
}

func (br *SlackBridge) GetAllPortals() []*Portal {
	return br.dbPortalsToPortals(br.DB.Portal.GetAll())
}

func (br *SlackBridge) GetAllIPortals() (iportals []bridge.Portal) {
	portals := br.GetAllPortals()
	iportals = make([]bridge.Portal, len(portals))
	for i, portal := range portals {
		iportals[i] = portal
	}
	return iportals
}

func (br *SlackBridge) GetAllPortalsForUserTeam(utk database.UserTeamKey) []*Portal {
	return br.dbPortalsToPortals(br.DB.Portal.GetAllForUserTeam(utk))
}

func (br *SlackBridge) GetDMPortalsWith(otherUserID string) []*Portal {
	return br.dbPortalsToPortals(br.DB.Portal.FindPrivateChatsWith(otherUserID))
}

func (br *SlackBridge) dbPortalsToPortals(dbPortals []*database.Portal) []*Portal {
	br.portalsLock.Lock()
	defer br.portalsLock.Unlock()

	output := make([]*Portal, len(dbPortals))
	for index, dbPortal := range dbPortals {
		if dbPortal == nil {
			continue
		}

		portal, ok := br.portalsByID[dbPortal.Key]
		if !ok {
			portal = br.loadPortal(dbPortal, nil)
		}

		output[index] = portal
	}

	return output
}

func (br *SlackBridge) NewPortal(dbPortal *database.Portal) *Portal {
	portal := &Portal{
		Portal: dbPortal,
		bridge: br,
		log:    br.Log.Sub(fmt.Sprintf("Portal/%s", dbPortal.Key)),

		matrixMessages: make(chan portalMatrixMessage, br.Config.Bridge.PortalMessageBuffer),
	}

	go portal.messageLoop()
	go portal.slackRepeatTypingUpdater()

	return portal
}

func (portal *Portal) messageLoop() {
	for {
		select {
		case msg := <-portal.matrixMessages:
			portal.handleMatrixMessages(msg)
		}
	}
}

func (portal *Portal) IsPrivateChat() bool {
	return portal.Type == database.ChannelTypeDM
}

func (portal *Portal) MainIntent() *appservice.IntentAPI {
	if portal.IsPrivateChat() && portal.DMUserID != "" {
		puppet := portal.bridge.GetPuppetByID(portal.Key.TeamID, portal.DMUserID)
		if puppet.CustomMXID == "" {
			return puppet.IntentFor(portal)
		}
	}

	return portal.bridge.Bot
}

func (portal *Portal) syncParticipants(source *User, sourceTeam *database.UserTeam, participants []string, invite bool) []id.UserID {
	userIDs := make([]id.UserID, 0, len(participants)+1)
	for _, participant := range participants {
		portal.log.Infofln("Getting participant %s", participant)
		puppet := portal.bridge.GetPuppetByID(sourceTeam.Key.TeamID, participant)

		puppet.UpdateInfo(sourceTeam, true, nil)

		user := portal.bridge.GetUserByID(sourceTeam.Key.TeamID, participant)

		if user != nil {
			userIDs = append(userIDs, user.MXID)
		}
		if user == nil || puppet.CustomMXID != user.MXID {
			userIDs = append(userIDs, puppet.MXID)
		}

		if invite {
			if user != nil {
				portal.ensureUserInvited(user)
			}

			if user == nil || !puppet.IntentFor(portal).IsCustomPuppet {
				if err := puppet.IntentFor(portal).EnsureJoined(portal.MXID); err != nil {
					portal.log.Warnfln("Failed to make puppet of %s join %s: %v", participant, portal.MXID, err)
				}
			}
		}
	}
	return userIDs
}

func (portal *Portal) GetEncryptionEventContent() (evt *event.EncryptionEventContent) {
	evt = &event.EncryptionEventContent{Algorithm: id.AlgorithmMegolmV1}
	if rot := portal.bridge.Config.Bridge.Encryption.Rotation; rot.EnableCustom {
		evt.RotationPeriodMillis = rot.Milliseconds
		evt.RotationPeriodMessages = rot.Messages
	}
	return
}

func (portal *Portal) CreateMatrixRoom(user *User, userTeam *database.UserTeam, channel *slack.Channel, fill bool) error {
	portal.roomCreateLock.Lock()
	defer portal.roomCreateLock.Unlock()

	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	// If we have a matrix id the room should exist so we have nothing to do.
	if portal.MXID != "" {
		return nil
	}

	channel = portal.UpdateInfo(user, userTeam, channel, false)
	if channel == nil {
		return fmt.Errorf("didn't find channel metadata")
	}
	typeFound := portal.setChannelType(channel)
	if !typeFound {
		portal.log.Warnln("No appropriate type found for channel")
		return nil
	}
	if portal.Type == database.ChannelTypeGroupDM && len(channel.Members) == 0 {
		portal.log.Warnln("Group DM with no members, not bridging")
		return nil
	}

	portal.log.Infoln("Creating Matrix room for channel:", portal.Portal.Key.ChannelID)

	intent := portal.MainIntent()
	if err := intent.EnsureRegistered(); err != nil {
		return err
	}

	bridgeInfoStateKey, bridgeInfo := portal.getBridgeInfo()
	initialState := []*event.Event{{
		Type:     event.StateBridge,
		Content:  event.Content{Parsed: bridgeInfo},
		StateKey: &bridgeInfoStateKey,
	}, {
		// TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec
		Type:     event.StateHalfShotBridge,
		Content:  event.Content{Parsed: bridgeInfo},
		StateKey: &bridgeInfoStateKey,
	}}

	creationContent := make(map[string]interface{})
	creationContent["m.federate"] = portal.bridge.Config.Bridge.FederateRooms

	var invite []id.UserID

	if portal.bridge.Config.Bridge.Encryption.Default {
		initialState = append(initialState, &event.Event{
			Type: event.StateEncryption,
			Content: event.Content{
				Parsed: portal.GetEncryptionEventContent(),
			},
		})
		portal.Encrypted = true

		if portal.IsPrivateChat() {
			invite = append(invite, portal.bridge.Bot.UserID)
			portal.log.Infoln("added the bot because this portal is encrypted")
		}
	}

	var members []string
	// no members are included in channels, only in group DMs
	switch portal.Type {
	case database.ChannelTypeChannel:
		members = portal.getChannelMembers(userTeam, 3) // TODO: this just fetches 3 members so channels don't have to look like DMs
	case database.ChannelTypeDM:
		members = []string{channel.User, userTeam.Key.SlackID}
	case database.ChannelTypeGroupDM:
		members = channel.Members
	}

	autoJoinInvites := portal.bridge.Config.Homeserver.Software == bridgeconfig.SoftwareHungry
	if autoJoinInvites {
		portal.log.Debugfln("Hungryserv mode: adding all group members in create request")
		participants := portal.syncParticipants(user, userTeam, members, false)
		invite = append(invite, participants...)
		if !slices.Contains(invite, user.MXID) {
			invite = append(invite, user.MXID)
		}
	}
	req := &mautrix.ReqCreateRoom{
		Visibility:            "private",
		Name:                  portal.Name,
		Topic:                 portal.Topic,
		Invite:                invite,
		Preset:                "private_chat",
		IsDirect:              portal.IsPrivateChat(),
		InitialState:          initialState,
		CreationContent:       creationContent,
		BeeperAutoJoinInvites: autoJoinInvites,
	}
	if !portal.shouldSetDMRoomMetadata() {
		req.Name = ""
	}
	resp, err := intent.CreateRoom(req)
	if err != nil {
		portal.log.Warnln("Failed to create room:", err)
		return err
	}

	portal.NameSet = req.Name != ""
	portal.TopicSet = true
	portal.MXID = resp.RoomID
	portal.bridge.portalsLock.Lock()
	portal.bridge.portalsByMXID[portal.MXID] = portal
	portal.bridge.portalsLock.Unlock()
	portal.Update(nil)

	portal.InsertUser(userTeam.Key)

	portal.log.Infoln("Matrix room created:", portal.MXID)

	if portal.Encrypted && portal.IsPrivateChat() {
		err = portal.bridge.Bot.EnsureJoined(portal.MXID, appservice.EnsureJoinedParams{BotOverride: portal.MainIntent().Client})
		if err != nil {
			portal.log.Errorfln("Failed to ensure bridge bot is joined to private chat portal: %v", err)
		}
	}

	// We set the memberships beforehand to make sure the encryption key exchange in initial backfill knows the users are here.
	inviteMembership := event.MembershipInvite
	if autoJoinInvites {
		inviteMembership = event.MembershipJoin
	}
	for _, userID := range invite {
		portal.bridge.StateStore.SetMembership(portal.MXID, userID, inviteMembership)
	}

	if !autoJoinInvites {
		portal.ensureUserInvited(user)
		user.syncChatDoublePuppetDetails(portal, true)
		portal.syncParticipants(user, userTeam, members, true)
	}
	if portal.Type == database.ChannelTypeChannel {
		user.updateChatMute(portal, true)
	}

	// if portal.IsPrivateChat() {
	// 	puppet := user.bridge.GetPuppetByID(userTeam.Key.TeamID, portal.Key.UserID)

	// 	chats := map[id.UserID][]id.RoomID{puppet.MXID: {portal.MXID}}
	// 	user.updateDirectChats(chats)
	// }

	firstEventResp, err := portal.MainIntent().SendMessageEvent(portal.MXID, portalCreationDummyEvent, struct{}{})
	if err != nil {
		portal.log.Errorln("Failed to send dummy event to mark portal creation:", err)
	} else {
		portal.FirstEventID = firstEventResp.EventID
		portal.Update(nil)
	}

	if portal.bridge.Config.Bridge.Backfill.Enable {
		portal.log.Debugln("Performing initial backfill batch")
		initialMessages, err := userTeam.Client.GetConversationHistory(&slack.GetConversationHistoryParameters{
			ChannelID: portal.Key.ChannelID,
			Inclusive: true,
			Limit:     portal.bridge.Config.Bridge.Backfill.ImmediateMessages,
		})
		backfillState := portal.bridge.DB.Backfill.NewBackfillState(&portal.Key)
		if err != nil {
			portal.log.Errorfln("Error fetching initial backfill messages: %v", err)
			backfillState.BackfillComplete = true
		} else {
			resp, err := portal.backfill(userTeam, initialMessages.Messages, true)
			if err != nil {
				portal.log.Errorfln("Error sending initial backfill batch: %v", err)
			}
			if resp != nil {
				backfillState.ImmediateComplete = true
				backfillState.MessageCount += len(initialMessages.Messages)
			} else {
				backfillState.BackfillComplete = true
			}
		}
		portal.log.Debugln("Enqueueing backfill")
		backfillState.Upsert()
		portal.bridge.BackfillQueue.ReCheck()
	}

	return nil
}

func (portal *Portal) getChannelMembers(userTeam *database.UserTeam, limit int) []string {
	members, _, err := userTeam.Client.GetUsersInConversation(&slack.GetUsersInConversationParameters{
		ChannelID: portal.Key.ChannelID,
		Limit:     limit,
	})
	if err != nil {
		portal.log.Errorfln("Error fetching channel members for %v: %v", portal.Key, err)
		return nil
	}
	return members

}

func (portal *Portal) ensureUserInvited(user *User) bool {
	return user.ensureInvited(portal.MainIntent(), portal.MXID, portal.IsPrivateChat())
}

func (portal *Portal) markMessageHandled(txn dbutil.Transaction, slackID string, slackThreadID string, mxid id.EventID, authorID string) *database.Message {
	msg := portal.bridge.DB.Message.New()
	msg.Channel = portal.Key
	msg.SlackID = slackID
	msg.MatrixID = mxid
	msg.AuthorID = authorID
	msg.SlackThreadID = slackThreadID
	msg.Insert(txn)

	return msg
}

// func (portal *Portal) sendMediaFailedMessage(intent *appservice.IntentAPI, bridgeErr error) {
// 	content := &event.MessageEventContent{
// 		Body:    fmt.Sprintf("Failed to bridge media: %v", bridgeErr),
// 		MsgType: event.MsgNotice,
// 	}

// 	_, err := portal.sendMatrixMessage(intent, event.EventMessage, content, nil, time.Now().UTC().UnixMilli())
// 	if err != nil {
// 		portal.log.Warnfln("failed to send error message to matrix: %v", err)
// 	}
// }

func (portal *Portal) encrypt(intent *appservice.IntentAPI, content *event.Content, eventType event.Type) (event.Type, error) {
	if !portal.Encrypted || portal.bridge.Crypto == nil {
		return eventType, nil
	}
	intent.AddDoublePuppetValue(content)
	// TODO maybe the locking should be inside mautrix-go?
	portal.encryptLock.Lock()
	err := portal.bridge.Crypto.Encrypt(portal.MXID, eventType, content)
	portal.encryptLock.Unlock()
	if err != nil {
		return eventType, fmt.Errorf("failed to encrypt event: %w", err)
	}
	return event.EventEncrypted, nil
}

const doublePuppetKey = "fi.mau.double_puppet_source"
const doublePuppetValue = "mautrix-slack"

func (portal *Portal) sendMatrixMessage(intent *appservice.IntentAPI, eventType event.Type, content *event.MessageEventContent, extraContent map[string]interface{}, timestamp int64) (*mautrix.RespSendEvent, error) {
	wrappedContent := event.Content{Parsed: content, Raw: extraContent}
	if timestamp != 0 && intent.IsCustomPuppet {
		if wrappedContent.Raw == nil {
			wrappedContent.Raw = map[string]interface{}{}
		}
		if intent.IsCustomPuppet {
			wrappedContent.Raw[doublePuppetKey] = doublePuppetValue
		}
	}
	var err error
	eventType, err = portal.encrypt(intent, &wrappedContent, eventType)
	if err != nil {
		return nil, err
	}

	if eventType == event.EventEncrypted {
		// Clear other custom keys if the event was encrypted, but keep the double puppet identifier
		if intent.IsCustomPuppet {
			wrappedContent.Raw = map[string]interface{}{doublePuppetKey: doublePuppetValue}
		} else {
			wrappedContent.Raw = nil
		}
	}

	_, _ = intent.UserTyping(portal.MXID, false, 0)
	if timestamp == 0 {
		return intent.SendMessageEvent(portal.MXID, eventType, &wrappedContent)
	} else {
		return intent.SendMassagedMessageEvent(portal.MXID, eventType, &wrappedContent, timestamp)
	}
}

func (portal *Portal) handleMatrixMessages(msg portalMatrixMessage) {

	evtTS := time.UnixMilli(msg.evt.Timestamp)
	timings := messageTimings{
		initReceive:  msg.evt.Mautrix.ReceivedAt.Sub(evtTS),
		decrypt:      msg.evt.Mautrix.DecryptionDuration,
		portalQueue:  time.Since(msg.receivedAt),
		totalReceive: time.Since(evtTS),
	}
	ms := metricSender{portal: portal, sender: msg.user, timings: &timings}

	switch msg.evt.Type {
	case event.EventMessage:
		portal.handleMatrixMessage(msg.user, msg.evt, &ms)
	case event.EventRedaction:
		portal.handleMatrixRedaction(msg.user, msg.evt)
	case event.EventReaction:
		portal.handleMatrixReaction(msg.user, msg.evt, &ms)
	default:
		portal.log.Debugln("unknown event type", msg.evt.Type)
	}
}

func (portal *Portal) handleMatrixMessage(sender *User, evt *event.Event, ms *metricSender) {
	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	start := time.Now()

	userTeam := sender.GetUserTeam(portal.Key.TeamID)
	if userTeam == nil {
		portal.log.Warnfln("User %s not logged into team %s", sender.MXID, portal.Key.TeamID)
		go ms.sendMessageMetrics(evt, errUserNotLoggedIn, "Ignoring", true)
		return
	}
	if userTeam.Client == nil {
		portal.log.Errorfln("Client for userteam %s is nil!", userTeam.Key)
		return
	}

	existing := portal.bridge.DB.Message.GetByMatrixID(portal.Key, evt.ID)
	if existing != nil {
		portal.log.Debugln("not handling duplicate message", evt.ID)
		go ms.sendMessageMetrics(evt, nil, "", true)
		return
	}

	messageAge := ms.timings.totalReceive
	errorAfter := portal.bridge.Config.Bridge.MessageHandlingTimeout.ErrorAfter
	deadline := portal.bridge.Config.Bridge.MessageHandlingTimeout.Deadline
	isScheduled, _ := evt.Content.Raw["com.beeper.scheduled"].(bool)
	if isScheduled {
		portal.log.Debugfln("%s is a scheduled message, extending handling timeouts", evt.ID)
		errorAfter *= 10
		deadline *= 10
	}

	if errorAfter > 0 {
		remainingTime := errorAfter - messageAge
		if remainingTime < 0 {
			go ms.sendMessageMetrics(evt, errTimeoutBeforeHandling, "Timeout handling", true)
			return
		} else if remainingTime < 1*time.Second {
			portal.log.Warnfln("Message %s was delayed before reaching the bridge, only have %s (of %s timeout) until delay warning", evt.ID, remainingTime, errorAfter)
		}
		go func() {
			time.Sleep(remainingTime)
			ms.sendMessageMetrics(evt, errMessageTakingLong, "Timeout handling", false)
		}()
	}

	ctx := context.Background()
	if deadline > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithTimeout(ctx, deadline)
		defer cancel()
	}
	ms.timings.preproc = time.Since(start)

	start = time.Now()
	options, fileUpload, threadTs, err := portal.convertMatrixMessage(ctx, sender, userTeam, evt)
	ms.timings.convert = time.Since(start)

	start = time.Now()
	var timestamp string
	if options == nil && fileUpload == nil {
		go ms.sendMessageMetrics(evt, err, "Error converting", true)
		return
	} else if options != nil {
		portal.log.Debugfln("Sending message %s to Slack %s %s", evt.ID, portal.Key.TeamID, portal.Key.ChannelID)
		_, timestamp, err = userTeam.Client.PostMessage(
			portal.Key.ChannelID,
			slack.MsgOptionAsUser(true),
			slack.MsgOptionCompose(options...))
		if err != nil {
			go ms.sendMessageMetrics(evt, err, "Error sending", true)
			return
		}
	} else if fileUpload != nil {
		portal.log.Debugfln("Uploading file from message %s to Slack %s %s", evt.ID, portal.Key.TeamID, portal.Key.ChannelID)
		file, err := userTeam.Client.UploadFile(*fileUpload)
		if err != nil {
			portal.log.Errorfln("Failed to upload slack attachment: %v", err)
			go ms.sendMessageMetrics(evt, errMediaSlackUploadFailed, "Error uploading", true)
			return
		}
		var shareInfo slack.ShareFileInfo
		// Slack puts the channel message info after uploading a file in either file.shares.private or file.shares.public
		if info, found := file.Shares.Private[portal.Key.ChannelID]; found && len(info) > 0 {
			shareInfo = info[0]
		} else if info, found := file.Shares.Public[portal.Key.ChannelID]; found && len(info) > 0 {
			shareInfo = info[0]
		} else {
			go ms.sendMessageMetrics(evt, errMediaSlackUploadFailed, "Error uploading", true)
			return
		}
		timestamp = shareInfo.Ts
	}
	ms.timings.totalSend = time.Since(start)
	go ms.sendMessageMetrics(evt, err, "Error sending", true)
	// TODO: store these timings in some way

	if timestamp != "" {
		dbMsg := portal.bridge.DB.Message.New()
		dbMsg.Channel = portal.Key
		dbMsg.SlackID = timestamp
		dbMsg.MatrixID = evt.ID
		dbMsg.AuthorID = userTeam.Key.SlackID
		dbMsg.SlackThreadID = threadTs
		dbMsg.Insert(nil)
	}
}

func (portal *Portal) convertMatrixMessage(ctx context.Context, sender *User, userTeam *database.UserTeam, evt *event.Event) (options []slack.MsgOption, fileUpload *slack.FileUploadParameters, threadTs string, err error) {
	content, ok := evt.Content.Parsed.(*event.MessageEventContent)
	if !ok {
		return nil, nil, "", errUnexpectedParsedContentType
	}

	var existingTs string
	if content.RelatesTo != nil && content.RelatesTo.Type == event.RelReplace { // fetch the slack original TS for editing purposes
		existing := portal.bridge.DB.Message.GetByMatrixID(portal.Key, content.RelatesTo.EventID)
		if existing != nil && existing.SlackID != "" {
			existingTs = existing.SlackID
			content = content.NewContent
		} else {
			portal.log.Errorfln("Matrix message %s is an edit, but can't find the original Slack message ID", evt.ID)
			return nil, nil, "", errTargetNotFound
		}
	} else if content.RelatesTo != nil && content.RelatesTo.Type == event.RelThread { // fetch the thread root ID via Matrix thread
		rootMessage := portal.bridge.DB.Message.GetByMatrixID(portal.Key, content.RelatesTo.GetThreadParent())
		if rootMessage != nil {
			threadTs = rootMessage.SlackID
		}
	} else if threadTs == "" && content.RelatesTo != nil && content.RelatesTo.InReplyTo != nil { // if the first method failed, try via Matrix reply
		var slackMessageID string
		var slackThreadID string
		parentMessage := portal.bridge.DB.Message.GetByMatrixID(portal.Key, content.RelatesTo.GetReplyTo())
		if parentMessage != nil {
			slackMessageID = parentMessage.SlackID
			slackThreadID = parentMessage.SlackThreadID
		} else {
			parentAttachment := portal.bridge.DB.Attachment.GetByMatrixID(portal.Key, content.RelatesTo.GetReplyTo())
			if parentAttachment != nil {
				slackMessageID = parentAttachment.SlackMessageID
				slackThreadID = parentAttachment.SlackThreadID
			}
		}
		if slackThreadID != "" {
			threadTs = slackThreadID
		} else {
			threadTs = slackMessageID
		}
	}

	switch content.MsgType {
	case event.MsgText, event.MsgEmote, event.MsgNotice:
		if content.Format == event.FormatHTML {
			options = []slack.MsgOption{slack.MsgOptionText(portal.bridge.ParseMatrix(content.FormattedBody), false)}
		} else {
			options = []slack.MsgOption{slack.MsgOptionText(content.Body, false)}
		}
		if threadTs != "" {
			options = append(options, slack.MsgOptionTS(threadTs))
		}
		if existingTs != "" {
			options = append(options, slack.MsgOptionUpdate(existingTs))
		}
		if content.MsgType == event.MsgEmote {
			options = append(options, slack.MsgOptionMeMessage())
		}
		return options, nil, threadTs, nil
	case event.MsgAudio, event.MsgFile, event.MsgImage, event.MsgVideo:
		data, err := portal.downloadMatrixAttachment(content)
		if err != nil {
			portal.log.Errorfln("Failed to download matrix attachment: %v", err)
			return nil, nil, "", errMediaDownloadFailed
		}

		var filename, caption string
		if content.FileName == "" || content.FileName == content.Body {
			filename = content.Body
		} else {
			filename = content.FileName
			caption = content.Body
		}
		fileUpload = &slack.FileUploadParameters{
			Filename:        filename,
			Filetype:        content.Info.MimeType,
			Reader:          bytes.NewReader(data),
			Channels:        []string{portal.Key.ChannelID},
			ThreadTimestamp: threadTs,
		}
		if caption != "" {
			fileUpload.InitialComment = caption
		}
		return nil, fileUpload, threadTs, nil
	default:
		return nil, nil, "", errUnknownMsgType
	}
}

func (portal *Portal) handleMatrixReaction(sender *User, evt *event.Event, ms *metricSender) {
	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	userTeam := sender.GetUserTeam(portal.Key.TeamID)
	if userTeam == nil {
		go ms.sendMessageMetrics(evt, errUserNotLoggedIn, "Ignoring", true)
		return
	}

	reaction := evt.Content.AsReaction()
	if reaction.RelatesTo.Type != event.RelAnnotation {
		portal.log.Errorfln("Ignoring reaction %s due to unknown m.relates_to data", evt.ID)
		ms.sendMessageMetrics(evt, errUnexpectedRelatesTo, "Error sending", true)
		return
	}

	var slackID string

	msg := portal.bridge.DB.Message.GetByMatrixID(portal.Key, reaction.RelatesTo.EventID)

	// Due to the differences in attachments between Slack and Matrix, if a
	// user reacts to a media message on discord our lookup above will fail
	// because the relation of matrix media messages to attachments in handled
	// in the attachments table instead of messages so we need to check that
	// before continuing.
	//
	// This also leads to interesting problems when a Slack message comes in
	// with multiple attachments. A user can react to each one individually on
	// Matrix, which will cause us to send it twice. Slack tends to ignore
	// this, but if the user removes one of them, discord removes it and now
	// they're out of sync. Perhaps we should add a counter to the reactions
	// table to keep them in sync and to avoid sending duplicates to Slack.
	if msg == nil {
		attachment := portal.bridge.DB.Attachment.GetByMatrixID(portal.Key, reaction.RelatesTo.EventID)
		if attachment != nil {
			slackID = attachment.SlackMessageID
		}
	} else {
		slackID = msg.SlackID
	}
	if slackID == "" {
		portal.log.Debugf("Message %s has not yet been sent to slack", reaction.RelatesTo.EventID)
		ms.sendMessageMetrics(evt, errReactionTargetNotFound, "Error sending", true)
		return
	}

	var emojiID string
	if strings.HasPrefix(reaction.RelatesTo.Key, "mxc://") {
		uri, err := id.ParseContentURI(reaction.RelatesTo.Key)
		if err == nil {
			customEmoji := portal.bridge.DB.Emoji.GetByMXC(uri)
			if customEmoji != nil {
				emojiID = customEmoji.SlackID
			}
		}
	} else {
		emojiID = emojiToShortcode(reaction.RelatesTo.Key)
	}

	if emojiID == "" {
		portal.log.Errorfln("Couldn't find shortcode for emoji %s", reaction.RelatesTo.Key)
		ms.sendMessageMetrics(evt, errEmojiShortcodeNotFound, "Error sending", true)
		return
	}

	// TODO: Figure out if this is a custom emoji or not.
	// emojiID := reaction.RelatesTo.Key
	// if strings.HasPrefix(emojiID, "mxc://") {
	// 	uri, _ := id.ParseContentURI(emojiID)
	// 	emoji := portal.bridge.DB.Emoji.GetByMatrixURL(uri)
	// 	if emoji == nil {
	// 		portal.log.Errorfln("failed to find emoji for %s", emojiID)

	// 		return
	// 	}

	// 	emojiID = emoji.APIName()
	// }

	err := userTeam.Client.AddReaction(emojiID, slack.ItemRef{
		Channel:   portal.Key.ChannelID,
		Timestamp: slackID,
	})
	ms.sendMessageMetrics(evt, err, "Error sending", true)
	if err != nil {
		portal.log.Debugfln("Failed to send reaction %s id:%s: %v", portal.Key, slackID, err)
		return
	}

	dbReaction := portal.bridge.DB.Reaction.New()
	dbReaction.Channel = portal.Key
	dbReaction.MatrixEventID = evt.ID
	dbReaction.SlackMessageID = slackID
	dbReaction.AuthorID = userTeam.Key.SlackID
	dbReaction.MatrixName = reaction.RelatesTo.Key
	dbReaction.SlackName = emojiID
	dbReaction.Insert(nil)
	portal.log.Debugfln("Inserted reaction %v %s %s %s %s into database", dbReaction.Channel, dbReaction.MatrixEventID, dbReaction.SlackMessageID, dbReaction.AuthorID, dbReaction.SlackName)
}

func (portal *Portal) handleMatrixRedaction(user *User, evt *event.Event) {
	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	userTeam := user.GetUserTeam(portal.Key.TeamID)
	if userTeam == nil {
		go portal.sendMessageMetrics(user, evt, errUserNotLoggedIn, "Ignoring", nil)
		return
	}
	portal.log.Debugfln("Received redaction %s from %s", evt.ID, evt.Sender)

	// First look if we're redacting a message
	message := portal.bridge.DB.Message.GetByMatrixID(portal.Key, evt.Redacts)
	if message != nil {
		if message.SlackID != "" {
			_, _, err := userTeam.Client.DeleteMessage(portal.Key.ChannelID, message.SlackID)
			if err != nil {
				portal.log.Debugfln("Failed to delete slack message %s: %v", message.SlackID, err)
			} else {
				message.Delete()
			}
			go portal.sendMessageMetrics(user, evt, err, "Error sending", nil)
		} else {
			go portal.sendMessageMetrics(user, evt, errTargetNotFound, "Error sending", nil)
		}
		return
	}

	// Now check if it's a reaction.
	reaction := portal.bridge.DB.Reaction.GetByMatrixID(portal.Key, evt.Redacts)
	if reaction != nil {
		if reaction.SlackName != "" {
			err := userTeam.Client.RemoveReaction(reaction.SlackName, slack.ItemRef{
				Channel:   portal.Key.ChannelID,
				Timestamp: reaction.SlackMessageID,
			})
			if err != nil && err.Error() != "no_reaction" {
				portal.log.Debugfln("Failed to delete reaction %s for message %s: %v", reaction.SlackName, reaction.SlackMessageID, err)
			} else if err != nil && err.Error() == "no_reaction" {
				portal.log.Warnfln("Didn't delete Slack reaction %s for message %s: reaction doesn't exist on Slack", reaction.SlackName, reaction.SlackMessageID)
				reaction.Delete()
				err = nil // not reporting an error for this
			} else {
				reaction.Delete()
			}
			go portal.sendMessageMetrics(user, evt, err, "Error sending", nil)
		} else {
			go portal.sendMessageMetrics(user, evt, errUnknownEmoji, "Error sending", nil)
		}
		return
	}

	portal.log.Warnfln("Failed to redact %s@%s: no event found", portal.Key, evt.Redacts)
	go portal.sendMessageMetrics(user, evt, errReactionTargetNotFound, "Error sending", nil)
}

func typingDiff(prev, new []id.UserID) (started []id.UserID) {
OuterNew:
	for _, userID := range new {
		for _, previousUserID := range prev {
			if userID == previousUserID {
				continue OuterNew
			}
		}
		started = append(started, userID)
	}
	return
}

func (portal *Portal) HandleMatrixTyping(newTyping []id.UserID) {
	portal.currentlyTypingLock.Lock()
	defer portal.currentlyTypingLock.Unlock()
	startedTyping := typingDiff(portal.currentlyTyping, newTyping)
	portal.currentlyTyping = newTyping
	for _, userID := range startedTyping {
		user := portal.bridge.GetUserByMXID(userID)
		if user != nil {
			userTeam := user.GetUserTeam(portal.Key.TeamID)
			if userTeam != nil && userTeam.IsLoggedIn() {
				portal.sendSlackTyping(userTeam)
			}
		}
	}
}

func (portal *Portal) sendSlackTyping(userTeam *database.UserTeam) {
	if userTeam.RTM != nil {
		typing := userTeam.RTM.NewTypingMessage(portal.Key.ChannelID)
		userTeam.RTM.SendMessage(typing)
	} else {
		portal.log.Debugfln("RTM for userteam %s not connected!", userTeam.Key)
	}
}

func (portal *Portal) slackRepeatTypingUpdater() {
	for {
		time.Sleep(3 * time.Second)
		portal.sendSlackRepeatTyping()
	}
}

func (portal *Portal) sendSlackRepeatTyping() {
	portal.currentlyTypingLock.Lock()
	defer portal.currentlyTypingLock.Unlock()

	for _, userID := range portal.currentlyTyping {
		user := portal.bridge.GetUserByMXID(userID)
		if user != nil {
			userTeam := user.GetUserTeam(portal.Key.TeamID)
			if userTeam != nil && userTeam.IsConnected() {
				portal.sendSlackTyping(userTeam)
			}
		}
	}
}

func (portal *Portal) HandleMatrixLeave(brSender bridge.User) {
	portal.log.Debugln("User left private chat portal, cleaning up and deleting...")
	portal.delete()
	portal.bridge.cleanupRoom(portal.MainIntent(), portal.MXID, false, portal.log)

	// TODO: figure out how to close a dm from the API.

	portal.cleanupIfEmpty()
}

func (portal *Portal) leave(userTeam *database.UserTeam) {
	if portal.MXID == "" {
		return
	}

	intent := portal.bridge.GetPuppetByID(portal.Key.TeamID, userTeam.Key.SlackID).IntentFor(portal)
	intent.LeaveRoom(portal.MXID)

	portal.cleanupIfEmpty()
}

func (portal *Portal) delete() {
	portal.Portal.Delete()
	portal.bridge.portalsLock.Lock()
	delete(portal.bridge.portalsByID, portal.Key)

	if portal.MXID != "" {
		delete(portal.bridge.portalsByMXID, portal.MXID)
	}

	portal.bridge.portalsLock.Unlock()
}

func (portal *Portal) cleanupIfEmpty() {
	users, err := portal.getMatrixUsers()
	if err != nil && !errors.Is(err, mautrix.MForbidden) {
		portal.log.Errorfln("Failed to get Matrix user list to determine if portal needs to be cleaned up: %v", err)

		return
	}

	if len(users) == 0 {
		portal.log.Infoln("Room seems to be empty, cleaning up...")
		portal.delete()
		if portal.bridge.SpecVersions.UnstableFeatures["com.beeper.room_yeeting"] {
			intent := portal.MainIntent()
			err := intent.BeeperDeleteRoom(portal.MXID)
			if err == nil || errors.Is(err, mautrix.MNotFound) {
				return
			}
			portal.log.Warnfln("Failed to delete %s using hungryserv yeet endpoint, falling back to normal behavior: %v", portal.MXID, err)
		}
		portal.bridge.cleanupRoom(portal.MainIntent(), portal.MXID, false, portal.log)
	}
}

func (br *SlackBridge) cleanupRoom(intent *appservice.IntentAPI, mxid id.RoomID, puppetsOnly bool, log log.Logger) {
	members, err := intent.JoinedMembers(mxid)
	if err != nil {
		log.Errorln("Failed to get portal members for cleanup:", err)
		return
	}

	for member := range members.Joined {
		if member == intent.UserID {
			continue
		}

		puppet := br.GetPuppetByMXID(member)
		if puppet != nil {
			_, err = puppet.DefaultIntent().LeaveRoom(mxid)
			if err != nil {
				log.Errorln("Error leaving as puppet while cleaning up portal:", err)
			}
		} else if !puppetsOnly {
			_, err = intent.KickUser(mxid, &mautrix.ReqKickUser{UserID: member, Reason: "Deleting portal"})
			if err != nil {
				log.Errorln("Error kicking user while cleaning up portal:", err)
			}
		}
	}

	_, err = intent.LeaveRoom(mxid)
	if err != nil {
		log.Errorln("Error leaving with main intent while cleaning up portal:", err)
	}
}

func (portal *Portal) getMatrixUsers() ([]id.UserID, error) {
	members, err := portal.MainIntent().JoinedMembers(portal.MXID)
	if err != nil {
		return nil, fmt.Errorf("failed to get member list: %w", err)
	}

	var users []id.UserID
	for userID := range members.Joined {
		_, _, isPuppet := portal.bridge.ParsePuppetMXID(userID)
		if !isPuppet && userID != portal.bridge.Bot.UserID {
			users = append(users, userID)
		}
	}

	return users, nil
}

func parseSlackTimestamp(timestamp string) time.Time {
	parts := strings.Split(timestamp, ".")

	seconds, err := strconv.ParseInt(parts[0], 10, 64)
	if err != nil {
		return time.Now().UTC()
	}

	var nanoSeconds int64
	if len(parts) > 1 {
		nsec, err := strconv.ParseInt(parts[1], 10, 64)
		if err != nil {
			nanoSeconds = 0
		} else {
			nanoSeconds = nsec
		}
	}

	return time.Unix(seconds, nanoSeconds)
}

func (portal *Portal) getBridgeInfoStateKey() string {
	return fmt.Sprintf("fi.mau.slack://slackgo/%s/%s", portal.Key.TeamID, portal.Key.ChannelID)
}

func (portal *Portal) getBridgeInfo() (string, CustomBridgeInfoContent) {
	bridgeInfo := CustomBridgeInfoContent{
		BridgeEventContent: event.BridgeEventContent{
			BridgeBot: portal.bridge.Bot.UserID,
			Creator:   portal.MainIntent().UserID,
			Protocol: event.BridgeInfoSection{
				ID:          "slackgo",
				DisplayName: "Slack",
				AvatarURL:   portal.bridge.Config.AppService.Bot.ParsedAvatar.CUString(),
				ExternalURL: "https://slack.com/",
			},
			Channel: event.BridgeInfoSection{
				ID:          portal.Key.ChannelID,
				DisplayName: portal.Name,
			},
		},
	}

	if portal.Type == database.ChannelTypeDM || portal.Type == database.ChannelTypeGroupDM {
		bridgeInfo.RoomType = "dm"
	}

	teamInfo := portal.bridge.DB.TeamInfo.GetBySlackTeam(portal.Key.TeamID)
	if teamInfo != nil {
		bridgeInfo.Network = &event.BridgeInfoSection{
			ID:          portal.Key.TeamID,
			DisplayName: teamInfo.TeamName,
			ExternalURL: teamInfo.TeamUrl,
			AvatarURL:   teamInfo.AvatarUrl.CUString(),
		}
	}
	var bridgeInfoStateKey = portal.getBridgeInfoStateKey()

	return bridgeInfoStateKey, bridgeInfo
}

func (portal *Portal) UpdateBridgeInfo() {
	if len(portal.MXID) == 0 {
		portal.log.Debugln("Not updating bridge info: no Matrix room created")
		return
	}
	portal.log.Debugln("Updating bridge info...")
	stateKey, content := portal.getBridgeInfo()
	_, err := portal.MainIntent().SendStateEvent(portal.MXID, event.StateBridge, stateKey, content)
	if err != nil {
		portal.log.Warnln("Failed to update m.bridge:", err)
	}
	// TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec
	_, err = portal.MainIntent().SendStateEvent(portal.MXID, event.StateHalfShotBridge, stateKey, content)
	if err != nil {
		portal.log.Warnln("Failed to update uk.half-shot.bridge:", err)
	}
}

func (portal *Portal) setChannelType(channel *slack.Channel) bool {
	if channel == nil {
		portal.log.Errorln("can't get type from nil channel metadata")
		return false
	}

	if channel.IsMpIM {
		portal.Type = database.ChannelTypeGroupDM
		return true
	} else if channel.IsIM {
		portal.Type = database.ChannelTypeDM
		return true
	} else if channel.Name != "" {
		portal.Type = database.ChannelTypeChannel
		return true
	}

	portal.log.Errorfln("unknown channel type, metadata %v", channel)
	return false
}

func (portal *Portal) GetPlainName(meta *slack.Channel) string {
	if portal.Type == database.ChannelTypeDM || portal.Type == database.ChannelTypeGroupDM {
		return ""
	} else {
		return meta.Name
	}
}

func (portal *Portal) UpdateNameDirect(name string) bool {
	if name == "#" || portal.Name == name && (portal.NameSet || portal.MXID == "" || !portal.shouldSetDMRoomMetadata()) {
		return false
	}
	portal.log.Debugfln("Updating name %q -> %q", portal.Name, name)
	portal.Name = name
	portal.NameSet = false
	if portal.MXID != "" && portal.Name != "" && portal.shouldSetDMRoomMetadata() {
		_, err := portal.MainIntent().SetRoomName(portal.MXID, portal.Name)
		if err != nil {
			portal.log.Warnln("Failed to update room name:", err)
		} else {
			portal.NameSet = true
		}
	}
	return true
}

func (portal *Portal) UpdateName(meta *slack.Channel, sourceTeam *database.UserTeam) bool {
	plainName := portal.GetPlainName(meta)

	plainNameChanged := portal.PlainName != plainName
	portal.PlainName = plainName

	formattedName := portal.bridge.Config.Bridge.FormatChannelName(config.ChannelNameParams{
		Name:     plainName,
		Type:     portal.Type,
		TeamName: sourceTeam.TeamName,
	})

	return portal.UpdateNameDirect(formattedName) || plainNameChanged
}

func (portal *Portal) updateRoomAvatar() {
	if portal.MXID == "" || !portal.shouldSetDMRoomMetadata() {
		return
	}
	_, err := portal.MainIntent().SetRoomAvatar(portal.MXID, portal.AvatarURL)
	if err != nil {
		portal.log.Warnln("Failed to update room avatar:", err)
	} else {
		portal.AvatarSet = true
	}
}

func (portal *Portal) UpdateAvatarFromPuppet(puppet *Puppet) bool {
	if portal.Avatar == puppet.Avatar && portal.AvatarURL == puppet.AvatarURL && (portal.AvatarSet || portal.MXID == "" || !portal.shouldSetDMRoomMetadata()) {
		return false
	}

	portal.log.Debugfln("Updating avatar from puppet %q -> %q", portal.Avatar, puppet.Avatar)
	portal.Avatar = puppet.Avatar
	portal.AvatarURL = puppet.AvatarURL
	portal.AvatarSet = false
	portal.updateRoomAvatar()

	return true
}

func (portal *Portal) UpdateTopicDirect(topic string) bool {
	if portal.Topic == topic && (portal.TopicSet || portal.MXID == "") {
		return false
	}

	portal.log.Debugfln("Updating topic for room %s", portal.Key.ChannelID)
	portal.Topic = topic
	portal.TopicSet = false
	if portal.MXID != "" {
		_, err := portal.MainIntent().SetRoomTopic(portal.MXID, portal.Topic)
		if err != nil {
			portal.log.Warnln("Failed to update room topic:", err)
		} else {
			portal.TopicSet = true
		}
	}

	return true
}

func (portal *Portal) getTopic(meta *slack.Channel) string {
	switch portal.Type {
	case database.ChannelTypeDM, database.ChannelTypeGroupDM:
		return ""
	case database.ChannelTypeChannel:
		plainTopic := meta.Topic.Value
		plainDescription := meta.Purpose.Value

		var topicParts []string

		if plainTopic != "" {
			topicParts = append(topicParts, fmt.Sprintf("Topic: %s", plainTopic))
		}
		if plainDescription != "" {
			topicParts = append(topicParts, fmt.Sprintf("Description: %s", plainDescription))
		}

		return strings.Join(topicParts, "\n")
	default:
		return ""
	}
}

func (portal *Portal) UpdateTopic(meta *slack.Channel, sourceTeam *database.UserTeam) bool {
	matrixTopic := portal.getTopic(meta)

	changed := portal.Topic != matrixTopic
	return portal.UpdateTopicDirect(matrixTopic) || changed
}

func (portal *Portal) UpdateInfo(source *User, sourceTeam *database.UserTeam, meta *slack.Channel, force bool) *slack.Channel {
	portal.log.Debugfln("Updating info for portal %s", portal.Key)
	changed := false

	if meta == nil {
		portal.log.Debugfln("UpdateInfo called without metadata, fetching from server via %s", sourceTeam.Key.SlackID)
		var err error
		meta, err = sourceTeam.Client.GetConversationInfo(&slack.GetConversationInfoInput{
			ChannelID:         portal.Key.ChannelID,
			IncludeLocale:     true,
			IncludeNumMembers: true,
		})
		if err != nil {
			portal.log.Errorfln("Failed to fetch meta via %s: %v", sourceTeam.Key.SlackID, err)
			return nil
		}
	}

	changed = portal.setChannelType(meta) || changed

	if portal.DMUserID == "" && portal.IsPrivateChat() {
		portal.DMUserID = meta.User
		portal.log.Infoln("Found other user ID:", portal.DMUserID)
		changed = true
	}

	changed = portal.UpdateName(meta, sourceTeam) || changed
	changed = portal.UpdateTopic(meta, sourceTeam) || changed

	if changed || force {
		portal.UpdateBridgeInfo()
		portal.Update(nil)
	}

	return meta
}

type ConvertedSlackFile struct {
	Event       *event.MessageEventContent
	SlackFileID string
}

type ConvertedSlackMessage struct {
	FileAttachments []ConvertedSlackFile
	Event           *event.MessageEventContent
	SlackTimestamp  string
	SlackThreadTs   string
	SlackAuthor     string
	SlackReactions  []slack.ItemReaction
	SlackThread     []slack.Message
}

func (portal *Portal) HandleSlackMessage(user *User, userTeam *database.UserTeam, msg *slack.MessageEvent) {
	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	if msg.Msg.Type != "message" {
		portal.log.Warnln("ignoring unknown message type:", msg.Msg.Type)
		return
	}
	if msg.Msg.IsEphemeral {
		portal.log.Debugfln("Ignoring ephemeral message")
		return
	}

	existing := portal.bridge.DB.Message.GetBySlackID(portal.Key, msg.Msg.Timestamp)
	if existing != nil && msg.Msg.SubType != "message_changed" { // Slack reuses the same message ID on message edits
		portal.log.Debugln("Dropping duplicate message:", msg.Msg.Timestamp)
		return
	}
	if msg.Msg.SubType == "message_changed" && existing == nil {
		portal.log.Debugfln("Not sending edit for nonexistent message %s", msg.Msg.Timestamp)
		return
	}

	if msg.Msg.User == "" {
		portal.log.Debugfln("Starting handling of %s (no sender), subtype %s", msg.Msg.Timestamp, msg.Msg.SubType)
	} else {
		portal.log.Debugfln("Starting handling of %s by %s, subtype %s", msg.Msg.Timestamp, msg.Msg.User, msg.Msg.SubType)
	}

	switch msg.Msg.SubType {
	case "", "me_message", "bot_message", "thread_broadcast": // Regular messages and /me
		portal.HandleSlackNormalMessage(user, userTeam, &msg.Msg, nil)
	case "huddle_thread":
		content := &event.MessageEventContent{
			MsgType: event.MsgNotice,
			Body:    fmt.Sprintf("A huddle started. Go get it in https://app.slack.com/client/%s/%s", portal.Key.TeamID, portal.Key.ChannelID),
		}
		_, err := portal.sendMatrixMessage(portal.MainIntent(), event.EventMessage, content, nil, 0)
		if err != nil {
			portal.log.Warnfln("Failed to send message about the huddle:", err)
		}
	case "message_changed":
		portal.HandleSlackNormalMessage(user, userTeam, msg.SubMessage, existing)
	case "channel_topic", "channel_purpose", "channel_name", "group_topic", "group_purpose", "group_name":
		portal.UpdateInfo(user, userTeam, nil, false)
		portal.log.Debugfln("Received %s update, updating portal name and topic", msg.Msg.SubType)
	case "message_deleted":
		// Slack doesn't tell us who deleted a message, so there is no intent here
		message := portal.bridge.DB.Message.GetBySlackID(portal.Key, msg.Msg.DeletedTimestamp)
		if message == nil {
			portal.log.Warnfln("Failed to redact %s: Matrix event not known", msg.Msg.DeletedTimestamp)
		} else {
			_, err := portal.MainIntent().RedactEvent(portal.MXID, message.MatrixID)
			if err != nil {
				portal.log.Errorfln("Failed to redact %s: %v", message.MatrixID, err)
			} else {
				message.Delete()
			}
		}

		attachments := portal.bridge.DB.Attachment.GetAllBySlackMessageID(portal.Key, msg.Msg.DeletedTimestamp)
		for _, attachment := range attachments {
			_, err := portal.MainIntent().RedactEvent(portal.MXID, attachment.MatrixEventID)
			if err != nil {
				portal.log.Errorfln("Failed to redact %s: %v", attachment.MatrixEventID, err)
			} else {
				attachment.Delete()
			}
		}
	case "message_replied", "group_join", "group_leave", "channel_join", "channel_leave": // Not yet an exhaustive list.
		// These subtypes are simply ignored, because they're handled elsewhere/in other ways (Slack sends multiple info of these events)
		portal.log.Debugfln("Received message subtype %s, which is ignored", msg.Msg.SubType)
	default:
		portal.log.Warnfln("Received unknown message subtype %s", msg.Msg.SubType)
	}
}

func (portal *Portal) addThreadMetadata(content *event.MessageEventContent, threadTs string) (hasThread bool, hasReply bool) {
	// fetch thread metadata and add to message
	if threadTs != "" {
		if content.RelatesTo == nil {
			content.RelatesTo = &event.RelatesTo{}
		}
		latestThreadMessage := portal.bridge.DB.Message.GetLastInThread(portal.Key, threadTs)
		rootThreadMessage := portal.bridge.DB.Message.GetBySlackID(portal.Key, threadTs)

		var latestThreadMessageID id.EventID
		if latestThreadMessage != nil {
			latestThreadMessageID = latestThreadMessage.MatrixID
		} else {
			latestThreadMessageID = ""
		}

		if rootThreadMessage != nil {
			content.RelatesTo.SetThread(rootThreadMessage.MatrixID, latestThreadMessageID)
			return true, true
		} else if latestThreadMessage != nil {
			content.RelatesTo.SetReplyTo(latestThreadMessage.MatrixID)
			return false, true
		}
	}
	return false, false
}

func (portal *Portal) ConvertSlackMessage(userTeam *database.UserTeam, msg *slack.Msg) (converted ConvertedSlackMessage) {
	if msg.User != "" {
		converted.SlackAuthor = msg.User
	} else if msg.BotID != "" {
		converted.SlackAuthor = msg.BotID
	} else {
		portal.log.Errorfln("Couldn't convert text message %s: no user or bot ID in message", msg.Timestamp)
		return
	}
	converted.SlackTimestamp = msg.Timestamp
	var text string
	if msg.Text != "" {
		text = msg.Text
	}
	for _, attachment := range msg.Attachments {
		if text != "" {
			text += "\n"
		}
		if attachment.Text != "" {
			text += attachment.Text
		} else if attachment.Fallback != "" {
			text += attachment.Fallback
		}
	}

	if len(msg.Blocks.BlockSet) != 0 || len(msg.Attachments) != 0 {
		var err error
		converted.Event, err = portal.SlackBlocksToMatrix(msg.Blocks, msg.Attachments, userTeam)
		if err != nil {
			portal.log.Warnfln("Error rendering Slack blocks: %v", err)
			converted.Event = nil
		}
	} else if text != "" {
		converted.Event = portal.renderSlackMarkdown(text)
	}

	for _, file := range msg.Files {
		fileInfo := file
		if file.FileAccess == "check_file_info" {
			connectFile, _, _, err := userTeam.Client.GetFileInfo(file.ID, 0, 0)
			if err != nil || connectFile == nil {
				portal.log.Errorln("Error fetching slack connect file info", err)
				continue
			}
			fileInfo = *connectFile
		}
		if fileInfo.Size > int(portal.bridge.MediaConfig.UploadSize) {
			portal.log.Errorfln("%d is too large to upload to Matrix, not bridging file %s", fileInfo.Size, fileInfo.ID)
			continue
		}
		convertedFile := ConvertedSlackFile{
			SlackFileID: fileInfo.ID,
		}
		content := portal.renderSlackFile(fileInfo)
		portal.addThreadMetadata(&content, msg.ThreadTimestamp)
		var data bytes.Buffer
		var err error
		var url string
		if fileInfo.URLPrivateDownload != "" {
			url = fileInfo.URLPrivateDownload
		} else if fileInfo.URLPrivate != "" {
			url = fileInfo.URLPrivate
		}
		portal.log.Debugfln("File download URLs: urlPrivate=%s, urlPrivateDownload=%s", fileInfo.URLPrivate, fileInfo.URLPrivateDownload)
		if url != "" {
			portal.log.Debugfln("Downloading private file from Slack: %s", url)
			err = userTeam.Client.GetFile(url, &data)
			if bytes.HasPrefix(data.Bytes(), []byte("<!DOCTYPE html>")) {
				portal.log.Warnfln("Received HTML file from Slack (URL %s), trying again in 5 seconds", url)
				time.Sleep(5 * time.Second)
				data.Reset()
				err = userTeam.Client.GetFile(fileInfo.URLPrivate, &data)
			} else {
				portal.log.Debugfln("Download success, expectedSize=%d, downloadedSize=%d", fileInfo.Size, data.Len())
			}
		} else if fileInfo.PermalinkPublic != "" {
			portal.log.Debugfln("Downloading public file from Slack: %s", fileInfo.PermalinkPublic)
			client := http.Client{}
			var resp *http.Response
			resp, err = client.Get(fileInfo.PermalinkPublic)
			if err != nil {
				portal.log.Errorfln("Error downloading Slack file %s: %v", fileInfo.ID, err)
				continue
			}
			_, err = data.ReadFrom(resp.Body)
		} else {
			portal.log.Errorln("No usable URL found in file object, not bridging file")
			continue
		}
		if err != nil {
			portal.log.Errorfln("Error downloading Slack file %s: %v", fileInfo.ID, err)
			continue
		}
		err = portal.uploadMedia(portal.MainIntent(), data.Bytes(), &content)
		if err != nil {
			if errors.Is(err, mautrix.MTooLarge) {
				portal.log.Errorfln("File %s too large for Matrix server: %v", fileInfo.ID, err)
				continue
			} else if httpErr, ok := err.(mautrix.HTTPError); ok && httpErr.IsStatus(413) {
				portal.log.Errorfln("Proxy rejected too large file %s: %v", fileInfo.ID, err)
				continue
			} else {
				portal.log.Errorfln("Error uploading file %s to Matrix: %v", fileInfo.ID, err)
				continue
			}
		}
		convertedFile.Event = &content
		converted.FileAttachments = append(converted.FileAttachments, convertedFile)
	}

	converted.SlackThreadTs = msg.ThreadTimestamp

	return converted
}

func (portal *Portal) HandleSlackNormalMessage(user *User, userTeam *database.UserTeam, msg *slack.Msg, editExisting *database.Message) {
	ts := parseSlackTimestamp(msg.Timestamp)
	e := portal.ConvertSlackMessage(userTeam, msg)

	puppet := portal.bridge.GetPuppetByID(portal.Key.TeamID, e.SlackAuthor)
	if puppet == nil {
		portal.log.Errorfln("Can't find puppet for %s", e.SlackAuthor)
		return
	}
	puppet.UpdateInfo(userTeam, true, nil)
	intent := puppet.IntentFor(portal)

	for _, file := range e.FileAttachments {
		if editExisting == nil {
			portal.addThreadMetadata(file.Event, msg.ThreadTimestamp)
		}

		resp, err := portal.sendMatrixMessage(intent, event.EventMessage, file.Event, nil, ts.UnixMilli())
		if err != nil {
			portal.log.Warnfln("Failed to send media message %s to matrix: %v", ts, err)
			continue
		}
		go portal.sendDeliveryReceipt(resp.EventID)
		attachment := portal.bridge.DB.Attachment.New()
		attachment.Channel = portal.Key
		attachment.SlackFileID = file.SlackFileID
		attachment.SlackMessageID = msg.Timestamp
		attachment.MatrixEventID = resp.EventID
		attachment.SlackThreadID = msg.ThreadTimestamp
		attachment.Insert(nil)
	}

	if e.Event != nil {
		// set m.emote if it's a /me message
		if msg.SubType == "me_message" {
			e.Event.MsgType = event.MsgEmote
		}

		if editExisting != nil {
			e.Event.SetEdit(editExisting.MatrixID)
		} else {
			portal.addThreadMetadata(e.Event, msg.ThreadTimestamp)
		}

		resp, err := portal.sendMatrixMessage(intent, event.EventMessage, e.Event, nil, ts.UnixMilli())
		if err != nil {
			portal.log.Warnfln("Failed to send message %s to matrix: %v", msg.Timestamp, err)
			return
		}

		portal.markMessageHandled(nil, msg.Timestamp, msg.ThreadTimestamp, resp.EventID, e.SlackAuthor)
		go portal.sendDeliveryReceipt(resp.EventID)
		return
	}
}

func (portal *Portal) HandleSlackReaction(user *User, userTeam *database.UserTeam, msg *slack.ReactionAddedEvent) {
	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	if msg.Type != "reaction_added" {
		portal.log.Warnln("ignoring unknown message type:", msg.Type)
		return
	}

	portal.log.Debugfln("Handling Slack reaction: %v %s %s", portal.Key, msg.Item.Timestamp, msg.Reaction)

	if portal.MXID == "" {
		portal.log.Warnfln("No Matrix portal created for room %s %s, not bridging reaction")
	}

	existing := portal.bridge.DB.Reaction.GetBySlackID(portal.Key, msg.User, msg.Item.Timestamp, msg.Reaction)
	if existing != nil {
		portal.log.Warnfln("Dropping duplicate reaction: %s %s %s", portal.Key, msg.Item.Timestamp, msg.Reaction)
		return
	}

	puppet := portal.bridge.GetPuppetByID(portal.Key.TeamID, msg.User)
	if puppet == nil {
		portal.log.Errorfln("Not sending reaction: can't find puppet for Slack user %s", msg.User)
		return
	}
	puppet.UpdateInfo(userTeam, true, nil)
	intent := puppet.IntentFor(portal)

	targetMessage := portal.bridge.DB.Message.GetBySlackID(portal.Key, msg.Item.Timestamp)
	if targetMessage == nil {
		portal.log.Errorfln("Not sending reaction: can't find Matrix message for %s %s %s", portal.Key.TeamID, portal.Key.ChannelID, msg.Item.Timestamp)
		return
	}

	slackReaction := strings.Trim(msg.Reaction, ":")

	key := portal.bridge.GetEmoji(slackReaction, userTeam)

	var content event.ReactionEventContent
	content.RelatesTo = event.RelatesTo{
		Type:    event.RelAnnotation,
		EventID: targetMessage.MatrixID,
		Key:     key,
	}
	extraContent := map[string]any{}
	if strings.HasPrefix(key, "mxc://") {
		extraContent["fi.mau.slack.reaction"] = map[string]any{
			"name": slackReaction,
			"mxc":  key,
		}
		if !portal.bridge.Config.Bridge.CustomEmojiReactions {
			content.RelatesTo.Key = slackReaction
		}
	}

	resp, err := intent.SendMassagedMessageEvent(portal.MXID, event.EventReaction, &event.Content{
		Parsed: &content,
		Raw:    extraContent,
	}, parseSlackTimestamp(msg.EventTimestamp).UnixMilli())
	if err != nil {
		portal.log.Errorfln("Failed to bridge reaction: %v", err)
		return
	}

	dbReaction := portal.bridge.DB.Reaction.New()
	dbReaction.Channel = portal.Key
	dbReaction.SlackMessageID = msg.Item.Timestamp
	dbReaction.MatrixEventID = resp.EventID
	dbReaction.AuthorID = msg.User
	dbReaction.MatrixName = key
	dbReaction.SlackName = msg.Reaction
	dbReaction.Insert(nil)
}

func (portal *Portal) HandleSlackReactionRemoved(user *User, userTeam *database.UserTeam, msg *slack.ReactionRemovedEvent) {
	if portal.MXID == "" {
		return
	}
	portal.slackMessageLock.Lock()
	defer portal.slackMessageLock.Unlock()

	if msg.Type != "reaction_removed" {
		portal.log.Warnln("ignoring unknown message type:", msg.Type)
		return
	}

	dbReaction := portal.bridge.DB.Reaction.GetBySlackID(portal.Key, msg.User, msg.Item.Timestamp, msg.Reaction)
	if dbReaction == nil {
		portal.log.Errorfln("Failed to redact reaction %v %s %s %s: reaction not found in database", portal.Key, msg.User, msg.Item.Timestamp, msg.Reaction)
		return
	}

	puppet := portal.bridge.GetPuppetByID(portal.Key.TeamID, msg.User)
	if puppet == nil {
		portal.log.Errorfln("Not redacting reaction: can't find puppet for Slack user %s %s", portal.Key.TeamID, msg.User)
		return
	}
	puppet.UpdateInfo(userTeam, true, nil)
	intent := puppet.IntentFor(portal)

	_, err := intent.RedactEvent(portal.MXID, dbReaction.MatrixEventID)
	if err != nil {
		portal.log.Errorfln("Failed to redact reaction %v %s %s %s: %v", portal.Key, msg.User, msg.Item.Timestamp, msg.Reaction, err)
		return
	}

	dbReaction.Delete()
}

func (portal *Portal) HandleSlackTyping(user *User, userTeam *database.UserTeam, msg *slack.UserTypingEvent) {
	if portal.MXID == "" {
		return
	}
	puppet := portal.bridge.GetPuppetByID(portal.Key.TeamID, msg.User)
	if puppet == nil {
		portal.log.Errorfln("Not sending typing status: can't find puppet for Slack user %s", msg.User)
		return
	}
	puppet.UpdateInfo(userTeam, true, nil)
	intent := puppet.IntentFor(portal)

	_, err := intent.UserTyping(portal.MXID, true, time.Duration(time.Second*5))
	if err != nil {
		portal.log.Warnfln("Error sending typing status to Matrix: %v", err)
	}
}

func (portal *Portal) HandleSlackChannelMarked(user *User, userTeam *database.UserTeam, msg *slack.ChannelMarkedEvent) {
	if portal.MXID == "" {
		return
	}
	puppet := portal.bridge.GetPuppetByCustomMXID(user.MXID)
	if puppet == nil {
		portal.log.Errorfln("Not marking room as read: can't find puppet for Slack user %s", msg.User)
		return
	}
	puppet.UpdateInfo(userTeam, true, nil)
	intent := puppet.IntentFor(portal)

	message := portal.bridge.DB.Message.GetBySlackID(portal.Key, msg.Timestamp)

	if message == nil {
		portal.log.Debugfln("Couldn't mark portal %s as read: no Matrix room", portal.Key)
		return
	}

	err := intent.MarkRead(portal.MXID, message.MatrixID)
	if err != nil {
		portal.log.Warnfln("Error marking Matrix room %s as read by %s: %v", portal.MXID, intent.UserID, err)
	}
}