/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qtextmarkdownimporter_p.h"
#include "qtextdocumentfragment_p.h"
#include <QLoggingCategory>
#if QT_CONFIG(regularexpression)
#include <QRegularExpression>
#endif
#include <QTextCursor>
#include <QTextDocument>
#include <QTextDocumentFragment>
#include <QTextList>
#include <QTextTable>
#include "../../3rdparty/md4c/md4c.h"

QT_BEGIN_NAMESPACE

Q_LOGGING_CATEGORY(lcMD, "qt.text.markdown")

static const QChar Newline = QLatin1Char('\n');
static const QChar Space = QLatin1Char(' ');

// TODO maybe eliminate the margins after all views recognize BlockQuoteLevel, CSS can format it, etc.
static const int BlockQuoteIndent = 40; // pixels, same as in QTextHtmlParserNode::initializeProperties

Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureCollapseWhitespace) == MD_FLAG_COLLAPSEWHITESPACE);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeaturePermissiveATXHeaders) == MD_FLAG_PERMISSIVEATXHEADERS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeaturePermissiveURLAutoLinks) == MD_FLAG_PERMISSIVEURLAUTOLINKS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeaturePermissiveMailAutoLinks) == MD_FLAG_PERMISSIVEEMAILAUTOLINKS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureNoIndentedCodeBlocks) == MD_FLAG_NOINDENTEDCODEBLOCKS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureNoHTMLBlocks) == MD_FLAG_NOHTMLBLOCKS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureNoHTMLSpans) == MD_FLAG_NOHTMLSPANS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureTables) == MD_FLAG_TABLES);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureStrikeThrough) == MD_FLAG_STRIKETHROUGH);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeaturePermissiveWWWAutoLinks) == MD_FLAG_PERMISSIVEWWWAUTOLINKS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeaturePermissiveAutoLinks) == MD_FLAG_PERMISSIVEAUTOLINKS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureTasklists) == MD_FLAG_TASKLISTS);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::FeatureNoHTML) == MD_FLAG_NOHTML);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::DialectCommonMark) == MD_DIALECT_COMMONMARK);
Q_STATIC_ASSERT(int(QTextMarkdownImporter::DialectGitHub) == MD_DIALECT_GITHUB);

// --------------------------------------------------------
// MD4C callback function wrappers

static int CbEnterBlock(MD_BLOCKTYPE type, void *detail, void *userdata)
{
    QTextMarkdownImporter *mdi = static_cast<QTextMarkdownImporter *>(userdata);
    return mdi->cbEnterBlock(int(type), detail);
}

static int CbLeaveBlock(MD_BLOCKTYPE type, void *detail, void *userdata)
{
    QTextMarkdownImporter *mdi = static_cast<QTextMarkdownImporter *>(userdata);
    return mdi->cbLeaveBlock(int(type), detail);
}

static int CbEnterSpan(MD_SPANTYPE type, void *detail, void *userdata)
{
    QTextMarkdownImporter *mdi = static_cast<QTextMarkdownImporter *>(userdata);
    return mdi->cbEnterSpan(int(type), detail);
}

static int CbLeaveSpan(MD_SPANTYPE type, void *detail, void *userdata)
{
    QTextMarkdownImporter *mdi = static_cast<QTextMarkdownImporter *>(userdata);
    return mdi->cbLeaveSpan(int(type), detail);
}

static int CbText(MD_TEXTTYPE type, const MD_CHAR *text, MD_SIZE size, void *userdata)
{
    QTextMarkdownImporter *mdi = static_cast<QTextMarkdownImporter *>(userdata);
    return mdi->cbText(int(type), text, size);
}

static void CbDebugLog(const char *msg, void *userdata)
{
    Q_UNUSED(userdata)
    qCDebug(lcMD) << msg;
}

// MD4C callback function wrappers
// --------------------------------------------------------

static Qt::Alignment MdAlignment(MD_ALIGN a, Qt::Alignment defaultAlignment = Qt::AlignLeft | Qt::AlignVCenter)
{
    switch (a) {
    case MD_ALIGN_LEFT:
        return Qt::AlignLeft | Qt::AlignVCenter;
    case MD_ALIGN_CENTER:
        return Qt::AlignHCenter | Qt::AlignVCenter;
    case MD_ALIGN_RIGHT:
        return Qt::AlignRight | Qt::AlignVCenter;
    default: // including MD_ALIGN_DEFAULT
        return defaultAlignment;
    }
}

