/*

* Copyright (c) 2008 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 "logger.h"

#include "pushdbhandler.h"

#include "javacommonutils.h"

#include "pusherrorcodes.h"

#include "pushexception.h"

#include "javastorageexception.h"

#include "javastoragenames.h"

using namespace java::push;

using namespace java::storage;

using namespace java::util;

/**

 *

 */

PushDBHandler::PushDBHandler()

        : mDbStorage(NULL)

{

    JELOG2(EJavaPush);

}

/**

 *

 */

PushDBHandler::~PushDBHandler()

{

    JELOG2(EJavaPush);

}

/**

 *

 */

void PushDBHandler::storeDynamicPushRegistration(const java::util::Uid& aUid,

        const std::wstring& aUri,

        const std::wstring& aMidletName,

        const std::wstring& aFilter)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageApplicationEntry_t entries;

        JavaStorageEntry entry;

        entry.setEntry(URL,aUri,JavaStorageEntry::STRING);

        entries.insert(entry);

        entry.setEntry(NAME,aMidletName,JavaStorageEntry::STRING);

        entries.insert(entry);

        entry.setEntry(FILTER,aFilter,JavaStorageEntry::STRING);

        entries.insert(entry);

        entry.setEntry(REGISTRATION_TYPE,L"0",JavaStorageEntry::INT);

        entries.insert(entry);

        entry.setEntry(ID, aUid.toString());

        entries.insert(entry);

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->startTransaction();

        mDbStorage->write(PUSH_REGISTRATIONS_TABLE,entries);

        mDbStorage->commitTransaction();

        mDbStorage->close();

    }

    catch (JavaStorageException& ex)

    {

        if (0 != mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in storeDynamicPushRegistration() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::unregisterDynamicPushRegistration(const java::util::Uid& aUid,

        const std::wstring& aUri)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageApplicationEntry_t entries;

        JavaStorageEntry entry;

        entry.setEntry(ID,aUid.toString(),JavaStorageEntry::STRING);

        entries.insert(entry);

        entry.setEntry(URL,aUri,JavaStorageEntry::STRING);

        entries.insert(entry);

        entry.setEntry(REGISTRATION_TYPE,L"0",JavaStorageEntry::INT);

        entries.insert(entry);

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->startTransaction();

        mDbStorage->remove(PUSH_REGISTRATIONS_TABLE,entries);

        mDbStorage->commitTransaction();

        mDbStorage->close();

    }

    catch (PushException& ex)

    {

        if (0 != mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw;

    }

    catch (JavaStorageException& ex)

    {

        if (0 != mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in unregisterDynamicPushRegistration() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::storeAlarm(const Uid& aUid,const long long& aAlarmInMilliSecs)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageApplicationEntry_t entries;

        JavaStorageEntry entry;

        std::wstring timeStr = JavaCommonUtils::longLongToWstring(aAlarmInMilliSecs);

        entry.setEntry(ALARM_TIME,timeStr,JavaStorageEntry::STRING);

        entries.insert(entry);

        entry.setEntry(ID, aUid.toString());

        entries.insert(entry);

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->startTransaction();

        mDbStorage->write(ALARM_REGISTRATIONS_TABLE,entries);

        mDbStorage->commitTransaction();

        mDbStorage->close();

    }

    catch (JavaStorageException& ex)

    {

        if (0 !=mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in storeAlarm() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::deleteAlarm(const Uid& aUid)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageApplicationEntry_t entries;

        JavaStorageEntry entry;

        entry.setEntry(ID, aUid.toString());

        entries.insert(entry);

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->startTransaction();

        mDbStorage->remove(ALARM_REGISTRATIONS_TABLE,entries);

        mDbStorage->commitTransaction();

        mDbStorage->close();

    }

    catch (JavaStorageException& ex)

    {

        if (0 !=mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in deleteAlarm() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->rollbackTransaction();

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::getPushRegs(const java::util::Uid& aUid,

                                java::storage::JavaStorageApplicationList_t& aPushRegs)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageApplicationEntry_t findPatterns;

        JavaStorageEntry findPattern;

        if (!aUid.isEmpty())

        {

            findPattern.setEntry(ID,aUid.toString(),JavaStorageEntry::STRING);

            findPatterns.insert(findPattern);

        }

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->search(PUSH_REGISTRATIONS_TABLE,findPatterns,aPushRegs);

        mDbStorage->close();

    }

    catch (JavaStorageException& ex)

    {

        if (0 !=mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in getPushRegs() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::getAlarms(const java::util::Uid& aUid,

                              std::list<DbAlarmData>& aAlarmList)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageEntry findPattern;

        JavaStorageApplicationEntry_t findPatterns;

        JavaStorageApplicationList_t foundEntries;

        if (!aUid.isEmpty())

        {

            findPattern.setEntry(ID,aUid.toString(),JavaStorageEntry::STRING);

            findPatterns.insert(findPattern);

        }

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->search(ALARM_REGISTRATIONS_TABLE,findPatterns,foundEntries);

        fillAlarmData(aAlarmList,foundEntries);

        mDbStorage->close();

    }

    catch (JavaStorageException& ex)

    {

        if (0 !=mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in getAlarms() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::getMidletSuiteInfo(const java::util::Uid& aSuiteUid,

                                       std::multimap<Uid,

                                       MidletSuiteData>& aMidletSuiteInfo)

{

    JELOG2(EJavaPush);

    getMidletSuiteInfo(aSuiteUid,PACKAGE_ID,aMidletSuiteInfo);

}

/**

 *

 */

void PushDBHandler::getMidletSuiteInfoByMidletUid

(const Uid& aMidletUid,std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo)

{

    JELOG2(EJavaPush);

    getMidletSuiteInfo(aMidletUid,ID,aMidletSuiteInfo);

}

/**

 *

 */

void PushDBHandler::getMidletSuiteInfo(const java::util::Uid& aUid,

                                       const std::wstring& aSearchColumn,

                                       std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo)

{

    JELOG2(EJavaPush);

    try

    {

        JavaStorageEntry findPattern;

        JavaStorageApplicationEntry_t findPatterns;

        JavaStorageApplicationList_t foundEntries;

        if (!aUid.isEmpty())

        {

            //Search condition can be PACKAGE_ID or ID.

            findPattern.setEntry(aSearchColumn,aUid.toString(),JavaStorageEntry::STRING);

            findPatterns.insert(findPattern);

        }

        findPattern.setEntry(PACKAGE_ID,L"");

        findPatterns.insert(findPattern);

        findPattern.setEntry(ID,L"");

        findPatterns.insert(findPattern);

        findPattern.setEntry(MAIN_CLASS,L"");

        findPatterns.insert(findPattern);

        //ScopedLock lockObj(mMutex);

        openDbStorage();

        mDbStorage->search(APPLICATION_TABLE,findPatterns,foundEntries);

        fillMidletSuiteInfo(aMidletSuiteInfo,foundEntries);

        addMediaId(*mDbStorage.get(),aMidletSuiteInfo);

        mDbStorage->close();

    }

    catch (ExceptionBase& ex)

    {

        if (0 !=mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);

    }

    catch (...)

    {

        WLOG(EJavaPush,"ERROR!!! Unexpected error in getAlarms() operation");

        if (0 != mDbStorage.get())

        {

            mDbStorage->close();

        }

        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);

    }

}

/**

 *

 */

void PushDBHandler::addMediaId(JavaStorage& aStorageObj,

                               std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo)

{

    JELOG2(EJavaPush);

    std::map<Uid,int> mediaIdContainer;

    std::map<Uid,int>::iterator mediaIdContainerIter;

    std::multimap<Uid,MidletSuiteData>::iterator iter;

    for (iter = aMidletSuiteInfo.begin(); iter != aMidletSuiteInfo.end(); ++iter)

    {

        if (UNDEFINED_MEDIA_ID == iter->second.mMediaId)

        {

            mediaIdContainerIter = mediaIdContainer.find(iter->first);

            if (mediaIdContainer.end() == mediaIdContainerIter)

            {

                getMediaId(aStorageObj,iter->first,mediaIdContainer);

                mediaIdContainerIter = mediaIdContainer.find(iter->first);

                if (mediaIdContainer.end() == mediaIdContainerIter)

                {

                    throw PushException(DB_ERROR,"media id by suite uid is not found",

                                        __FILE__,__FUNCTION__,__LINE__);

                }

            }

            iter->second.mMediaId = mediaIdContainerIter->second;

        }//end if(-1 == iter->second.mMediaId)

    }//end for

    mediaIdContainer.clear();

}

/**

 *

 */

void PushDBHandler::getMediaId(JavaStorage& aStorageObj,const Uid& aSuiteUid,

                               std::map<Uid,int>& aMediaIdContainer)

{

    JavaStorageEntry findPattern;

    JavaStorageApplicationEntry_t findPatterns;

    JavaStorageApplicationList_t foundEntries;

    findPattern.setEntry(ID,aSuiteUid.toString(),JavaStorageEntry::STRING);

    findPatterns.insert(findPattern);

    findPattern.setEntry(MEDIA_ID,L"");

    findPatterns.insert(findPattern);

    aStorageObj.search(APPLICATION_PACKAGE_TABLE,findPatterns,foundEntries);

    fillMidletId(aSuiteUid,aMediaIdContainer,foundEntries);

}

/**

 *

 */

void PushDBHandler::fillMidletId(const Uid& aSuiteUid,

                                 std::map<Uid,int>& aMediaIdContainer,

                                 JavaStorageApplicationList_t& aFoundEntries)

{

    JavaStorageEntry findPatternForMediaId;

    std::wstring empty = L"";

    findPatternForMediaId.setEntry(MEDIA_ID,empty);

    JavaStorageApplicationList_t::iterator iter;

    for (iter = aFoundEntries.begin(); iter != aFoundEntries.end(); ++iter)

    {

        int mediaId = 0;

        if ((true == getDbValueAsInt(iter,findPatternForMediaId,mediaId)))

            aMediaIdContainer.insert(std::pair<Uid,int>(aSuiteUid,mediaId));

    }//end for

}

/**

 *

 */

void PushDBHandler::fillAlarmData(std::list<DbAlarmData>& aAlarmList,

                                  JavaStorageApplicationList_t& aFoundEntries)

{

    JELOG2(EJavaPush);

    JavaStorageEntry findPatternForUid;

    std::wstring empty = L"";

    findPatternForUid.setEntry(ID,empty);

    JavaStorageEntry findPatternForTime;

    findPatternForTime.setEntry(ALARM_TIME,empty);

    JavaStorageApplicationList_t::iterator iter;

    for (iter = aFoundEntries.begin(); iter != aFoundEntries.end(); ++iter)

    {

        // Get application ID.

        Uid tmpUid;

        long long tmpTime = 0LL;

        if ((true == getDbValueAsUid(iter,findPatternForUid,tmpUid))

                && (true == getDbValueAsLongLong(iter,findPatternForTime,tmpTime)))

        {

            DbAlarmData alarmData(tmpUid,tmpTime,true);

            aAlarmList.push_back(alarmData);

        }

    }//end for

}

/**

 *

 */

void PushDBHandler::fillMidletSuiteInfo(std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo,

                                        JavaStorageApplicationList_t& aFoundEntries)

{

    JELOG2(EJavaPush);

    JavaStorageEntry findPatternForSuiteUid;

    std::wstring empty = L"";

    findPatternForSuiteUid.setEntry(PACKAGE_ID,empty);

    JavaStorageEntry findPatternForMidletUid;

    findPatternForMidletUid.setEntry(ID,empty);

    JavaStorageEntry findPatternForMainClass;

    findPatternForMainClass.setEntry(MAIN_CLASS,empty);

    JavaStorageApplicationList_t::iterator iter;

    for (iter = aFoundEntries.begin(); iter != aFoundEntries.end(); ++iter)

    {

        Uid tmpSuiteUid;

        Uid tmpMidletUid;