/*

 * 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 "hswidgetregistryservice.h"

const char *DATABASE_CONNECTION_NAME = "CaService";

const char *DATABASE_TYPE = "QSQLITE";

const char *DATABASE_NAME = "castoragedb";

static QSqlDatabase dbConnection()

{

    return QSqlDatabase::database(DATABASE_CONNECTION_NAME, false);

}

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

//

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

CaClientProxy::CaClientProxy() :

    mWidgetRegistryPath("hsresources/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<HsWidgetToken> widgets = rs->widgets();

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

    // registry with Content Storage database.

    foreach(const HsWidgetToken &widgetToken, widgets) {

        int uid = widgetToken.mUid;

        if (!hsWidgetExists(uid)) {

            // The given widget does not have a corresonding entry

            // in the databse, so such an entry needs do be created.

            addWidgetEntry(widgetToken);

        }

    }

    delete rs;

    qDebug("CaClientProxy::updateWidgets end");

}

/*!

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

 */

void CaClientProxy::addWidgetEntry(const HsWidgetToken &widgetToken)

{

    QString description = widgetToken.mDescription;

    QString iconUri = widgetToken.mIconUri;

    QString library = widgetToken.mLibrary;

    QString title = widgetToken.mTitle;

    int uid = widgetToken.mUid;

    QString uri = widgetToken.mUri;

    QSqlDatabase db = dbConnection();

    QSqlQuery query(db);

    QString hexUid;

    hexUid.setNum(uid,16);

    QDir currentDir = QDir::current();

    // 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();

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

    // Add attribute packageuid

    QString queryAddAttribute1 =

        "INSERT INTO CA_ATTRIBUTE " \

        "(AT_ENTRY_ID, AT_NAME, AT_VALUE) " \

        "VALUES " \

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

    query.prepare(queryAddAttribute1);

    query.addBindValue(lastId);

    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(lastId);

    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(lastId);

    query.addBindValue(library);

    query.exec();

    qDebug() << query.executedQuery();

}

/*!

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

 */

bool CaClientProxy::hsWidgetExists(int uid)

{

    bool exists(false);

    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()) {

        // Query returned a non empty result.

        exists = true;

    } else {

        // The widget with the given uid was not found.

        exists = false;

    }

    qDebug() << query.executedQuery();

    return exists;

}

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

//

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

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<CaEntry *> entryList;

    getData(entryIdList, entryList);

    QList<QList<int> > parentsIds;

    foreach(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 = ? ");

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

        query.addBindValue(groupId);

        success = query.exec();

    }

    ErrorCode error(NoErrorCode);

    if (success) {

        query.exec("commit");

        if (calledDirectly) {

            CaNotifiers::Notify(groupId);

        }

    } else {

        query.exec("rollback");

        error = UnknownErrorCode;

    }

    return error;

}

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

//

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

ErrorCode CaClientProxy::getData(const QList<int> &entryIdList,

                                 QList<CaEntry *> &sourceList)

{

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

             << entryIdList;

    QSqlDatabase db = dbConnection();

    bool success(true);

    foreach(int i, entryIdList) {

        QSqlQuery query(db);

        query.prepare(

            "SELECT ENTRY_ID, EN_TEXT, EN_DESCRIPTION, EN_TYPE_NAME, EN_FLAGS, EN_ROLE, EN_UID,  \

                  FROM CA_ENTRY LEFT JOIN CA_ICON ON EN_ICON_ID = ICON_ID WHERE ENTRY_ID = ?");

        query.addBindValue(i);

        success = query.exec();

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

            qDebug() << query.executedQuery();

            int role =

                query.value(query.record().indexOf("EN_ROLE")).toInt();

            CaEntry *entry = new CaEntry((EntryRole) role);

            CaObjectAdapter::setId(*entry,

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

            entry->setText(query.value(

                               query.record().indexOf("EN_TEXT")).toString());

            entry->setDescription(query.value(