QTextMarkdownImporter::QTextMarkdownImporter(QTextMarkdownImporter::Features features)
  : m_monoFont(QFontDatabase::systemFont(QFontDatabase::FixedFont))
  , m_features(features)
{
}

QTextMarkdownImporter::QTextMarkdownImporter(QTextDocument::MarkdownFeatures features)
  : QTextMarkdownImporter(static_cast<QTextMarkdownImporter::Features>(int(features)))
{
}

void QTextMarkdownImporter::import(QTextDocument *doc, const QString &markdown)
{
    MD_PARSER callbacks = {
        0, // abi_version
        unsigned(m_features),
        &CbEnterBlock,
        &CbLeaveBlock,
        &CbEnterSpan,
        &CbLeaveSpan,
        &CbText,
        &CbDebugLog,
        nullptr // syntax
    };
    m_doc = doc;
    m_paragraphMargin = m_doc->defaultFont().pointSize() * 2 / 3;
    m_cursor = new QTextCursor(doc);
    doc->clear();
    if (doc->defaultFont().pointSize() != -1)
        m_monoFont.setPointSize(doc->defaultFont().pointSize());
    else
        m_monoFont.setPixelSize(doc->defaultFont().pixelSize());
    qCDebug(lcMD) << "default font" << doc->defaultFont() << "mono font" << m_monoFont;
    QByteArray md = markdown.toUtf8();
    md_parse(md.constData(), MD_SIZE(md.size()), &callbacks, this);
    delete m_cursor;
    m_cursor = nullptr;
}

