#include <QtGui>

#include "DictTableModel.h"
#include "UndoCommands.h"
#include "../dictionary/Dictionary.h"
#include "../dictionary/DicRecord.h"
#include "../dictionary/Field.h"

DictTableModel::DictTableModel( Dictionary* aDict, QObject *parent ):
    QAbstractTableModel( parent ), m_dictionary( aDict )
    {
    m_undoStack = new QUndoStack( this );
    connect( m_dictionary, SIGNAL(destroyed(QObject*)), SLOT(discardCurDictionary()) );
    }

int DictTableModel::rowCount( const QModelIndex &/*parent*/ ) const
    {
    if( m_dictionary )
        return m_dictionary->entriesNum();
    else
        return 0;
    }

int DictTableModel::columnCount(const QModelIndex &/*parent*/) const
    {
    if( m_dictionary )
        return m_dictionary->fieldsNum();
    else
        return 0;
    }

QVariant DictTableModel::data( const QModelIndex &index, int role ) const
    {
    if( !m_dictionary || !index.isValid() || index.row() >= rowCount() ||
        index.column() >= columnCount() )
            return QVariant();
    QString text = m_dictionary->getFieldValue(index.row(), index.column());
    switch(role)
        {
        case Qt::DisplayRole:
            return QVariant();
        case Qt::EditRole:
            return m_dictionary->extendImagePaths(text);
        case DicRecordRole:
        {
            const DicRecord* record = m_dictionary->getRecord(index.row());
            return QVariant::fromValue(*record);
        }
        default:
            return QVariant();
        }
    }

QVariant DictTableModel::headerData( int section, Qt::Orientation orientation, int role ) const
    {
    if( !m_dictionary )
        return QVariant();
    switch( role )
        {
        case Qt::DisplayRole:
            if(orientation == Qt::Vertical)
                return QString::number( section + 1 );
            else
                {
                if( section < columnCount() )
                    return m_dictionary->field( section )->name();
                else
                    return QVariant();
                }
        default:
            return QVariant();
        }
    }

bool DictTableModel::setData( const QModelIndex &index, const QVariant &value, int role )
    {
    if( !index.isValid() || !m_dictionary )
        return false;
    if( value == data( index, role ) )
        return false;

    switch( role )
        {
        case Qt::DisplayRole:
        case Qt::EditRole:
            m_dictionary->setFieldValue(index.row(), index.column(), value.toString());
            break;
        case DicRecordRole:
            {
                DicRecord record = value.value<DicRecord>();
                m_dictionary->setRecord( index.row(), record );
                break;
            }
        default:
            return false;
        }
    emit dataChanged( index, index );
    return true;
    }

bool DictTableModel::insertRows( int position, int rows, const QModelIndex& /*parent*/ )
    {
    if( !m_dictionary )
        return false;
    beginInsertRows( QModelIndex(), position, position + rows - 1 );
    m_dictionary->insertEntries( position, rows );
    endInsertRows();
    return true;
    }

bool DictTableModel::addFields( QStringList aFields )
    {
    if( !m_dictionary )
        return false;
    beginInsertColumns( QModelIndex(), columnCount(), columnCount() + aFields.size() - 1 );
    m_dictionary->addFields( aFields );
    endInsertColumns();
    return true;
    }

bool DictTableModel::removeRows( int position, int rows, const QModelIndex& /*parent*/ )
    {
    if( !m_dictionary )
        return false;
    beginRemoveRows( QModelIndex(), position, position + rows - 1 );
    m_dictionary->removeRecords( position, rows );
    endRemoveRows();
    return true;
    }

void DictTableModel::resetData()    // TODO: Suspicious method, just reveals protected methods
    {
    beginResetModel();
    endResetModel();
    }

void DictTableModel::discardCurDictionary()
    {
    beginResetModel();
    m_dictionary = NULL;
    endResetModel();
    }