// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#include "stackhandler.h"

#include "debuggeractions.h"
#include "debuggercore.h"
#include "debuggerdialogs.h"
#include "debuggerengine.h"
#include "debuggericons.h"
#include "debuggerprotocol.h"
#include "debuggertr.h"
#include "memoryagent.h"
#include "simplifytype.h"

#include <coreplugin/icore.h>

#include <utils/basetreeview.h>
#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <utils/stringutils.h>
#include <utils/widgets.h>

#include <QContextMenuEvent>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QFileDialog>
#include <QInputDialog>
#include <QMenu>
#include <QTextStream>
#include <QTimer>

using namespace Utils;

namespace Debugger::Internal {

/*!
    \class Debugger::Internal::StackHandler
    \brief The StackHandler class provides a model to represent the stack in a
    QTreeView.
 */

StackHandler::StackHandler(DebuggerEngine *engine)
  : m_engine(engine)
{
    setObjectName("StackModel");
    setHeader({Tr::tr("Level"), Tr::tr("Function"), Tr::tr("File"), Tr::tr("Line"), Tr::tr("Address") });

    connect(settings().expandStack.action(), &QAction::triggered,
            this, &StackHandler::reloadFullStack);
    connect(settings().maximalStackDepth.action(), &QAction::triggered,
            this, &StackHandler::reloadFullStack);

    // For now there's always only "the" current thread.
    rootItem()->appendChild(new ThreadDummyItem);
}

StackHandler::~StackHandler() = default;

QVariant SpecialStackItem::data(int column, int role) const
{
    if (role == Qt::DisplayRole && column == StackLevelColumn)
        return Tr::tr("...");
    if (role == Qt::DisplayRole && column == StackFunctionNameColumn)
        return Tr::tr("<More>");
    if (role == Qt::DecorationRole && column == StackLevelColumn)
        return Icons::EMPTY.icon();
    return {};
}

QVariant StackFrameItem::data(int column, int role) const
{
    if (role == Qt::DisplayRole) {
        switch (column) {
        case StackLevelColumn: {
            // Show the real backend frame level, but 1-based: backend
            // levels are 0-based, while the column has always been 1-based.
            // For a regular stack level == row, so this matches the old
            // row + 1; in native mixed stacks the level differs from the
            // row (QML frames are spliced in without a level, and collapsed
            // machinery frames leave gaps), and showing it keeps those gaps
            // visible. Fall back to the 1-based row when there is no numeric
            // level, e.g. for QML frames or for DAP, whose frame id is not a
            // sequential level.
            bool ok = false;
            const int level = frame.level.toInt(&ok);
            if (ok)
                return level + 1;
            return row >= 0 ? QString::number(row + 1) : QString();
        }
        case StackFunctionNameColumn:
            return simplifyType(frame.function);
        case StackFileNameColumn:
            return frame.file.isEmpty() ? frame.module : frame.file.fileName();
        case StackLineNumberColumn:
            return frame.line > 0 ? QVariant(frame.line) : QVariant();
        case StackAddressColumn:
            if (frame.address)
                return QString("0x%1").arg(frame.address, 0, 16);
            return QString();
        }
        return {};
    }

    if (role == Qt::DecorationRole && column == StackLevelColumn)
        return handler->iconForRow(row);

    if (role == Qt::ToolTipRole && settings().useToolTipsInStackView())
        return frame.toToolTip();

    return {};
}

Qt::ItemFlags StackFrameItem::flags(int column) const
{
    const bool isValid = frame.isUsable() || frame.machineryPlaceholder
                         || handler->operatesByInstruction();
    return isValid && handler->isContentsValid()
            ? TreeItem::flags(column) : Qt::ItemFlags();
}

QIcon StackHandler::iconForRow(int row) const
{
    // Return icon that indicates whether this is the active stack frame
    return (m_contentsValid && row == m_currentIndex)
            ? Icons::LOCATION.icon() : Icons::EMPTY.icon();
}

bool StackHandler::setData(const QModelIndex &idx, const QVariant &data, int role)
{
    if (role == BaseTreeView::ItemActivatedRole || role == BaseTreeView::ItemClickedRole) {
        if (isMachineryPlaceholder(idx.row())) {
            // Expand on activation (double-click / Enter); a plain click only
            // selects the placeholder row.
            if (role == BaseTreeView::ItemActivatedRole)
                setMachineryRunExpanded(frameAt(idx.row()).machineryRunId, true);
            return true;
        }
        m_engine->activateFrame(idx.row());
        return true;
    }

    if (role == BaseTreeView::ItemViewEventRole) {
        ItemViewEvent ev = data.value<ItemViewEvent>();
        if (ev.type() == QEvent::ContextMenu)
            return contextMenuEvent(ev);
    }

    return false;
}

ThreadDummyItem *StackHandler::dummyThreadItem() const
{
    QTC_ASSERT(rootItem()->childCount() == 1, return nullptr);
    return rootItem()->childAt(0);
}

StackFrame StackHandler::currentFrame() const
{
    if (m_currentIndex == -1)
        return {};
    QTC_ASSERT(m_currentIndex >= 0, return {});
    return frameAt(m_currentIndex);
}

StackFrame StackHandler::frameAt(int index) const
{
    auto threadItem = dummyThreadItem();
    QTC_ASSERT(threadItem, return {});
    StackFrameItem *frameItem = threadItem->childAt(index);
    QTC_ASSERT(frameItem, return {});
    return frameItem->frame;
}

int StackHandler::stackSize() const
{
    return stackRowCount() - m_canExpand;
}

quint64 StackHandler::topAddress() const
{
    QTC_ASSERT(stackRowCount() > 0, return 0);
    return frameAt(0).address;
}

void StackHandler::setCurrentIndex(int level)
{
    if (level == -1 || level == m_currentIndex)
        return;

    // Emit changed for previous frame
    QModelIndex i = index(m_currentIndex, 0);
    emit dataChanged(i, i);

    m_currentIndex = level;
    emit currentIndexChanged();

    // Emit changed for new frame
    i = index(m_currentIndex, 0);
    emit dataChanged(i, i);
}

void StackHandler::removeAll()
{
    auto threadItem = dummyThreadItem();
    QTC_ASSERT(threadItem, return);
    threadItem->removeChildren();

    setCurrentIndex(-1);
}

bool StackHandler::operatesByInstruction() const
{
    return m_engine->operatesByInstruction();
}

void StackHandler::setFrames(const StackFrames &frames, bool canExpand)
{
    auto threadItem = dummyThreadItem();
    QTC_ASSERT(threadItem, return);

    threadItem->removeChildren();

    m_contentsValid = true;
    m_canExpand = canExpand;

    int row = 0;
    for (const StackFrame &frame : frames)
        threadItem->appendChild(new StackFrameItem(this, frame, row++));

    if (canExpand)
        threadItem->appendChild(new SpecialStackItem(this));

    if (frames.isEmpty())
        m_currentIndex = -1;
    else
        setCurrentIndex(0);

    emit stackChanged();
}

// Replaces each run of debugger machinery frames with a single placeholder
// frame, unless the user expanded that run (then the frames are shown but
// tagged so they can be collapsed again). The frames keep their backend
// levels, so the resulting list works for frame activation despite the gaps.
// A run is identified by the address of its first frame.
static StackFrames collapseMachinery(const StackFrames &frames,
                                     const QSet<quint64> &expandedRuns)
{
    StackFrames result;
    StackFrames run;
    const auto flush = [&] {
        if (run.isEmpty())
            return;
        const quint64 runId = run.first().address;
        if (expandedRuns.contains(runId)) {
            // Expanded on purpose: re-evaluate usability the same way normal
            // frames do (the backend forced usable=0 for machinery), so a
            // frame is navigable exactly when its source is available.
            for (StackFrame frame : std::as_const(run)) {
                frame.machineryRunId = runId;
                frame.usable = frame.file.isReadableFile();
                result.append(frame);
            }
        } else {
            StackFrame placeholder = run.first();
            placeholder.function = Tr::tr("<%n frames of debugger machinery>",
                                          nullptr, int(run.size()));
            placeholder.file = {};
            placeholder.module.clear();
            placeholder.line = -1;
            placeholder.machineryPlaceholder = true;
            placeholder.machineryRunId = runId;
            result.append(placeholder);
        }
        run.clear();
    };
    for (const StackFrame &frame : frames) {
        if (frame.machinery) {
            run.append(frame);
            continue;
        }
        flush();
        result.append(frame);
    }
    flush();
    return result;
}

void StackHandler::setFramesAndCurrentIndex(const GdbMi &frames, bool isFull)
{
    StackFrames stackFrames;
    const int n = frames.childCount();
    for (int i = 0; i != n; ++i)
        stackFrames.append(StackFrame::parseFrame(frames.childAt(i), m_engine->runParameters()));

    m_fullFrames = stackFrames;
    m_expandedMachineryRuns.clear();
    if (settings().collapseMachineryFrames())
        stackFrames = collapseMachinery(stackFrames, m_expandedMachineryRuns);

    // Initialize top frame to the first valid frame.
    int targetFrame = -1;
    for (int i = 0; i != stackFrames.size(); ++i) {
        const StackFrame &frame = stackFrames.at(i);
        if (frame.isUsable() && !frame.function.isEmpty()) {
            targetFrame = i;
            break;
        }
    }

    bool canExpand = !isFull && n >= settings().maximalStackDepth();
    settings().expandStack.setEnabled(canExpand);
    setFrames(stackFrames, canExpand);

    // We can't jump to any file if we don't have any frames.
    if (stackFrames.isEmpty())
        return;

    // targetFrame contains the top most frame for which we have source
    // information. That's typically the frame we'd like to jump to, with
    // a few exceptions:

    // Always jump to frame #0 when stepping by instruction.
    if (m_engine->operatesByInstruction())
        targetFrame = 0;

    // If there is no frame with source, jump to frame #0.
    if (targetFrame == -1)
        targetFrame = 0;

    setCurrentIndex(targetFrame);
}

void StackHandler::prependFrames(const StackFrames &frames)
{
    if (frames.isEmpty())
        return;
    auto threadItem = dummyThreadItem();
    QTC_ASSERT(threadItem, return);
    const int count = frames.size();
    for (int i = count - 1; i >= 0; --i)
        threadItem->prependChild(new StackFrameItem(this, frames.at(i)));
    if (m_currentIndex >= 0)
        setCurrentIndex(m_currentIndex + count);
    emit stackChanged();
}

bool StackHandler::isSpecialFrame(int index) const
{
    return m_canExpand && index + 1 == stackRowCount();
}

bool StackHandler::isMachineryPlaceholder(int index) const
{
    return index >= 0 && index < stackSize() && frameAt(index).machineryPlaceholder;
}

void StackHandler::setMachineryRunExpanded(quint64 runId, bool expanded)
{
    if (!runId)
        return;
    if (expanded)
        m_expandedMachineryRuns.insert(runId);
    else
        m_expandedMachineryRuns.remove(runId);
    rebuildStackFrames();
}

void StackHandler::rebuildStackFrames()
{
    // A pure view operation: re-apply machinery collapsing to the full frame
    // list, preserving the current frame across the rebuild by its address.
    const quint64 currentAddress = (m_currentIndex >= 0 && m_currentIndex < stackSize())
            ? frameAt(m_currentIndex).address : 0;

    StackFrames frames = m_fullFrames;
    if (settings().collapseMachineryFrames())
        frames = collapseMachinery(frames, m_expandedMachineryRuns);

    setFrames(frames, m_canExpand);

    if (currentAddress) {
        for (int i = 0, n = stackSize(); i != n; ++i) {
            const StackFrame &frame = frameAt(i);
            if (!frame.machineryPlaceholder && frame.address == currentAddress) {
                setCurrentIndex(i);
                break;
            }
        }
    }
}

int StackHandler::firstUsableIndex() const
{
    if (!m_engine->operatesByInstruction()) {
        for (int i = 0, n = stackRowCount(); i != n; ++i)
            if (frameAt(i).isUsable())
                return i;
    }
    return 0;
}

void StackHandler::scheduleResetLocation()
{
    m_contentsValid = false;
}

void StackHandler::resetLocation()
{
    emit layoutChanged();
}

int StackHandler::stackRowCount() const
{
    // Only one "thread" for now.
    auto threadItem = dummyThreadItem();
    QTC_ASSERT(threadItem, return 0);
    return threadItem->childCount();
}

// Input a function to be disassembled. Accept CDB syntax
// 'Module!function' for module specification

static StackFrame inputFunctionForDisassembly()
{
    StackFrame frame;
    QInputDialog dialog;
    dialog.setInputMode(QInputDialog::TextInput);
    dialog.setLabelText(Tr::tr("Function:"));
    dialog.setWindowTitle(Tr::tr("Disassemble Function"));
    if (dialog.exec() != QDialog::Accepted)
        return frame;
    const QString function = dialog.textValue();
    if (function.isEmpty())
        return frame;
    const int bangPos = function.indexOf('!');
    if (bangPos != -1) {
        frame.module = function.left(bangPos);
        frame.function = function.mid(bangPos + 1);
    } else {
        frame.function = function;
    }
    frame.line = 42; // trick gdb into mixed mode.
    return frame;
}

// Write stack frames as task file for displaying it in the build issues pane.
void StackHandler::saveTaskFile()
{
    QFile file;
    QFileDialog fileDialog(Core::ICore::dialogParent());
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    fileDialog.selectFile(QDir::currentPath() + "/stack.tasks");
    while (!file.isOpen()) {
        if (fileDialog.exec() != QDialog::Accepted)
            return;
        const QString fileName = fileDialog.selectedFiles().constFirst();
        file.setFileName(fileName);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
            QString msg = Tr::tr("Cannot open \"%1\": %2")
                    .arg(QDir::toNativeSeparators(fileName), file.errorString());
            Utils::AsynchronousMessageBox::warning(Tr::tr("Cannot Open Task File"), msg);
        }
    }

