discordo-plus/internal/ui/chat/messages_list.go

package chat

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"slices"
	"strings"
	"sync"
	"time"
	"unicode/utf8"

	"github.com/ayn2op/discordo/internal/clipboard"
	"github.com/ayn2op/discordo/internal/config"
	"github.com/ayn2op/discordo/internal/markdown"
	"github.com/ayn2op/discordo/internal/ui"
	"github.com/ayn2op/tview"
	"github.com/ayn2op/tview/help"
	"github.com/ayn2op/tview/keybind"
	"github.com/ayn2op/tview/list"
	"github.com/diamondburned/arikawa/v3/api"
	"github.com/diamondburned/arikawa/v3/discord"
	"github.com/diamondburned/arikawa/v3/gateway"
	"github.com/diamondburned/arikawa/v3/state"
	"github.com/diamondburned/arikawa/v3/utils/json/option"
	"github.com/diamondburned/ningen/v3/discordmd"
	"github.com/gdamore/tcell/v3"
	"github.com/gdamore/tcell/v3/color"
	"github.com/yuin/goldmark/ast"
)

type messagesList struct {
	*list.Model
	cfg      *config.Config
	chatView *Model
	messages []discord.Message
	// rows is the virtual list model rendered by tview (message rows +
	// date-separator rows). It is rebuilt lazily when rowsDirty is true.
	rows      []messagesListRow
	rowsDirty bool

	renderer *markdown.Renderer
	// itemByID caches unselected message TextViews.
	itemByID map[discord.MessageID]*tview.TextView

	attachmentsPicker *attachmentsPicker

	fetchingMembers struct {
		mu    sync.Mutex
		value bool
		count uint
		done  chan struct{}
	}
}

var _ help.KeyMap = (*messagesList)(nil)

type messagesListRowKind uint8

const (
	messagesListRowMessage messagesListRowKind = iota
	messagesListRowSeparator
)

type messagesListRow struct {
	kind         messagesListRowKind
	messageIndex int
	timestamp    discord.Timestamp
}

func newMessagesList(cfg *config.Config, chatView *Model) *messagesList {
	ml := &messagesList{
		Model:    list.NewModel(),
		cfg:      cfg,
		chatView: chatView,
		renderer: markdown.NewRenderer(cfg),
		itemByID: make(map[discord.MessageID]*tview.TextView),
	}
	ml.attachmentsPicker = newAttachmentsPicker(cfg, chatView)

	ml.Box = ui.ConfigureBox(ml.Box, &cfg.Theme)
	ml.SetTitle("Messages")
	ml.SetBuilder(ml.buildItem)
	ml.SetChangedFunc(ml.onRowCursorChanged)
	ml.SetTrackEnd(true)
	ml.SetKeybinds(list.Keybinds{
		ScrollUp:     cfg.Keybinds.MessagesList.ScrollUp.Keybind,
		ScrollDown:   cfg.Keybinds.MessagesList.ScrollDown.Keybind,
		ScrollTop:    cfg.Keybinds.MessagesList.ScrollTop.Keybind,
		ScrollBottom: cfg.Keybinds.MessagesList.ScrollBottom.Keybind,
	})
	ml.SetScrollBarVisibility(cfg.Theme.ScrollBar.Visibility.ScrollBarVisibility)
	ml.SetScrollBar(tview.NewScrollBar().
		SetTrackStyle(cfg.Theme.ScrollBar.TrackStyle.Style).
		SetThumbStyle(cfg.Theme.ScrollBar.ThumbStyle.Style).
		SetGlyphSet(cfg.Theme.ScrollBar.GlyphSet.GlyphSet))
	return ml
}

func (ml *messagesList) reset() {
	ml.messages = nil
	ml.rows = nil
	ml.rowsDirty = false
	clear(ml.itemByID)
	ml.
		Clear().
		SetBuilder(ml.buildItem).
		SetTitle("")
}

func (ml *messagesList) setTitle(channel discord.Channel) {
	title := ui.ChannelToString(channel, ml.cfg.Icons, ml.chatView.state)
	if topic := channel.Topic; topic != "" {
		title += " - " + topic
	}

	ml.SetTitle(title)
}

func (ml *messagesList) setMessages(messages []discord.Message) {
	ml.messages = slices.Clone(messages)
	slices.Reverse(ml.messages)
	ml.invalidateRows()
	// New channel payload / refetch: replace the cache wholesale to keep it in
	// lockstep with the current message slice.
	clear(ml.itemByID)
}

func (ml *messagesList) addMessage(message discord.Message) {
	ml.messages = append(ml.messages, message)
	ml.invalidateRows()
	// Defensive invalidation for ID reuse/edits delivered out-of-order.
	delete(ml.itemByID, message.ID)
}

