/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/

#include <QSqlQuery>
#include <QSqlError>
#include <QStringList>
#include <QSettings>
#include <QSqlDriver>
#include <QDebug>
#include "hsactivitystorage_p.h"
#include "hsactivity.h"

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
HsActivityStoragePrivate::HsActivityStoragePrivate()
{
    // determine database localization
    QSettings settings(ActivityOrganization, ActivityApplication);
    settings.setValue(ActivityStorageProperty, ActivityDefaultStorage);
    if (!settings.contains(ActivityStorageProperty)) {
        settings.setValue(ActivityStorageProperty, ActivityDefaultStorage);
    }
    QString databaseFile = settings.value(ActivityStorageProperty).toString();

    if (QSqlDatabase::contains(ActivityStorageName)) {
        mConn = QSqlDatabase::database(ActivityStorageName);
    } else {
        mConn = QSqlDatabase::addDatabase(ActivityStorageDriver, ActivityStorageName);
        mConn.setDatabaseName(databaseFile);
        if (!mConn.open()) {
            qWarning(qPrintable(mConn.lastError().text()));
            return;
        }
    }
    if (!checkTables()) {
        recreateTables();
    }
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
HsActivityStoragePrivate::~HsActivityStoragePrivate()
{
    mConn.close();
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::addActivity(const QVariantHash &activity)
{
    // stream whole entry to bytearray
    QByteArray streamedData;
    QDataStream stream(&streamedData, QIODevice::WriteOnly);
    stream << activity;

    //insert data
    QSqlQuery query(mConn);
    query.prepare(ActivitySelectActivityQuery);
    bind(query, activity);
    exec(query);
    if (query.next()) {
        return KErrGeneral;
    }
    query.prepare(ActivityInsertActivityQuery);
    QVariantHash additionalData;
    additionalData.insert(ActivityDataKeyword, streamedData);
    bind(query, activity, additionalData);
    exec(query);
    return 0>=query.numRowsAffected() ? KErrGeneral : getSqlErrorCode(query);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::updateActivity(const QVariantHash &activity)
{
    // stream whole entry to bytearray
    QByteArray streamedData;
    QDataStream stream(&streamedData, QIODevice::WriteOnly);
    stream << activity;

    // update
    QSqlQuery query(mConn);
    query.prepare(ActivityUpdateActivityQuery);
    QVariantHash additionalData;
    additionalData.insert(ActivityDataKeyword, streamedData);
    bind(query, activity, additionalData);
    exec(query);
    return 0>=query.numRowsAffected() ? KErrGeneral : getSqlErrorCode(query);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::removeActivity(const QVariantHash &activity)
{
    return exec(ActivityDeleteActivityQuery, activity);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::removeApplicationActivities(const QVariantHash &activity)
{
    return exec(ActivityDeleteApplicationActivitiesQuery, activity);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::requestedActivityName(QString &result,
        const QVariantHash &activity)
{
    QSqlQuery query(mConn);
    query.prepare(ActivitySelectActiveQuery);
    bind(query, activity);
    int retVal(KErrNone);
    if (exec(query) && query.next()) {
        result = query.value(0).toString();
    } else {
        retVal = KErrNotFound;
    }
    return retVal;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::activities(QList<QVariantHash>& result)
{
    return activities(result, ActivityActivitiesQuery, QVariantHash());
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::applicationActivities(QList<QVariantHash> & result,
        const QVariantHash &condition)
{
    return activities(result, ActivityApplicationActivitiesQuery, condition);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::waitActivity(const QVariantHash &)
{
    return KErrNotSupported;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::launchActivity(const QVariantHash &)
{
    return KErrNotSupported;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
bool HsActivityStoragePrivate::checkTables()
{
    return (QStringList("Activities") == mConn.tables());
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityStoragePrivate::recreateTables()
{
    //start sql transaction
    if (!mConn.transaction()) {
        qErrnoWarning(qPrintable(mConn.lastError().text()));
        return;
    }

    // drop any existing tables
    QSqlQuery query(mConn);
    foreach(const QString &tableName, mConn.tables()) {
        query.prepare(ActivityDropQuery);
        query.bindValue(ActivityTableKeyword, tableName);
        exec(query);
    }

    // create new table
    query.prepare(ActivityCreateQuery);
    exec(query);

    //finish sql transaction
    if (!mConn.commit()) {
        qErrnoWarning(qPrintable(mConn.lastError().text()));
    }
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::getSqlErrorCode(const QSqlQuery &query)
{
    const QSqlError err(query.lastError());
    const QString errStr(err.text());

    if (QSqlError ::NoError == err.type()) {
        return 0;
    } else {
        qErrnoWarning(qPrintable(errStr));
        return err.number();
    }
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
bool HsActivityStoragePrivate::exec(QSqlQuery &query)
{
    const bool retVal = query.exec();
    qErrnoWarning(qPrintable(query.lastQuery()));
    if (!retVal) {
        getSqlErrorCode(query);
    }
    return retVal;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
bool HsActivityStoragePrivate::exec(const QString &queryStr, const QVariantHash &params)
{
    QSqlQuery query(mConn);
    query.prepare(queryStr);
    bind(query, params);
    query.exec();
    return getSqlErrorCode(query);

}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityStoragePrivate::bind(QSqlQuery &query,
                                    const QVariantHash &activity,
                                    const QVariantHash &additionalData)
{
    const QChar tag(' ');
    QString queryString(query.lastQuery());
    QVariantHash::const_iterator iter;
    int offset(0);
    QStringList tokens;

    //explode SQL query to tokens
    do {
        offset = queryString.indexOf(tag, 0);
        if (0 < offset) {
            tokens << queryString.left(offset++);
            queryString = queryString.right(queryString.length() - offset);
        } else {
            if (0 < queryString.length()) {
                tokens << queryString;
            }
            break;
        }
    } while (true);

    //current Sql driver doesnt support proper query formating.
    //reuest filtering data has to be binded in right order.
    QStringList::iterator token = tokens.begin();
    //iterate all tokens
    for (; token != tokens.end(); token = tokens.erase(token)) {
        //iterate all provided data and chcek if it match pattern
        for (iter = activity.constBegin();
                iter != activity.constEnd();
                ++iter) {
            if ((*token).contains(iter.key())) {
                query.bindValue(iter.key(), iter.value());
                break;
            }
        }
        for (iter = additionalData.constBegin();
                iter != additionalData.constEnd();
                ++iter) {
            if ((*token).contains(iter.key())) {
                query.bindValue(iter.key(), iter.value());
                break;
            }
        }
    }
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityStoragePrivate::activities(QList<QVariantHash> &results,
        const QString &queryStr,
        const QVariantHash &conditions)
{
    results.clear();

    QSqlQuery query(mConn);
    query.prepare(queryStr);
    bind(query, conditions);
    if (exec(query)) {
        QVariantHash activityEntry;
        while (query.next()) {
            activityEntry.clear();
            QByteArray data(query.value(0).toByteArray());
            QDataStream stream(&data, QIODevice::ReadOnly);
            stream >> activityEntry;
            results.append(activityEntry);
        }
    }
    return getSqlErrorCode(query);
}