    QTextStream str(&file);
    forItemsAtLevel<2>([&str](StackFrameItem *item) {
        const StackFrame &frame = item->frame;
        if (frame.isUsable())
            str << frame.file << '\t' << frame.line << "\tstack\tFrame #" << frame.level << '\n';
    });
}

bool StackHandler::contextMenuEvent(const ItemViewEvent &ev)
{
    auto menu = new QMenu;

    const int row = ev.sourceModelIndex().row();
    StackFrame frame;
    if (row >= 0 && row < stackSize())
        frame = frameAt(row);
    const quint64 address = frame.address;

    menu->addAction(settings().expandStack.action());

    bool hasMachinery = false;
    for (const StackFrame &f : std::as_const(m_fullFrames)) {
        if (f.machinery) {
            hasMachinery = true;
            break;
        }
    }
    if (hasMachinery) {
        if (frame.machineryPlaceholder) {
            const quint64 runId = frame.machineryRunId;
            addAction(this, menu, Tr::tr("Expand Debugger Machinery Frames"), true,
                      [this, runId] { setMachineryRunExpanded(runId, true); });
        } else if (frame.machinery && frame.machineryRunId) {
            const quint64 runId = frame.machineryRunId;
            addAction(this, menu, Tr::tr("Collapse Debugger Machinery Frames"), true,
                      [this, runId] { setMachineryRunExpanded(runId, false); });
        }
        const bool collapse = settings().collapseMachineryFrames();
        addAction(this, menu,
                  collapse ? Tr::tr("Show All Debugger Machinery Frames")
                           : Tr::tr("Collapse Debugger Machinery Frames"),
                  true, [this, collapse] {
                      settings().collapseMachineryFrames.setValue(!collapse);
                      rebuildStackFrames();
                  });
    }

    addAction(this, menu, Tr::tr("Save as Task File..."), true, [this] { saveTaskFile(); });

    if (m_engine->hasCapability(CreateFullBacktraceCapability))
        menu->addAction(settings().createFullBacktrace.action());

    if (m_engine->hasCapability(AdditionalQmlStackCapability))
        addAction(this, menu, Tr::tr("Load QML Stack"), true, [this] { m_engine->loadAdditionalQmlStack(); });

    if (m_engine->hasCapability(ShowMemoryCapability))
        addAction(this, menu, Tr::tr("Open Memory Editor at 0x%1").arg(address, 0, 16),
                  Tr::tr("Open Memory Editor"),
                  address,
                  [this, row, frame, address] {
                        MemoryViewSetupData data;
                        data.startAddress = address;
                        data.title = Tr::tr("Memory at Frame #%1 (%2) 0x%3")
                                        .arg(row).arg(frame.function).arg(address, 0, 16);
                        data.markup.push_back(MemoryMarkup(address, 1, QColor(Qt::blue).lighter(),
                                                  Tr::tr("Frame #%1 (%2)").arg(row).arg(frame.function)));
                        m_engine->openMemoryView(data);
                   });

    if (m_engine->hasCapability(DisassemblerCapability)) {
        addAction(this, menu, Tr::tr("Open Disassembler at 0x%1").arg(address, 0, 16),
                  Tr::tr("Open Disassembler"),
                  address,
                  [this, frame] { m_engine->openDisassemblerView(frame); });

        addAction(this, menu, Tr::tr("Open Disassembler at Address..."), true,
                  [this, address] {
                        if (std::optional<quint64> result = runAddressDialog(address))
                            m_engine->openDisassemblerView(Location(*result));
                   });

        addAction(this, menu, Tr::tr("Disassemble Function..."), true,
                  [this] {
                        const StackFrame frame = inputFunctionForDisassembly();
                        if (!frame.function.isEmpty())
                            m_engine->openDisassemblerView(Location(frame));
                  });
    }

    if (m_engine->hasCapability(ShowModuleSymbolsCapability)) {
        addAction(this, menu, Tr::tr("Try to Load Unknown Symbols"), true,
                  [this] { m_engine->loadSymbolsForStack(); });
    }

    menu->addSeparator();
    menu->addAction(settings().useToolTipsInStackView.action());

    addStandardActions(qobject_cast<BaseTreeView *>(ev.view()), menu);

    menu->setAttribute(Qt::WA_DeleteOnClose);
    menu->popup(ev.globalPos());
    return true;
}

void StackHandler::reloadFullStack()
{
    m_engine->reloadFullStack();
}

} // Debugger::Internal