func (ml *messagesList) setMessage(index int, message discord.Message) {
	if index < 0 || index >= len(ml.messages) {
		return
	}

	ml.messages[index] = message
	delete(ml.itemByID, message.ID)
	ml.invalidateRows()
}

func (ml *messagesList) deleteMessage(index int) {
	if index < 0 || index >= len(ml.messages) {
		return
	}

	delete(ml.itemByID, ml.messages[index].ID)
	ml.messages = append(ml.messages[:index], ml.messages[index+1:]...)
	ml.invalidateRows()
}

func (ml *messagesList) clearSelection() {
	ml.SetCursor(-1)
}

func (ml *messagesList) buildItem(index int, cursor int) list.Item {
	ml.ensureRows()

	if index < 0 || index >= len(ml.rows) {
		return nil
	}

	row := ml.rows[index]
	if row.kind == messagesListRowSeparator {
		return ml.buildSeparatorItem(row.timestamp)
	}

	message := ml.messages[row.messageIndex]
	if index == cursor {
		return tview.NewTextView().
			SetWrap(true).
			SetWordWrap(true).
			SetLines(ml.renderMessage(message, ml.cfg.Theme.MessagesList.SelectedMessageStyle.Style))
	}

	item, ok := ml.itemByID[message.ID]
	if !ok {
		item = tview.NewTextView().
			SetWrap(true).
			SetWordWrap(true).
			SetLines(ml.renderMessage(message, ml.cfg.Theme.MessagesList.MessageStyle.Style))
		ml.itemByID[message.ID] = item
		// Evict stale cache entries when the map grows too large.
		if len(ml.itemByID) > 500 {
			ml.evictStaleCache()
		}
	}
	return item
}

func (ml *messagesList) evictStaleCache() {
	active := make(map[discord.MessageID]struct{}, len(ml.messages))
	for _, msg := range ml.messages {
		active[msg.ID] = struct{}{}
	}
	for id := range ml.itemByID {
		if _, ok := active[id]; !ok {
			delete(ml.itemByID, id)
		}
	}
}

func (ml *messagesList) renderMessage(message discord.Message, baseStyle tcell.Style) []tview.Line {
	builder := tview.NewLineBuilder()
	ml.writeMessage(builder, message, baseStyle)
	return builder.Finish()
}

func (ml *messagesList) buildSeparatorItem(ts discord.Timestamp) *tview.TextView {
	builder := tview.NewLineBuilder()
	ml.drawDateSeparator(builder, ts, ml.cfg.Theme.MessagesList.MessageStyle.Style)
	return tview.NewTextView().
		SetScrollable(false).
		SetWrap(false).
		SetWordWrap(false).
		SetLines(builder.Finish())
}

func (ml *messagesList) drawDateSeparator(builder *tview.LineBuilder, ts discord.Timestamp, baseStyle tcell.Style) {
	date := ts.Time().In(time.Local).Format(ml.cfg.DateSeparator.Format)
	label := " " + date + " "
	fillChar := ml.cfg.DateSeparator.Character
	dimStyle := baseStyle.Dim(true)
	_, _, width, _ := ml.InnerRect()
	if width <= 0 {
		builder.Write(strings.Repeat(fillChar, 8)+label+strings.Repeat(fillChar, 8), dimStyle)
		return
	}

	labelWidth := utf8.RuneCountInString(label)
	if width <= labelWidth {
		builder.Write(date, dimStyle)
		return
	}

	fillWidth := width - labelWidth
	left := fillWidth / 2
	right := fillWidth - left
	builder.Write(strings.Repeat(fillChar, left)+label+strings.Repeat(fillChar, right), dimStyle)
}

func (ml *messagesList) rebuildRows() {
	rows := make([]messagesListRow, 0, len(ml.messages)*2)

	for i := range ml.messages {
		// Always show a date separator before the first message, and between messages on different days.
		if ml.cfg.DateSeparator.Enabled && (i == 0 || !sameLocalDate(ml.messages[i-1].Timestamp, ml.messages[i].Timestamp)) {
			rows = append(rows, messagesListRow{
				kind:      messagesListRowSeparator,
				timestamp: ml.messages[i].Timestamp,
			})
		}

		rows = append(rows, messagesListRow{
			kind:         messagesListRowMessage,
			messageIndex: i,
		})
	}

	ml.rows = rows
	ml.rowsDirty = false
}

func (ml *messagesList) invalidateRows() {
	ml.rowsDirty = true
}

// ensureRows lazily rebuilds list rows. This avoids repeated O(n) row rebuild
// work when multiple message mutations happen close together.
func (ml *messagesList) ensureRows() {
	if !ml.rowsDirty {
		return
	}

	ml.rebuildRows()
}

