/*
    Copyright (C) 2010 Klarälvdalens Datakonsult AB,
        a KDAB Group company, info@kdab.net,
        author Stephen Kelly <stephen@kdab.com>

    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.

    This library 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 Library General Public
    License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "breadcrumbnavigationwidget.h"

#include "dynamictreemodel.h"
#include "dynamictreewidget.h"

#include <QSplitter>
#include <QListView>
#include <QTreeView>
#include <QHBoxLayout>

#include "kselectionproxymodel.h"
#include "kbreadcrumbselectionmodel.h"

#define SON(object) object->setObjectName(QStringLiteral(#object))

CurrentItemLabel::CurrentItemLabel(QAbstractItemModel *model, QWidget *parent, Qt::WindowFlags f)
    : QLabel(parent, f), m_model(model)
{
    connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(dataChanged(QModelIndex,QModelIndex)));
    connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(rowsInserted(QModelIndex,int,int)));
    connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(rowsRemoved(QModelIndex,int,int)));
    connect(model, SIGNAL(modelReset()), SLOT(modelReset()));

    if (!m_model->hasChildren()) {
        setText(QStringLiteral("No selection"));
    }
}

void CurrentItemLabel::dataChanged(const QModelIndex &, const QModelIndex &)
{
    setText(m_model->index(0, 0).data().toString());
}

void CurrentItemLabel::rowsInserted(const QModelIndex &, int, int)
{
    setText(m_model->index(0, 0).data().toString());
}

void CurrentItemLabel::rowsRemoved(const QModelIndex &, int, int)
{
    if (!m_model->hasChildren()) {
        setText(QStringLiteral("No selection"));
        return;
    }
    setText(m_model->index(0, 0).data().toString());
}

void CurrentItemLabel::modelReset()
{
    if (!m_model->hasChildren()) {
        setText(QStringLiteral("No selection"));
    }
    setText(m_model->index(0, 0).data().toString());
}

KBreadcrumbNavigationProxyModel::KBreadcrumbNavigationProxyModel(QItemSelectionModel *selectionModel, QObject *parent)
    : KSelectionProxyModel(selectionModel, parent)
{

}

QVariant KBreadcrumbNavigationProxyModel::data(const QModelIndex &index, int role) const
{
    if (rowCount() > 2 && index.row() == 0 && role == Qt::DisplayRole) {
        QModelIndex sourceIndex = mapToSource(index);
        QStringList dataList;
        while (sourceIndex.isValid()) {
            dataList.prepend(sourceIndex.data().toString());
            sourceIndex = sourceIndex.parent();
        }
        return dataList.join(QLatin1String(" > "));
    }
    return KSelectionProxyModel::data(index, role);
}

void KBreadcrumbNavigationProxyModel::setShowHiddenAscendantData(bool showHiddenAscendantData)
{
    m_showHiddenAscendantData = showHiddenAscendantData;
}

bool KBreadcrumbNavigationProxyModel::showHiddenAscendantData() const
{
    return m_showHiddenAscendantData;
}

KNavigatingProxyModel::KNavigatingProxyModel(QItemSelectionModel *selectionModel, QObject *parent)
    : KSelectionProxyModel(selectionModel, parent), m_selectionModel(selectionModel)
{

}

void KNavigatingProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
{
    connect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
            SLOT(navigationSelectionChanged(QItemSelection,QItemSelection)));

    KSelectionProxyModel::setSourceModel(sourceModel);
    updateNavigation();
}

void KNavigatingProxyModel::navigationSelectionChanged(const QItemSelection &, const QItemSelection &)
{
    updateNavigation();
}

void KNavigatingProxyModel::updateNavigation()
{
    if (!sourceModel()) {
        return;
    }

    if (m_selectionModel->selection().isEmpty()) {
        setFilterBehavior(KSelectionProxyModel::ExactSelection);
        QModelIndex top = sourceModel()->index(0, 0);
        QModelIndex bottom = sourceModel()->index(sourceModel()->rowCount() - 1, 0);

        disconnect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                   this, SLOT(navigationSelectionChanged(QItemSelection,QItemSelection)));
        m_selectionModel->select(QItemSelection(top, bottom), QItemSelectionModel::Select);
        connect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                SLOT(navigationSelectionChanged(QItemSelection,QItemSelection)));
    } else if (filterBehavior() != KSelectionProxyModel::ChildrenOfExactSelection) {
        setFilterBehavior(KSelectionProxyModel::ChildrenOfExactSelection);
    }
}

void KNavigatingProxyModel::modelReset()
{
    updateNavigation();
}

QVariant KNavigatingProxyModel::data(const QModelIndex &index, int role) const
{
    if (role == Qt::DisplayRole && sourceModel()->hasChildren(mapToSource(index))) {
        return QString("+ " + KSelectionProxyModel::data(index, role).toString());
    }
    return KSelectionProxyModel::data(index, role);
}

KForwardingItemSelectionModel::KForwardingItemSelectionModel(QAbstractItemModel *model, QItemSelectionModel *selectionModel, QObject *parent)
    : QItemSelectionModel(model, parent), m_selectionModel(selectionModel), m_direction(Forward)
{
    Q_ASSERT(model == selectionModel->model());
    connect(selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
            SLOT(navigationSelectionChanged(QItemSelection,QItemSelection)));
}

KForwardingItemSelectionModel::KForwardingItemSelectionModel(QAbstractItemModel *model, QItemSelectionModel *selectionModel, Direction direction, QObject *parent)
    : QItemSelectionModel(model, parent), m_selectionModel(selectionModel), m_direction(direction)
{
    Q_ASSERT(model == selectionModel->model());
    if (m_direction == Forward)
        connect(selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                SLOT(navigationSelectionChanged(QItemSelection,QItemSelection)));
}

void KForwardingItemSelectionModel::select(const QModelIndex &index, QItemSelectionModel::SelectionFlags command)
{
    if (m_direction == Reverse) {
        m_selectionModel->select(index, command);
    } else {
        QItemSelectionModel::select(index, command);
    }
}

void KForwardingItemSelectionModel::select(const QItemSelection &selection, QItemSelectionModel::SelectionFlags command)
{
    if (m_direction == Reverse) {
        m_selectionModel->select(selection, command);
    } else {
        QItemSelectionModel::select(selection, command);
    }
}

void KForwardingItemSelectionModel::navigationSelectionChanged(const QItemSelection &selected, const QItemSelection &)
{
    select(selected, ClearAndSelect);
}

BreadcrumbNavigationWidget::BreadcrumbNavigationWidget(QWidget *parent, Qt::WindowFlags f)
    : QWidget(parent, f)
{
    DynamicTreeModel *rootModel = new DynamicTreeModel(this);
    QSplitter *splitter = new QSplitter(this);
    QHBoxLayout *layout = new QHBoxLayout(this);
    layout->addWidget(splitter);

    DynamicTreeWidget *dynamicTree = new DynamicTreeWidget(rootModel, splitter);
    dynamicTree->treeView()->setSelectionMode(QAbstractItemView::SingleSelection);
    dynamicTree->setInitialTree(
        QLatin1String("- 1"
        "- - 2"
        "- - 2"
        "- - - 3"
        "- - - - 4"
        "- - - - - 5"
        "- - 2"
        "- 6"
        "- 6"
        "- 6"
        "- - 7"
        "- - - 8"
        "- - - 8"
        "- - - - 9"
        "- - - - - 10"
        "- - - 8"
        "- - - 8"
        "- - 8"
        "- 16"
        "- - 17"
        "- - - 18"
        "- - - - 19"
        "- - - - - 20"));

    QList<QItemSelectionModel *> selectionModelList;

    QSplitter *vSplitter = new QSplitter(Qt::Vertical, splitter);

    QItemSelectionModel *rootSelectionModel = new QItemSelectionModel(rootModel, this);
    SON(rootSelectionModel);

    dynamicTree->treeView()->setSelectionModel(rootSelectionModel);

    KBreadcrumbSelectionModel *breadcrumbOnlyProxySelector2 = new KBreadcrumbSelectionModel(rootSelectionModel, KBreadcrumbSelectionModel::MakeBreadcrumbSelectionInOther, this);
    SON(breadcrumbOnlyProxySelector2);
    breadcrumbOnlyProxySelector2->setActualSelectionIncluded(false);

    KBreadcrumbNavigationProxyModel *breadcrumbNavigationModel = new KBreadcrumbNavigationProxyModel(breadcrumbOnlyProxySelector2, this);
    SON(breadcrumbNavigationModel);
    breadcrumbNavigationModel->setSourceModel(rootModel);
    breadcrumbNavigationModel->setFilterBehavior(KSelectionProxyModel::ExactSelection);

    QListView *breadcrumbView = new QListView(vSplitter);
//   SON(breadcrumbNavigationModel);
    breadcrumbView->setModel(breadcrumbNavigationModel);

    // This shouldn't operate on rootSelectionModel. It should operate on oneway instead?
    KLinkItemSelectionModel *breadcrumbViewSelectionModel = new KLinkItemSelectionModel(breadcrumbNavigationModel, rootSelectionModel, this);
    SON(breadcrumbViewSelectionModel);

    KForwardingItemSelectionModel *oneway2 = new KForwardingItemSelectionModel(breadcrumbNavigationModel, breadcrumbViewSelectionModel, KForwardingItemSelectionModel::Reverse);
    SON(oneway2);

    breadcrumbView->setSelectionModel(oneway2);

    KSelectionProxyModel *currentItemSelectionModel = new KSelectionProxyModel(rootSelectionModel, this);
    currentItemSelectionModel->setFilterBehavior(KSelectionProxyModel::ExactSelection);
    currentItemSelectionModel->setSourceModel(rootModel);
    SON(currentItemSelectionModel);

    new CurrentItemLabel(currentItemSelectionModel, vSplitter);

    QListView *selectionView = new QListView(vSplitter);

    // Need a one-way connection from rootSelectionModel to rootSelectionModel2

    KForwardingItemSelectionModel *oneway = new KForwardingItemSelectionModel(rootModel, rootSelectionModel);

    KNavigatingProxyModel *navigatingProxyModel = new KNavigatingProxyModel(oneway, this);
    SON(navigatingProxyModel);
    navigatingProxyModel->setSourceModel(rootModel);
    selectionView->setModel(navigatingProxyModel);

    KLinkItemSelectionModel *selectedChildrenSelectionModel = new KLinkItemSelectionModel(navigatingProxyModel, rootSelectionModel, this);

    selectionView->setSelectionModel(selectedChildrenSelectionModel);
}