/***************************************************************************
 *   Copyright (C) 2014 by Eike Hein <hein@kde.org>                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
 ***************************************************************************/

#include "positioner.h"
#include "foldermodel.h"

#include <QDebug>

Positioner::Positioner(QObject *parent): QAbstractItemModel(parent)
, m_enabled(false)
, m_folderModel(0)
, m_perStripe(0)
, m_pendingPositionsUpdate(false)
, m_applyPositions(false)
, m_resetting(false)
, m_lastIndex(-1)
, m_ignoreNextTransaction(false)
{
}

Positioner::~Positioner()
{
}

bool Positioner::enabled() const
{
    return m_enabled;
}

void Positioner::setEnabled(bool enabled)
{
    if (m_enabled != enabled) {
        beginResetModel();

        m_enabled = enabled;

        if (enabled) {
            initMaps();
        }

        endResetModel();

        emit enabledChanged();

        if (!m_pendingPositionsUpdate && m_folderModel->rowCount()) {
            m_pendingPositionsUpdate = true;
            QMetaObject::invokeMethod(this, "updatePositions", Qt::QueuedConnection);
        }
    }
}

FolderModel* Positioner::folderModel() const
{
    return m_folderModel;
}

void Positioner::setFolderModel(QObject *folderModel)
{
    if (m_folderModel != folderModel) {
        beginResetModel();

        if (m_folderModel) {
            disconnectSignals(m_folderModel);
        }

        m_folderModel = qobject_cast<FolderModel *>(folderModel);
        connect(m_folderModel, SIGNAL(urlChanged()), this, SLOT(reset()), Qt::UniqueConnection);

        if (m_folderModel) {
            connectSignals(m_folderModel);
        }

        endResetModel();

        emit folderModelChanged();
    }
}

int Positioner::perStripe() const
{
    return m_perStripe;
}

void Positioner::setPerStripe(int perStripe)
{
    if (m_perStripe != perStripe) {
        m_perStripe = perStripe;

        emit perStripeChanged();

        if (m_enabled && m_perStripe > 0) {
            applyPositions();

            if (!m_pendingPositionsUpdate) {
                m_pendingPositionsUpdate = true;
                QMetaObject::invokeMethod(this, "updatePositions", Qt::QueuedConnection);
            }
        }
    }
}

QStringList Positioner::positions() const
{
    return m_positions;
}

void Positioner::setPositions(QStringList positions)
{
    if (m_positions != positions) {
        m_positions = positions;

        emit positionsChanged();
    }
}

int Positioner::map(int row) const
{
    if (m_enabled) {
        if (m_proxyToSource.contains(row)) {
            return m_proxyToSource.value(row);
        } else {
            return -1;
        }
    }

    return row;
}

bool Positioner::isBlank(int row) const
{
    if (!m_enabled && m_folderModel) {
        return m_folderModel->isBlank(row);
    }

    if (m_proxyToSource.contains(row) && !m_folderModel->isBlank(m_proxyToSource.value(row))) {
        return false;
    }

    return true;
}

int Positioner::indexForUrl(const QUrl &url) const
{
    if (!m_folderModel) {
        return -1;
    }

    const QString &name = url.fileName();

    int sourceIndex = -1;

    // TODO Optimize.
    for (int i = 0; i < m_folderModel->rowCount(); ++i) {
        if (m_folderModel->data(m_folderModel->index(i, 0), FolderModel::FileNameRole).toString() == name) {
            sourceIndex = i;

            break;
        }
    }

    if (m_sourceToProxy.contains(sourceIndex)) {
        return m_sourceToProxy.value(sourceIndex);
    }

    return -1;
}

QHash< int, QByteArray > Positioner::roleNames() const
{
    if (m_folderModel) {
        return m_folderModel->roleNames();
    }

    return QAbstractItemModel::roleNames();
}

QModelIndex Positioner::index(int row, int column, const QModelIndex &parent) const
{
    if (parent.isValid()) {
        return QModelIndex();
    }

    return createIndex(row, column);
}

QModelIndex Positioner::parent(const QModelIndex &index) const
{
    if (m_folderModel) {
        m_folderModel->parent(index);
    }

    return QModelIndex();
}

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

    if (m_folderModel) {
        if (m_enabled) {
            if (m_proxyToSource.contains(index.row())) {
                return m_folderModel->data(m_folderModel->index(m_proxyToSource.value(index.row()), 0), role);
            } else if (role == FolderModel::BlankRole) {
                return true;
            }
        } else {
            return m_folderModel->data(m_folderModel->index(index.row(), 0), role);
        }
    }

    return QVariant();
}

int Positioner::rowCount(const QModelIndex& parent) const
{
    if (m_folderModel) {
        if (m_enabled) {
            return lastIndex() + 1;
        } else {
            return m_folderModel->rowCount(parent);
        }
    }

    return 0;
}