func sameLocalDate(a discord.Timestamp, b discord.Timestamp) bool {
	ta := a.Time().In(time.Local)
	tb := b.Time().In(time.Local)
	return ta.Year() == tb.Year() && ta.YearDay() == tb.YearDay()
}

// Cursor returns the selected message index, skipping separator rows.
func (ml *messagesList) Cursor() int {
	ml.ensureRows()
	rowIndex := ml.Model.Cursor()
	if rowIndex < 0 || rowIndex >= len(ml.rows) {
		return -1
	}

	row := ml.rows[rowIndex]
	if row.kind != messagesListRowMessage {
		return -1
	}
	return row.messageIndex
}

// SetCursor selects a message index and maps it to the corresponding row.
func (ml *messagesList) SetCursor(index int) {
	ml.Model.SetCursor(ml.messageToRowIndex(index))
}

func (ml *messagesList) messageToRowIndex(messageIndex int) int {
	ml.ensureRows()
	if messageIndex < 0 || messageIndex >= len(ml.messages) {
		return -1
	}

	for i, row := range ml.rows {
		if row.kind == messagesListRowMessage && row.messageIndex == messageIndex {
			return i
		}
	}

	return -1
}

func (ml *messagesList) onRowCursorChanged(rowIndex int) {
	ml.ensureRows()
	if rowIndex < 0 || rowIndex >= len(ml.rows) || ml.rows[rowIndex].kind == messagesListRowMessage {
		return
	}

	target := ml.nearestMessageRowIndex(rowIndex)
	ml.Model.SetCursor(target)
}

// nearestMessageRowIndex expects rowIndex to be within bounds.
func (ml *messagesList) nearestMessageRowIndex(rowIndex int) int {
	for i := rowIndex - 1; i >= 0; i-- {
		if ml.rows[i].kind == messagesListRowMessage {
			return i
		}
	}
	for i := rowIndex + 1; i < len(ml.rows); i++ {
		if ml.rows[i].kind == messagesListRowMessage {
			return i
		}
	}
	return -1
}

func (ml *messagesList) writeMessage(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	if ml.cfg.HideBlockedUsers {
		isBlocked := ml.chatView.state.UserIsBlocked(message.Author.ID)
		if isBlocked {
			builder.Write("Blocked message", baseStyle.Foreground(color.Red).Bold(true))
			return
		}
	}

	switch message.Type {
	case discord.DefaultMessage:
		if message.Reference != nil && message.Reference.Type == discord.MessageReferenceTypeForward {
			ml.drawForwardedMessage(builder, message, baseStyle)
		} else {
			ml.drawDefaultMessage(builder, message, baseStyle)
		}
	case discord.GuildMemberJoinMessage:
		ml.drawTimestamps(builder, message.Timestamp, baseStyle)
		ml.drawAuthor(builder, message, baseStyle)
		builder.Write("joined the server.", baseStyle)
	case discord.InlinedReplyMessage:
		ml.drawReplyMessage(builder, message, baseStyle)
	case discord.ChannelPinnedMessage:
		ml.drawPinnedMessage(builder, message, baseStyle)
	default:
		ml.drawTimestamps(builder, message.Timestamp, baseStyle)
		ml.drawAuthor(builder, message, baseStyle)
	}
}

func (ml *messagesList) formatTimestamp(ts discord.Timestamp) string {
	return ts.Time().In(time.Local).Format(ml.cfg.Timestamps.Format)
}

func (ml *messagesList) drawTimestamps(builder *tview.LineBuilder, ts discord.Timestamp, baseStyle tcell.Style) {
	dimStyle := baseStyle.Dim(true)
	builder.Write(ml.formatTimestamp(ts)+" ", dimStyle)
}

func (ml *messagesList) drawAuthor(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	name := message.Author.DisplayOrUsername()
	foreground := tcell.ColorDefault

	if member := ml.memberForMessage(message); member != nil {
		if member.Nick != "" {
			name = member.Nick
		}

		color, ok := state.MemberColor(member, func(id discord.RoleID) *discord.Role {
			r, _ := ml.chatView.state.Cabinet.Role(message.GuildID, id)
			return r
		})
		if ok {
			foreground = tcell.NewHexColor(int32(color))
		}
	}

	style := baseStyle.Foreground(foreground).Bold(true)
	builder.Write(name+" ", style)
}

func (ml *messagesList) memberForMessage(message discord.Message) *discord.Member {
	// Webhooks do not have nicknames or roles.
	if !message.GuildID.IsValid() || message.WebhookID.IsValid() {
		return nil
	}

	member, err := ml.chatView.state.Cabinet.Member(message.GuildID, message.Author.ID)
	if err != nil {
		slog.Error("failed to get member from state", "guild_id", message.GuildID, "member_id", message.Author.ID, "err", err)
		return nil
	}
	return member
}

