@emaxe/tuigram 1.3.0 → 1.5.0

package/src/ui/components/chatView.js

@@ -3,7 +3,11 @@ import { formatMessageTime, formatDateDivider } from "../../utils/time.js";
 import { formatMessageText, escapeBlessed } from "../../telegram/formatter.js";
 import { fg } from "../theme.js";
 
-import { getMessageAtLine } from "../../utils/mouse.js";
+import { getMessagePartAtPoint, isRightClick, stringCellWidth } from "../../utils/mouse.js";
+import { isMessageVideo } from "../../utils/video.js";
+
+/** Отступ тела сообщения от левого края ленты, в ячейках. */
+const BODY_INDENT = 2;
 
 /**
  * Создаёт компонент просмотра сообщений чата (правая центральная панель).
@@ -11,9 +15,24 @@ import { getMessageAtLine } from "../../utils/mouse.js";
  * @param {object} theme
  * @param {object} callbacks
  * @param {() => void} [callbacks.onLoadMoreHistory]
- * @param {(msg: object) => void} [callbacks.onActionMenu]
+ * @param {(msg: object) => void} [callbacks.onActionMenu] правый клик / Enter / Ctrl+A
+ * @param {(msg: object) => void} [callbacks.onSelectMessage] сообщение выделено
+ * @param {(msg: object) => void} [callbacks.onOpenImage] клик по превью изображения
+ * @param {(msg: object) => void} [callbacks.onPlayVideo] клик по превью видео
+ * @param {() => void} [callbacks.onFocusRequest] вызывается перед взятием фокуса мышью
+ * @param {(maxReadId: number) => void} [callbacks.onMessagesRead] вызывается при прокрутке и прочтении сообщений
+ * @param {(visibleMessages: Array<object>) => void} [callbacks.onVisibleMessagesChanged] вызывается при смене видимой области для Lazy Loading превью
  */
