/* This file is part of the KDE project
   SPDX-FileCopyrightText: 2010 Thomas Fjellstrom <thomas@fjellstrom.ca>

   SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "katefiletreemodel.h"

#include <QDir>
#include <QGuiApplication>
#include <QIcon>
#include <QList>
#include <QMimeData>
#include <QStack>
#include <QWidget>

#include <KColorScheme>
#include <KColorUtils>
#include <KLocalizedString>

#include <KTextEditor/MainWindow>
#include <ktexteditor/application.h>
#include <ktexteditor/editor.h>

#include "doc_or_widget.h"
#include "ktexteditor_utils.h"

static constexpr int MaxHistoryItems = 10;

class FileTreeMimeData : public QMimeData
{
    Q_OBJECT
public:
    FileTreeMimeData(const QModelIndex &index)
        : m_index(index)
    {
    }

    QModelIndex index() const
    {
        return m_index;
    }

private:
    QPersistentModelIndex m_index;
};

class ProxyItemDir;
class ProxyItem
{
    friend class KateFileTreeModel;

public:
    enum Flag {
        None = 0,
        Dir = 1,
        Modified = 2,
        ModifiedExternally = 4,
        DeletedExternally = 8,
        Empty = 16,
        ShowFullPath = 32,
        Host = 64,
        Widget = 128,
    };
    Q_DECLARE_FLAGS(Flags, Flag)

    ProxyItem(QString n, ProxyItemDir *p = nullptr, Flags f = ProxyItem::None);
    ~ProxyItem();

    int addChild(ProxyItem *p);
    void removeChild(ProxyItem *p);

    ProxyItemDir *parent() const;

    ProxyItem *child(int idx) const;
    int childCount() const;

    int row() const;

    const QString &display() const;
    const QString &documentName() const;

    const QString &path() const;
    void setPath(const QString &str);

    void setHost(const QString &host);
    const QString &host() const;

    void setIcon(const QIcon &i);
    const QIcon &icon() const;

    const std::vector<ProxyItem *> &children() const;
    std::vector<ProxyItem *> &children();

    void setDoc(KTextEditor::Document *doc);
    KTextEditor::Document *doc() const;

    void setWidget(QWidget *);
    QWidget *widget() const;

    /**
     * the view uses this to close all the documents under the folder
     * @returns list of all the (nested) documents under this node
     */
    QList<KTextEditor::Document *> docTree() const;

    void setFlags(Flags flags);
    void setFlag(Flag flag);
    void clearFlag(Flag flag);
    bool flag(Flag flag) const;

private:
    QString m_path;
    QString m_documentName;
    ProxyItemDir *m_parent;
    std::vector<ProxyItem *> m_children;
    int m_row;
    Flags m_flags;

    QString m_display;
    QIcon m_icon;
    DocOrWidget m_object;
    QString m_host;

protected:
    void updateDisplay();
    void updateDocumentName();
};

QDebug operator<<(QDebug dbg, ProxyItem *item)
{
    if (!item) {
        dbg.nospace() << "ProxyItem(0x0) ";
        return dbg.maybeSpace();
    }

    const void *parent = static_cast<void *>(item->parent());

    dbg.nospace() << "ProxyItem(" << item << ",";
    dbg.nospace() << parent << "," << item->row() << ",";
    dbg.nospace() << item->doc() << "," << item->path() << ") ";
    return dbg.maybeSpace();
}

class ProxyItemDir : public ProxyItem
{
public:
    ProxyItemDir(const QString &n, ProxyItemDir *p = nullptr)
        : ProxyItem(n, p)
    {
        setFlag(ProxyItem::Dir);
        updateDisplay();

        setIcon(QIcon::fromTheme(QStringLiteral("folder")));
    }
};

QDebug operator<<(QDebug dbg, ProxyItemDir *item)
{
    if (!item) {
        dbg.nospace() << "ProxyItemDir(0x0) ";
        return dbg.maybeSpace();
    }

    const void *parent = static_cast<void *>(item->parent());

    dbg.nospace() << "ProxyItemDir(" << item << ",";
    dbg.nospace() << parent << "," << item->row() << ",";
    dbg.nospace() << item->path() << ", children:" << item->childCount() << ") ";
    return dbg.maybeSpace();
}

Q_DECLARE_OPERATORS_FOR_FLAGS(ProxyItem::Flags)

// BEGIN ProxyItem
ProxyItem::ProxyItem(QString d, ProxyItemDir *p, ProxyItem::Flags f)
    : m_path(std::move(d))
    , m_parent(nullptr)
    , m_row(-1)
    , m_flags(f)
{
    updateDisplay();

    if (f.testFlag(Widget) && f.testFlag(Dir)) {
        m_documentName = display();
    }

    /**
     * add to parent, if parent passed
     * we assigned above nullptr to parent to not trigger
     * remove from old parent here!
     */
    if (p) {
        p->addChild(this);
    }
}

ProxyItem::~ProxyItem()
{
    qDeleteAll(m_children);
}

void ProxyItem::updateDisplay()
{
    // triggers only if this is a top level node and the root has the show full path flag set.
    if (flag(ProxyItem::Dir) && m_parent && !m_parent->m_parent && m_parent->flag(ProxyItem::ShowFullPath)) {
        m_display = m_path;
        if (m_display.startsWith(QDir::homePath())) {
            m_display.replace(0, QDir::homePath().length(), QStringLiteral("~"));
        }
    } else {
        m_display = m_path.section(u'/', -1, -1);
        if (flag(ProxyItem::Host) && (!m_parent || (m_parent && !m_parent->m_parent))) {
            const QString hostPrefix = QStringLiteral("[%1]").arg(host());
            if (hostPrefix != m_display) {
                m_display = hostPrefix + m_display;
            }
        }
    }
}