func (ml *messagesList) drawContent(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	lines, root := ml.renderContentLines(message, baseStyle)
	if ml.chatView.cfg.Markdown.Enabled && builder.HasCurrentLine() {
		startsWithCodeBlock := false
		if root != nil {
			if first := root.FirstChild(); first != nil {
				_, startsWithCodeBlock = first.(*ast.FencedCodeBlock)
			}
		}

		if startsWithCodeBlock {
			// Keep code blocks visually separate from "timestamp + author".
			builder.NewLine()
			for len(lines) > 0 && len(lines[0]) == 0 {
				lines = lines[1:]
			}
		} else {
			for len(lines) > 1 && len(lines[0]) == 0 {
				lines = lines[1:]
			}
		}
	}
	builder.AppendLines(lines)
}

func (ml *messagesList) renderContentLines(message discord.Message, baseStyle tcell.Style) ([]tview.Line, ast.Node) {
	return ml.renderContentLinesWithMarkdown(message, baseStyle, false)
}

func (ml *messagesList) renderContentLinesWithMarkdown(message discord.Message, baseStyle tcell.Style, forceMarkdown bool) ([]tview.Line, ast.Node) {
	// Keep one rendering path for both normal messages and embed fragments so we preserve mention/link parsing behavior consistently across both.
	if forceMarkdown || ml.chatView.cfg.Markdown.Enabled {
		c := []byte(message.Content)
		root := discordmd.ParseWithMessage(c, *ml.chatView.state.Cabinet, &message, false)
		return ml.renderer.RenderLines(c, root, baseStyle), root
	}

	b := tview.NewLineBuilder()
	b.Write(message.Content, baseStyle)
	return b.Finish(), nil
}

func (ml *messagesList) drawSnapshotContent(builder *tview.LineBuilder, parent discord.Message, snapshot discord.MessageSnapshotMessage, baseStyle tcell.Style) {
	// Convert discord.MessageSnapshotMessage to discord.Message with common fields.
	message := discord.Message{
		Type:            snapshot.Type,
		Content:         snapshot.Content,
		Embeds:          snapshot.Embeds,
		Attachments:     snapshot.Attachments,
		Timestamp:       snapshot.Timestamp,
		EditedTimestamp: snapshot.EditedTimestamp,
		Flags:           snapshot.Flags,
		Mentions:        snapshot.Mentions,
		MentionRoleIDs:  snapshot.MentionRoleIDs,
		Stickers:        snapshot.Stickers,
		Components:      snapshot.Components,
		ChannelID:       parent.ChannelID,
		GuildID:         parent.GuildID,
	}
	ml.drawContent(builder, message, baseStyle)
}

func (ml *messagesList) drawDefaultMessage(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	if ml.cfg.Timestamps.Enabled {
		ml.drawTimestamps(builder, message.Timestamp, baseStyle)
	}

	ml.drawAuthor(builder, message, baseStyle)
	ml.drawContent(builder, message, baseStyle)

	if message.EditedTimestamp.IsValid() {
		dimStyle := baseStyle.Dim(true)
		builder.Write(" (edited)", dimStyle)
	}

	ml.drawEmbeds(builder, message, baseStyle)

	attachmentStyle := ui.MergeStyle(baseStyle, ml.cfg.Theme.MessagesList.AttachmentStyle.Style)
	for _, a := range message.Attachments {
		builder.NewLine()
		builder.Write(a.Filename, attachmentStyle.Url(a.URL))
	}

	// Thread indicator
	if message.Thread != nil {
		thread := *message.Thread
		builder.NewLine()
		dimStyle := baseStyle.Dim(true)
		threadLabel := "Thread: " + thread.Name
		builder.Write(threadLabel, dimStyle)
	}

	ml.drawReactions(builder, message, baseStyle)
}

func (ml *messagesList) drawReactions(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	if len(message.Reactions) == 0 {
		return
	}

	builder.NewLine()
	dimStyle := baseStyle.Dim(true)
	boldStyle := baseStyle.Bold(true)
	for i, r := range message.Reactions {
		if i > 0 {
			builder.Write("  ", dimStyle)
		}
		name := r.Emoji.Name
		if !r.Emoji.ID.IsValid() {
			// Unicode emoji — use name directly
		} else if name != "" {
			name = ":" + name + ":"
		}
		style := dimStyle
		if r.Me {
			style = boldStyle
		}
		builder.Write(fmt.Sprintf("%s %d", name, r.Count), style)
	}
}