int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det)
{
    m_blockType = blockType;
    switch (blockType) {
    case MD_BLOCK_P:
        if (!m_listStack.isEmpty())
            qCDebug(lcMD, m_listItem ? "P of LI at level %d"  : "P continuation inside LI at level %d", m_listStack.count());
        else
            qCDebug(lcMD, "P");
        m_needsInsertBlock = true;
        break;
    case MD_BLOCK_QUOTE:
        ++m_blockQuoteDepth;
        qCDebug(lcMD, "QUOTE level %d", m_blockQuoteDepth);
        break;
    case MD_BLOCK_CODE: {
        MD_BLOCK_CODE_DETAIL *detail = static_cast<MD_BLOCK_CODE_DETAIL *>(det);
        m_codeBlock = true;
        m_blockCodeLanguage = QLatin1String(detail->lang.text, int(detail->lang.size));
        m_blockCodeFence = detail->fence_char;
        QString info = QLatin1String(detail->info.text, int(detail->info.size));
        m_needsInsertBlock = true;
        if (m_blockQuoteDepth)
            qCDebug(lcMD, "CODE lang '%s' info '%s' fenced with '%c' inside QUOTE %d", qPrintable(m_blockCodeLanguage), qPrintable(info), m_blockCodeFence, m_blockQuoteDepth);
        else
            qCDebug(lcMD, "CODE lang '%s' info '%s' fenced with '%c'", qPrintable(m_blockCodeLanguage), qPrintable(info), m_blockCodeFence);
    } break;
    case MD_BLOCK_H: {
        MD_BLOCK_H_DETAIL *detail = static_cast<MD_BLOCK_H_DETAIL *>(det);
        QTextBlockFormat blockFmt;
        QTextCharFormat charFmt;
        int sizeAdjustment = 4 - int(detail->level); // H1 to H6: +3 to -2
        charFmt.setProperty(QTextFormat::FontSizeAdjustment, sizeAdjustment);
        charFmt.setFontWeight(QFont::Bold);
        blockFmt.setHeadingLevel(int(detail->level));
        m_needsInsertBlock = false;
        if (m_doc->isEmpty()) {
            m_cursor->setBlockFormat(blockFmt);
            m_cursor->setCharFormat(charFmt);
        } else {
            m_cursor->insertBlock(blockFmt, charFmt);
        }
        qCDebug(lcMD, "H%d", detail->level);
    } break;
    case MD_BLOCK_LI: {
        m_needsInsertBlock = true;
        m_listItem = true;
        MD_BLOCK_LI_DETAIL *detail = static_cast<MD_BLOCK_LI_DETAIL *>(det);
        m_markerType = detail->is_task ?
                    (detail->task_mark == ' ' ? QTextBlockFormat::MarkerType::Unchecked : QTextBlockFormat::MarkerType::Checked) :
                    QTextBlockFormat::MarkerType::NoMarker;
        qCDebug(lcMD) << "LI";
    } break;
    case MD_BLOCK_UL: {
        if (m_needsInsertList) // list nested in an empty list
            m_listStack.push(m_cursor->insertList(m_listFormat));
        else
            m_needsInsertList = true;
        MD_BLOCK_UL_DETAIL *detail = static_cast<MD_BLOCK_UL_DETAIL *>(det);
        m_listFormat = QTextListFormat();
        m_listFormat.setIndent(m_listStack.count() + 1);
        switch (detail->mark) {
        case '*':
            m_listFormat.setStyle(QTextListFormat::ListCircle);
            break;
        case '+':
            m_listFormat.setStyle(QTextListFormat::ListSquare);
            break;
        default: // including '-'
            m_listFormat.setStyle(QTextListFormat::ListDisc);
            break;
        }
        qCDebug(lcMD, "UL %c level %d", detail->mark, m_listStack.count() + 1);
    } break;
    case MD_BLOCK_OL: {
        if (m_needsInsertList) // list nested in an empty list
            m_listStack.push(m_cursor->insertList(m_listFormat));
        else
            m_needsInsertList = true;
        MD_BLOCK_OL_DETAIL *detail = static_cast<MD_BLOCK_OL_DETAIL *>(det);
        m_listFormat = QTextListFormat();
        m_listFormat.setIndent(m_listStack.count() + 1);
        m_listFormat.setNumberSuffix(QChar::fromLatin1(detail->mark_delimiter));
        m_listFormat.setStyle(QTextListFormat::ListDecimal);
        qCDebug(lcMD, "OL xx%d level %d", detail->mark_delimiter, m_listStack.count() + 1);
    } break;
    case MD_BLOCK_TD: {
        MD_BLOCK_TD_DETAIL *detail = static_cast<MD_BLOCK_TD_DETAIL *>(det);
        ++m_tableCol;
        // absolute movement (and storage of m_tableCol) shouldn't be necessary, but
        // movePosition(QTextCursor::NextCell) doesn't work
        QTextTableCell cell = m_currentTable->cellAt(m_tableRowCount - 1, m_tableCol);
        if (!cell.isValid()) {
            qWarning("malformed table in Markdown input");
            return 1;
        }
        *m_cursor = cell.firstCursorPosition();
        QTextBlockFormat blockFmt = m_cursor->blockFormat();
        blockFmt.setAlignment(MdAlignment(detail->align));
        m_cursor->setBlockFormat(blockFmt);
        qCDebug(lcMD) << "TD; align" << detail->align << MdAlignment(detail->align) << "col" << m_tableCol;
    } break;
    case MD_BLOCK_TH: {
        ++m_tableColumnCount;
        ++m_tableCol;
        if (m_currentTable->columns() < m_tableColumnCount)
            m_currentTable->appendColumns(1);
        auto cell = m_currentTable->cellAt(m_tableRowCount - 1, m_tableCol);
        if (!cell.isValid()) {
            qWarning("malformed table in Markdown input");
            return 1;
        }
        auto fmt = cell.format();
        fmt.setFontWeight(QFont::Bold);
        cell.setFormat(fmt);
    } break;
    case MD_BLOCK_TR: {
        ++m_tableRowCount;
        m_nonEmptyTableCells.clear();
        if (m_currentTable->rows() < m_tableRowCount)
            m_currentTable->appendRows(1);
        m_tableCol = -1;
        qCDebug(lcMD) << "TR" << m_currentTable->rows();
    } break;
    case MD_BLOCK_TABLE:
        m_tableColumnCount = 0;
        m_tableRowCount = 0;
        m_currentTable = m_cursor->insertTable(1, 1); // we don't know the dimensions yet
        break;
    case MD_BLOCK_HR: {
        qCDebug(lcMD, "HR");
        QTextBlockFormat blockFmt;
        blockFmt.setProperty(QTextFormat::BlockTrailingHorizontalRulerWidth, 1);
        m_cursor->insertBlock(blockFmt, QTextCharFormat());
    } break;
    default:
        break; // nothing to do for now
    }
    return 0; // no error
}