int Positioner::columnCount(const QModelIndex& parent) const
{
    Q_UNUSED(parent)

    if (m_folderModel) {
        return 1;
    }

    return 0;
}

void Positioner::reset()
{
    m_resetting = true;

    beginResetModel();

    initMaps();

    m_positions = QStringList();
    emit positionsChanged();

    endResetModel();
}

void Positioner::move(int from, int to) {
    if (!m_proxyToSource.contains(from) || from == to) {
        return;
    }

    if (to == -1) {
        to = firstFreeRow();

        if (to == -1) {
            to = lastIndex() + 1;
        }
    }

    if (!isBlank(to)) {
        return;
    }

    int oldCount = rowCount();

    int sourceRow = m_proxyToSource.value(from);
    m_proxyToSource.remove(from);
    m_proxyToSource.insert(to, sourceRow);
    m_lastIndex = -1;
    m_sourceToProxy.insert(sourceRow, to);

    const QModelIndex &fromIdx = index(from, 0);
    emit dataChanged(fromIdx, fromIdx);

    if (to < oldCount) {
        const QModelIndex &toIdx = index(to, 0);
        emit dataChanged(toIdx, toIdx);
    } else {
        beginInsertRows(QModelIndex(), oldCount, to);
        endInsertRows();
    }

    int newCount = rowCount();

    if (newCount < oldCount) {
        beginRemoveRows(QModelIndex(), newCount, oldCount - 1);
        endRemoveRows();
    }

    if (!m_pendingPositionsUpdate) {
        m_pendingPositionsUpdate = true;
        QMetaObject::invokeMethod(this, "updatePositions", Qt::QueuedConnection);
    }
}

void Positioner::updatePositions()
{
    if (m_perStripe < 1) {
        m_pendingPositionsUpdate = false;

        return;
    }

    QStringList positions;

    if (m_enabled && !m_proxyToSource.isEmpty()) {
        positions.append(QString::number((1 + ((rowCount() - 1) / m_perStripe))));
        positions.append(QString::number(m_perStripe));

        QHashIterator<int, int> it(m_proxyToSource);

        while (it.hasNext()) {
            it.next();

            const QString &name = m_folderModel->data(m_folderModel->index(it.value(), 0),
                FolderModel::UrlRole).toString();

            if (name.isEmpty()) {
                qDebug() << it.value() << "Source model doesn't know this index!";

                return;
            }

            positions.append(name);
            positions.append(QString::number(qMax(0, it.key() / m_perStripe)));
            positions.append(QString::number(qMax(0, it.key() % m_perStripe)));
        }
    }

    setPositions(positions);

    m_pendingPositionsUpdate = false;
}

void Positioner::sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight,
    const QVector<int>& roles)
{
    if (m_enabled) {
        int start = topLeft.row();
        int end = bottomRight.row();

        for (int i = start; i <= end; ++i) {
            if (m_sourceToProxy.contains(i)) {
                const QModelIndex &idx = index(m_sourceToProxy.value(i), 0);

                emit dataChanged(idx, idx);
            }
        }
    } else {
        emit dataChanged(topLeft, bottomRight, roles);
    }
}

void Positioner::sourceModelAboutToBeReset()
{
    emit beginResetModel();
}

void Positioner::sourceModelReset()
{
    emit endResetModel();
}

void Positioner::sourceRowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
{
    if (m_enabled) {
        if (m_sourceToProxy.isEmpty()) {
            if (m_positions.isEmpty()) {
                emit beginInsertRows(parent, start, end);

                initMaps(end);
            } else {
                m_applyPositions = true;
            }

            return;
        }

        int free = -1;
        int rest = -1;

        for (int i = start; i <= end; ++i) {
            free = firstFreeRow();

            if (free != -1) {
                m_proxyToSource.insert(free, i);
                m_lastIndex = -1;
                m_sourceToProxy.insert(i, free);
                m_pendingChanges << createIndex(free, 0);
            } else {
                rest = i;
                break;
            }
        }

        if (rest != -1) {
            int firstNew = lastIndex() + 1;
            int remainder = (end - rest);

            beginInsertRows(parent, firstNew, firstNew + remainder);

            for (int i = 0; i <= remainder; ++i) {
                m_proxyToSource.insert(firstNew + i, rest +i);
                m_lastIndex = -1;
                m_sourceToProxy.insert(rest + i, firstNew + i);
            }
        } else {
            m_ignoreNextTransaction = true;
        }
    } else {
        emit beginInsertRows(parent, start, end);
    }
}

void Positioner::sourceRowsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart,
    int sourceEnd, const QModelIndex& destinationParent, int destinationRow)
{
    qDebug();

    emit beginMoveRows(sourceParent, sourceStart, sourceEnd, destinationParent, destinationRow);
}