int ProxyItem::addChild(ProxyItem *item)
{
    // remove from old parent, is any
    if (item->m_parent) {
        item->m_parent->removeChild(item);
    }

    const int item_row = int(m_children.size());
    item->m_row = item_row;
    m_children.push_back(item);
    item->m_parent = static_cast<ProxyItemDir *>(this);

    item->updateDisplay();

    return item_row;
}

void ProxyItem::removeChild(ProxyItem *item)
{
    auto it = std::find(m_children.begin(), m_children.end(), item);
    Q_ASSERT(it != m_children.end());
    m_children.erase(it);

    auto idx = std::distance(m_children.begin(), it);
    for (size_t i = idx; i < m_children.size(); i++) {
        m_children[i]->m_row = int(i);
    }

    item->m_parent = nullptr;
}

ProxyItemDir *ProxyItem::parent() const
{
    return m_parent;
}

ProxyItem *ProxyItem::child(int idx) const
{
    return (size_t(idx) >= m_children.size()) ? nullptr : m_children[idx];
}

int ProxyItem::childCount() const
{
    return int(m_children.size());
}

int ProxyItem::row() const
{
    return m_row;
}

const QIcon &ProxyItem::icon() const
{
    return m_icon;
}

void ProxyItem::setIcon(const QIcon &i)
{
    m_icon = i;
}

const QString &ProxyItem::documentName() const
{
    return m_documentName;
}

const QString &ProxyItem::display() const
{
    return m_display;
}

const QString &ProxyItem::path() const
{
    return m_path;
}

void ProxyItem::setPath(const QString &p)
{
    m_path = p;
    updateDisplay();
}

const std::vector<ProxyItem *> &ProxyItem::children() const
{
    return m_children;
}

std::vector<ProxyItem *> &ProxyItem::children()
{
    return m_children;
}

void ProxyItem::setDoc(KTextEditor::Document *doc)
{
    Q_ASSERT(doc);
    m_object = doc;
    updateDocumentName();
}

void ProxyItem::setWidget(QWidget *w)
{
    Q_ASSERT(w);
    m_object = w;
    updateDocumentName();
}

QWidget *ProxyItem::widget() const
{
    return m_object.widget();
}

KTextEditor::Document *ProxyItem::doc() const
{
    return m_object.doc();
}

QList<KTextEditor::Document *> ProxyItem::docTree() const
{
    QList<KTextEditor::Document *> result;

    if (doc()) {
        result.append(doc());
        return result;
    }

    for (const ProxyItem *item : m_children) {
        result.append(item->docTree());
    }

    return result;
}

bool ProxyItem::flag(Flag f) const
{
    return m_flags & f;
}

void ProxyItem::setFlag(Flag f)
{
    m_flags |= f;
}

void ProxyItem::setFlags(Flags f)
{
    m_flags = f;
}

void ProxyItem::clearFlag(Flag f)
{
    m_flags &= ~f;
}

void ProxyItem::setHost(const QString &host)
{
    m_host = host;

    if (host.isEmpty()) {
        clearFlag(Host);
    } else {
        setFlag(Host);
    }

    updateDocumentName();
    updateDisplay();
}

const QString &ProxyItem::host() const
{
    return m_host;
}

void ProxyItem::updateDocumentName()
{
    QString name;
    if (doc()) {
        name = doc()->documentName();
    } else if (widget()) {
        name = widget()->windowTitle();
    }

    if (flag(ProxyItem::Host)) {
        m_documentName = QStringLiteral("[%1]%2").arg(m_host, name);
    } else {
        m_documentName = name;
    }
}

// END ProxyItem

KateFileTreeModel::KateFileTreeModel(KTextEditor::MainWindow *mainWindow, QObject *p)
    : QAbstractItemModel(p)
    , m_mainWindow(mainWindow)
    , m_root(new ProxyItemDir(QStringLiteral("m_root"), nullptr))
{
    // setup default settings
    // session init will set these all soon
    const KColorScheme colors(QPalette::Active);
    const QColor bg = colors.background().color();
    m_editShade = KColorUtils::tint(bg, colors.foreground(KColorScheme::ActiveText).color(), 0.5);
    m_viewShade = KColorUtils::tint(bg, colors.foreground(KColorScheme::VisitedText).color(), 0.5);
    m_inactiveDocColor = colors.foreground(KColorScheme::InactiveText).color();
    m_shadingEnabled = true;
    m_listMode = false;

    initModel();

    // ensure palette change updates the colors properly
    connect(KTextEditor::Editor::instance(), &KTextEditor::Editor::configChanged, this, [this]() {
        m_inactiveDocColor = KColorScheme(QPalette::Active).foreground(KColorScheme::InactiveText).color();
        updateBackgrounds(true);
    });
    // Handle documentPinStatusChanged, reuse documentModifiedChanged slot as we just need to
    // update the icon
    connect(KTextEditor::Editor::instance()->application()->parent(),
            SIGNAL(documentPinStatusChanged(KTextEditor::Document *)),
            this,
            SLOT(documentModifiedChanged(KTextEditor::Document *)));
}

