/*

 * Copyright (c) 2007 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 <QList>

#include <QDebug>

#include <QString>

#include <QtSql>

#include <QMap>

#include <QMapIterator>

#include "caclientproxy.h"

#include "caobjectadapter.h"

#include "caentry.h"

#include "caquery.h"

#include "cadefs.h"

#include "canotifier.h"

#include "canotifier_p.h"

#include "canotifiers.h"

#include "caclient_defines.h"

#include "hswidgetregistryservice.h"

const char *DATABASE_CONNECTION_NAME = "CaService";

const char *DATABASE_TYPE = "QSQLITE";

const char *DATABASE_NAME = "castorage.db";

static QSqlDatabase dbConnection()

{

    return QSqlDatabase::database(DATABASE_CONNECTION_NAME, false);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

CaClientProxy::CaClientProxy() :

    mWidgetRegistryPath("private/20022F35/import/widgetregistry")

{

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

CaClientProxy::~CaClientProxy()

{

    QSqlDatabase db = dbConnection();

    if (db.isOpen()) {

        db.close();

    }

    QSqlDatabase::removeDatabase(DATABASE_CONNECTION_NAME);

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::connect()

{

    ErrorCode errorCode = NotFoundErrorCode;

    QSqlDatabase db = QSqlDatabase::addDatabase(DATABASE_TYPE,

                      DATABASE_CONNECTION_NAME);

    if (db.isValid()) {

        db.setDatabaseName(DATABASE_NAME);

        if (db.open()) {

            errorCode = NoErrorCode;

            updateWidgets();

        }

    }

    if (errorCode) {

        qDebug("CaClientProxy::CaClientProxy FAILED");

    }

    return errorCode;

}

/*!

 Updates widgets.

 */

void CaClientProxy::updateWidgets()

{

    qDebug("CaClientProxy::updateWidgets start");

    HsWidgetRegistryService *rs =

        new HsWidgetRegistryService(mWidgetRegistryPath);

    QList<HsWidgetComponentDescriptor> widgets = rs->widgets();

    // Read widgets in order to add synchronize the content of the widgets

    // registry with Content Storage database.

    foreach(const HsWidgetComponentDescriptor &widgetToken, widgets) {

        int uid = widgetToken.uid;

        addWidgetEntry(widgetToken, hsWidgetId(uid));        

    }

    delete rs;

    qDebug("CaClientProxy::updateWidgets end");

}

/*!

 Returns true if a widget with the given uid exists in the database.

 */

void CaClientProxy::addWidgetEntry(const HsWidgetComponentDescriptor &widgetToken, 

                                   int widgetId)