int QTextMarkdownImporter::cbLeaveBlock(int blockType, void *detail)
{
    Q_UNUSED(detail)
    switch (blockType) {
    case MD_BLOCK_P:
        m_listItem = false;
        break;
    case MD_BLOCK_UL:
    case MD_BLOCK_OL:
        if (Q_UNLIKELY(m_needsInsertList))
            m_listStack.push(m_cursor->createList(m_listFormat));
        if (Q_UNLIKELY(m_listStack.isEmpty())) {
            qCWarning(lcMD, "list ended unexpectedly");
        } else {
            qCDebug(lcMD, "list at level %d ended", m_listStack.count());
            m_listStack.pop();
        }
        break;
    case MD_BLOCK_TR: {
        // https://github.com/mity/md4c/issues/29
        // MD4C doesn't tell us explicitly which cells are merged, so merge empty cells
        // with previous non-empty ones
        int mergeEnd = -1;
        int mergeBegin = -1;
        for (int col = m_tableCol; col >= 0; --col) {
            if (m_nonEmptyTableCells.contains(col)) {
                if (mergeEnd >= 0 && mergeBegin >= 0) {
                    qCDebug(lcMD) << "merging cells" << mergeBegin << "to" << mergeEnd << "inclusive, on row" << m_currentTable->rows() - 1;
                    m_currentTable->mergeCells(m_currentTable->rows() - 1, mergeBegin - 1, 1, mergeEnd - mergeBegin + 2);
                }
                mergeEnd = -1;
                mergeBegin = -1;
            } else {
                if (mergeEnd < 0)
                    mergeEnd = col;
                else
                    mergeBegin = col;
            }
        }
    } break;
    case MD_BLOCK_QUOTE: {
        qCDebug(lcMD, "QUOTE level %d ended", m_blockQuoteDepth);
        --m_blockQuoteDepth;
        m_needsInsertBlock = true;
    } break;
    case MD_BLOCK_TABLE:
        qCDebug(lcMD) << "table ended with" << m_currentTable->columns() << "cols and" << m_currentTable->rows() << "rows";
        m_currentTable = nullptr;
        m_cursor->movePosition(QTextCursor::End);
        break;
    case MD_BLOCK_LI:
        qCDebug(lcMD, "LI at level %d ended", m_listStack.count());
        m_listItem = false;
        break;
    case MD_BLOCK_CODE: {
        m_codeBlock = false;
        m_blockCodeLanguage.clear();
        m_blockCodeFence = 0;
        if (m_blockQuoteDepth)
            qCDebug(lcMD, "CODE ended inside QUOTE %d", m_blockQuoteDepth);
        else
            qCDebug(lcMD, "CODE ended");
        m_needsInsertBlock = true;
    } break;
    case MD_BLOCK_H:
        m_cursor->setCharFormat(QTextCharFormat());
        break;
    default:
        break;
    }
    return 0; // no error
}

int QTextMarkdownImporter::cbEnterSpan(int spanType, void *det)
{
    QTextCharFormat charFmt;
    if (!m_spanFormatStack.isEmpty())
        charFmt = m_spanFormatStack.top();
    switch (spanType) {
    case MD_SPAN_EM:
        charFmt.setFontItalic(true);
        break;
    case MD_SPAN_STRONG:
        charFmt.setFontWeight(QFont::Bold);
        break;
    case MD_SPAN_A: {
        MD_SPAN_A_DETAIL *detail = static_cast<MD_SPAN_A_DETAIL *>(det);
        QString url = QString::fromUtf8(detail->href.text, int(detail->href.size));
        QString title = QString::fromUtf8(detail->title.text, int(detail->title.size));
        charFmt.setAnchor(true);
        charFmt.setAnchorHref(url);
        if (!title.isEmpty())
            charFmt.setToolTip(title);
        charFmt.setForeground(m_palette.link());
        qCDebug(lcMD) << "anchor" << url << title;
        } break;
    case MD_SPAN_IMG: {
        m_imageSpan = true;
        m_imageFormat = QTextImageFormat();
        MD_SPAN_IMG_DETAIL *detail = static_cast<MD_SPAN_IMG_DETAIL *>(det);
        m_imageFormat.setName(QString::fromUtf8(detail->src.text, int(detail->src.size)));
        m_imageFormat.setProperty(QTextFormat::ImageTitle, QString::fromUtf8(detail->title.text, int(detail->title.size)));
        break;
    }
    case MD_SPAN_CODE:
        charFmt.setFont(m_monoFont);
        break;
    case MD_SPAN_DEL:
        charFmt.setFontStrikeOut(true);
        break;
    }
    m_spanFormatStack.push(charFmt);
    qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().family() << charFmt.fontWeight()
                  << (charFmt.fontItalic() ? "italic" : "") << charFmt.foreground().color().name();
    m_cursor->setCharFormat(charFmt);
    return 0; // no error
}