KateFileTreeModel::~KateFileTreeModel()
{
    delete m_root;
}

bool KateFileTreeModel::shadingEnabled() const
{
    return m_shadingEnabled;
}

void KateFileTreeModel::setShadingEnabled(bool se)
{
    if (m_shadingEnabled != se) {
        updateBackgrounds(true);
        m_shadingEnabled = se;
    }

    if (!se) {
        m_viewHistory.clear();
        m_editHistory.clear();
        m_brushes.clear();
    }
}

void KateFileTreeModel::setEditShade(const QColor &es)
{
    m_editShade = es;
}

void KateFileTreeModel::setViewShade(const QColor &vs)
{
    m_viewShade = vs;
}

bool KateFileTreeModel::showFullPathOnRoots() const
{
    return m_root->flag(ProxyItem::ShowFullPath);
}

void KateFileTreeModel::setShowFullPathOnRoots(bool s)
{
    if (s) {
        m_root->setFlag(ProxyItem::ShowFullPath);
    } else {
        m_root->clearFlag(ProxyItem::ShowFullPath);
    }

    const std::vector<ProxyItem *> &rootChildren = m_root->children();
    for (ProxyItem *root : rootChildren) {
        root->updateDisplay();
    }
}

void KateFileTreeModel::initModel()
{
    beginInsertRows(QModelIndex(), 0, 0);
    Q_ASSERT(!m_widgetsRoot);
    m_widgetsRoot = new ProxyItem(i18nc("Open here is a description, i.e. 'list of widgets that are open' not a verb", "Open Widgets"),
                                  nullptr,
                                  ProxyItem::Flags(ProxyItem::Dir | ProxyItem::Widget));
    m_widgetsRoot->setFlags(ProxyItem::Flags(ProxyItem::Dir | ProxyItem::Widget));
    m_widgetsRoot->setIcon(QIcon::fromTheme(QStringLiteral("folder-windows")));
    m_root->addChild(m_widgetsRoot);
    endInsertRows();

    // add already existing documents
    const auto documents = KTextEditor::Editor::instance()->application()->documents();
    for (KTextEditor::Document *doc : documents) {
        documentOpened(doc);
    }

    if (m_mainWindow) {
        QWidgetList widgets = m_mainWindow->widgets();
        for (auto *w : std::as_const(widgets)) {
            addWidget(w);
        }
    }
}

void KateFileTreeModel::clearModel()
{
    // remove all items
    // can safely ignore documentClosed here

    beginResetModel();

    delete m_root;
    m_root = new ProxyItemDir(QStringLiteral("m_root"), nullptr);

    m_widgetsRoot = nullptr;

    m_docmap.clear();
    m_viewHistory.clear();
    m_editHistory.clear();
    m_brushes.clear();

    endResetModel();
}

void KateFileTreeModel::connectDocument(const KTextEditor::Document *doc) const
{
    connect(doc, &KTextEditor::Document::documentNameChanged, this, &KateFileTreeModel::documentNameChanged);
    connect(doc, &KTextEditor::Document::documentUrlChanged, this, &KateFileTreeModel::documentNameChanged);
    connect(doc, &KTextEditor::Document::modifiedChanged, this, &KateFileTreeModel::documentModifiedChanged);
    connect(doc, &KTextEditor::Document::modifiedOnDisk, this, &KateFileTreeModel::documentModifiedOnDisc);
    // needed to get mime-type udate right, see bug 489452
    connect(doc, &KTextEditor::Document::reloaded, this, &KateFileTreeModel::documentModifiedChanged);
}

QModelIndex KateFileTreeModel::docIndex(const KTextEditor::Document *doc) const
{
    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return {};
    }
    ProxyItem *item = it.value();
    return createIndex(item->row(), 0, item);
}

QModelIndex KateFileTreeModel::widgetIndex(QWidget *widget) const
{
    ProxyItem *item = nullptr;
    const std::vector<ProxyItem *> &items = m_widgetsRoot->children();
    for (ProxyItem *it : items) {
        if (it->widget() == widget) {
            item = it;
            break;
        }
    }
    if (!item) {
        return {};
    }

    return createIndex(item->row(), 0, item);
}

Qt::ItemFlags KateFileTreeModel::flags(const QModelIndex &index) const
{
    Qt::ItemFlags flags = Qt::ItemIsEnabled;

    if (!index.isValid()) {
        return Qt::NoItemFlags | Qt::ItemIsDropEnabled;
    }

    const ProxyItem *item = static_cast<ProxyItem *>(index.internalPointer());
    if (item) {
        if (!item->flag(ProxyItem::Dir)) {
            flags |= Qt::ItemIsSelectable;
        }

        if (item->flag(ProxyItem::Dir) && !item->flag(ProxyItem::Widget)) {
            flags |= Qt::ItemIsDropEnabled;
        }

        if (item->doc() && item->doc()->url().isValid()) {
            flags |= Qt::ItemIsDragEnabled;
        }
    }

    return flags;
}

