/**
 ******************************************************************************
 *
 * @file       notifytablemodel.cpp
 * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
 * @brief
 * @see        The GNU Public License (GPL) Version 3
 * @defgroup   notifyplugin
 * @{
 *
 *****************************************************************************/
/*
 * 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 3 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.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "notifytablemodel.h"
#include "notifylogging.h"
#include <qdebug.h>
#include <QMimeData>

const char* mime_type_notify_table = "openpilot/notify_plugin_table";

NotifyTableModel::NotifyTableModel(QList<NotificationItem*>& parentList, QObject* parent)
	: QAbstractTableModel(parent)
	, _list(parentList)
{
	_headerStrings << "Name" << "Repeats" << "Lifetime,sec" << "Mute";
	connect(this, SIGNAL(dragRows(int, int)), this, SLOT(dropRows(int, int)));
}


bool NotifyTableModel::setData(const QModelIndex &index,
							   const QVariant &value, int role)
{
    if (index.isValid() && role == Qt::DisplayRole) {
        if (eMessageName == index.column()) {
            emit dataChanged(index, index);
            return true;
        }
    }
    if (index.isValid() && role == Qt::EditRole) {
        if (eRepeatValue == index.column())
             _list.at(index.row())->setRetryValue(NotificationItem::retryValues.indexOf(value.toString()));
        else {
            if (eExpireTimer == index.column())
                _list.at(index.row())->setLifetime(value.toInt());
            else {
                if (eTurnOn == index.column())
                    _list.at(index.row())->setMute(value.toBool());
            }
        }
        emit dataChanged(index, index);
        return true;
    }
    return false;
}

QVariant NotifyTableModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        qWarning() << "NotifyTableModel::data - index.isValid()";
        return QVariant();
    }

    if (index.row() >= _list.size())
        return QVariant();

    if (role == Qt::DisplayRole || role == Qt::EditRole)
    {
        switch(index.column())
        {
        case eMessageName:
            return _list.at(index.row())->toString();

        case eRepeatValue:
            return (NotificationItem::retryValues.at(_list.at(index.row())->retryValue()));

        case eExpireTimer:
            return _list.at(index.row())->lifetime();

        case eTurnOn:
            return _list.at(index.row())->mute();

        default:
            return QVariant();
        }
    }
    else
    {
        if (Qt::SizeHintRole == role){
            return  QVariant(10);
        }
    }
    return QVariant();
}

QVariant NotifyTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole)
        return QVariant();

    if (orientation == Qt::Horizontal)
        return _headerStrings.at(section);
    else
        if (orientation == Qt::Vertical)
            return QString("%1").arg(section);

    return QVariant();
}

bool NotifyTableModel::insertRows(int position, int rows, const QModelIndex& index)
{
    Q_UNUSED(index);

    if (-1 == position || -1 == rows)
        return false;

    beginInsertRows(QModelIndex(), position, position + rows - 1);

    for (int i = 0; i < rows; ++i) {
        _list.insert(position + i, new NotificationItem());
    }

    endInsertRows();
    return true;
}

bool NotifyTableModel::removeRows(int position, int rows, const QModelIndex& index)
{
    Q_UNUSED(index);

    if ((-1 == position) || (-1 == rows) )
        return false;

    beginRemoveRows(QModelIndex(), position, position + rows - 1);

    for (int row = 0; row < rows; ++row) {
        _list.removeAt(position);
    }

    endRemoveRows();
    return true;
}

void NotifyTableModel::entryUpdated(int offset)
{
    QModelIndex idx = index(offset, 0);
    emit dataChanged(idx, idx);
}

void NotifyTableModel::entryAdded(NotificationItem* item)
{
    insertRows(rowCount(), 1, QModelIndex());
    NotificationItem* tmp = _list.at(rowCount() - 1);
    _list.replace(rowCount() - 1, item);
    delete tmp;
    entryUpdated(rowCount() - 1);
}

Qt::DropActions NotifyTableModel::supportedDropActions() const
{
    return Qt::MoveAction;
}

QStringList NotifyTableModel::mimeTypes() const
{
    QStringList types;
    types << mime_type_notify_table;
    return types;
}

bool NotifyTableModel::dropMimeData( const QMimeData * data, Qt::DropAction action, int row,
                   int column, const QModelIndex& parent)
{
    if (action == Qt::IgnoreAction)
        return true;

    if (!data->hasFormat(mime_type_notify_table))
        return false;

    int beginRow = -1;

    if (row != -1)
        beginRow = row;
    else {
        if (parent.isValid())
            beginRow = parent.row();
        else
            beginRow = rowCount(QModelIndex());
    }

    if (-1 == beginRow)
        return false;

    QByteArray encodedData = data->data(mime_type_notify_table);
    QDataStream stream(&encodedData, QIODevice::ReadOnly);
    int rows = beginRow;
    // read next item from input MIME and drop into the table line by line
    while(!stream.atEnd()) {
        quintptr ptr;
        stream >> ptr;
        NotificationItem* item = reinterpret_cast<NotificationItem*>(ptr);
        int dragged = _list.indexOf(item);
        // we can drag item from top rows to bottom (DOWN_DIRECTION),
        // or from bottom rows to top rows (UP_DIRECTION)
        enum { UP_DIRECTION, DOWN_DIRECTION };
        int direction = (dragged < rows) ? DOWN_DIRECTION : (dragged += 1, UP_DIRECTION);
        // check drop bounds
        if (dragged < 0 || ((dragged + 1) >= _list.size() && direction == DOWN_DIRECTION)  || dragged == rows) {
            qNotifyDebug() << "no such item";
            continue;
        }
        // addiional check in case dropping of multiple rows
        if(rows + direction > _list.size()) continue;

        bool success = insertRows(rows + direction, 1, QModelIndex());
        Q_ASSERT(success);
        _list.replace(rows + direction, item);
        success = removeRows(dragged, 1, QModelIndex());
        Q_ASSERT(success);
        if (direction == UP_DIRECTION)
            ++rows;
    };

    QModelIndex idxTopLeft = index(beginRow, 0, QModelIndex());
    QModelIndex idxBotRight = index(beginRow, columnCount(QModelIndex()), QModelIndex());
    emit dataChanged(idxTopLeft, idxBotRight);
    return true;
}

QMimeData* NotifyTableModel::mimeData(const QModelIndexList& indexes) const
{
    QMimeData* mimeData = new QMimeData();
    QByteArray encodedData;

    QDataStream stream(&encodedData, QIODevice::WriteOnly);
    int rows = 0;
    foreach (const QModelIndex& index, indexes) {
        if (!index.column()) {
            quintptr item = reinterpret_cast<quintptr>(_list.at(index.row()));
            stream << item;
            ++rows;
        }
    }
    mimeData->setData(mime_type_notify_table, encodedData);
    return mimeData;
}

void NotifyTableModel::dropRows(int position, int count) const
{
    for (int row = 0; row < count; ++row) {
        _list.removeAt(position);
    }
}