{

    QString description = widgetToken.description;

    QString iconUri = widgetToken.iconUri;

    QString library = widgetToken.library;

    QString title = widgetToken.title;

    int uid = widgetToken.uid;

    QString uri = widgetToken.uri;

    QString previewImage = widgetToken.previewImage;

    QString translationFileName = widgetToken.translationFilename;

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    QString hexUid;

    hexUid.setNum(uid,16);

    QDir currentDir = QDir::current();

    if (widgetId == -1) {

        // Add icon.

        QString queryAddIcon =

            "INSERT INTO CA_ICON " \

            "(IC_FILENAME) " \

            "VALUES " \

            "(?)";

        query.prepare(queryAddIcon);

        query.addBindValue(iconUri);

        query.exec();

        qDebug() << query.executedQuery();

        // Add entry.

        QString queryAddEntry =

            "INSERT INTO CA_ENTRY " \

            "(EN_TEXT, EN_DESCRIPTION, EN_ROLE, EN_TYPE_NAME, EN_ICON_ID) " \

            "VALUES " \

            "(?, ?, 1, 'widget', last_insert_rowid())";

        query.prepare(queryAddEntry);

        query.addBindValue(title);

        query.addBindValue(description);

        query.exec();

        qDebug() << query.executedQuery();

        // Get last id

        QString queryLastId = "SELECT last_insert_rowid() AS LAST_ID";

        query.prepare(queryLastId);

        query.exec();

        query.next();

        widgetId = query.value(query.record().indexOf("LAST_ID")).toInt();

    } else {

        // update entry.

        QString queryUpdateEntry =

            "UPDATE CA_ENTRY SET EN_TEXT = ?, EN_DESCRIPTION = ? WHERE ENTRY_ID = ?";

        query.prepare(queryUpdateEntry);

        query.addBindValue(title);

        query.addBindValue(description);

        query.addBindValue(widgetId);

        query.exec();

        qDebug() << query.executedQuery();

        QString queryUpdateIcon =

            "UPDATE CA_ICON SET IC_FILENAME = ? WHERE" \

            " ICON_ID = (SELECT EN_ICON_ID FROM CA_ENTRY WHERE ENTRY_ID = ?)";

        query.prepare(queryUpdateIcon);

        query.addBindValue(iconUri);

        query.addBindValue(widgetId);

        query.exec();

        qDebug() << query.executedQuery();

        // delete old attribute         

        query.prepare("DELETE FROM CA_ATTRIBUTE WHERE AT_ENTRY_ID = ?");

        query.addBindValue(widgetId);

        query.exec();

        qDebug() << query.executedQuery();

    }

    // Add attribute packageuid

    QString queryAddAttribute1 =

        "INSERT INTO CA_ATTRIBUTE " \

        "(AT_ENTRY_ID, AT_NAME, AT_VALUE) " \

        "VALUES " \

        "(?, 'packageuid', ?)";

    query.prepare(queryAddAttribute1);

    query.addBindValue(widgetId);

    query.addBindValue(hexUid);

    query.exec();

    qDebug() << query.executedQuery();

    // Add attribute widget uri

    QString queryAddAttribute2 =

        "INSERT INTO CA_ATTRIBUTE " \

        "(AT_ENTRY_ID, AT_NAME, AT_VALUE) " \

        "VALUES " \

        "(?, 'widget:uri', ?)";

    query.prepare(queryAddAttribute2);

    query.addBindValue(widgetId);

    query.addBindValue(uri);

    query.exec();

    qDebug() << query.executedQuery();

    // Add attribute widget library

    QString queryAddAttribute3 =

        "INSERT INTO CA_ATTRIBUTE " \

        "(AT_ENTRY_ID, AT_NAME, AT_VALUE) " \

        "VALUES " \

        "(?, 'widget:library', ?)";

    query.prepare(queryAddAttribute3);

    query.addBindValue(widgetId);

    query.addBindValue(library);

    query.exec();

    qDebug() << query.executedQuery();

    // Add attribute preview image

    if (!previewImage.isEmpty()) {

        QString queryAddPreviewImage =

            "INSERT INTO CA_ATTRIBUTE " \

            "(AT_ENTRY_ID, AT_NAME, AT_VALUE) " \

            "VALUES " \

            "(?, 'preview_image_name', ?)";

        query.prepare(queryAddPreviewImage);

        query.addBindValue(widgetId);

        query.addBindValue(previewImage);

        query.exec();

        qDebug() << query.executedQuery();

    }

    // Add attribute widget:traslation_file

    if (!translationFileName.isEmpty()) {

        QString queryAddWidgetTranslationFile =

            "INSERT INTO CA_ATTRIBUTE " \

            "(AT_ENTRY_ID, AT_NAME, AT_VALUE) " \

            "VALUES " \

            "(?, 'widget:traslation_file', ?)";

        query.prepare(queryAddWidgetTranslationFile);

        query.addBindValue(widgetId);

        query.addBindValue(translationFileName);

        query.exec();

        qDebug() << query.executedQuery();

    }

}

/*!

 Returns true if a widget with the given uid exists in the database.

 */

int CaClientProxy::hsWidgetId(int uid)