QVariant KateFileTreeModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        return {};
    }

    auto *item = static_cast<ProxyItem *>(index.internalPointer());
    if (!item) {
        return {};
    }

    switch (role) {
    case KateFileTreeModel::PathRole:
        // allow to sort with hostname + path, bug 271488
        return (item->doc() && !item->doc()->url().isEmpty()) ? item->doc()->url().toString() : item->path();

    case KateFileTreeModel::DocumentRole:
        return QVariant::fromValue(item->doc());

    case KateFileTreeModel::WidgetRole:
        return QVariant::fromValue(item->widget());

    case KateFileTreeModel::OpeningOrderRole:
        return item->row();

    case KateFileTreeModel::DocumentTreeRole:
        return QVariant::fromValue(item->docTree());

    case Qt::DisplayRole:
        // in list mode we want to use kate's fancy names.
        if (index.column() == 0) {
            if (m_listMode) {
                return item->documentName();
            } else {
                return item->display();
            }
        }
        break;
    case Qt::DecorationRole:
        if (index.column() == 0) {
            return item->icon();
        }
        break;
    case Qt::ToolTipRole: {
        QString tooltip = item->path();
        if (item->flag(ProxyItem::DeletedExternally) || item->flag(ProxyItem::ModifiedExternally)) {
            tooltip = i18nc("%1 is the full path", "<p><b>%1</b></p><p>The document has been modified by another application.</p>", item->path());
        }

        return tooltip;
    }

    case Qt::ForegroundRole: {
        if (!item->flag(ProxyItem::Widget) && !item->flag(ProxyItem::Dir) && (!item->doc() || item->doc()->openingError())) {
            return m_inactiveDocColor;
        }
    } break;

    case Qt::BackgroundRole:
        // TODO: do that funky shading the file list does...
        if (m_shadingEnabled) {
            if (auto it = m_brushes.find(item); it != m_brushes.end()) {
                return it->second;
            }
        }
        break;
    }

    return {};
}

Qt::DropActions KateFileTreeModel::supportedDropActions() const
{
    Qt::DropActions a = QAbstractItemModel::supportedDropActions();
    a |= Qt::MoveAction;
    return a;
}

QMimeData *KateFileTreeModel::mimeData(const QModelIndexList &indexes) const
{
    if (indexes.size() != columnCount()) {
        return nullptr;
    }

    auto *item = static_cast<ProxyItem *>(indexes.at(0).internalPointer());
    QList<QUrl> urls;
    if (!item || !item->doc() || !item->doc()->url().isValid()) {
        return nullptr;
    }
    urls.append(item->doc()->url());

    auto *mimeData = new FileTreeMimeData(indexes.at(0));
    mimeData->setUrls(urls);
    return mimeData;
}

bool KateFileTreeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int, int, const QModelIndex &parent) const
{
    if (auto md = qobject_cast<const FileTreeMimeData *>(data)) {
        return action == Qt::MoveAction && md->index().parent() == parent;
    }
    return false;
}

bool KateFileTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction, int row, int, const QModelIndex &parent)
{
    auto md = qobject_cast<const FileTreeMimeData *>(data);
    if (!md) {
        return false;
    }

    const auto index = md->index();
    Q_ASSERT(parent == index.parent()); // move is only allowed within the same parent
    if (!index.isValid() || index.row() > rowCount(parent) || index.row() == row) {
        return false;
    }

    if (index.row() + 1 == row) {
        // beginMoveRows has crappy api. If you want to move items by +1 in the same parent,
        // then the dest should actually be 1+destIdx. so source.row + 1 is bogus and will crash
        return false;
    }

    auto parentItem = parent.isValid() ? static_cast<ProxyItemDir *>(parent.internalPointer()) : m_root;
    std::vector<ProxyItem *> &childs = parentItem->children();
    int sourceRow = index.row();

    auto result = beginMoveRows(index.parent(), index.row(), index.row(), parent, row);
    if (!result) {
        return false;
    }

    childs.insert(childs.begin() + row, childs.at(index.row()));
    if (sourceRow > row) {
        sourceRow++;
    }
    childs.erase(childs.begin() + sourceRow);
    // update row number of children
    for (size_t i = 0; i < childs.size(); i++) {
        childs[i]->m_row = int(i);
    }

    endMoveRows();
    return true;
}

QVariant KateFileTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    Q_UNUSED(orientation);
    Q_UNUSED(role);

    if (section == 0) {
        return QLatin1String("name");
    }

    return {};
}

int KateFileTreeModel::rowCount(const QModelIndex &parent) const
{
    if (!parent.isValid()) {
        return m_root->childCount();
    }

    // we only have children for column 0
    if (parent.column() != 0) {
        return 0;
    }

    const ProxyItem *item = static_cast<ProxyItem *>(parent.internalPointer());
    if (!item) {
        return 0;
    }

    return item->childCount();
}

int KateFileTreeModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return 2;
}

QModelIndex KateFileTreeModel::parent(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return {};
    }

    const ProxyItem *item = static_cast<ProxyItem *>(index.internalPointer());
    if (!item) {
        return {};
    }

    if (!item->parent()) {
        return {};
    }

    if (item->parent() == m_root) {
        return {};
    }

    return createIndex(item->parent()->row(), 0, item->parent());
}

QModelIndex KateFileTreeModel::index(int row, int column, const QModelIndex &parent) const
{
    const ProxyItem *p = nullptr;
    if (column != 0 && column != 1) {
        return {};
    }

    if (!parent.isValid()) {
        p = m_root;
    } else {
        p = static_cast<ProxyItem *>(parent.internalPointer());
    }

    if (!p) {
        return {};
    }

    if (row < 0 || row >= p->childCount()) {
        return {};
    }

    return createIndex(row, column, p->child(row));
}