void Positioner::sourceRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
{
    if (m_enabled) {
        int oldLast = lastIndex();

        for (int i = first; i <= last; ++i) {
            int proxyRow = m_sourceToProxy.take(i);
            m_proxyToSource.remove(proxyRow);

            QHash<int, int> newProxyToSource;
            QHashIterator<int, int> it(m_proxyToSource);

            while (it.hasNext()) {
                it.next();

                if (it.value() > i) {
                    newProxyToSource.insert(it.key(), it.value() - 1);
                } else {
                    newProxyToSource.insert(it.key(), it.value());
                }
            }

            m_proxyToSource = newProxyToSource;
            m_lastIndex = -1;

            QHash<int, int> newSourceToProxy;
            QHashIterator<int, int> it2(m_sourceToProxy);

            while (it2.hasNext()) {
                it2.next();

                if (it2.key() > i) {
                    newSourceToProxy.insert(it2.key() - 1, it2.value());
                } else {
                    newSourceToProxy.insert(it2.key(), it2.value());
                }
            }

            m_sourceToProxy = newSourceToProxy;

            m_pendingChanges << createIndex(proxyRow, 0);
        }

        int newLast = lastIndex();

        if (oldLast > newLast) {
            int diff = oldLast - newLast;
            beginRemoveRows(QModelIndex(), ((oldLast - diff) + 1), oldLast);
        } else {
            m_ignoreNextTransaction = true;
        }
    } else {
        emit beginRemoveRows(parent, first, last);
    }
}

void Positioner::sourceRowsInserted(const QModelIndex &parent, int first, int last)
{
    Q_UNUSED(parent)
    Q_UNUSED(first)
    Q_UNUSED(last)

    if (!m_ignoreNextTransaction) {
        if (!m_applyPositions) {
            emit endInsertRows();
        } else {
            if (m_perStripe > 0) {
                applyPositions();
            }
        }
    } else {
        m_ignoreNextTransaction = false;
    }

    flushPendingChanges();

    if (!m_pendingPositionsUpdate && !m_applyPositions) {
        m_pendingPositionsUpdate = true;
        QMetaObject::invokeMethod(this, "updatePositions", Qt::QueuedConnection);
    }
}

void Positioner::sourceRowsMoved(const QModelIndex &sourceParent, int sourceStart,
    int sourceEnd, const QModelIndex &destinationParent, int destinationRow)
{
    qDebug();

    Q_UNUSED(sourceParent)
    Q_UNUSED(sourceStart)
    Q_UNUSED(sourceEnd)
    Q_UNUSED(destinationParent)
    Q_UNUSED(destinationRow)

    emit endMoveRows();
}

void Positioner::sourceRowsRemoved(const QModelIndex &parent, int first, int last)
{
    Q_UNUSED(parent)
    Q_UNUSED(first)
    Q_UNUSED(last)

    if (!m_ignoreNextTransaction) {
        emit endRemoveRows();
    } else {
        m_ignoreNextTransaction = false;
    }

    flushPendingChanges();

    if (!m_pendingPositionsUpdate) {
        m_pendingPositionsUpdate = true;
        QMetaObject::invokeMethod(this, "updatePositions", Qt::QueuedConnection);
    }
}

void Positioner::initMaps(int size)
{
    m_proxyToSource.clear();
    m_sourceToProxy.clear();

    if (size == -1) {
        size = m_folderModel->rowCount() - 1;
    }

    if (!size) {
        return;
    }

    for (int i = 0; i <= size; ++i) {
        m_proxyToSource.insert(i, i);
        m_sourceToProxy.insert(i, i);
    }

    m_lastIndex = -1;
}

int Positioner::lastIndex() const
{
    if (!m_proxyToSource.isEmpty()) {
        if (m_lastIndex != -1) {
            return m_lastIndex;
        } else {
            QList<int> keys = m_proxyToSource.keys();
            qSort(keys);
            return keys.last();
        }
    }

    return 0;
}

int Positioner::firstFreeRow() const
{
    if (!m_proxyToSource.isEmpty()) {
        int last = lastIndex();

        for (int i = 0; i <= last; ++i) {
            if (!m_proxyToSource.contains(i)) {
                return i;
            }
        }
    }

    return -1;
}

