#ifndef ODBTABLEMODEL_H
#define ODBTABLEMODEL_H

#include <QAbstractTableModel>
#include <QSharedPointer>
#include <QMetaProperty>
#include <QModelIndex>

#include "core_global.h"

template<class T>
class AutoTableModel : public QAbstractTableModel
{

public:
    explicit AutoTableModel(QObject *parent = NULL)
        :QAbstractTableModel(parent)
    {
    }

    virtual ~AutoTableModel() {}

private:
    class Comparator
    {
    public:
        Comparator(const QString &property, Qt::SortOrder order)
        {
            m_property = property;
            m_order = order;
        }

        bool operator()(QSharedPointer<T> entA, QSharedPointer<T> entB) {
            QObject *rawEntityA = (QObject*)entA.data();
            QObject *rawEntityB = (QObject*)entB.data();

            if (m_order == Qt::AscendingOrder) {
                return rawEntityA->property(m_property.toStdString().c_str()) < rawEntityB->property(m_property.toStdString().c_str());
            } else {
                return rawEntityB->property(m_property.toStdString().c_str()) < rawEntityA->property(m_property.toStdString().c_str());
            }
        }

    private:
        QString m_property;
        Qt::SortOrder m_order;
    };


    // QAbstractItemModel interface
public:
    int rowCount(const QModelIndex &parent = QModelIndex()) const
    {
        Q_UNUSED(parent)

        return m_list.size();
    }

    int columnCount(const QModelIndex &parent = QModelIndex()) const
    {
        Q_UNUSED(parent)

        if (m_list.isEmpty())
        {
            return 0;
        }

        QSharedPointer<T> entity = m_list.at(0);
        QObject *rawEntity = (QObject*)entity.data();

        return rawEntity->metaObject()->propertyCount() - 1;
    }

    QVariant data(const QModelIndex &index, int role) const
    {
        if (role == Qt::DisplayRole)
        {
            QSharedPointer<T> entity = m_list.at(index.row());
            QObject *rawEntity = (QObject*)entity.data();

            return rawEntity->property(rawEntity->metaObject()->property(index.column() + 1).name());
        }

        return QVariant::Invalid;
    }

    QList<QSharedPointer<T> > list()
    {
        return m_list;
    }

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

        if (orientation == Qt::Horizontal) {
            QObject *entity = (QObject*)new T();

            for (int i = 0; i < entity->metaObject()->propertyCount(); i++) {
                if (i == section) {
                    QString colName(entity->metaObject()->property(i + 1).name());
                    return tr(colName.toStdString().c_str());
                }
            }

            delete entity;
        }

        return QVariant(section + 1);
    }

    virtual void sort(int column, Qt::SortOrder order) {
        if (m_list.isEmpty()) {
            return;
        }

        beginResetModel();
        QObject *rawEntity = (QObject*)m_list.at(0).data();
        Comparator c(rawEntity->metaObject()->property(column + 1).name(), order);

        std::sort(m_list.begin(), m_list.end(), c);
        endResetModel();
    }

    /*///////////////////////*/

    QSharedPointer<T> itemFromIndex(const QModelIndex &index) const
    {
        return m_list.at(index.row());
    }

    void setItemToIndex(const QModelIndex &index, QSharedPointer<T> data)
    {
        m_list.removeAt(index.row());
        m_list.insert(index.row(), data);

        emit dataChanged(index, index);
    }

    void addRow(QSharedPointer<T> data)
    {
        beginInsertRows(QModelIndex(), rowCount() - 1, rowCount() - 1);
        insertRow(rowCount());
        m_list.append(data);
        endInsertRows();
    }

    void removeRowAt(const QModelIndex &index)
    {
        beginRemoveRows(QModelIndex(), index.row(), index.row());
        removeRow(index.row());
        m_list.removeAt(index.row());
        endRemoveRows();
    }

    void setData(QList<QSharedPointer<T> > list)
    {
        m_list = list;
    }

private:
    friend class Comparator;

    QList<QSharedPointer<T> > m_list;

};

#endif // ODBTABLEMODEL_H