bool KateFileTreeModel::hasChildren(const QModelIndex &parent) const
{
    if (!parent.isValid()) {
        return m_root->childCount() > 0;
    }

    // we only have children for column 0
    if (parent.column() != 0) {
        return false;
    }

    const ProxyItem *item = static_cast<ProxyItem *>(parent.internalPointer());
    if (!item) {
        return false;
    }

    return item->childCount() > 0;
}

ProxyItem *KateFileTreeModel::itemForIndex(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return m_root;
    }

    auto *item = static_cast<ProxyItem *>(index.internalPointer());
    if (!item) {
        return nullptr;
    }
    return item;
}

bool KateFileTreeModel::isDir(const QModelIndex &index) const
{
    if (ProxyItem *item = itemForIndex(index)) {
        return item->flag(ProxyItem::Dir) && !item->flag(ProxyItem::Widget);
    }
    return false;
}

bool KateFileTreeModel::isWidgetDir(const QModelIndex &index) const
{
    if (ProxyItem *item = itemForIndex(index)) {
        return item->flag(ProxyItem::Dir) && item->flag(ProxyItem::Widget);
    }
    return false;
}

bool KateFileTreeModel::listMode() const
{
    return m_listMode;
}

void KateFileTreeModel::setListMode(bool lm)
{
    if (lm != m_listMode) {
        m_listMode = lm;

        clearModel();
        initModel();
    }
}

void KateFileTreeModel::documentOpened(KTextEditor::Document *doc)
{
    auto *item = new ProxyItem(QString());
    item->setDoc(doc);

    updateItemPathAndHost(item);
    setupIcon(item);
    handleInsert(item);
    m_docmap[doc] = item;
    connectDocument(doc);
}

void KateFileTreeModel::documentsOpened(const QList<KTextEditor::Document *> &docs)
{
    for (KTextEditor::Document *doc : docs) {
        if (m_docmap.contains(doc)) {
            documentNameChanged(doc);
        } else {
            documentOpened(doc);
        }
    }
}

void KateFileTreeModel::documentModifiedChanged(KTextEditor::Document *doc)
{
    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return;
    }

    ProxyItem *item = it.value();

    if (doc->isModified()) {
        item->setFlag(ProxyItem::Modified);
    } else {
        item->clearFlag(ProxyItem::Modified);
        item->clearFlag(ProxyItem::ModifiedExternally);
        item->clearFlag(ProxyItem::DeletedExternally);
    }

    setupIcon(item);

    const QModelIndex idx = createIndex(item->row(), 0, item);
    Q_EMIT dataChanged(idx, idx);
}

void KateFileTreeModel::documentModifiedOnDisc(KTextEditor::Document *doc, bool modified, KTextEditor::Document::ModifiedOnDiskReason reason)
{
    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return;
    }

    ProxyItem *item = it.value();

    // This didn't do what I thought it did, on an ignore
    // we'd get !modified causing the warning icons to disappear
    if (!modified) {
        item->clearFlag(ProxyItem::ModifiedExternally);
        item->clearFlag(ProxyItem::DeletedExternally);
    } else {
        if (reason == KTextEditor::Document::OnDiskDeleted) {
            item->setFlag(ProxyItem::DeletedExternally);
        } else if (reason == KTextEditor::Document::OnDiskModified) {
            item->setFlag(ProxyItem::ModifiedExternally);
        } else if (reason == KTextEditor::Document::OnDiskCreated) {
            // with out this, on "reload" we don't get the icons removed :(
            item->clearFlag(ProxyItem::ModifiedExternally);
            item->clearFlag(ProxyItem::DeletedExternally);
        }
    }

    setupIcon(item);

    const QModelIndex idx = createIndex(item->row(), 0, item);
    Q_EMIT dataChanged(idx, idx);
}

void KateFileTreeModel::documentActivated(const KTextEditor::Document *doc)
{
    if (!m_shadingEnabled) {
        return;
    }

    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return;
    }

    ProxyItem *item = it.value();

    m_viewHistory.erase(std::remove(m_viewHistory.begin(), m_viewHistory.end(), item), m_viewHistory.end());
    m_viewHistory.insert(m_viewHistory.begin(), item);

    while (m_viewHistory.size() > MaxHistoryItems) {
        m_viewHistory.pop_back();
    }

    updateBackgrounds();
}

void KateFileTreeModel::documentEdited(const KTextEditor::Document *doc)
{
    if (!m_shadingEnabled) {
        return;
    }

    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return;
    }

    ProxyItem *item = it.value();

    m_editHistory.erase(std::remove(m_editHistory.begin(), m_editHistory.end(), item), m_editHistory.end());
    m_editHistory.insert(m_editHistory.begin(), item);

    while (m_editHistory.size() > MaxHistoryItems) {
        m_editHistory.pop_back();
    }

    updateBackgrounds();
}

class EditViewCount
{
public:
    EditViewCount() = default;
    int edit = 0;
    int view = 0;
};