void Positioner::applyPositions()
{
    if (m_positions.size() < 5) {
        if (m_folderModel) {
            if (m_resetting) {
                m_resetting = false;
            } else {
                beginResetModel();
                m_proxyToSource.clear();
                m_sourceToProxy.clear();
                endResetModel();

                initMaps();
                beginInsertRows(QModelIndex(), 0, lastIndex());
                endInsertRows();
            }
        }

        return;
    }

    beginResetModel();
    m_proxyToSource.clear();
    m_sourceToProxy.clear();
    endResetModel();

    QStringList positions(m_positions);

    bool ok = false;

    int stripes = positions.takeFirst().toInt(&ok);
    if (!ok) { return; }
    int perStripe = positions.takeFirst().toInt(&ok);
    if (!ok) { return; }

    Q_UNUSED(stripes)
    Q_UNUSED(perStripe)

    QString name;
    int stripe = -1;
    int pos = -1;
    int sourceIndex = -1;
    int index = -1;

    QHash<QString, int> sourceIndices;

    for (int i = 0; i < m_folderModel->rowCount(); ++i) {
        sourceIndices.insert(m_folderModel->data(m_folderModel->index(i, 0),
            FolderModel::UrlRole).toString(), i);
    }

    int items = positions.count() / 3;

    QStringList leftOvers;

    for (int i = 0; i < items; ++i) {
        name = positions.takeFirst();
        stripe = positions.takeFirst().toInt(&ok);
        if (!ok) { return; }
        pos = positions.takeFirst().toInt(&ok);
        if (!ok) { return; }

        if (pos <= m_perStripe) {
            if (!sourceIndices.contains(name)) {
                continue;
            } else {
                sourceIndex = sourceIndices.value(name);
            }

            index = (stripe * m_perStripe) + pos;

            if (m_proxyToSource.contains(index)) {
                continue;
            }

            m_proxyToSource.insert(index, sourceIndex);
            m_lastIndex = -1;
            m_sourceToProxy.insert(sourceIndex, index);

            sourceIndices.remove(name);
        } else {
            leftOvers.append(name);
            leftOvers.append(QString::number(stripe));
            leftOvers.append(QString::number(pos));
        }
    }

    items = leftOvers.count() / 3;

    for (int i = 0; i < items; ++i) {
        name = leftOvers.takeFirst();
        stripe = leftOvers.takeFirst().toInt(&ok);
        if (!ok) { return; }
        pos = leftOvers.takeFirst().toInt(&ok);
        if (!ok) { return; }

        if (!sourceIndices.contains(name)) {
            continue;
        } else {
            sourceIndex = sourceIndices.take(name);
        }

        index = firstFreeRow();

        if (index == -1) {
            index = lastIndex() + 1;
        }

        m_proxyToSource.insert(index, sourceIndex);
        m_lastIndex = -1;
        m_sourceToProxy.insert(sourceIndex, index);
    }

    QHashIterator<QString, int> it(sourceIndices);

    while (it.hasNext()) {
        it.next();

        index = firstFreeRow();

        if (index == -1) {
            index = lastIndex() + 1;
        }

        m_proxyToSource.insert(index, it.value());
        m_lastIndex = -1;
        m_sourceToProxy.insert(it.value(), index);
    }

    m_applyPositions = false;

    beginInsertRows(QModelIndex(), 0, lastIndex());
    endInsertRows();
}

void Positioner::flushPendingChanges()
{
    if (m_pendingChanges.isEmpty()) {
        return;
    }

    int last = lastIndex();

    foreach (const QModelIndex &idx, m_pendingChanges) {
        if (idx.row() <= last) {
            emit dataChanged(idx, idx);
        }
    }

    m_pendingChanges.clear();
}

void Positioner::connectSignals(FolderModel* model)
{
    connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
            this, SLOT(sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)),
            Qt::UniqueConnection);
    connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
            this, SLOT(sourceRowsAboutToBeInserted(QModelIndex,int,int)),
            Qt::UniqueConnection);
    connect(model, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
            this, SLOT(sourceRowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
            Qt::UniqueConnection);
    connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
            this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)),
            Qt::UniqueConnection);
    connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
            this, SLOT(sourceRowsInserted(QModelIndex,int,int)),
            Qt::UniqueConnection);
    connect(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
            this, SLOT(sourceRowsMoved(QModelIndex,int,int,QModelIndex,int)),
            Qt::UniqueConnection);
    connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
            this, SLOT(sourceRowsRemoved(QModelIndex,int,int)),
            Qt::UniqueConnection);
}

void Positioner::disconnectSignals(FolderModel* model)
{
    disconnect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
            this, SLOT(sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)));
    disconnect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
            this, SLOT(sourceRowsAboutToBeInserted(QModelIndex,int,int)));
    disconnect(model, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
            this, SLOT(sourceRowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
    disconnect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
            this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
    disconnect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
            this, SLOT(sourceRowsInserted(QModelIndex,int,int)));
    disconnect(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
            this, SLOT(sourceRowsMoved(QModelIndex,int,int,QModelIndex,int)));
    disconnect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
            this, SLOT(sourceRowsRemoved(QModelIndex,int,int)));
}