int QTextMarkdownImporter::cbLeaveSpan(int spanType, void *detail)
{
    Q_UNUSED(detail)
    QTextCharFormat charFmt;
    if (!m_spanFormatStack.isEmpty()) {
        m_spanFormatStack.pop();
        if (!m_spanFormatStack.isEmpty())
            charFmt = m_spanFormatStack.top();
    }
    m_cursor->setCharFormat(charFmt);
    qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().family() << charFmt.fontWeight()
                  << (charFmt.fontItalic() ? "italic" : "") << charFmt.foreground().color().name();
    if (spanType == int(MD_SPAN_IMG))
        m_imageSpan = false;
    return 0; // no error
}

int QTextMarkdownImporter::cbText(int textType, const char *text, unsigned size)
{
    if (m_needsInsertBlock)
        insertBlock();
#if QT_CONFIG(regularexpression)
    static const QRegularExpression openingBracket(QStringLiteral("<[a-zA-Z]"));
    static const QRegularExpression closingBracket(QStringLiteral("(/>|</)"));
#endif
    QString s = QString::fromUtf8(text, int(size));

    switch (textType) {
    case MD_TEXT_NORMAL:
#if QT_CONFIG(regularexpression)
        if (m_htmlTagDepth) {
            m_htmlAccumulator += s;
            s = QString();
        }
#endif
        break;
    case MD_TEXT_NULLCHAR:
        s = QString(QChar(0xFFFD)); // CommonMark-required replacement for null
        break;
    case MD_TEXT_BR:
        s = QString(Newline);
        break;
    case MD_TEXT_SOFTBR:
        s = QString(Space);
        break;
    case MD_TEXT_CODE:
        // We'll see MD_SPAN_CODE too, which will set the char format, and that's enough.
        break;
#if QT_CONFIG(texthtmlparser)
    case MD_TEXT_ENTITY:
        m_cursor->insertHtml(s);
        s = QString();
        break;
#endif
    case MD_TEXT_HTML:
        // count how many tags are opened and how many are closed
#if QT_CONFIG(regularexpression) && QT_CONFIG(texthtmlparser)
        {
            int startIdx = 0;
            while ((startIdx = s.indexOf(openingBracket, startIdx)) >= 0) {
                ++m_htmlTagDepth;
                startIdx += 2;
            }
            startIdx = 0;
            while ((startIdx = s.indexOf(closingBracket, startIdx)) >= 0) {
                --m_htmlTagDepth;
                startIdx += 2;
            }
        }
        m_htmlAccumulator += s;
        if (!m_htmlTagDepth) { // all open tags are now closed
            qCDebug(lcMD) << "HTML" << m_htmlAccumulator;
            m_cursor->insertHtml(m_htmlAccumulator);
            if (m_spanFormatStack.isEmpty())
                m_cursor->setCharFormat(QTextCharFormat());
            else
                m_cursor->setCharFormat(m_spanFormatStack.top());
            m_htmlAccumulator = QString();
        }
#endif
        s = QString();
        break;
    }

    switch (m_blockType) {
    case MD_BLOCK_TD:
        m_nonEmptyTableCells.append(m_tableCol);
        break;
    default:
        break;
    }

    if (m_imageSpan) {
        // TODO we don't yet support alt text with formatting, because of the cases where m_cursor
        // already inserted the text above.  Rather need to accumulate it in case we need it here.
        m_imageFormat.setProperty(QTextFormat::ImageAltText, s);
        qCDebug(lcMD) << "image" << m_imageFormat.name()
                      << "title" << m_imageFormat.stringProperty(QTextFormat::ImageTitle)
                      << "alt" << s << "relative to" << m_doc->baseUrl();
        m_cursor->insertImage(m_imageFormat);
        return 0; // no error
    }

    if (!s.isEmpty())
        m_cursor->insertText(s);
    if (m_cursor->currentList()) {
        // The list item will indent the list item's text, so we don't need indentation on the block.
        QTextBlockFormat bfmt = m_cursor->blockFormat();
        bfmt.setIndent(0);
        m_cursor->setBlockFormat(bfmt);
    }
    if (lcMD().isEnabled(QtDebugMsg)) {
        QTextBlockFormat bfmt = m_cursor->blockFormat();
        QString debugInfo;
        if (m_cursor->currentList())
            debugInfo = QLatin1String("in list at depth ") + QString::number(m_cursor->currentList()->format().indent());
        if (bfmt.hasProperty(QTextFormat::BlockQuoteLevel))
            debugInfo += QLatin1String("in blockquote at depth ") +
                    QString::number(bfmt.intProperty(QTextFormat::BlockQuoteLevel));
        if (bfmt.hasProperty(QTextFormat::BlockCodeLanguage))
            debugInfo += QLatin1String("in a code block");
        qCDebug(lcMD) << textType << "in block" << m_blockType << s << qPrintable(debugInfo)
                      << "bindent" << bfmt.indent() << "tindent" << bfmt.textIndent()
                      << "margins" << bfmt.leftMargin() << bfmt.topMargin() << bfmt.bottomMargin() << bfmt.rightMargin();
    }
    qCDebug(lcMD) << textType << "in block" << m_blockType << s << "in list?" << m_cursor->currentList()
                  << "indent" << m_cursor->blockFormat().indent();
    return 0; // no error
}