-export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu } = {}) {
+export function createChatView(screen, theme, {
+    onLoadMoreHistory,
+    onActionMenu,
+    onSelectMessage,
+    onOpenImage,
+    onPlayVideo,
+    onFocusRequest,
+    onMessagesRead,
+    onVisibleMessagesChanged,
+} = {}) {
     const container = blessed.box({
         parent: screen,
         top: 4,
@@ -41,9 +60,13 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
         bottom: 0,
         tags: true,
         scrollable: true,
+        // alwaysScroll обязателен: без него blessed копит смещение в childOffset,
+        // не двигая содержимое (первые щелчки колеса «проглатываются»), а getScroll()
+        // перестаёт совпадать с реальным сдвигом ленты — клики попадали не в то сообщение.
+        alwaysScroll: true,
         mouse: true,
-        keys: true,
-        vi: true,
+        // keys/vi намеренно выключены: их встроенные обработчики скроллят ленту на
+        // стрелках, а стрелки здесь двигают выделение. Все клавиши навешаны явно ниже.
         scrollbar: {
             ch: "│",
             style: {
@@ -57,6 +80,11 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
         },
     });
 
+    // blessed сам вешает на scrollable-box с mouse:true прокрутку колесом на пол-экрана.
+    // Вместе с нашими обработчиками получалось height/2 + 3 строки за щелчок.
+    scrollBox.removeAllListeners("wheelup");
+    scrollBox.removeAllListeners("wheeldown");
+
     /** Подсвечивает рамку, когда лента сообщений в фокусе. */
     function setFocusHighlight(active) {
         container.style.border.fg = active ? theme.borders.focusFg : theme.borders.fg;
@@ -68,14 +96,108 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
 
     let currentMessages = [];
     let currentRanges = [];
+    let selectedId = null;
+    let currentFirstUnreadId = null;
+    let lastReportedMaxReadId = 0;
+
+    // Кэш отформатированных строк сообщений для мгновенной перерисовки и прокрутки ленты
+    const messageLinesCache = new Map();
+    const MAX_LINES_CACHE = 1000;
+
+    /**
+     * Форматирует одиночное сообщение или возвращает готовые строки из кэша.
+     * @param {object} msg
+     * @returns {{ lines: Array<string>, bodyStartOffset: number, imageMeta: object|null }}
+     */
+    function getFormattedMessage(msg) {
+        const previewLen = msg.imagePreview ? msg.imagePreview.length : 0;
+        const reactionsCount = msg.reactions?.length || 0;
+        const cacheKey = `${msg.id}_${msg.editDate || 0}_${previewLen}_${reactionsCount}_${msg.senderName || ""}_${msg.text || ""}`;
+
+        if (messageLinesCache.has(cacheKey)) {
+            return messageLinesCache.get(cacheKey);
+        }
+
+        const time = formatMessageTime(msg.date);
+        const timeTag = fg(theme.chatView.time, `[${time}]`);
+
+        // Отправитель
+        let authorTag = "";
+        if (msg.out) {
+            const readCheck = fg(theme.chatView.outgoingName, "✓✓");
+            authorTag = `${fg(theme.chatView.outgoingName, "{bold}Вы{/bold}")} ${timeTag} ${readCheck}`;
+        } else {
+            const name = escapeBlessed(msg.senderName || "Собеседник");
+            authorTag = `${fg(theme.chatView.incomingName, `{bold}${name}{/bold}`)} ${timeTag}`;
+        }
+
+        // Метка редактирования
+        const editedTag = msg.editDate ? ` ${fg(theme.chatView.time, "(изменено)")}` : "";
+        const lines = [` ${authorTag}${editedTag}`];
+
+        // Блок ответа (Reply)
+        if (msg.replyToMsgId) {
+            lines.push(`  ${fg(theme.chatView.replyBorder, `┌─ Ответ на сообщение #${msg.replyToMsgId}`)}`);
+        }
+
+        // Текст сообщения и entities
+        let bodyText = formatMessageText(msg.text, msg.entities);
+
+        // Блок медиа-вложения и превью изображения
+        let mediaBlock = "";
+        if (msg.imagePreview) {
+            mediaBlock = msg.mediaDescription
+                ? `${msg.mediaDescription}\n${msg.imagePreview}`
+                : msg.imagePreview;
+        } else if (msg.mediaDescription) {
+            mediaBlock = msg.mediaDescription;
+        }
+
+        if (mediaBlock) {
+            bodyText = bodyText ? `${mediaBlock}\n${bodyText}` : mediaBlock;
+        }
+
+        // Строка, с которой начинается тело — нужна для координат превью
+        const bodyStartOffset = lines.length;
+        for (const line of bodyText.split("\n")) {
+            lines.push(`  ${line}`);
+        }
+
+        // Реакции
+        if (msg.reactions && msg.reactions.length > 0) {
+            const list = msg.reactions.map((r) => `${r.emoticon} ${r.count}`).join("  ");
+            lines.push(`  ${fg(theme.chatView.reactionFg, `{bold}${list}{/bold}`)}`);
+        }
+
+        let imageMeta = null;
+        if (msg.imagePreview) {
+            const descLines = msg.mediaDescription ? msg.mediaDescription.split("\n").length : 0;
+            const previewLines = msg.imagePreview.split("\n");
+            const width = previewLines.reduce((max, line) => Math.max(max, stringCellWidth(line)), 0);
+            imageMeta = {
+                descLines,
+                lineCount: previewLines.length,
+                width,
+            };
+        }
+
+        const result = { lines, bodyStartOffset, imageMeta };
+        if (messageLinesCache.size >= MAX_LINES_CACHE) {
+            const firstKey = messageLinesCache.keys().next().value;
+            messageLinesCache.delete(firstKey);
+        }
+        messageLinesCache.set(cacheKey, result);
+        return result;
+    }
 
     /**
      * Форматирует список сообщений в единую ленту текста с разметкой Blessed
      * и вычисляет координаты строк каждого сообщения для кликов мыши.
      * @param {Array<object>} messages
-     * @returns {{ text: string, ranges: Array<{ message: object, startLine: number, endLine: number }> }}
+     * @param {number|null} [firstUnreadId=null]
+     * @returns {{ text: string, ranges: Array<object> }}
      */
-    function renderMessagesWithRanges(messages) {
+    function renderMessagesWithRanges(messages, firstUnreadId = null) {
         if (!messages || messages.length === 0) {
             return {
                 text: `\n\n  ${fg(theme.muted, "Сообщений пока нет. Напишите первое сообщение ниже!")}`,
@@ -97,183 +219,406 @@ export function createChatView(screen, theme, { onLoadMoreHistory, onActionMenu
                 lastDateString = dateStr;
             }
 
-            const time = formatMessageTime(msg.date);
-            const timeTag = fg(theme.chatView.time, `[${time}]`);
-
-            // Отправитель
-            let authorTag = "";
-            if (msg.out) {
-                const readCheck = fg(theme.chatView.outgoingName, "✓✓");
-                authorTag = `${fg(theme.chatView.outgoingName, "{bold}Вы{/bold}")} ${timeTag} ${readCheck}`;
-            } else {
-                const name = escapeBlessed(msg.senderName || "Собеседник");
-                authorTag = `${fg(theme.chatView.incomingName, `{bold}${name}{/bold}`)} ${timeTag}`;
+            // Разделитель непрочитанных сообщений
+            if (firstUnreadId && msg.id === firstUnreadId) {
+                const unreadColor = theme.chatView.unreadDivider || theme.accent;
+                output += `\n  ${fg(unreadColor, "─────── Непрочитанные сообщения ───────")}\n\n`;
+                lineCursor += 3;
             }
 
-            // Блок ответа (Reply)
-            let replyBlock = "";
-            let replyLines = 0;
-            if (msg.replyToMsgId) {
-                replyBlock = `  ${fg(theme.chatView.replyBorder, `┌─ Ответ на сообщение #${msg.replyToMsgId}`)}\n`;
-                replyLines = 1;
-            }
+            const { lines, bodyStartOffset, imageMeta } = getFormattedMessage(msg);
+            const startLine = lineCursor;
 
-            // Текст сообщения и entities
-            let bodyText = formatMessageText(msg.text, msg.entities);
-
-            // Блок медиа-вложения и превью изображения
-            let mediaBlock = "";
-            if (msg.imagePreview) {
-                mediaBlock = msg.mediaDescription
-                    ? `${msg.mediaDescription}\n${msg.imagePreview}`
-                    : msg.imagePreview;
-            } else if (msg.mediaDescription) {
-                mediaBlock = msg.mediaDescription;
+            // Прямоугольник превью изображения внутри сообщения
+            let image = null;
+            if (imageMeta) {
+                const imageStart = startLine + bodyStartOffset + imageMeta.descLines;
+                image = {
+                    startLine: imageStart,
+                    endLine: imageStart + imageMeta.lineCount - 1,
+                    left: BODY_INDENT,
+                    right: BODY_INDENT + imageMeta.width,
+                };
             }
 
-            if (mediaBlock) {
-                bodyText = bodyText ? `${mediaBlock}\n${bodyText}` : mediaBlock;
-            }
+            // Выделенное сообщение помечается полосой в первой колонке. Первая колонка
+            // каждой строки — пробел отступа, поэтому ширина строк не меняется и карта
+            // координат остаётся верной.
+            const isSelected = msg.id === selectedId;
+            const rendered = isSelected
+                ? lines.map((line) => `${fg(theme.accent, "▌")}${line.slice(1)}`)
+                : lines;
+
+            ranges.push({
+                message: msg,
+                startLine,
+                endLine: startLine + lines.length - 1,
+                image,
+            });
+
+            // lines.length строк + одна пустая строка-разделитель между сообщениями
+            lineCursor += lines.length + 1;
+            output += `${rendered.join("\n")}\n\n`;
+        }
 
-            // Отступ строк текста сообщения
-            const indentedBody = bodyText
-                .split("\n")
-                .map((line) => `  ${line}`)
-                .join("\n");
-            const bodyLinesCount = indentedBody.split("\n").length;
-
-            // Реакции
-            let reactionsLine = "";
-            let reactionLinesCount = 0;
-            if (msg.reactions && msg.reactions.length > 0) {
-                const list = msg.reactions.map((r) => `${r.emoticon} ${r.count}`).join("  ");
-                reactionsLine = `\n  ${fg(theme.chatView.reactionFg, `{bold}${list}{/bold}`)}`;
-                reactionLinesCount = 1;
-            }
+        return { text: output, ranges };
+    }
 
-            // Метка редактирования
-            let editedTag = "";
-            if (msg.editDate) {
-                editedTag = ` ${fg(theme.chatView.time, "(изменено)")}`;
-            }
+    /**
+     * Вычисляет фактическую видимую высоту окна ленты сообщений в строках терминала.
+     * @returns {number}
+     */
+    function getVisibleHeight() {
+        const lpos = scrollBox.lpos || scrollBox._getCoords();
+        if (lpos && lpos.yl > lpos.yi) {
+            return Math.max(1, lpos.yl - lpos.yi - (scrollBox.iheight || 0));
+        }
+        return Math.max(1, (screen.height || 24) - 10);
+    }
 
-            const startLine = lineCursor;
-            const totalMsgLines = 1 + replyLines + bodyLinesCount + reactionLinesCount;
-            const endLine = startLine + totalMsgLines - 1;
+    /**
+     * Точно прокручивает ленту к указанной строке содержимого, избегая багов blessed с относительными высотами.
+     * @param {number} targetLine
+     */
+    function scrollToLine(targetLine) {
+        const totalLines = scrollBox._clines?.length || scrollBox.getScrollHeight() || 0;
+        const visible = getVisibleHeight();
+        const maxBase = Math.max(0, totalLines - visible);
+        const clamped = Math.max(0, Math.min(targetLine, maxBase));
+        scrollBox.childBase = clamped;
+        scrollBox.childOffset = 0;
+    }
 
-            ranges.push({ message: msg, startLine, endLine });
-            lineCursor += totalMsgLines + 2;
+    /**
+     * Прокручивает ленту в самый низ (к последнему сообщению).
+     */
+    function scrollToBottom() {
+        const totalLines = scrollBox._clines?.length || scrollBox.getScrollHeight() || 0;
+        const visible = getVisibleHeight();
+        scrollBox.childBase = Math.max(0, totalLines - visible);
+        scrollBox.childOffset = 0;
+    }
+
+    /** Перерисовывает ленту, сохраняя позицию прокрутки (например, после смены выделения). */
+    function redraw() {
+        const prevBase = scrollBox.childBase || 0;
+        const rendered = renderMessagesWithRanges(currentMessages, currentFirstUnreadId);
+        currentRanges = rendered.ranges;
+        scrollBox.setContent(rendered.text);
+        scrollToLine(prevBase);
+        screen.render();
+    }
+
+    /**
+     * Вычисляет видимые в данный момент сообщения, уведомляет о прочитанных
+     * и передаёт видимые сообщения для ленивой подгрузки превью (Lazy Loading).
+     */
+    function checkVisibleMessages() {
+        if (!currentRanges || currentRanges.length === 0) return;
+
+        const visibleHeight = getVisibleHeight();
+        const viewportTop = scrollBox.childBase || 0;
+        const viewportBottom = viewportTop + visibleHeight - 1;
+
+        // Буфер в 5 строк сверху и снизу для плавной подгрузки перед появлением на экране
+        const bufferTop = Math.max(0, viewportTop - 5);
+        const bufferBottom = viewportBottom + 5;
+
+        let maxVisibleId = 0;
+        const visibleMessages = [];
 
-            output += ` ${authorTag}${editedTag}\n${replyBlock}${indentedBody}${reactionsLine}\n\n`;
+        for (const range of currentRanges) {
+            const startRendered = toRenderedLine(range.startLine, "first");
+            const endRendered = toRenderedLine(range.endLine, "last");
+
+            // Проверка для отметки прочитанных (сообщение началось до низа экрана)
+            if (startRendered <= viewportBottom) {
+                if (range.message.id > maxVisibleId) {
+                    maxVisibleId = range.message.id;
+                }
+            }
+
+            // Проверка попадания в видимый диапазон (для Lazy Loading)
+            if (endRendered >= bufferTop && startRendered <= bufferBottom) {
+                visibleMessages.push(range.message);
+            }
         }
 
-        return { text: output, ranges };
+        if (maxVisibleId > lastReportedMaxReadId) {
+            lastReportedMaxReadId = maxVisibleId;
+            onMessagesRead?.(maxVisibleId);
+        }
+
+        if (visibleMessages.length > 0) {
+            onVisibleMessagesChanged?.(visibleMessages);
+        }
     }
 
     /**
      * Устанавливает сообщения в ленту.
      * @param {Array<object>} messages
-     * @param {boolean} [autoScrollToBottom=true]
+     * @param {boolean|object} [scrollOption=true]
      */
-    function setMessages(messages, autoScrollToBottom = true) {
+    function setMessages(messages, scrollOption = true) {
         currentMessages = messages;
-        const prevScroll = scrollBox.getScroll();
+        const prevScroll = scrollBox.childBase || 0;
         const prevHeight = scrollBox.getScrollHeight();
 
-        const rendered = renderMessagesWithRanges(messages);
+        let autoScrollToBottom = true;
+        let firstUnreadId = null;
+        let preserveScroll = false;
+
+        if (typeof scrollOption === "boolean") {
+            autoScrollToBottom = scrollOption;
+            preserveScroll = !scrollOption;
+        } else if (scrollOption && typeof scrollOption === "object") {
+            autoScrollToBottom = Boolean(scrollOption.autoScrollToBottom);
+            firstUnreadId = scrollOption.firstUnreadId !== undefined ? scrollOption.firstUnreadId : null;
+            preserveScroll = Boolean(scrollOption.preserveScroll);
+        }
+
+        if (firstUnreadId !== undefined) {
+            currentFirstUnreadId = firstUnreadId;
+        }
+
+        // Выделенное сообщение могло быть удалено или относиться к другому чату
+        if (selectedId !== null && !messages.some((m) => m.id === selectedId)) {
+            selectedId = null;
+        }
+
+        const rendered = renderMessagesWithRanges(messages, currentFirstUnreadId);
         currentRanges = rendered.ranges;
         scrollBox.setContent(rendered.text);
 
-        if (autoScrollToBottom) {
-            scrollBox.setScrollPerc(100);
-        } else {
+        if (currentFirstUnreadId) {
+            const range = currentRanges.find((r) => r.message.id === currentFirstUnreadId);
+            if (range) {
+                const targetLine = toRenderedLine(range.startLine, "first");
+                scrollToLine(Math.max(0, targetLine - 2));
+            } else if (autoScrollToBottom) {
+                scrollToBottom();
+            }
+        } else if (autoScrollToBottom) {
+            scrollToBottom();
+        } else if (preserveScroll) {
             // Сохраняем относительную позицию скролла: если добавились старые сообщения сверху,
             // компенсируем сдвиг высоты ленты
             const newHeight = scrollBox.getScrollHeight();
             const addedLines = newHeight - prevHeight;
             if (addedLines > 0 && prevScroll > 0) {
-                scrollBox.scrollTo(prevScroll + addedLines);
+                scrollToLine(prevScroll + addedLines);
             } else if (prevScroll > 0) {
-                scrollBox.scrollTo(prevScroll);
+                scrollToLine(prevScroll);
             }
         }
         screen.render();
+        checkVisibleMessages();
+    }
+
+    /**
+     * Переводит номер отрисованной строки в номер строки исходного содержимого.
+     * blessed переносит длинные строки, поэтому напрямую индексы не совпадают.
+     * @param {number} renderedLine
+     * @returns {number}
+     */
+    function toContentLine(renderedLine) {
+        const rtof = scrollBox._clines?.rtof;
+        if (Array.isArray(rtof) && renderedLine >= 0 && renderedLine < rtof.length) {
+            return rtof[renderedLine];
+        }
+        return renderedLine;
+    }
+
+    /**
+     * Обратное преобразование: первая и последняя отрисованные строки для строки содержимого.
+     * @param {number} contentLine
+     * @param {"first"|"last"} edge
+     * @returns {number}
+     */
+    function toRenderedLine(contentLine, edge = "first") {
+        const ftor = scrollBox._clines?.ftor;
+        const mapped = Array.isArray(ftor) ? ftor[contentLine] : null;
+        if (!Array.isArray(mapped) || mapped.length === 0) return contentLine;
+        return edge === "first" ? mapped[0] : mapped[mapped.length - 1];
+    }
+
+    /** Подкручивает ленту так, чтобы выделенное сообщение было видно целиком. */
+    function scrollMessageIntoView(range) {
+        if (!range) return;
+        const visible = getVisibleHeight();
+        const base = scrollBox.childBase || 0;
+        const top = toRenderedLine(range.startLine, "first");
+        const bottom = toRenderedLine(range.endLine, "last");
+
+        if (top < base) {
+            scrollToLine(top);
+        } else if (bottom >= base + visible) {
+            scrollToLine(Math.max(0, bottom - visible + 1));
+        }
+    }
+
+    /**
+     * Выделяет сообщение по идентификатору.
+     * @param {number|null} id
+     * @param {object} [options]
+     * @param {boolean} [options.scrollIntoView=false]
+     * @param {boolean} [options.notify=false] вызвать onSelectMessage
+     */
+    function setSelected(id, { scrollIntoView = false, notify = false } = {}) {
+        if (selectedId === id && !scrollIntoView) return;
+        selectedId = id;
+        redraw();
+
+        const range = currentRanges.find((r) => r.message.id === id);
+        if (scrollIntoView && range) {
+            scrollMessageIntoView(range);
+            screen.render();
+        }
+        if (notify && range) {
+            onSelectMessage?.(range.message);
+        }
+    }
+
+    /** @returns {object|null} выделенное сообщение */
+    function getSelected() {
+        if (selectedId === null) return null;
+        return currentMessages.find((m) => m.id === selectedId) || null;
+    }
+
+    /** Сообщение, над которым выполняются действия: выделенное, иначе последнее. */
+    function getTargetMessage() {
+        return getSelected() || currentMessages[currentMessages.length - 1] || null;
+    }
+
+    /**
+     * Двигает выделение на step сообщений и подкручивает ленту к нему.
+     * @param {number} step
+     */
+    function selectByOffset(step) {
+        if (currentMessages.length === 0) return;
+
+        const currentIndex = currentMessages.findIndex((m) => m.id === selectedId);
+        let nextIndex;
+        if (currentIndex === -1) {
+            nextIndex = currentMessages.length - 1;
+        } else {
+            nextIndex = Math.min(currentMessages.length - 1, Math.max(0, currentIndex + step));
+        }
+
+        setSelected(currentMessages[nextIndex].id, { scrollIntoView: true, notify: true });
+
+        // Дошли до верха ленты — подтягиваем предыдущую страницу истории
+        if (nextIndex === 0 && step < 0) {
+            onLoadMoreHistory?.();
+        }
     }
 
     // Обработка прокрутки вверх для подгрузки истории
     function handleScrollUp(step = 10) {
-        scrollBox.scroll(-step);
-        if (scrollBox.getScroll() <= 0) {
+        const current = scrollBox.childBase || 0;
+        scrollToLine(Math.max(0, current - step));
+        if ((scrollBox.childBase || 0) <= 0) {
             onLoadMoreHistory?.();
         }
         screen.render();
+        checkVisibleMessages();
     }
 
     function handleScrollDown(step = 10) {
-        scrollBox.scroll(step);
+        const current = scrollBox.childBase || 0;
+        scrollToLine(current + step);
         screen.render();
+        checkVisibleMessages();
     }
 
     scrollBox.key(["pageup", "C-u"], () => handleScrollUp(10));
     scrollBox.key(["pagedown", "C-d"], () => handleScrollDown(10));
-    scrollBox.key(["up", "k"], () => handleScrollUp(2));
-    scrollBox.key(["down", "j"], () => handleScrollDown(2));
+    scrollBox.key(["up", "k"], () => selectByOffset(-1));
+    scrollBox.key(["down", "j"], () => selectByOffset(1));
     scrollBox.key(["home"], () => {
-        scrollBox.scrollTo(0);
+        scrollToLine(0);
         onLoadMoreHistory?.();
         screen.render();
+        checkVisibleMessages();
     });
     scrollBox.key(["end"], () => {
-        scrollBox.setScrollPerc(100);
+        scrollToBottom();
         screen.render();
+        checkVisibleMessages();
     });
 
-    scrollBox.on("wheelup", () => {
-        handleScrollUp(3);
-    });
-
-    scrollBox.on("wheeldown", () => {
-        handleScrollDown(3);
-    });
-
-    container.on("wheelup", () => {
-        handleScrollUp(3);
-    });
-
-    container.on("wheeldown", () => {
-        handleScrollDown(3);
-    });
+    scrollBox.on("wheelup", () => handleScrollUp(3));
+    scrollBox.on("wheeldown", () => handleScrollDown(3));
+    container.on("wheelup", () => handleScrollUp(3));
+    container.on("wheeldown", () => handleScrollDown(3));
 
     scrollBox.on("click", (data) => {
-        const clickY = data.y;
-        const itop = scrollBox.itop || 0;
-        const lineIndex = clickY - (scrollBox.atop || 0) + scrollBox.getScroll() - itop;
-        const clickedMsg = getMessageAtLine(lineIndex, currentRanges);
-        if (clickedMsg) {
-            onActionMenu?.(clickedMsg);
-        } else {
+        const renderedLine = data.y - (scrollBox.atop || 0) - (scrollBox.itop || 0) + (scrollBox.childBase || 0);
+        const relX = data.x - (scrollBox.aleft || 0) - (scrollBox.ileft || 0);
+        const hit = getMessagePartAtPoint(toContentLine(renderedLine), relX, currentRanges);
+
+        if (!hit) {
+            // Клик по пустому месту ленты — просто передаём ей фокус
+            onFocusRequest?.();
             scrollBox.focus();
             screen.render();
+            return;
+        }
+
+        if (isRightClick(data)) {
+            setSelected(hit.message.id);
+            onActionMenu?.(hit.message);
+            return;
         }
+
+        if (hit.part === "image") {
+            setSelected(hit.message.id);
+            if (isMessageVideo(hit.message) && onPlayVideo) {
+                onPlayVideo(hit.message);
+            } else {
+                onOpenImage?.(hit.message);
+            }
+            return;
+        }
+
+        onFocusRequest?.();
+        scrollBox.focus();
+        setSelected(hit.message.id, { notify: true });
     });
 
     // Ctrl+M терминал шлёт как "\r" (имя клавиши "return"), поэтому меню действий
     // висит на Ctrl+A — иначе оно недостижимо.
-    scrollBox.key(["C-a"], () => {
-        if (currentMessages.length > 0) {
-            const lastMsg = currentMessages[currentMessages.length - 1];
-            onActionMenu?.(lastMsg);
+    scrollBox.key(["C-a", "enter", "return"], () => {
+        const msg = getTargetMessage();
+        if (msg) {
+            setSelected(msg.id);
+            onActionMenu?.(msg);
         }
     });
 
+    // Отслеживание прокрутки для обновления прочитанных сообщений
+    scrollBox.on("scroll", () => {
+        checkVisibleMessages();
+    });
+
     return {
         container,
         scrollBox,
         setMessages,
+        setSelected,
+        getSelected,
+        getTargetMessage,
+        selectByOffset,
+        resetReadState: (initialReadMaxId = 0) => {
+            lastReportedMaxReadId = initialReadMaxId;
+            currentFirstUnreadId = null;
+        },
+        checkVisibleMessages,
         loadMore: () => onLoadMoreHistory?.(),
         scrollToBottom: () => {
-            scrollBox.setScrollPerc(100);
+            scrollToBottom();
             screen.render();
+            checkVisibleMessages();
         },
         focus: () => scrollBox.focus(),
     };