void KateFileTreeModel::updateBackgrounds(bool force)
{
    if (!m_shadingEnabled && !force) {
        return;
    }

    std::unordered_map<ProxyItem *, EditViewCount> helper;
    helper.reserve(m_viewHistory.size() + m_editHistory.size());

    int i = 1;
    for (ProxyItem *item : std::as_const(m_viewHistory)) {
        helper[item].view = i;
        i++;
    }

    i = 1;
    for (ProxyItem *item : std::as_const(m_editHistory)) {
        helper[item].edit = i;
        i++;
    }

    std::unordered_map<ProxyItem *, QBrush> oldBrushes = std::move(m_brushes);

    const int hc = (int)m_viewHistory.size();
    const int ec = (int)m_editHistory.size();
    const QColor base = QPalette().color(QPalette::Base);

    for (const auto &[item, editViewCount] : helper) {
        QColor shade(m_viewShade);
        QColor eshade(m_editShade);

        if (editViewCount.edit > 0) {
            int v = hc - editViewCount.view;
            int e = ec - editViewCount.edit + 1;

            e = e * e;

            const int n = qMax(v + e, 1);

            shade.setRgb(((shade.red() * v) + (eshade.red() * e)) / n,
                         ((shade.green() * v) + (eshade.green() * e)) / n,
                         ((shade.blue() * v) + (eshade.blue() * e)) / n);
        }

        // blend in the shade color; latest is most colored.
        const double t = double(hc - editViewCount.view + 1) / double(hc);

        m_brushes[item] = QBrush(KColorUtils::mix(base, shade, t));
    }

    for (const auto &[item, brush] : m_brushes) {
        oldBrushes.erase(item);
        const QModelIndex idx = createIndex(item->row(), 0, item);
        Q_EMIT dataChanged(idx, idx);
    }

    for (const auto &[item, brush] : oldBrushes) {
        const QModelIndex idx = createIndex(item->row(), 0, item);
        Q_EMIT dataChanged(idx, idx);
    }
}

void KateFileTreeModel::handleEmptyParents(ProxyItemDir *item)
{
    Q_ASSERT(item != nullptr);

    if (!item->parent()) {
        return;
    }

    ProxyItemDir *parent = item->parent();

    while (parent) {
        if (!item->childCount()) {
            const QModelIndex parent_index = (parent == m_root) ? QModelIndex() : createIndex(parent->row(), 0, parent);
            beginRemoveRows(parent_index, item->row(), item->row());
            parent->removeChild(item);
            endRemoveRows();
            delete item;
        } else {
            // breakout early, if this node isn't empty, there's no use in checking its parents
            return;
        }

        item = parent;
        parent = item->parent();
    }
}

void KateFileTreeModel::documentClosed(KTextEditor::Document *doc)
{
    disconnect(doc, &KTextEditor::Document::documentNameChanged, this, &KateFileTreeModel::documentNameChanged);
    disconnect(doc, &KTextEditor::Document::documentUrlChanged, this, &KateFileTreeModel::documentNameChanged);
    disconnect(doc, &KTextEditor::Document::modifiedChanged, this, &KateFileTreeModel::documentModifiedChanged);
    disconnect(doc, &KTextEditor::Document::modifiedOnDisk, this, &KateFileTreeModel::documentModifiedOnDisc);
    disconnect(doc, &KTextEditor::Document::reloaded, this, &KateFileTreeModel::documentModifiedChanged);

    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return;
    }

    if (m_shadingEnabled) {
        ProxyItem *toRemove = it.value();
        m_brushes.erase(toRemove);
        m_viewHistory.erase(std::remove(m_viewHistory.begin(), m_viewHistory.end(), toRemove), m_viewHistory.end());
        m_editHistory.erase(std::remove(m_editHistory.begin(), m_editHistory.end(), toRemove), m_editHistory.end());
    }

    ProxyItem *node = it.value();
    ProxyItemDir *parent = node->parent();

    const QModelIndex parent_index = (parent == m_root) ? QModelIndex() : createIndex(parent->row(), 0, parent);
    beginRemoveRows(parent_index, node->row(), node->row());
    node->parent()->removeChild(node);
    endRemoveRows();

    delete node;
    handleEmptyParents(parent);

    m_docmap.erase(it);
}

void KateFileTreeModel::documentNameChanged(KTextEditor::Document *doc)
{
    auto it = m_docmap.find(doc);
    if (it == m_docmap.end()) {
        return;
    }

    handleNameChange(it.value());
    Q_EMIT triggerViewChangeAfterNameChange(); // FIXME: heh, non-standard signal?
}

ProxyItemDir *KateFileTreeModel::findRootNode(const QString &name, const int r) const
{
    const std::vector<ProxyItem *> &rootChildren = m_root->children();
    for (ProxyItem *item : rootChildren) {
        if (!item->flag(ProxyItem::Dir)) {
            continue;
        }

        // make sure we're actually matching against the right dir,
        // previously the check below would match /foo/xy against /foo/x
        // and return /foo/x rather than /foo/xy
        // this seems a bit hackish, but is the simplest way to solve the
        // current issue.
        QString path = item->path().section(u'/', 0, -r) + u'/';

        if (name.startsWith(path)) {
            return static_cast<ProxyItemDir *>(item);
        }
    }

    return nullptr;
}

ProxyItemDir *KateFileTreeModel::findChildNode(const ProxyItemDir *parent, const QString &name)
{
    Q_ASSERT(parent != nullptr);
    Q_ASSERT(!name.isEmpty());

    if (!parent->childCount()) {
        return nullptr;
    }

    for (ProxyItem *item : parent->children()) {
        if (!item->flag(ProxyItem::Dir)) {
            continue;
        }

        if (item->display() == name) {
            return static_cast<ProxyItemDir *>(item);
        }
    }

    return nullptr;
}