/*!
    Insert a new block based on stored state.

    m_cursor cannot store the state for the _next_ block ahead of time, because
    m_cursor->setBlockFormat() controls the format of the block that the cursor
    is already in; so cbLeaveBlock() cannot call setBlockFormat() without
    altering the block that was just added. Therefore cbLeaveBlock() and the
    following cbEnterBlock() set variables to remember what formatting should
    come next, and insertBlock() is called just before the actual text
    insertion, to create a new block with the right formatting.
*/
void QTextMarkdownImporter::insertBlock()
{
    QTextCharFormat charFormat;
    if (!m_spanFormatStack.isEmpty())
        charFormat = m_spanFormatStack.top();
    QTextBlockFormat blockFormat;
    if (!m_listStack.isEmpty() && !m_needsInsertList && m_listItem) {
        QTextList *list = m_listStack.top();
        if (list)
            blockFormat = list->item(list->count() - 1).blockFormat();
        else
            qWarning() << "attempted to insert into a list that no longer exists";
    }
    if (m_blockQuoteDepth) {
        blockFormat.setProperty(QTextFormat::BlockQuoteLevel, m_blockQuoteDepth);
        blockFormat.setLeftMargin(BlockQuoteIndent * m_blockQuoteDepth);
        blockFormat.setRightMargin(BlockQuoteIndent);
    }
    if (m_codeBlock) {
        blockFormat.setProperty(QTextFormat::BlockCodeLanguage, m_blockCodeLanguage);
        if (m_blockCodeFence)
            blockFormat.setProperty(QTextFormat::BlockCodeFence, QString(QLatin1Char(m_blockCodeFence)));
        charFormat.setFont(m_monoFont);
    } else {
        blockFormat.setTopMargin(m_paragraphMargin);
        blockFormat.setBottomMargin(m_paragraphMargin);
    }
    if (m_markerType == QTextBlockFormat::MarkerType::NoMarker)
        blockFormat.clearProperty(QTextFormat::BlockMarker);
    else
        blockFormat.setMarker(m_markerType);
    if (!m_listStack.isEmpty())
        blockFormat.setIndent(m_listStack.count());
    if (m_doc->isEmpty()) {
        m_cursor->setBlockFormat(blockFormat);
        m_cursor->setCharFormat(charFormat);
    } else {
        m_cursor->insertBlock(blockFormat, charFormat);
    }
    if (m_needsInsertList) {
        m_listStack.push(m_cursor->createList(m_listFormat));
    } else if (!m_listStack.isEmpty() && m_listItem && m_listStack.top()) {
        m_listStack.top()->add(m_cursor->block());
    }
    m_needsInsertList = false;
    m_needsInsertBlock = false;
}

QT_END_NAMESPACE