/*
 * This file is part of smolbote. It's copyrighted by the contributors recorded
 * in the version control history of the file, available from its original
 * location: git://neueland.iserlohn-fortress.net/smolbote.git
 *
 * SPDX-License-Identifier: GPL-3.0
 */

#include "bookmarksmodel.h"
#include <QStyle>

BookmarksModel::BookmarksModel(QStyle *style, QObject *parent) : QAbstractItemModel(parent)
{
    folderIcon.addPixmap(style->standardPixmap(QStyle::SP_DirOpenIcon), QIcon::Normal, QIcon::On);
    folderIcon.addPixmap(style->standardPixmap(QStyle::SP_DirClosedIcon), QIcon::Normal, QIcon::Off);
    bookmarkIcon.addPixmap(style->standardPixmap(QStyle::SP_FileIcon));

    // create a root item
    m_rootItem = new BookmarkItem(BookmarkItem::Root, nullptr);
    m_rootItem->title = tr("Title");
    m_rootItem->href = tr("href");
}

BookmarksModel::~BookmarksModel()
{
    delete m_rootItem;
}

void BookmarksModel::setRoot(BookmarkItem *root)
{
    Q_CHECK_PTR(root);

    delete m_rootItem;
    m_rootItem = root;
}

QVariant BookmarksModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(orientation == Qt::Horizontal && role == Qt::DisplayRole) {
        if(section == 0) {
            return m_rootItem->title;
        } else if(section == 1) {
            return m_rootItem->href;
        } else {
            return QVariant();
        }
    }

    return QVariant();
}

QModelIndex BookmarksModel::index(BookmarkItem *node, int column) const
{
    BookmarkItem *parentItem = node->parentItem();
    if(!parentItem) {
        return QModelIndex();
    }

    return createIndex(parentItem->childIndex(node), column, node);
}

QModelIndex BookmarksModel::index(int row, int column, const QModelIndex &parent) const
{
    // invalid item requested
    if (!hasIndex(row, column, parent)) {
        return QModelIndex();
    }

    // index exists
    BookmarkItem *parentItem;
    if(parent.isValid()) {
        parentItem = static_cast<BookmarkItem*>(parent.internalPointer());
    } else {
        parentItem = m_rootItem;
    }

    BookmarkItem *childItem = parentItem->child(row);
    if(childItem) {
        return createIndex(row, column, childItem);
    }
    return QModelIndex();
}

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

    BookmarkItem *childItem = static_cast<BookmarkItem*>(index.internalPointer());
    BookmarkItem *parentItem = childItem->parentItem();

    if(parentItem == m_rootItem) {
        return QModelIndex();
    }

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

int BookmarksModel::rowCount(const QModelIndex &parent) const
{
    if(parent.column() > 0) {
        return 0;
    }

    BookmarkItem *parentItem;
    if(!parent.isValid()) {
        parentItem = m_rootItem;
    } else {
        parentItem = static_cast<BookmarkItem*>(parent.internalPointer());
    }

    return parentItem->childCount();
}

int BookmarksModel::columnCount(const QModelIndex &parent) const
{
    if(parent.isValid()) {
        return static_cast<BookmarkItem*>(parent.internalPointer())->columnCount();
    } else {
        return m_rootItem->columnCount();
    }
}

QVariant BookmarksModel::data(const QModelIndex &index, int role) const
{
    // get data of invalid index?
    if (!index.isValid()) {
        return QVariant();
    }

    const BookmarkItem *item = static_cast<BookmarkItem *>(index.internalPointer());
    switch (role) {
    case Qt::DisplayRole:
    case Qt::EditRole:
        if(index.column() == 0) {
            return item->title;
        } else if(index.column() == 1) {
            return item->href;
        } else {
            return QVariant();
        }

    case Qt::DecorationRole:
        if(index.column() == 0) {
            if(item->type() == BookmarkItem::Folder) {
                return folderIcon;
            } else if(item->type() == BookmarkItem::Bookmark) {
                return bookmarkIcon;
            } else {
                return QVariant();
            }
        } else {
            return QVariant();
        }

    case OpenUrlRole:
        if(item->type() == BookmarkItem::Bookmark) {
            return item->href;
        } else {
            return QVariant();
        }

    default:
        return QVariant();
    }
}

bool BookmarksModel::hasChildren(const QModelIndex &parent) const
{
    if(!parent.isValid()) {
        return true;
    }

    const BookmarkItem *parentItem = static_cast<BookmarkItem *>(parent.internalPointer());
    return (parentItem->type() == BookmarkItem::Folder);
}

QModelIndexList BookmarksModel::match(const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags) const
{
    QModelIndexList list;

    // search root
    BookmarkItem *searchRoot;
    if(!start.isValid()) {
        searchRoot = m_rootItem;
    } else {
        searchRoot = static_cast<BookmarkItem *>(start.internalPointer());
    }

    // iterate through searchRoot children
    for(int i = 0; i < searchRoot->childCount(); ++i) {
        BookmarkItem *item = searchRoot->child(i);
        if(item->type() == BookmarkItem::Bookmark) {
            if(item->href.contains(value.toString())) {
                list.append(index(item, 1));
            }
        } else if(item->type() == BookmarkItem::Folder) {
            list.append(match(index(item), role, value, hits, flags));
        }
    }


    return list;
}