func (ml *messagesList) drawEmbeds(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	if len(message.Embeds) == 0 {
		return
	}

	contentListURLs := extractURLs(message.Content)
	contentURLs := make(map[string]struct{}, len(contentListURLs))
	for _, u := range contentListURLs {
		contentURLs[u] = struct{}{}
	}

	lineStyles := embedLineStyles(baseStyle, ml.cfg.Theme.MessagesList.Embeds)
	defaultBarStyle := baseStyle.Dim(true)
	prefixText := "  ▎ "
	prefixWidth := tview.TaggedStringWidth(prefixText)
	_, _, innerWidth, _ := ml.InnerRect()
	// Wrap against the current list viewport. This keeps embed wrapping stable even when sidebars/panes are resized.
	wrapWidth := max(innerWidth-prefixWidth, 1)

	for _, embed := range message.Embeds {
		lines := embedLines(embed, contentURLs)
		if len(lines) == 0 {
			continue
		}

		embedContentLines := make([]tview.Line, 0, len(lines)*2)
		barStyle := defaultBarStyle
		if embed.Color != discord.NullColor && embed.Color != 0 {
			barStyle = barStyle.Foreground(tcell.NewHexColor(int32(embed.Color.Uint32())))
		}
		prefix := tview.NewSegment(prefixText, barStyle)
		builder.NewLine()
		for _, line := range lines {
			if strings.TrimSpace(line.Text) == "" {
				continue
			}
			msg := message
			msg.Content = line.Text
			lineStyle := lineStyles[line.Kind]
			// Embed descriptions are always markdown-rendered to match Discord's rich embed semantics, even when message markdown is globally disabled.
			rendered, _ := ml.renderContentLinesWithMarkdown(msg, lineStyle, line.Kind == embedLineDescription)
			for _, renderedLine := range rendered {
				if line.URL != "" {
					renderedLine = lineWithURL(renderedLine, line.URL)
				}
				// Prefix must be applied after wrapping so every visual line keeps the embed bar marker ("▎"), not only the first logical line.
				for _, wrapped := range wrapStyledLine(renderedLine, wrapWidth) {
					prefixed := make(tview.Line, 0, len(wrapped)+1)
					prefixed = append(prefixed, prefix)
					prefixed = append(prefixed, wrapped...)
					embedContentLines = append(embedContentLines, prefixed)
				}
			}
		}

		if len(embedContentLines) > 0 {
			builder.AppendLines(embedContentLines)
		}
	}
}

func (ml *messagesList) drawForwardedMessage(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	dimStyle := baseStyle.Dim(true)
	ml.drawTimestamps(builder, message.Timestamp, baseStyle)
	ml.drawAuthor(builder, message, baseStyle)
	builder.Write(ml.cfg.Theme.MessagesList.ForwardedIndicator+" ", dimStyle)
	ml.drawSnapshotContent(builder, message, message.MessageSnapshots[0].Message, baseStyle)
	builder.Write(" ("+ml.formatTimestamp(message.MessageSnapshots[0].Message.Timestamp)+") ", dimStyle)
}

func (ml *messagesList) drawReplyMessage(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	replyStyle := baseStyle.Dim(true).Italic(true)
	// indicator
	builder.Write(ml.cfg.Theme.MessagesList.ReplyIndicator+" ", replyStyle)

	if m := message.ReferencedMessage; m != nil {
		m.GuildID = message.GuildID
		ml.drawAuthor(builder, *m, replyStyle)
		ml.drawContent(builder, *m, replyStyle)
	} else {
		builder.Write("Original message was deleted", replyStyle)
	}

	builder.NewLine()
	// main
	ml.drawDefaultMessage(builder, message, baseStyle)
}

func (ml *messagesList) drawPinnedMessage(builder *tview.LineBuilder, message discord.Message, baseStyle tcell.Style) {
	builder.Write(message.Author.DisplayOrUsername(), baseStyle)
	builder.Write(" pinned a message.", baseStyle)
}

func (ml *messagesList) selectedMessage() (*discord.Message, error) {
	if len(ml.messages) == 0 {
		return nil, errors.New("no messages available")
	}

	cursor := ml.Cursor()
	if cursor == -1 || cursor >= len(ml.messages) {
		return nil, errors.New("no message is currently selected")
	}

	return &ml.messages[cursor], nil
}