void KateFileTreeModel::insertItemInto(ProxyItemDir *root, ProxyItem *item, bool move, ProxyItemDir **moveDest)
{
    Q_ASSERT(root != nullptr);
    Q_ASSERT(item != nullptr);

    QString tail = item->path();
    tail.remove(0, root->path().length());
    QStringList parts = tail.split(u'/', Qt::SkipEmptyParts);
    ProxyItemDir *ptr = root;
    QStringList current_parts;
    current_parts.append(root->path());

    // seems this can be empty, see bug 286191
    if (!parts.isEmpty()) {
        parts.pop_back();
    }

    for (const QString &part : std::as_const(parts)) {
        current_parts.append(part);
        ProxyItemDir *find = findChildNode(ptr, part);
        if (!find) {
            // One of child's parent dir didn't exist, create it
            // This is like you have a folder:
            // folder/dir/dir2/a.c
            // folder/b.c
            // if only a.c is opened, then we only show dir2,
            // but if you open b.c, we now need to create a new root i.e., "folder"
            // and since a.c lives in a child dir, we create "dir" as well.
            const QString new_name = current_parts.join(u'/');
            const QModelIndex parent_index = (ptr == m_root) ? QModelIndex() : createIndex(ptr->row(), 0, ptr);
            beginInsertRows(parent_index, ptr->childCount(), ptr->childCount());
            ptr = new ProxyItemDir(new_name, ptr);
            endInsertRows();
        } else {
            ptr = find;
        }
    }

    if (!move) {
        // We are not moving rows, this is all new stuff
        const QModelIndex parent_index = (ptr == m_root) ? QModelIndex() : createIndex(ptr->row(), 0, ptr);
        beginInsertRows(parent_index, ptr->childCount(), ptr->childCount());
        ptr->addChild(item);
        endInsertRows();
    } else {
        // We are moving
        *moveDest = ptr;
    }
}

void KateFileTreeModel::handleInsert(ProxyItem *item)
{
    Q_ASSERT(item != nullptr);

    if (m_listMode || item->flag(ProxyItem::Empty)) {
        beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());
        m_root->addChild(item);
        endInsertRows();
        return;
    }

    // case (item.path > root.path)
    if (ProxyItemDir *root = findRootNode(item->path()); root) {
        insertItemInto(root, item);
        return;
    }

    // trim off trailing file and dir
    QString base = item->path().section(u'/', 0, -2);

    // create new root
    auto *new_root = new ProxyItemDir(base);
    new_root->setHost(item->host());

    // add new root to m_root
    beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());
    m_root->addChild(new_root);
    endInsertRows();

    // same fix as in findRootNode, try to match a full dir, instead of a partial path
    base += u'/';

    // try and merge existing roots with the new root node (new_root.path < root.path)
    // Iterate over a copy as the list is updated
    const std::vector<ProxyItem *> rootChildren = m_root->children();
    for (ProxyItem *root : rootChildren) {
        if (root == new_root || !root->flag(ProxyItem::Dir)) {
            continue;
        }

        if (root->path().startsWith(base)) {
            // We can't move directly because this items parent directories might not be in the model yet
            // so check and insert them first. Then find out where we need to move
            ProxyItemDir *moveDest = nullptr;
            insertItemInto(new_root, root, true, &moveDest);

            const QModelIndex destParent = (moveDest == m_root) ? QModelIndex() : createIndex(moveDest->row(), 0, moveDest);
            // We are moving from topLevel root to maybe some child node
            // We MUST move, otherwise if "root" was expanded, it will be collapsed if we did a remove + insert instead.
            // This is the reason for added complexity in insertItemInto
            if (beginMoveRows(QModelIndex(), root->row(), root->row(), destParent, moveDest->childCount())) {
                m_root->removeChild(root);
                moveDest->addChild(root);
                endMoveRows();
            } else {
                Q_ASSERT_X(false, Q_FUNC_INFO, "Failed to move row");
            }
        }
    }

    // add item to new root
    // have to call begin/endInsertRows here, or the new item won't show up.
    const QModelIndex new_root_index = createIndex(new_root->row(), 0, new_root);
    beginInsertRows(new_root_index, new_root->childCount(), new_root->childCount());
    new_root->addChild(item);
    endInsertRows();

    handleDuplicitRootDisplay(new_root);
}

