#include "databasetable.h"

#include "logger.h"

#include <QJsonDocument>
#include <QMetaProperty>

#include <memory>

namespace serversdk {

DatabaseTable::DatabaseTable(QObject *parent) : QObject(parent)
{
}

QString DatabaseTable::primaryKey() const
{
    const QMetaObject *metaObj = this->metaObject();
    for (int i = metaObj->propertyOffset(); i < metaObj->propertyCount(); ++i) {
        QMetaProperty prop = metaObj->property(i);
        if (!prop.isUser())
            continue;
        return prop.name();
    }
    return QString();
}

QByteArray DatabaseTable::jsonData(const QSet<QString> &filters) const
{
    auto variantMap = this->toVariantMap(filters);
    QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
    return doc.toJson(QJsonDocument::Compact);
}

bool DatabaseTable::fromJson(const QByteArray &data)
{
    // in: JSON ( e.g. {"id": 300} )
    QJsonDocument doc = QJsonDocument::fromJson(data);
    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());

    // Populate this object data
    bool res = fromVariantMap(variant);
    return res;
}

/** Creates universal variant structure to hold key / value pairs */
QVariantMap DatabaseTable::toVariantMap(const QSet<QString> &filters) const
{
    QVariantMap variantMap;

    const QMetaObject *metaObj = this->metaObject();
    for (int i = metaObj->propertyOffset(); i < metaObj->propertyCount(); ++i) {
        QMetaProperty prop = metaObj->property(i);
        // Skip non USER so -> ( Q_PROPERTY( ...... USER false ) only
        if (!prop.isUser())
            continue;

        // Get key -> value pairs
        QString name = prop.name();

        // Filter property
        if (filters.contains(name))
            continue;

        QVariant::Type type = prop.type();
        QVariant value(type);
        value.setValue(prop.read(this));

        variantMap.insert(name, value);
    }
    return variantMap;
}


bool DatabaseTable::fromVariantMap(const QVariantMap &variantMap)
{

    const QMetaObject *metaObj = this->metaObject();
    for (int i = metaObj->propertyOffset(); i < metaObj->propertyCount(); ++i) {
        QMetaProperty prop = metaObj->property(i);
        // Skip non USER so -> ( Q_PROPERTY( ...... USER false ) only
        if (!prop.isUser())
            continue;

        // Property name
        QString name = prop.name();
        // Get value from variant map

        QVariant value = variantMap.value(name);
        prop.write(this, value);

    }
    return true;
}


QList<std::shared_ptr<DatabaseTable> > DatabaseTable::fromListVariantMap(const QList<QVariantMap> &listMap)
{
    QList<std::shared_ptr<DatabaseTable>> list;
    for (const QVariantMap &map : listMap) {
        auto data = std::make_shared<DatabaseTable>();
        data->fromVariantMap(map);
        list << data;
    }
    return list;
}


QString DatabaseTable::textSQLIteType(QVariant::Type type) const
{
    switch (type) {
    case QVariant::Int:
        return QStringLiteral("INTEGER");
        break;
    case QVariant::Uuid:
        return QStringLiteral("TEXT");
        break;
    case QVariant::String:
        return QStringLiteral("TEXT");
        break;
    case QVariant::DateTime:
        return QStringLiteral("INTEGER");
        break;
    case QVariant::Bool:
        return QStringLiteral("INTEGER");
        break;
    default:
        return QString();
        break;
    }
}

QString DatabaseTable::textPostgresType(QVariant::Type type) const
{
    switch (type) {
    case QVariant::Int:
        return QStringLiteral("INTEGER");
        break;
    case QVariant::Uuid:
        return QStringLiteral("TEXT");
        break;
    case QVariant::String:
        return QStringLiteral("TEXT");
        break;
    case QVariant::DateTime:
        return QStringLiteral("INTEGER");
        break;
    case QVariant::Bool:
        return QStringLiteral("INTEGER");
        break;
    default:
        return QString();
        break;
    }
}

} // namespace serversdk