func (ml *messagesList) HandleEvent(event tview.Event) tview.Command {
	switch event := event.(type) {
	case *tview.KeyEvent:
		switch {
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.Cancel.Keybind):
			ml.clearSelection()
			return tview.SetFocus(ml.chatView.guildsTree)
		case event.Key() == tcell.KeyLeft:
			if cmd := ml.chatView.focusGuildsTree(); cmd != nil {
				return cmd
			}
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.SelectUp.Keybind):
			return ml.selectUp()
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.SelectDown.Keybind):
			ml.selectDown()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.SelectTop.Keybind):
			ml.selectTop()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.SelectBottom.Keybind):
			ml.selectBottom()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.SelectReply.Keybind):
			ml.selectReply()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.YankID.Keybind):
			return ml.yankMessageID()
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.YankContent.Keybind):
			return ml.yankContent()
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.YankURL.Keybind):
			return ml.yankURL()
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.Open.Keybind):
			ml.open()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.SaveImage.Keybind):
			ml.saveImage()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.Reply.Keybind):
			ml.reply(false)
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.ReplyMention.Keybind):
			ml.reply(true)
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.Edit.Keybind):
			ml.editSelectedMessage()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.Delete.Keybind):
			return ml.deleteSelectedMessage()
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.DeleteConfirm.Keybind):
			ml.confirmDelete()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.OpenThread.Keybind):
			ml.openThread()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.Search.Keybind):
			ml.chatView.openSearch()
			return nil
		case keybind.Matches(event, ml.cfg.Keybinds.MessagesList.UserInfo.Keybind):
			ml.showUserInfo()
			return nil
		}
		return ml.Model.HandleEvent(event)

	case *olderMessagesLoadedEvent:
		selectedChannel := ml.chatView.SelectedChannel()
		if selectedChannel == nil || selectedChannel.ID != event.ChannelID {
			return nil
		}

		// Defensive invalidation if Discord returns overlapping windows.
		for _, message := range event.Older {
			delete(ml.itemByID, message.ID)
		}
		ml.messages = slices.Concat(event.Older, ml.messages)
		ml.invalidateRows()
		ml.SetCursor(len(event.Older) - 1)
		return nil
	}
	return ml.Model.HandleEvent(event)
}

func (ml *messagesList) selectUp() tview.Command {
	messages := ml.messages
	if len(messages) == 0 {
		return nil
	}

	cursor := ml.Cursor()
	switch {
	case cursor == -1:
		cursor = len(messages) - 1
	case cursor > 0:
		cursor--
	case cursor == 0:
		return ml.fetchOlderMessages()
	}

	ml.SetCursor(cursor)
	return nil
}

func (ml *messagesList) selectDown() {
	messages := ml.messages
	if len(messages) == 0 {
		return
	}

	cursor := ml.Cursor()
	switch {
	case cursor == -1:
		cursor = len(messages) - 1
	case cursor < len(messages)-1:
		cursor++
	}

	ml.SetCursor(cursor)
}

func (ml *messagesList) selectTop() {
	if len(ml.messages) == 0 {
		return
	}
	ml.SetCursor(0)
}

func (ml *messagesList) selectBottom() {
	if len(ml.messages) == 0 {
		return
	}
	ml.SetCursor(len(ml.messages) - 1)
}

func (ml *messagesList) selectReply() {
	messages := ml.messages
	if len(messages) == 0 {
		return
	}

	cursor := ml.Cursor()
	if cursor == -1 || cursor >= len(messages) {
		return
	}

	if ref := messages[cursor].ReferencedMessage; ref != nil {
		refIdx := slices.IndexFunc(messages, func(m discord.Message) bool {
			return m.ID == ref.ID
		})
		if refIdx != -1 {
			ml.SetCursor(refIdx)
		}
	}
}

func (ml *messagesList) fetchOlderMessages() tview.Command {
	selectedChannel := ml.chatView.SelectedChannel()
	if selectedChannel == nil {
		return nil
	}

	channelID := selectedChannel.ID
	before := ml.messages[0].ID
	limit := uint(ml.cfg.MessagesLimit)
	return func() tview.Event {
		messages, err := ml.chatView.state.MessagesBefore(channelID, before, limit)
		if err != nil {
			slog.Error("failed to fetch older messages", "err", err)
			return nil
		}
		if len(messages) == 0 {
			return nil
		}

		if guildID := selectedChannel.GuildID; guildID.IsValid() {
			ml.requestGuildMembers(guildID, messages)
		}

		older := slices.Clone(messages)
		slices.Reverse(older)
		return newOlderMessagesLoadedEvent(channelID, older)
	}
}

func (ml *messagesList) yankMessageID() tview.Command {
	msg, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return nil
	}

	return func() tview.Event {
		if err := clipboard.Write(clipboard.FmtText, []byte(msg.ID.String())); err != nil {
			slog.Error("failed to copy message id", "err", err)
		}
		return nil
	}
}

func (ml *messagesList) yankContent() tview.Command {
	msg, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return nil
	}

	return func() tview.Event {
		if err := clipboard.Write(clipboard.FmtText, []byte(msg.Content)); err != nil {
			slog.Error("failed to copy message content", "err", err)
		}
		return nil
	}
}

func (ml *messagesList) yankURL() tview.Command {
	msg, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return nil
	}

	return func() tview.Event {
		if err := clipboard.Write(clipboard.FmtText, []byte(msg.URL())); err != nil {
			slog.Error("failed to copy message url", "err", err)
		}
		return nil
	}
}