void KateFileTreeModel::handleDuplicitRootDisplay(ProxyItemDir *init)
{
    QStack<ProxyItemDir *> rootsToCheck;
    rootsToCheck.push(init);

    // make sure the roots don't match (recursively)
    while (!rootsToCheck.isEmpty()) {
        ProxyItemDir *check_root = rootsToCheck.pop();

        if (check_root->parent() != m_root) {
            continue;
        }

        // iterate on copy
        const std::vector<ProxyItem *> rootChildren = m_root->children();
        for (ProxyItem *root : rootChildren) {
            if (root == check_root || !root->flag(ProxyItem::Dir)) {
                continue;
            }

            if (check_root->display() == root->display()) {
                bool changed = false;
                bool check_root_removed = false;

                const QString rdir = root->path().section(u'/', 0, -2);
                if (!rdir.isEmpty()) {
                    beginRemoveRows(QModelIndex(), root->row(), root->row());
                    m_root->removeChild(root);
                    endRemoveRows();

                    auto *irdir = new ProxyItemDir(rdir);
                    beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());
                    m_root->addChild(irdir);
                    endInsertRows();

                    insertItemInto(irdir, root);

                    // iterate on copy
                    const std::vector<ProxyItem *> children = m_root->children();
                    for (ProxyItem *node : children) {
                        if (node == irdir || !root->flag(ProxyItem::Dir)) {
                            continue;
                        }

                        const QString xy = rdir + u'/';
                        if (node->path().startsWith(xy)) {
                            beginRemoveRows(QModelIndex(), node->row(), node->row());
                            // check_root_removed must be sticky
                            check_root_removed = check_root_removed || (node == check_root);
                            m_root->removeChild(node);
                            endRemoveRows();
                            insertItemInto(irdir, node);
                        }
                    }

                    rootsToCheck.push(irdir);
                    changed = true;
                }

                if (!check_root_removed) {
                    const QString nrdir = check_root->path().section(u'/', 0, -2);
                    if (!nrdir.isEmpty()) {
                        beginRemoveRows(QModelIndex(), check_root->row(), check_root->row());
                        m_root->removeChild(check_root);
                        endRemoveRows();

                        auto *irdir = new ProxyItemDir(nrdir);
                        beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());
                        m_root->addChild(irdir);
                        endInsertRows();

                        insertItemInto(irdir, check_root);

                        rootsToCheck.push(irdir);
                        changed = true;
                    }
                }

                if (changed) {
                    break; // restart
                }
            }
        } // for root
    }
}

void KateFileTreeModel::handleNameChange(ProxyItem *item)
{
    Q_ASSERT(item != nullptr);
    Q_ASSERT(item->parent());

    updateItemPathAndHost(item);

    if (m_listMode) {
        const QModelIndex idx = createIndex(item->row(), 0, item);
        setupIcon(item);
        Q_EMIT dataChanged(idx, idx);
        return;
    }

    // in either case (new/change) we want to remove the item from its parent
    ProxyItemDir *parent = item->parent();

    const QModelIndex parent_index = (parent == m_root) ? QModelIndex() : createIndex(parent->row(), 0, parent);
    beginRemoveRows(parent_index, item->row(), item->row());
    parent->removeChild(item);
    endRemoveRows();

    // clear all but Empty flag
    if (item->flag(ProxyItem::Empty)) {
        item->setFlags(ProxyItem::Empty);
    } else {
        item->setFlags(ProxyItem::None);
    }

    setupIcon(item);
    handleInsert(item);

    handleEmptyParents(parent);
}

void KateFileTreeModel::updateItemPathAndHost(ProxyItem *item)
{
    const KTextEditor::Document *doc = item->doc();
    Q_ASSERT(doc); // this method should not be called at directory items

    QString path = doc->url().path();
    QString host;
    if (doc->url().isEmpty()) {
        path = doc->documentName();
        item->setFlag(ProxyItem::Empty);
    } else {
        item->clearFlag(ProxyItem::Empty);
        host = doc->url().host();
        if (!host.isEmpty()) {
            path = QStringLiteral("[%1]%2").arg(host, path);
        }
    }

    // for some reason we get useless name changes [should be fixed in 5.0]
    if (item->path() == path) {
        return;
    }

    item->setPath(path);
    item->setHost(host);
}

void KateFileTreeModel::setupIcon(ProxyItem *item)
{
    Q_ASSERT(item != nullptr);
    Q_ASSERT(item->doc() != nullptr);

    // use common method as e.g. in tabbar, too
    item->setIcon(Utils::iconForDocument(item->doc()));
}

void KateFileTreeModel::resetHistory()
{
    QSet<ProxyItem *> list{m_viewHistory.begin(), m_viewHistory.end()};
    list += QSet<ProxyItem *>{m_editHistory.begin(), m_editHistory.end()};

    m_viewHistory.clear();
    m_editHistory.clear();
    m_brushes.clear();

    for (ProxyItem *item : std::as_const(list)) {
        QModelIndex idx = createIndex(item->row(), 0, item);
        Q_EMIT dataChanged(idx, idx, QList<int>(1, Qt::BackgroundRole));
    }
}

void KateFileTreeModel::addWidget(QWidget *w)
{
    if (!w) {
        return;
    }

    const QModelIndex parentIdx = createIndex(m_widgetsRoot->row(), 0, m_widgetsRoot);
    beginInsertRows(parentIdx, m_widgetsRoot->childCount(), m_widgetsRoot->childCount());
    auto *item = new ProxyItem(w->windowTitle());
    item->setFlag(ProxyItem::Widget);
    item->setIcon(w->windowIcon());
    item->setWidget(w);
    m_widgetsRoot->addChild(item);
    endInsertRows();
}

void KateFileTreeModel::removeWidget(QWidget *w)
{
    ProxyItem *item = nullptr;
    const std::vector<ProxyItem *> &items = m_widgetsRoot->children();
    for (ProxyItem *it : items) {
        if (it->widget() == w) {
            item = it;
            break;
        }
    }
    if (!item) {
        return;
    }

    const QModelIndex parentIdx = createIndex(m_widgetsRoot->row(), 0, m_widgetsRoot);
    beginRemoveRows(parentIdx, item->row(), item->row());
    m_widgetsRoot->removeChild(item);
    endRemoveRows();
    delete item;
}

#include "katefiletreemodel.moc"
#include "moc_katefiletreemodel.cpp"
