/*
* 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);
}