func (ml *messagesList) open() {
	msg, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return
	}

	urls := messageURLs(*msg)

	if len(urls) == 0 && len(msg.Attachments) == 0 {
		return
	}

	if len(urls)+len(msg.Attachments) == 1 {
		if len(urls) == 1 {
			go ml.openURL(urls[0])
		} else {
			attachment := msg.Attachments[0]
			if strings.HasPrefix(attachment.ContentType, "image/") {
				go ml.openAttachment(msg.Attachments[0])
			} else {
				go ml.openURL(attachment.URL)
			}
		}
	} else {
		ml.showAttachmentsList(urls, msg.Attachments)
	}
}

func (ml *messagesList) openThread() {
	msg, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return
	}

	if msg.Thread == nil {
		return
	}

	thread := *msg.Thread
	node := ml.chatView.guildsTree.findNodeByChannelID(thread.ID)
	if node == nil {
		return
	}

	ml.chatView.guildsTree.expandPathToNode(node)
	ml.chatView.guildsTree.SetCurrentNode(node)
	ml.chatView.guildsTree.onSelected(node)
}

func (ml *messagesList) reply(mention bool) {
	message, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return
	}

	name := message.Author.DisplayOrUsername()
	if member := ml.memberForMessage(*message); member != nil && member.Nick != "" {
		name = member.Nick
	}

	data := ml.chatView.messageInput.sendMessageData
	data.Reference = &discord.MessageReference{MessageID: message.ID}
	data.AllowedMentions = &api.AllowedMentions{RepliedUser: option.False}

	title := "Replying to "
	if mention {
		data.AllowedMentions.RepliedUser = option.True
		title = "[@] " + title
	}

	ml.chatView.messageInput.sendMessageData = data
	ml.chatView.messageInput.SetTitle(title + name)
	ml.chatView.app.SetFocus(ml.chatView.messageInput)
}

func (ml *messagesList) editSelectedMessage() {
	message, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return
	}

	me, err := ml.chatView.state.Cabinet.Me()
	if err != nil {
		slog.Error("failed to get current user", "err", err)
		return
	}
	if message.Author.ID != me.ID {
		slog.Error("failed to edit message; not the author", "channel_id", message.ChannelID, "message_id", message.ID)
		return
	}

	ml.chatView.messageInput.SetTitle("Editing")
	ml.chatView.messageInput.edit = true
	ml.chatView.messageInput.SetText(message.Content, true)
	ml.chatView.app.SetFocus(ml.chatView.messageInput)
}

func (ml *messagesList) confirmDelete() {
	onChoice := func(choice string) {
		if choice == "Yes" {
			if command := ml.deleteSelectedMessage(); command != nil {
				command()
			}
		}
	}

	ml.chatView.showConfirmModal(
		"Are you sure you want to delete this message?",
		[]string{"Yes", "No"},
		onChoice,
	)
}

func (ml *messagesList) deleteSelectedMessage() tview.Command {
	selectedMessage, err := ml.selectedMessage()
	if err != nil {
		slog.Error("failed to get selected message", "err", err)
		return nil
	}

	return func() tview.Event {
		if selectedMessage.GuildID.IsValid() {
			me, err := ml.chatView.state.Cabinet.Me()
			if err != nil {
				slog.Error("failed to get current user", "err", err)
				return nil
			}
			if selectedMessage.Author.ID != me.ID && !ml.chatView.state.HasPermissions(selectedMessage.ChannelID, discord.PermissionManageMessages) {
				slog.Error("failed to delete message; missing relevant permissions", "channel_id", selectedMessage.ChannelID, "message_id", selectedMessage.ID)
				return nil
			}
		}

		if err := ml.chatView.state.DeleteMessage(selectedMessage.ChannelID, selectedMessage.ID, ""); err != nil {
			slog.Error("failed to delete message", "channel_id", selectedMessage.ChannelID, "message_id", selectedMessage.ID, "err", err)
			return nil
		}

		if err := ml.chatView.state.MessageRemove(selectedMessage.ChannelID, selectedMessage.ID); err != nil {
			slog.Error("failed to delete message", "channel_id", selectedMessage.ChannelID, "message_id", selectedMessage.ID, "err", err)
			return nil
		}
		return nil
	}
}

