/*
    SPDX-FileCopyrightText: 2019 Arjen Hiemstra <ahiemstra@heimr.nl>

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

#include "kcolumnheadersmodel.h"

class KColumnHeadersModelPrivate
{
public:
    QAbstractItemModel *sourceModel = nullptr;
    int sortColumn = -1;
    Qt::SortOrder sortOrder = Qt::AscendingOrder;
};

KColumnHeadersModel::KColumnHeadersModel(QObject *parent)
    : QAbstractListModel(parent)
    , d(new KColumnHeadersModelPrivate)
{
}

KColumnHeadersModel::~KColumnHeadersModel()
{
}

int KColumnHeadersModel::rowCount(const QModelIndex &parent) const
{
    if (!d->sourceModel || parent.isValid()) {
        return 0;
    }

    return d->sourceModel->columnCount();
}

QVariant KColumnHeadersModel::data(const QModelIndex &index, int role) const
{
    if (!d->sourceModel || !index.isValid()) {
        return QVariant{};
    }

    if (role == SortRole) {
        if (index.row() == d->sortColumn) {
            return d->sortOrder;
        } else {
            return QVariant{};
        }
    }

    return sourceModel()->headerData(index.row(), Qt::Horizontal, role);
}

QHash<int, QByteArray> KColumnHeadersModel::roleNames() const
{
    if (!d->sourceModel) {
        return QHash<int, QByteArray>{};
    }

    auto names = d->sourceModel->roleNames();
    names.insert(SortRole, "sort");
    return names;
}

QAbstractItemModel *KColumnHeadersModel::sourceModel() const
{
    return d->sourceModel;
}

void KColumnHeadersModel::setSourceModel(QAbstractItemModel *newSourceModel)
{
    if (newSourceModel == d->sourceModel) {
        return;
    }

    if (d->sourceModel) {
        d->sourceModel->disconnect(this);
    }

    beginResetModel();
    d->sourceModel = newSourceModel;
    endResetModel();

    if (newSourceModel) {
        connect(newSourceModel, &QAbstractItemModel::columnsAboutToBeInserted, this, [this](const QModelIndex &, int first, int last) {
            beginInsertRows(QModelIndex{}, first, last);
        });
        connect(newSourceModel, &QAbstractItemModel::columnsInserted, this, [this]() {
            endInsertRows();
        });
        connect(newSourceModel,
                &QAbstractItemModel::columnsAboutToBeMoved,
                this,
                [this](const QModelIndex &, int start, int end, const QModelIndex &, int destination) {
                    beginMoveRows(QModelIndex{}, start, end, QModelIndex{}, destination);
                });
        connect(newSourceModel, &QAbstractItemModel::columnsMoved, this, [this]() {
            endMoveRows();
        });
        connect(newSourceModel, &QAbstractItemModel::columnsAboutToBeRemoved, this, [this](const QModelIndex &, int first, int last) {
            beginRemoveRows(QModelIndex{}, first, last);
        });
        connect(newSourceModel, &QAbstractItemModel::columnsRemoved, this, [this]() {
            endRemoveRows();
        });
        connect(newSourceModel, &QAbstractItemModel::headerDataChanged, this, [this](Qt::Orientation orientation, int first, int last) {
            if (orientation == Qt::Horizontal) {
                Q_EMIT dataChanged(index(first, 0), index(last, 0));
            }
        });
        connect(newSourceModel, &QAbstractItemModel::modelAboutToBeReset, this, [this]() {
            beginResetModel();
        });
        connect(newSourceModel, &QAbstractItemModel::modelReset, this, [this]() {
            endResetModel();
        });
    }
}

int KColumnHeadersModel::sortColumn() const
{
    return d->sortColumn;
}

void KColumnHeadersModel::setSortColumn(int newSortColumn)
{
    if (newSortColumn == d->sortColumn) {
        return;
    }

    auto previousSortColumn = d->sortColumn;

    d->sortColumn = newSortColumn;

    if (previousSortColumn >= 0) {
        Q_EMIT dataChanged(index(previousSortColumn), index(previousSortColumn), {SortRole});
    }

    if (newSortColumn >= 0) {
        Q_EMIT dataChanged(index(newSortColumn), index(newSortColumn), {SortRole});
    }

    Q_EMIT sortColumnChanged();
}

Qt::SortOrder KColumnHeadersModel::sortOrder() const
{
    return d->sortOrder;
}

void KColumnHeadersModel::setSortOrder(Qt::SortOrder newSortOrder)
{
    if (newSortOrder == d->sortOrder) {
        return;
    }

    d->sortOrder = newSortOrder;

    if (d->sortColumn >= 0) {
        Q_EMIT dataChanged(index(d->sortColumn), index(d->sortColumn), {SortRole});
    }

    Q_EMIT sortOrderChanged();
}

#include "moc_kcolumnheadersmodel.cpp"