{

    int result(-1);

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    QString hexUid;

    hexUid.setNum(uid,16);

    QString queryString =

        "SELECT " \

        "AT_ENTRY_ID " \

        "FROM " \

        "CA_ATTRIBUTE " \

        "WHERE " \

        "AT_VALUE LIKE ?";

    query.prepare(queryString);

    query.addBindValue(hexUid);

    if (query.exec() && query.next()) {        

        result = query.value(query.record().indexOf("AT_ENTRY_ID")).toInt();

    } 

    qDebug() << query.executedQuery();

    return result;

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::addData(const CaEntry &entryToAdd,

                                 CaEntry &targetEntry)

{

    qDebug() << "CaClientProxy::addData" << "entry id: "

             << entryToAdd.id();

    targetEntry = entryToAdd;

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    if (entryToAdd.id() == 0) {

        CaObjectAdapter::setId(targetEntry, 0);

    }

    query.exec("begin");

    bool success = (setIconInDb(&targetEntry)

                    && setEntryInDb(&targetEntry)

                    && setAttributesInDb(&targetEntry));

    if (success) {

        query.exec("commit");

        QList<int> parentIds;

        GetParentsIds(QList<int>() << targetEntry.id(), parentIds);

        if (entryToAdd.id() == 0) {

            CaNotifiers::Notify(targetEntry, AddChangeType, parentIds);

        } else {

            CaNotifiers::Notify(targetEntry, UpdateChangeType, parentIds);

        }

        return NoErrorCode;

    } else {

        query.exec("rollback");

        return UnknownErrorCode;

    }

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::removeData(const QList<int> &entryIdList)

{

    qDebug() << "CaClientProxy::removeData" << "entryIdList: "

             << entryIdList;

    QList< QSharedPointer<CaEntry> > entryList;

    getData(entryIdList, entryList);

    QList<QList<int> > parentsIds;

    foreach(QSharedPointer<CaEntry> entry, entryList) {

        QList<int> parentIds;

        GetParentsIds(QList<int>() << entry->id(), parentIds);

        parentsIds.append(parentIds);

    }

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    //begin transaction

    bool success(false);

    query.exec("begin");

    foreach(int entryId, entryIdList) {

        query.prepare(

            "SELECT ENTRY_ID FROM CA_ENTRY WHERE ENTRY_ID = ?");

        query.addBindValue(entryId);

        success = query.exec();

        if (success && query.next()) {

            success

            = query.value(query.record().indexOf("ENTRY_ID")).toInt()

              > 0;

        }

        if (!success) {

            break;

        }

        query.prepare(

            "SELECT EN_ICON_ID FROM CA_ENTRY WHERE ENTRY_ID = ?");

        query.addBindValue(entryId);

        int iconId(0);

        success = query.exec();

        if (success && query.next()) {

            iconId

            = query.value(query.record().indexOf("EN_ICON_ID")).toInt();

        } else {

            break;

        }

        query.prepare("DELETE FROM CA_LAUNCH WHERE LA_ENTRY_ID = ?");

        query.addBindValue(entryId);

        success = query.exec();

        if (success) {

            qDebug() << query.lastQuery() << " rows deleted: "

                     << query.numRowsAffected();

        } else {

            break;

        }

        query.prepare(

            "DELETE FROM CA_GROUP_ENTRY WHERE GE_ENTRY_ID = ?");

        query.addBindValue(entryId);

        success = query.exec();

        if (success) {

            qDebug() << query.lastQuery() << " rows deleted: "

                     << query.numRowsAffected();

        } else {

            break;

        }

        query.prepare(

            "DELETE FROM CA_GROUP_ENTRY WHERE GE_GROUP_ID = ?");

        query.addBindValue(entryId);

        success = query.exec();

        if (success) {

            qDebug() << query.lastQuery() << " rows deleted: "

                     << query.numRowsAffected();

        } else {

            break;

        }

        query.prepare("DELETE FROM CA_ATTRIBUTE WHERE AT_ENTRY_ID = ?");

        query.addBindValue(entryId);

        success = query.exec();

        if (success) {

            qDebug() << query.lastQuery() << " rows deleted: "

                     << query.numRowsAffected();

        } else {

            break;

        }

        query.prepare("DELETE FROM CA_ENTRY WHERE ENTRY_ID = ?");

        query.addBindValue(entryId);

        success = query.exec();

        if (success) {

            qDebug() << query.lastQuery() << " rows deleted: "

                     << query.numRowsAffected();

        } else {

            break;

        }

        if (iconId != 0) {

            query.prepare("DELETE FROM CA_ICON WHERE ICON_ID = ?");

            query.addBindValue(iconId);

            success = query.exec();

            if (success) {

                qDebug() << query.lastQuery() << " rows deleted: "

                         << query.numRowsAffected();

            } else {

                // ignore, this means that the icon cannot be removed

                // because some other entry has the same icon.

                success = true;

            }

        }

    }

    ErrorCode error(NoErrorCode);

    if (success) {

        query.exec("commit");

        if (parentsIds.count() == entryList.count()) {

            for (int i = 0; i < entryList.count(); i++) {

                GetParentsIds(QList<int>() << entryList[i]->id(), parentsIds[i]);

                CaNotifiers::Notify(*entryList[i], RemoveChangeType, parentsIds[i]);

            }

        }

    } else {

        query.exec("rollback");

        error = UnknownErrorCode;

    }

    return error;

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::insertEntriesIntoGroup(int groupId,

        const QList<int> &entryIdList, int beforeEntryId)

{

    qDebug() << "CaClientProxy::insertEntriesIntoGroup" << "groupId: "

             << groupId << "beforeEntryId: " << beforeEntryId << "entryIdList: "

             << entryIdList;

    removeEntriesFromGroup(groupId, entryIdList, false);

    QString queryText;

    if (beforeEntryId == AfterTheLastEntry) {

        queryText = QString("INSERT INTO CA_GROUP_ENTRY (GE_GROUP_ID,GE_ENTRY_ID,GE_POSITION) "

                            "VALUES ( ?, ?,(SELECT MAX(DATA) FROM ( SELECT MAX(GE_POSITION)+ 1 AS DATA FROM CA_GROUP_ENTRY "

                            "WHERE GE_GROUP_ID = %1 UNION SELECT 1 AS DATA FROM CA_GROUP_ENTRY ) ) )").arg(groupId);

    } else if (beforeEntryId == BeforeTheFirstEntry) {

        queryText = "INSERT INTO CA_GROUP_ENTRY (GE_GROUP_ID,GE_ENTRY_ID,GE_POSITION) VALUES ( ?, ?, 0 ) ";

    } else {

        queryText = QString("INSERT INTO CA_GROUP_ENTRY (GE_GROUP_ID,GE_ENTRY_ID,GE_POSITION) VALUES ( "

                            "?, ?, ( SELECT GE_POSITION FROM CA_GROUP_ENTRY WHERE GE_ENTRY_ID = %1 ) ) ").arg(beforeEntryId);

    }

    bool success = true;

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    query.exec("begin");

    for (int i = 0; i < entryIdList.count() && success; ++i) {

        query.prepare(queryText);

        query.addBindValue(groupId);

        query.addBindValue(entryIdList.at(i));

        success = query.exec();

    }

    ErrorCode error(NoErrorCode);

    if (success) {

        query.exec("commit");

        CaNotifiers::Notify(groupId);

    } else {

        query.exec("rollback");

        error = UnknownErrorCode;

    }

    return error;

}

//----------------------------------------------------------------------------

//

//----------------------------------------------------------------------------

ErrorCode CaClientProxy::removeEntriesFromGroup(int groupId,

        const QList<int> &entryIdList,

        bool calledDirectly)

{

    qDebug() << "CaClientProxy::removeEntriesFromGroup" << "groupId: "

             << groupId << "entryIdList: " << entryIdList;

    bool success = true;

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    query.exec("begin");

    for (int i = 0; i < entryIdList.count() && success; ++i) {

        query.prepare(

            "DELETE FROM CA_GROUP_ENTRY WHERE GE_ENTRY_ID = ? AND GE_GROUP_ID = ? ");