func (ml *messagesList) requestGuildMembers(guildID discord.GuildID, messages []discord.Message) {
	usersToFetch := make([]discord.UserID, 0, len(messages))
	seen := make(map[discord.UserID]struct{}, len(messages))

	for _, message := range messages {
		// Do not fetch member for a webhook message.
		if message.WebhookID.IsValid() {
			continue
		}

		if member, _ := ml.chatView.state.Cabinet.Member(guildID, message.Author.ID); member == nil {
			userID := message.Author.ID
			if _, ok := seen[userID]; !ok {
				seen[userID] = struct{}{}
				usersToFetch = append(usersToFetch, userID)
			}
		}
	}

	if len(usersToFetch) > 0 {
		err := ml.chatView.state.SendGateway(context.Background(), &gateway.RequestGuildMembersCommand{
			GuildIDs: []discord.GuildID{guildID},
			UserIDs:  usersToFetch,
		})
		if err != nil {
			slog.Error("failed to request guild members", "guild_id", guildID, "err", err)
			return
		}

		ml.setFetchingChunk(true, 0)
		ml.waitForChunkEvent()
	}
}

func (ml *messagesList) setFetchingChunk(value bool, count uint) {
	ml.fetchingMembers.mu.Lock()
	defer ml.fetchingMembers.mu.Unlock()

	if ml.fetchingMembers.value == value {
		return
	}

	ml.fetchingMembers.value = value

	if value {
		ml.fetchingMembers.done = make(chan struct{})
	} else {
		ml.fetchingMembers.count = count
		close(ml.fetchingMembers.done)
	}
}

func (ml *messagesList) waitForChunkEvent() uint {
	ml.fetchingMembers.mu.Lock()
	if !ml.fetchingMembers.value {
		ml.fetchingMembers.mu.Unlock()
		return 0
	}
	ml.fetchingMembers.mu.Unlock()

	<-ml.fetchingMembers.done
	return ml.fetchingMembers.count
}

func (ml *messagesList) ShortHelp() []keybind.Keybind {
	cfg := ml.cfg.Keybinds.MessagesList
	help := []keybind.Keybind{
		cfg.SelectUp.Keybind,
		cfg.SelectDown.Keybind,
		cfg.Cancel.Keybind,
		cfg.Search.Keybind,
	}

	if msg, err := ml.selectedMessage(); err == nil {
		if me, err := ml.chatView.state.Cabinet.Me(); err == nil {
			if msg.Author.ID != me.ID {
				help = append(help, cfg.Reply.Keybind)
			}
		}
		if len(messageURLs(*msg)) != 0 || len(msg.Attachments) != 0 {
			help = append(help, cfg.Open.Keybind)
		}
		if msg.Thread != nil {
			help = append(help, cfg.OpenThread.Keybind)
		}
	}

	return help
}

func (ml *messagesList) FullHelp() [][]keybind.Keybind {
	cfg := ml.cfg.Keybinds.MessagesList

	canSelectReply := false
	canReply := false
	canEdit := false
	canDelete := false
	canOpen := false
	canOpenThread := false
	if msg, err := ml.selectedMessage(); err == nil {
		canSelectReply = msg.ReferencedMessage != nil
		canOpen = len(messageURLs(*msg)) != 0 || len(msg.Attachments) != 0
		canOpenThread = msg.Thread != nil

		if me, err := ml.chatView.state.Cabinet.Me(); err == nil {
			canReply = msg.Author.ID != me.ID
			canEdit = msg.Author.ID == me.ID
			canDelete = canEdit
		}
		if !canDelete {
			selected := ml.chatView.SelectedChannel()
			canDelete = selected != nil && ml.chatView.state.HasPermissions(selected.ID, discord.PermissionManageMessages)
		}
	}

	actions := make([]keybind.Keybind, 0, 4)
	if canReply {
		actions = append(actions, cfg.Reply.Keybind, cfg.ReplyMention.Keybind)
	}
	if canSelectReply {
		actions = append(actions, cfg.SelectReply.Keybind)
	}
	actions = append(actions, cfg.Cancel.Keybind)

	manage := make([]keybind.Keybind, 0, 4)
	if canEdit {
		manage = append(manage, cfg.Edit.Keybind)
	}
	if canDelete {
		manage = append(manage, cfg.DeleteConfirm.Keybind, cfg.Delete.Keybind)
	}
	if canOpen {
		manage = append(manage, cfg.Open.Keybind, cfg.SaveImage.Keybind)
	}
	if canOpenThread {
		manage = append(manage, cfg.OpenThread.Keybind)
	}
	manage = append(manage, cfg.UserInfo.Keybind)

	return [][]keybind.Keybind{
		{cfg.SelectUp.Keybind, cfg.SelectDown.Keybind, cfg.SelectTop.Keybind, cfg.SelectBottom.Keybind},
		{cfg.ScrollUp.Keybind, cfg.ScrollDown.Keybind, cfg.ScrollTop.Keybind, cfg.ScrollBottom.Keybind},
		actions,
		manage,
		{cfg.YankContent.Keybind, cfg.YankURL.Keybind, cfg.YankID.Keybind, cfg.Search.Keybind},
	}
}