/***************************************************************************
 *   Copyright (C) 2026 by Vadim Peretokin - vadim.peretokin@mudlet.org    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <QClipboard>
#include <QFontDatabase>
#include <QPainter>
#include <QtTest/QtTest>

#include "Host.h"
#include "MudletInstanceCoordinator.h"
#include "TLuaInterpreter.h"
#include "TMainConsole.h"
#include "TTextEdit.h"
#include "TelnetServerStub.h"
#include "ctelnet.h"
#include "dlgConnectionProfiles.h"
#include "mudlet.h"

extern void qInitResources_mudlet();
extern void qInitResources_qm();
extern void qInitResources_additional_splash_screens();
extern void qInitResources_mudlet_fonts_common();
extern void qInitResources_mudlet_fonts_posix();
void initializeQRCResources();

// TTextEdit lays text out in cells of QFontMetrics::height(), which is a
// typographic measure rather than the glyph ink box. At a good number of font
// sizes the ink of a glyph such as "_" reaches a pixel past the bottom of its
// cell, so it only renders completely if nothing paints over that pixel
// afterwards. #9070 and #9719 are both reports of underscores vanishing because
// something did.
class GlyphOverflowTest : public QObject
{
    Q_OBJECT

private:
    TelnetServerStub* mpServer = nullptr;
    const QString mHostname = "Test-GlyphOverflow";
    QString mPort;
    const QString mLocalhost = "localhost";

    // What the line below the underscores looks like. Each one takes a different
    // branch of the background fill in layoutGrapheme().
    struct Underlay
    {
        QString name;
        QString colourTag;
        bool selected = false;
    };

    static QVector<Underlay> underlays()
    {
        return {
                {qsl("the console background"), qsl("<white>")},
                {qsl("an explicit background colour"), qsl("<white:blue>")},
                {qsl("a bright background colour"), qsl("<black:yellow>")},
                {qsl("a selection"), qsl("<blue>"), true},
        };
    }

    static constexpr int kUnderscoreCount = 40;
    static constexpr int kFillerCount = 60;
    // Column used to sample what a pixel row looks like where no glyph was
    // drawn; whatever the line below paints there is the reference for its own
    // pixel row.
    static constexpr int kBackgroundSampleColumn = 50;
    // How far a channel has to move from its row's background before the pixel
    // counts as glyph ink rather than antialiasing noise.
    static constexpr int kInkThreshold = 24;
    // How far past the bottom of a cell to look for ink that overflowed out of it
    static constexpr int kOverflowScanRows = 4;
    static const inline QStringList kTestFamilies = {qsl("Bitstream Vera Sans Mono"), qsl("Ubuntu Mono")};
    static constexpr int kFirstSize = 9;
    static constexpr int kLastSize = 30;

    static bool pixelIsInk(QRgb pixel, QRgb background)
    {
        return qAbs(qRed(pixel) - qRed(background)) > kInkThreshold || qAbs(qGreen(pixel) - qGreen(background)) > kInkThreshold || qAbs(qBlue(pixel) - qBlue(background)) > kInkThreshold;
    }

private slots:
    void initTestCase()
    {
        initializeQRCResources();
#ifndef INCLUDE_FONTS
        QSKIP("Built with WITH_FONTS=NO, so the fonts whose metrics this measures are not available");
#else
        // src/main.cpp extracts the bundled fonts into the config directory and
        // FontManager picks them up from there, but QTEST_MAIN never runs
        // main(), so on a machine that has not run Mudlet before there is
        // nothing on disk to pick up and Qt quietly substitutes another family.
        for (const QString& file : {qsl(":/fonts/ttf-bitstream-vera-1.10/VeraMono.ttf"),
                                    qsl(":/fonts/ttf-bitstream-vera-1.10/VeraMoBd.ttf"),
                                    qsl(":/fonts/ubuntu-font-family-0.83/UbuntuMono-R.ttf"),
                                    qsl(":/fonts/ubuntu-font-family-0.83/UbuntuMono-B.ttf")}) {
            QVERIFY2(QFontDatabase::addApplicationFont(file) != -1, qPrintable(qsl("Could not register the bundled font %1").arg(file)));
        }
        for (const QString& family : kTestFamilies) {
            QVERIFY2(QFontDatabase::families().contains(family), qPrintable(qsl("'%1' is missing from the font database after registering the bundled files").arg(family)));
        }
#endif
    }

    void init()
    {
        mpServer = new TelnetServerStub(qApp);
        // Port 0 asks the OS for an ephemeral port so parallel test runs do not
        // collide on a hardcoded one
        mpServer->start(mLocalhost, 0);
        QVERIFY2(mpServer->isListening(), "TelnetServerStub failed to bind a loopback port");
        mPort = QString::number(mpServer->serverPort());
        mudlet::start();
        mudlet::self()->setupConfig();
        mudlet::self()->takeOwnershipOfInstanceCoordinator(std::make_unique<MudletInstanceCoordinator>("MudletInstanceCoordinator"));
        mudlet::self()->init();
        mudlet::self()->setStorePasswordsSecurely(false);
        deleteProfileDirectory(mHostname);
    }

    // A line has to render all of its ink whatever the line below it looks like,
    // and that ink has to match the same glyph drawn on its own with the same
    // font, cell geometry and painter flags.
    void test_lineBelowDoesNotEraseOverflowingInk()
    {
        Host* host = startOfflineProfile();
        QVERIFY2(host, "Could not start an offline profile");
        TTextEdit* pane = host->mpConsole->mUpperPane;
        QVERIFY2(pane, "No upper pane available");

        int sizesWithOverflow = 0;
        for (const QString& family : kTestFamilies) {
            for (int size = kFirstSize; size <= kLastSize; ++size) {
                applyFont(host, family, size);
                QVERIFY2(pane->getColumnCount() > kBackgroundSampleColumn,
                         qPrintable(qsl("%1 %2pt narrowed the pane to %3 columns, too few for the background sample at column %4")
                                            .arg(family)
                                            .arg(size)
                                            .arg(pane->getColumnCount())
                                            .arg(kBackgroundSampleColumn)));
                const int cellHeight = cellHeightOf(pane);
                const QPair<int, int> expected = referenceInkExtent(pane->font(), qsl("_"), cellWidthOf(pane), cellHeight);
                if (expected.second >= cellHeight) {
                    ++sizesWithOverflow;
                }

                for (const Underlay& underlay : underlays()) {
                    const QVector<QPoint> ink = renderAndCollectInk(host, underlay);
                    const QString where = qsl("%1 %2pt below %3").arg(family).arg(size).arg(underlay.name);
                    QVERIFY2(!ink.isEmpty(), qPrintable(qsl("%1: no underscore ink rendered at all").arg(where)));

                    const QPair<int, int> actual = inkExtent(ink);
                    QVERIFY2(actual == expected,
                             qPrintable(qsl("%1: underscore ink occupies %2 of its cell, expected %3 (cell is %4 tall)").arg(where, describeExtent(actual), describeExtent(expected)).arg(cellHeight)));
                }
            }
        }

        if (sizesWithOverflow == 0) {
            // The comparisons above all ran and passed, so this is a coverage
            // warning rather than a skip
            QWARN("None of the tested font sizes overflow their cell on this platform, so the overflow case went unexercised");
        }
    }

    // The screen is rendered into a pixmap sized from the number of whole
    // character cells that fit, so the bottom line's overflow only survives if
    // that pixmap has somewhere to put it.
    void test_bottomLineOverflowSurvivesThePixmapEdge()
    {
        Host* host = startOfflineProfile();
        QVERIFY2(host, "Could not start an offline profile");
        TTextEdit* pane = host->mpConsole->mUpperPane;
        QVERIFY2(pane, "No upper pane available");

        int checkedSizes = 0;
        for (int size = kFirstSize; size <= kLastSize; ++size) {
            applyFont(host, kTestFamilies.first(), size);
            const int cellHeight = cellHeightOf(pane);
            const int cellWidth = cellWidthOf(pane);
            const QPair<int, int> expected = referenceInkExtent(pane->font(), qsl("_"), cellWidth, cellHeight);
            if (expected.second < cellHeight) {
                continue; // this size keeps its ink inside the cell, nothing to check
            }
            // A pane whose height is an exact multiple of the cell height has no
            // pixel left over for the bottom line's overflow to appear in.
            if (pane->height() % cellHeight == 0) {
                continue;
            }
            ++checkedSizes;

            const int screenHeight = pane->getScreenHeight();
            runLua(host, qsl("clearWindow()"));
            runLua(host, qsl("cecho('<white>' .. string.rep('filler\\n', %1) .. '%2\\n')").arg(screenHeight - 1).arg(QString(kUnderscoreCount, QLatin1Char('_'))));
            pane->forceUpdate();
            QApplication::processEvents();

            const QImage rendered = renderPane(host);
            const int cellTop = (screenHeight - 1) * cellHeight;
            const QPair<int, int> actual = inkExtent(collectInk(rendered, cellTop, cellHeight, cellWidth));
            QVERIFY2(actual == expected,
                     qPrintable(qsl("%1pt: the bottom line's underscore ink occupies %2 of its cell, expected %3").arg(QString::number(size), describeExtent(actual), describeExtent(expected))));
        }

        if (checkedSizes == 0) {
            QSKIP("No font size produced an overflowing bottom line on this platform, so nothing here is being proved");
        }
    }

    // Repainting part of the pane clears whole character cells, which takes the
    // previous line's overflow pixel with it. That line sits outside the dirty
    // region and is not redrawn, so the pixel has to be put back explicitly.
    void test_partialRepaintKeepsTheLineAboveIntact()
    {
        Host* host = startOfflineProfile();
        QVERIFY2(host, "Could not start an offline profile");
        TTextEdit* pane = host->mpConsole->mUpperPane;
        QVERIFY2(pane, "No upper pane available");

        int checkedSizes = 0;
        for (int size = kFirstSize; size <= kLastSize; ++size) {
            applyFont(host, kTestFamilies.first(), size);
            const int cellHeight = cellHeightOf(pane);
            const int cellWidth = cellWidthOf(pane);
            const QPair<int, int> expected = referenceInkExtent(pane->font(), qsl("_"), cellWidth, cellHeight);
            if (expected.second < cellHeight) {
                continue;
            }
            ++checkedSizes;

            // More lines than fit, so imageTopLine() is past zero - the
            // precondition for the partial repaint below to reach
            // drawForeground()'s cached-pixmap path.
            runLua(host, qsl("clearWindow()"));
            runLua(host, qsl("cecho('<white>' .. string.rep('%1\\n', %2))").arg(QString(kUnderscoreCount, QLatin1Char('_'))).arg(pane->getScreenHeight() * 2));
            pane->forceUpdate();
            QApplication::processEvents();
            QVERIFY2(pane->imageTopLine() > 0, "The pane did not scroll, so the partial repaint would not reach the cached-pixmap path");

            // Simulate a partial repaint: the previous frame, the damaged band
            // reset to the console background, then only that band re-rendered.
            QImage rendered = renderPane(host);
            const int row = pane->getScreenHeight() / 2;
            const QRect damaged(0, row * cellHeight, pane->width(), cellHeight * 2);
            QPainter eraser(&rendered);
            eraser.fillRect(damaged, host->mpConsole->getConsoleBgColor());
            eraser.end();
            pane->render(&rendered, damaged.topLeft(), QRegion(damaged), QWidget::DrawChildren);

            // Only the bottom of the ink can be pinned here: every line is
            // underscores, so the top rows of the cell hold the overflow of the
            // line above it rather than this line's own glyph.
            const QPair<int, int> actual = inkExtent(collectInk(rendered, (row - 1) * cellHeight, cellHeight, cellWidth));
            QVERIFY2(actual.second == expected.second,
                     qPrintable(qsl("%1pt: after a partial repaint the line above the dirty region ends at row %2 of its cell, expected %3").arg(size).arg(actual.second).arg(expected.second)));
        }

        if (checkedSizes == 0) {
            QSKIP("No font size produced an overflowing line on this platform, so nothing here is being proved");
        }
    }

    // Scrolling reuses the cached screen by blitting it a whole number of cells
    // up or down, which lands a complete line of text in the strip below the
    // last one. Only the bottom line's own overflow belongs there.
    void test_scrollingLeavesNoGhostLineBelowTheBottomOne()
    {
        Host* host = startOfflineProfile();
        QVERIFY2(host, "Could not start an offline profile");
        TTextEdit* pane = host->mpConsole->mUpperPane;
        QVERIFY2(pane, "No upper pane available");

        int checkedSizes = 0;
        for (int size = kFirstSize; size <= kLastSize; ++size) {
            applyFont(host, kTestFamilies.first(), size);
            const int cellHeight = cellHeightOf(pane);
            const int cellWidth = cellWidthOf(pane);
            const QPair<int, int> expected = referenceInkExtent(pane->font(), qsl("_"), cellWidth, cellHeight);
            const int spareTop = pane->getScreenHeight() * cellHeight;
            if (expected.second < cellHeight || pane->height() - spareTop <= kOverflowScanRows) {
                continue;
            }
            ++checkedSizes;

            // Underscores for the overflow, letters past them so that a whole
            // ghost line would be unmistakable in the strip.
            const QString line = QString(kUnderscoreCount, QLatin1Char('_')) + QString(20, QLatin1Char('M'));
            runLua(host, qsl("clearWindow()"));
            runLua(host, qsl("cecho('<white>' .. string.rep('%1\\n', %2))").arg(line).arg(pane->getScreenHeight() * 4));
            pane->forceUpdate();
            QApplication::processEvents();
            // primes the cached screen the scroll below is blitted from
            renderPane(host);

            // drawForeground() ignores the cache entirely below ten scrolled-off
            // lines, so there has to be more scrollback than that
            const int topLineBeforeScroll = pane->imageTopLine();
            QVERIFY2(topLineBeforeScroll >= 10, "Not enough scrollback for drawForeground() to take its scrolling path");

            // Render straight after the scroll so the frame under test is the
            // one drawForeground() builds from the shifted cache.
            pane->scrollUp(3);
            QVERIFY2(pane->imageTopLine() < topLineBeforeScroll, "The pane did not scroll back, so the frame below is not built from a shifted cache");
            const QImage rendered = renderPane(host);

            for (int y = spareTop + kOverflowScanRows; y < pane->height(); ++y) {
                int litPixels = 0;
                for (int x = 0; x < rendered.width(); ++x) {
                    if (pixelIsInk(rendered.pixel(x, y), consoleBackground(host))) {
                        ++litPixels;
                    }
                }
                QVERIFY2(litPixels == 0, qPrintable(qsl("%1pt: %2 stray pixels %3 rows below the last character cell after scrolling back").arg(size).arg(litPixels).arg(y - spareTop)));
            }

            // As above, the top of the cell holds the previous line's overflow
            const QPair<int, int> actual = inkExtent(collectInk(rendered, spareTop - cellHeight, cellHeight, cellWidth));
            QVERIFY2(actual.second == expected.second,
                     qPrintable(qsl("%1pt: after scrolling back the bottom line's underscore ink ends at row %2 of its cell, expected %3").arg(size).arg(actual.second).arg(expected.second)));
        }

        if (checkedSizes == 0) {
            QSKIP("No font size produced an overflowing bottom line on this platform, so nothing here is being proved");
        }
    }

    // Miniconsoles keep the fill rule the main console does not, so check the
    // paint order protects their overflow too.
    void test_miniConsoleKeepsOverflowingInk()
    {
        Host* host = startOfflineProfile();
        QVERIFY2(host, "Could not start an offline profile");
        runLua(host, qsl("createMiniConsole('overflowMini', 0, 0, 800, 400)"));
        auto* mini = host->mpConsole->mSubConsoleMap.value(qsl("overflowMini"));
        QVERIFY2(mini, "The miniconsole was not created");
        TTextEdit* pane = mini->mUpperPane;
        QVERIFY2(pane, "The miniconsole has no pane");

        int checkedSizes = 0;
        for (int size = kFirstSize; size <= kLastSize; ++size) {
            runLua(host, qsl("setFont('overflowMini', '%1')").arg(kTestFamilies.first()));
            runLua(host, qsl("setMiniConsoleFontSize('overflowMini', %1)").arg(size));
            QApplication::processEvents();
            // this one goes through the miniconsole API rather than applyFont(),
            // so it needs its own check that the family was not substituted
            QVERIFY2(QFontInfo(pane->font()).family() == kTestFamilies.first(),
                     qPrintable(qsl("The miniconsole resolved to '%1' rather than '%2', so this would measure the wrong glyph").arg(QFontInfo(pane->font()).family(), kTestFamilies.first())));
            const int cellHeight = cellHeightOf(pane);
            const int cellWidth = cellWidthOf(pane);
            const QPair<int, int> expected = referenceInkExtent(pane->font(), qsl("_"), cellWidth, cellHeight);
            if (expected.second < cellHeight || pane->getColumnCount() <= kBackgroundSampleColumn) {
                continue;
            }
            ++checkedSizes;

            runLua(host, qsl("clearWindow('overflowMini')"));
            runLua(host, qsl("cecho('overflowMini', '<white>%1\\n')").arg(QString(kUnderscoreCount, QLatin1Char('_'))));
            runLua(host, qsl("cecho('overflowMini', '<white:blue>%1\\n')").arg(QString(kFillerCount, QLatin1Char(' '))));
            pane->forceUpdate();
            QApplication::processEvents();

            QImage rendered(pane->size(), QImage::Format_ARGB32_Premultiplied);
            rendered.fill(mini->getConsoleBgColor());
            pane->render(&rendered, QPoint(), QRegion(), QWidget::DrawChildren);

            const QPair<int, int> actual = inkExtent(collectInk(rendered, 0, cellHeight, cellWidth));
            QVERIFY2(actual == expected,
                     qPrintable(qsl("%1pt: a miniconsole's underscore ink occupies %2 of its cell, expected %3").arg(QString::number(size), describeExtent(actual), describeExtent(expected))));
        }

        if (checkedSizes == 0) {
            QSKIP("No font size produced an overflowing line in a miniconsole on this platform, so nothing here is being proved");
        }
    }

    // Copy-as-image sizes its pixmap at exactly one cell per selected line, so
    // the bottom line's overflow has nowhere to go unless the paint leaves room
    // for it and the image is trimmed back afterwards.
    void test_copyAsImageKeepsTheBottomLineOverflow()
    {
        Host* host = startOfflineProfile();
        QVERIFY2(host, "Could not start an offline profile");
        TTextEdit* pane = host->mpConsole->mUpperPane;
        QVERIFY2(pane, "No upper pane available");

        int checkedSizes = 0;
        for (int size = kFirstSize; size <= kLastSize; ++size) {
            applyFont(host, kTestFamilies.first(), size);
            const int cellHeight = cellHeightOf(pane);
            const int cellWidth = cellWidthOf(pane);
            const QPair<int, int> expected = referenceInkExtent(pane->font(), qsl("_"), cellWidth, cellHeight);
            if (expected.second < cellHeight) {
                continue;
            }
            ++checkedSizes;

            const int selectedLines = 5;
            runLua(host, qsl("clearWindow()"));
            runLua(host, qsl("cecho('<white>' .. string.rep('%1\\n', %2))").arg(QString(kUnderscoreCount, QLatin1Char('_'))).arg(selectedLines));
            pane->forceUpdate();
            QApplication::processEvents();

            selectRows(pane, 0, selectedLines - 1, cellHeight, cellWidth);
            QMetaObject::invokeMethod(pane, "slot_copySelectionToClipboardImage", Qt::DirectConnection);
            QApplication::processEvents();

            const QImage copied = QApplication::clipboard()->image();
            QVERIFY2(!copied.isNull(), qPrintable(qsl("%1pt: copy as image produced nothing").arg(size)));
            const QPair<int, int> actual = inkExtentOnFlat(copied, (selectedLines - 1) * cellHeight, cellHeight, consoleBackground(host));
            QVERIFY2(actual.second == expected.second,
                     qPrintable(qsl("%1pt: the copied image's bottom line ends at row %2 of its cell, expected %3").arg(size).arg(actual.second).arg(expected.second)));
            // the spare row must not survive as blank padding, nor bring an
            // extra line of text with it
            QVERIFY2(copied.height() <= selectedLines * cellHeight + kOverflowScanRows,
                     qPrintable(qsl("%1pt: the copied image is %2px tall for %3 lines of %4px").arg(size).arg(copied.height()).arg(selectedLines).arg(cellHeight)));
        }

        if (checkedSizes == 0) {
            QSKIP("No font size produced an overflowing line on this platform, so nothing here is being proved");
        }
    }

    void cleanup()
    {
        const QString profilePath = mudlet::getMudletPath(enums::profileHomePath, mHostname);
        delete mudlet::self();
        delete mpServer;
        mpServer = nullptr;
        deleteDirectory(profilePath);
    }

private:
    // The pane paints its cells onto whatever the parent widget is showing, so
    // start from the console background rather than letting render() lay down
    // the default palette colour where no cell was filled.
    static QImage renderPane(Host* host)
    {
        TTextEdit* pane = host->mpConsole->mUpperPane;
        QImage image(pane->size(), QImage::Format_ARGB32_Premultiplied);
        image.fill(host->mpConsole->getConsoleBgColor());
        pane->render(&image, QPoint(), QRegion(), QWidget::DrawChildren);
        return image;
    }

    // For images too narrow to carry a background sample column, such as the
    // copy-as-image output, which is only as wide as the selected text.
    static QPair<int, int> inkExtentOnFlat(const QImage& image, int cellTop, int cellHeight, QRgb background)
    {
        int top = -1;
        int bottom = -1;
        for (int y = qMax(0, cellTop); y < qMin(image.height(), cellTop + cellHeight + kOverflowScanRows); ++y) {
            for (int x = 0; x < image.width(); ++x) {
                if (pixelIsInk(image.pixel(x, y), background)) {
                    if (top < 0) {
                        top = y;
                    }
                    bottom = y;
                    break;
                }
            }
        }
        return {top - cellTop, bottom - cellTop};
    }

    static QRgb consoleBackground(Host* host) { return host->mpConsole->getConsoleBgColor().rgb(); }

    static int cellHeightOf(const TTextEdit* pane) { return QFontMetrics(pane->font()).height(); }
    static int cellWidthOf(const TTextEdit* pane) { return QFontMetrics(pane->font()).averageCharWidth(); }

    // First and last pixel row of a set of ink, as offsets from the cell top.
    // Empty ink reports {-1, -1} so a completely erased glyph never matches a
    // real reference extent.
    static QPair<int, int> inkExtent(const QVector<QPoint>& ink)
    {
        if (ink.isEmpty()) {
            return {-1, -1};
        }
        int top = ink.first().y();
        int bottom = top;
        for (const QPoint& point : ink) {
            top = qMin(top, point.y());
            bottom = qMax(bottom, point.y());
        }
        return {top, bottom};
    }

    static QString describeExtent(const QPair<int, int>& extent) { return qsl("rows %1..%2").arg(extent.first).arg(extent.second); }

    void applyFont(Host* host, const QString& family, int size)
    {
        QFont font(family, size);
        font.setFixedPitch(true);
        QVERIFY2(QFontInfo(font).family() == family, qPrintable(qsl("Qt substituted '%1' for the requested '%2', so this would measure the wrong glyph").arg(QFontInfo(font).family(), family)));
        const auto result = host->setDisplayFont(font);
        QVERIFY2(result.first, qPrintable(qsl("Could not set the display font to %1 %2pt: %3").arg(family).arg(size).arg(result.second)));
        QApplication::processEvents();
    }

    // Prints a line of underscores followed by a filler line dressed up as the
    // given underlay, repaints, and returns the ink of the underscore line.
    QVector<QPoint> renderAndCollectInk(Host* host, const Underlay& underlay)
    {
        TTextEdit* pane = host->mpConsole->mUpperPane;
        runLua(host, qsl("clearWindow()"));
        runLua(host, qsl("cecho('<white>%1\\n')").arg(QString(kUnderscoreCount, QLatin1Char('_'))));
        runLua(host, qsl("cecho('%1%2\\n')").arg(underlay.colourTag, QString(kFillerCount, QLatin1Char(' '))));

        const int underscoreLine = findLine(host, QString(kUnderscoreCount, QLatin1Char('_')));
        if (underscoreLine < 0) {
            return {};
        }
        if (underlay.selected) {
            if (underscoreLine + 1 >= static_cast<int>(host->mpConsole->buffer.buffer.size())) {
                return {};
            }
            auto& below = host->mpConsole->buffer.buffer.at(underscoreLine + 1);
            for (TChar& character : below) {
                character.select();
            }
        }
        pane->forceUpdate();
        QApplication::processEvents();

        const QImage rendered = renderPane(host);
        const int cellHeight = cellHeightOf(pane);
        return collectInk(rendered, (underscoreLine - pane->imageTopLine()) * cellHeight, cellHeight, cellWidthOf(pane));
    }

    static int findLine(Host* host, const QString& text)
    {
        TBuffer& buffer = host->mpConsole->buffer;
        for (int i = 0; i <= buffer.getLastLineNumber(); ++i) {
            if (buffer.line(i) == text) {
                return i;
            }
        }
        return -1;
    }

    // Every pixel of the underscore run that differs from what its own pixel row
    // looks like away from the glyphs, as offsets from the cell's top left.
    // Reaches a few rows past the bottom of the cell so overflow is included.
    // That only avoids picking up the line below because every caller leaves it
    // blank or puts underscores on it, whose ink sits at the bottom of a cell.
    static QVector<QPoint> collectInk(const QImage& image, int cellTop, int cellHeight, int cellWidth)
    {
        QVector<QPoint> ink;
        const int sampleX = kBackgroundSampleColumn * cellWidth + cellWidth / 2;
        if (sampleX >= image.width() || cellTop < 0) {
            return ink;
        }
        const int lastX = qMin(kUnderscoreCount * cellWidth, image.width()) - 1;
        const int lastY = qMin(cellTop + cellHeight + kOverflowScanRows, image.height()) - 1;
        for (int y = cellTop; y <= lastY; ++y) {
            const QRgb background = image.pixel(sampleX, y);
            for (int x = 0; x <= lastX; ++x) {
                if (pixelIsInk(image.pixel(x, y), background)) {
                    ink.append(QPoint(x, y - cellTop));
                }
            }
        }
        return ink;
    }

    // Where the ink of a run of graphemes starts and ends relative to the top of
    // its cell, drawn cell by cell the way TTextEdit::paintGraphemeForeground()
    // draws it. The whole run is rendered rather than a single glyph because
    // neighbouring cells' antialiasing overlaps at the cell boundaries, which
    // moves the faintest row of the ink.
    static QPair<int, int> referenceInkExtent(const QFont& font, const QString& grapheme, int cellWidth, int cellHeight)
    {
        QImage image(kUnderscoreCount * cellWidth, cellHeight * 3, QImage::Format_ARGB32_Premultiplied);
        image.fill(Qt::black);
        QPainter painter(&image);
        painter.setFont(font);
        painter.setPen(Qt::white);
        for (int cell = 0; cell < kUnderscoreCount; ++cell) {
            painter.drawText(QRect(cell * cellWidth, cellHeight, cellWidth, cellHeight), Qt::AlignCenter | Qt::TextDontClip | Qt::TextSingleLine, grapheme);
        }
        painter.end();

        int top = -1;
        int bottom = -1;
        for (int y = 0; y < image.height(); ++y) {
            for (int x = 0; x < image.width(); ++x) {
                if (pixelIsInk(image.pixel(x, y), qRgb(0, 0, 0))) {
                    if (top < 0) {
                        top = y;
                    }
                    bottom = y;
                    break;
                }
            }
        }
        return {top - cellHeight, bottom - cellHeight};
    }

    void runLua(Host* host, const QString& script) { QVERIFY2(host->getLuaInterpreter()->compileAndExecuteScript(script), qPrintable(qsl("Lua script failed: %1").arg(script))); }

    Host* startOfflineProfile()
    {
        startProfile(mHostname, mLocalhost, mPort);
        auto* host = mudlet::self()->getActiveHost();
        if (!host) {
            return nullptr;
        }
        host->mEchoLuaErrors = true;

        mudlet::self()->resize(1400, 900);
        QApplication::processEvents();

        // cecho() into a live connection would race with the stub's traffic
        host->mTelnet.disconnectIt();
        if (!QTest::qWaitFor(
                    [host]() {
                        return host->mTelnet.getConnectionState() == QAbstractSocket::UnconnectedState;
                    },
                    5000)) {
            qWarning() << "Profile did not go offline in time; stub traffic may interleave with the printed lines";
        }
        return host;
    }

    // Starts a profile the way a user would via the GUI (mirrors the helper in
    // TelnetTextDisplayedTest).
    void startProfile(const QString& hostname, const QString& address, const QString& port)
    {
        QTimer::singleShot(0, qApp, [hostname, address, port]() {
            mudlet::self()->startAutoLogin({});
            QTest::qWait(100);
            QTest::mouseClick(mudlet::self()->mpConnectionDialog->new_profile_button, Qt::LeftButton);
            QTest::qWait(100);
            QTest::keyClicks(QApplication::focusWidget(), hostname);
            QTest::qWait(100);
            QTest::keyClick(QApplication::focusWidget(), Qt::Key_Tab);
            QTest::qWait(100);
            QTest::keyClicks(QApplication::focusWidget(), address);
            QTest::qWait(100);
            QTest::keyClick(QApplication::focusWidget(), Qt::Key_Tab);
            QTest::qWait(100);
            QTest::keyClicks(QApplication::focusWidget(), port);
            QTest::qWait(100);
            QTest::keyClick(QApplication::focusWidget(), Qt::Key_Return);
        });

        QSignalSpy spy(mudlet::self(), &mudlet::signal_profileLoaded);
        if (!spy.wait(5000)) {
            QFAIL("Profile took too long to load.");
        }
        if (!mudlet::self()->getActiveHost()) {
            QFAIL("No active host available for the test.");
        }

        QSignalSpy spy2(&(mudlet::self()->getActiveHost()->mTelnet), &cTelnet::signal_connected);
        if (!spy2.wait(2000)) {
            QFAIL("Could not connect with the host.");
        }
    }

    // Drag-selects whole rows, which is the only way in from outside the class.
    static void selectRows(TTextEdit* pane, int firstRow, int lastRow, int cellHeight, int cellWidth)
    {
        auto send = [pane](QEvent::Type type, Qt::MouseButton button, Qt::MouseButtons buttons, const QPointF& pos) {
            QMouseEvent event(type, pos, pane->mapToGlobal(pos.toPoint()), button, buttons, Qt::NoModifier);
            QApplication::sendEvent(pane, &event);
        };
        const QPointF start(2, firstRow * cellHeight + 2);
        const QPointF end(kUnderscoreCount * cellWidth - 2, lastRow * cellHeight + cellHeight / 2);
        send(QEvent::MouseButtonPress, Qt::LeftButton, Qt::LeftButton, start);
        send(QEvent::MouseMove, Qt::NoButton, Qt::LeftButton, end);
        send(QEvent::MouseButtonRelease, Qt::LeftButton, Qt::NoButton, end);
        QApplication::processEvents();
    }

    void deleteProfileDirectory(const QString& profileName) { deleteDirectory(mudlet::getMudletPath(enums::profileHomePath, profileName)); }

    void deleteDirectory(const QString& path)
    {
        QDir dir(path);
        if (!dir.exists()) {
            return;
        }
        dir.removeRecursively();
    }
};

void initializeQRCResources()
{
#ifdef INCLUDE_VARIABLE_SPLASH_SCREEN
    qInitResources_additional_splash_screens();
#endif
#ifdef INCLUDE_FONTS
    qInitResources_mudlet_fonts_common();
#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
    qInitResources_mudlet_fonts_posix();
#endif
#endif
    qInitResources_mudlet();
    qInitResources_qm();
}

#include "GlyphOverflowTest.moc"
QTEST_MAIN(GlyphOverflowTest)