/*
    Copyright (c) 2014, Lukas Holecek <hluk@email.cz>

    This file is part of CopyQ.

    CopyQ 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 3 of the License, or
    (at your option) any later version.

    CopyQ 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 CopyQ.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "itempinned.h"
#include "ui_itempinnedsettings.h"

#include "common/command.h"
#include "common/contenttype.h"
#include "common/display.h"

#ifdef HAS_TESTS
#   include "tests/itempinnedtests.h"
#endif

#include <QApplication>
#include <QBoxLayout>
#include <QMessageBox>
#include <QModelIndex>

#include <algorithm>

namespace {

const char mimePinned[] = "application/x-copyq-item-pinned";

bool isPinned(const QModelIndex &index)
{
    const auto dataMap = index.data(contentType::data).toMap();
    return dataMap.contains(mimePinned);
}

Command dummyPinCommand()
{
    Command c;
    c.icon = QString(QChar(IconThumbTack));
    c.inMenu = true;
    c.shortcuts = QStringList()
            << ItemPinnedLoader::tr("Ctrl+Shift+P", "Shortcut to pin and unpin items");
    return c;
}

} // namespace

ItemPinned::ItemPinned(ItemWidget *childItem)
    : QWidget( childItem->widget()->parentWidget() )
    , ItemWidget(this)
    , m_border(new QWidget(this))
    , m_childItem(childItem)
{
    m_childItem->widget()->setObjectName("item_child");
    m_childItem->widget()->setParent(this);

    m_border->setFixedWidth( pointsToPixels(6) );

    // Set pinned item border color.
    const auto *parent = parentWidget();
    auto color = parent->palette().color(QPalette::Background);
    const int lightThreshold = 100;
    const bool menuBackgrounIsLight = color.lightness() > lightThreshold;
    color.setHsl(
                color.hue(),
                color.saturation(),
                qMax(0, qMin(255, color.lightness() + (menuBackgrounIsLight ? -200 : 50)))
                );
    const auto styleSheet = QString("background-color: rgba(%1,%2,%3,15\\%)")
            .arg(color.red())
            .arg(color.green())
            .arg(color.blue());
    m_border->setStyleSheet(styleSheet);

    QBoxLayout *layout;
    layout = new QHBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);
    layout->setSpacing( pointsToPixels(5) );

    layout->addWidget(m_childItem->widget());
    layout->addStretch();
    layout->addWidget(m_border);
}

void ItemPinned::highlight(const QRegExp &re, const QFont &highlightFont, const QPalette &highlightPalette)
{
    m_childItem->setHighlight(re, highlightFont, highlightPalette);
}

QWidget *ItemPinned::createEditor(QWidget *parent) const
{
    return m_childItem->createEditor(parent);
}

void ItemPinned::setEditorData(QWidget *editor, const QModelIndex &index) const
{
    return m_childItem->setEditorData(editor, index);
}

void ItemPinned::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
{
    return m_childItem->setModelData(editor, model, index);
}

bool ItemPinned::hasChanges(QWidget *editor) const
{
    return m_childItem->hasChanges(editor);
}

QObject *ItemPinned::createExternalEditor(const QModelIndex &index, QWidget *parent) const
{
    return m_childItem->createExternalEditor(index, parent);
}

void ItemPinned::updateSize(const QSize &maximumSize, int idealWidth)
{
    setMinimumWidth(idealWidth);
    setMaximumWidth(maximumSize.width());
    const int width = m_border->width() + layout()->spacing();
    const int childItemWidth = idealWidth - width;
    const auto childItemMaximumSize = QSize(maximumSize.width() - width, maximumSize.height());
    m_childItem->updateSize(childItemMaximumSize, childItemWidth);
    adjustSize();
}

bool ItemPinnedScriptable::isPinned()
{
    const auto args = currentArguments();
    for (const auto &arg : args) {
        bool ok;
        const int row = arg.toInt(&ok);
        if (ok) {
            const auto result = call("read", QVariantList() << "?" << row);
            if ( result.toByteArray().contains(mimePinned) )
                return true;
        }
    }

    return false;
}

void ItemPinnedScriptable::pin()
{
    const auto args = currentArguments();
    for (const auto &arg : args) {
        bool ok;
        const int row = arg.toInt(&ok);
        if (ok)
            call("change", QVariantList() << row << mimePinned << QString());
    }
}

void ItemPinnedScriptable::unpin()
{
    const auto args = currentArguments();
    for (const auto &arg : args) {
        bool ok;
        const int row = arg.toInt(&ok);
        if (ok)
            call("change", QVariantList() << row << mimePinned << QVariant());
    }
}

void ItemPinnedScriptable::pinData()
{
    call("setData", QVariantList() << mimePinned << QString());
}

void ItemPinnedScriptable::unpinData()
{
    call("removeData", QVariantList() << mimePinned);
}

ItemPinnedSaver::ItemPinnedSaver(QAbstractItemModel *model, QVariantMap &settings, const ItemSaverPtr &saver)
    : m_model(model)
    , m_settings(settings)
    , m_saver(saver)
{
    connect( model, SIGNAL(rowsInserted(QModelIndex,int,int)),
             SLOT(onRowsInserted(QModelIndex,int,int)) );
    connect( model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             SLOT(onRowsRemoved(QModelIndex,int,int)) );
    connect( model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
             SLOT(onRowsMoved(QModelIndex,int,int,QModelIndex,int)) );
    connect( model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             SLOT(onDataChanged(QModelIndex,QModelIndex)) );

    updateLastPinned( 0, m_model->rowCount() );
}

bool ItemPinnedSaver::saveItems(const QString &tabName, const QAbstractItemModel &model, QIODevice *file)
{
    return m_saver->saveItems(tabName, model, file);
}

bool ItemPinnedSaver::canRemoveItems(const QList<QModelIndex> &indexList, QString *error)
{
    const bool containsPinnedItems = std::any_of(
                std::begin(indexList), std::end(indexList), isPinned);

    if (!containsPinnedItems)
        return m_saver->canRemoveItems(indexList, error);

    if (error) {
        *error = "Removing pinned item is not allowed (unpin item first)";
        return false;
    }

    QMessageBox::information(
                QApplication::activeWindow(),
                ItemPinnedLoader::tr("Cannot Remove Pinned Items"),
                ItemPinnedLoader::tr("Unpin items first to remove them.") );
    return false;
}

bool ItemPinnedSaver::canMoveItems(const QList<QModelIndex> &indexList)
{
    return m_saver->canMoveItems(indexList);
}

void ItemPinnedSaver::itemsRemovedByUser(const QList<QModelIndex> &indexList)
{
    m_saver->itemsRemovedByUser(indexList);
}

QVariantMap ItemPinnedSaver::copyItem(const QAbstractItemModel &model, const QVariantMap &itemData)
{
    return m_saver->copyItem(model, itemData);
}

void ItemPinnedSaver::onRowsInserted(const QModelIndex &, int start, int end)
{
    if (!m_model || m_lastPinned < start) {
        updateLastPinned(start, end);
        return;
    }

    disconnect( m_model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
                this, SLOT(onRowsMoved(QModelIndex,int,int,QModelIndex,int)) );

    // Shift rows below inserted up.
    const int rowCount = end - start + 1;
    for (int row = end + 1; row <= m_lastPinned + rowCount; ++row) {
        const auto index = m_model->index(row, 0);
        if ( isPinned(index) )
            moveRow(row, row - rowCount);
    }

    connect( m_model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
             SLOT(onRowsMoved(QModelIndex,int,int,QModelIndex,int)) );
}

void ItemPinnedSaver::onRowsRemoved(const QModelIndex &, int start, int end)
{
    if (!m_model || m_lastPinned < start)
        return;

    disconnect( m_model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
                this, SLOT(onRowsMoved(QModelIndex,int,int,QModelIndex,int)) );

    // Shift rows below removed down.
    const int rowCount = end - start + 1;
    for (int row = m_lastPinned - rowCount; row >= start; --row) {
        const auto index = m_model->index(row, 0);
        if ( isPinned(index) )
            moveRow(row, row + rowCount + 1);
    }

    connect( m_model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
             SLOT(onRowsMoved(QModelIndex,int,int,QModelIndex,int)) );
}

void ItemPinnedSaver::onRowsMoved(const QModelIndex &, int start, int end, const QModelIndex &, int destinationRow)
{
    if ( (m_lastPinned < start && m_lastPinned < destinationRow)
         || (end < m_lastPinned && destinationRow < m_lastPinned) )
    {
        return;
    }

    if (start < destinationRow)
        updateLastPinned(start, destinationRow + end - start + 1);
    else
        updateLastPinned(destinationRow, end);
}

void ItemPinnedSaver::onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
    if ( bottomRight.row() < m_lastPinned )
        return;

    updateLastPinned( topLeft.row(), bottomRight.row() );
}

void ItemPinnedSaver::moveRow(int from, int to)
{
#if QT_VERSION < 0x050000
    QMetaObject::invokeMethod(m_model, "moveRow", Q_ARG(int, from), Q_ARG(int, to));
#else
    m_model->moveRow(QModelIndex(), from, QModelIndex(), to);
#endif
}

void ItemPinnedSaver::updateLastPinned(int from, int to)
{
    for (int row = to; row >= from; --row) {
        const auto index = m_model->index(row, 0);
        if ( isPinned(index) ) {
            m_lastPinned = row;
            break;
        }
    }
}

ItemPinnedLoader::ItemPinnedLoader()
{
}

ItemPinnedLoader::~ItemPinnedLoader() = default;

QStringList ItemPinnedLoader::formatsToSave() const
{
    return QStringList() << mimePinned;
}

QVariantMap ItemPinnedLoader::applySettings()
{
    return m_settings;
}

QWidget *ItemPinnedLoader::createSettingsWidget(QWidget *parent)
{
    ui.reset(new Ui::ItemPinnedSettings);
    QWidget *w = new QWidget(parent);
    ui->setupUi(w);

    connect( ui->pushButtonAddCommands, SIGNAL(clicked()),
             this, SLOT(addCommands()) );

    return w;
}

ItemWidget *ItemPinnedLoader::transform(ItemWidget *itemWidget, const QModelIndex &index)
{
    return isPinned(index) ? new ItemPinned(itemWidget) : nullptr;
}

ItemSaverPtr ItemPinnedLoader::transformSaver(const ItemSaverPtr &saver, QAbstractItemModel *model)
{
    return std::make_shared<ItemPinnedSaver>(model, m_settings, saver);
}

QObject *ItemPinnedLoader::tests(const TestInterfacePtr &test) const
{
#ifdef HAS_TESTS
    QObject *tests = new ItemPinnedTests(test);
    return tests;
#else
    Q_UNUSED(test);
    return nullptr;
#endif
}

ItemScriptable *ItemPinnedLoader::scriptableObject(QObject *parent)
{
    return new ItemPinnedScriptable(parent);
}

QList<Command> ItemPinnedLoader::commands() const
{
    QList<Command> commands;

    Command c;

    c = dummyPinCommand();
    c.name = tr("Pin");
    c.input = "!OUTPUT";
    c.output = mimePinned;
    c.cmd = "copyq: plugins.itempinned.pinData()";
    commands.append(c);

    c = dummyPinCommand();
    c.name = tr("Unpin");
    c.input = mimePinned;
    c.cmd = "copyq: plugins.itempinned.unpinData()";
    commands.append(c);

    return commands;
}

void ItemPinnedLoader::addCommands()
{
    emit addCommands(commands());
}

Q_EXPORT_PLUGIN2(itempinned, ItemPinnedLoader)