/*

* 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 <utility>

#include <algorithm>

#include "pushdatacontainer.h"

#include "comms.h"

#include "logger.h"

#include "javacommonutils.h"

#include "pushdbhandler.h"

#include "pushexception.h"

#include "pusherrorcodes.h"

#include "javauid.h"

#include "javastoragenames.h"

using namespace java::push;

using namespace java::captain;

using namespace java::comms;

using namespace java::storage;

using namespace java::util;

/**

 *

 */

PushDataContainer::PushDataContainer(java::captain::CoreInterface& aCore,

                                     PushDBHandler& aDbHandler)

        : mCore(aCore),mPushDbHandler(aDbHandler),mPushRegsLoaded(false)

{

    JELOG2(EJavaPush);

}

/**

 *

 */

PushDataContainer::~PushDataContainer()

{

    JELOG2(EJavaPush);

    mPushRegistrations.clear();

    mDoNotLaunchList.clear();

    mMidletSuiteInfo.clear();

}

/**

 *

 */

void PushDataContainer::getIdsOfMidlets(std::set<Uid>& aUidList)

{

    JELOG2(EJavaPush);

    //Retrieving all push registrations from the db.

    loadPushRegs();

    PushRegsContainerIter_t iter;

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

    {

        aUidList.insert(iter->first);

    }//end for

}

/**

 *

 */

bool PushDataContainer::isPushConnections(const Uid& aUid)

{

    JELOG2(EJavaPush);

    loadPushRegs();

    std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

    pushRegsOfMidletIter = mPushRegistrations.equal_range(aUid);

    if (pushRegsOfMidletIter.first == pushRegsOfMidletIter.second)

        return false;

    return true;

}

/**

 *

 */

void PushDataContainer::storeDynamicPushRegistration(const Uid& aUid,const std::wstring& aUri,

        const std::wstring& aMidletName,

        const std::wstring& aFilter)

{

    JELOG2(EJavaPush);

    loadPushRegs();

    if (true == pushRegExists(aUri))

    {

        throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,"Push connection already exists",

                            __FILE__,__FUNCTION__,__LINE__);

    }

    mPushDbHandler.storeDynamicPushRegistration(aUid,aUri,aMidletName,aFilter);

    PushRegistrationData data(aUri,aMidletName,aFilter,PushRegistrationData::DYNAMIC_REG);

    mPushRegistrations.insert(std::pair<Uid,PushRegistrationData>(aUid,data));

    //This situation MIDlet must be also removed from "do not launch" list.

    mDoNotLaunchList.erase(aUid);

}

/**

 *

 */

void PushDataContainer::unregisterDynamicPushRegistration(const Uid& aUid,const std::wstring& aUri)

{

    JELOG2(EJavaPush);

    loadPushRegs();

    //Deleting push reg from the storage. It has been checked in the java side that

    //type of the push reg is dynamic and it belongs to one MIDlet in the MIDlet suite.

    mPushDbHandler.unregisterDynamicPushRegistration(aUid,aUri);

    //Deleting push registration from the cache.

    std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

    pushRegsOfMidletIter = mPushRegistrations.equal_range(aUid);

    PushRegsContainerIter_t iter;

    for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

    {

        if (0 == aUri.compare(iter->second.mUri))

        {

            mPushRegistrations.erase(iter);

            break;

        }

    }//end for

    //This situation MIDlet must be also removed from "do not launch" list.

    mDoNotLaunchList.erase(aUid);

}

/**

 *

 */

void PushDataContainer::setMidletDoNotLaunchList(const Uid& aUid)

{

    JELOG2(EJavaPush);

    mDoNotLaunchList.insert(aUid);

}

/**

 *

 */

void PushDataContainer::removeMidletFromDoNotLaunchList(const Uid& aMidletUid)

{

    JELOG2(EJavaPush);

    mDoNotLaunchList.erase(aMidletUid);

}

/**

 *

 */

bool PushDataContainer::isMidletInDoNotLaunchList(const Uid& aUid)

{

    JELOG2(EJavaPush);

    if (0 == mDoNotLaunchList.size())

        return false;

    DoNotLaunchListIter_t iter = mDoNotLaunchList.find(aUid);

    if (mDoNotLaunchList.end() != iter)

        return true;

    return false;

}

/**

 *

 */

void PushDataContainer::removeApp(const Uid& aMidletUid)

{

    JELOG2(EJavaPush);

    mPushRegistrations.erase(aMidletUid);

    removeMidletFromDoNotLaunchList(aMidletUid);

    MidletSuiteInfoContainerIter_t iter;

    for (iter = mMidletSuiteInfo.begin(); iter != mMidletSuiteInfo.end();)

    {

        if (aMidletUid == iter->second.mMidletUid)

        {

            mMidletSuiteInfo.erase(iter++);

            break;

        }

        else

        {

            ++iter;

        }

    }//end for

}

/**

 *

 */

void PushDataContainer::readAppDataFromDb(const Uid& aUid)

{

    JELOG2(EJavaPush);

    try

    {

        loadPushRegs();

        readPushRegs(aUid);

        mPushDbHandler.getMidletSuiteInfoByMidletUid(aUid,mMidletSuiteInfo);

        mDoNotLaunchList.erase(aUid);

    }

    catch (...)

    {

        ELOG(EJavaPush,"ERROR!!! Exception caught in the PushDataContainer::readAppDataFromDb() operation");

    }

}

/**

 *

 */

void PushDataContainer::setPendingStatusOfConn(const Uid& aUid,const std::wstring& aUri,

        bool aMsgWaitsHandling)

{

    JELOG2(EJavaPush);

    LOG1(EJavaPush,EInfo,"aMsgWaitsHandling: %d",(int)aMsgWaitsHandling);

    PushRegistrationData* dataObj = getPushDataByMidletUidAndUri(aUid,aUri);

    dataObj->mPendingStatus = aMsgWaitsHandling;

}

/**

 *

 */

void PushDataContainer::clearPendingStatusesOfMidlet(const java::util::Uid& aMidletUid)

{

    JELOG2(EJavaPush);

    std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

    pushRegsOfMidletIter = mPushRegistrations.equal_range(aMidletUid);

    PushRegsContainerIter_t iter;

    for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

    {

        iter->second.mPendingStatus = false;

    }

}

/**

 *

 */

void PushDataContainer::getPushRegsOfMidletSuite(const Uid& aMidletSuiteUid,

        bool aAllConnsFlag,

        std::list<std::wstring>& aListOfPushUris)

{

    JELOG2(EJavaPush);

    LOG1WSTR(EJavaPush,EInfo,"getPushRegsOfMidletSuite(): Value of the suite UID: %s",

             aMidletSuiteUid.toString());

    LOG1(EJavaPush,EInfo,"aAllConnsFlag: %d",(int)aAllConnsFlag);

    std::pair<MidletSuiteInfoContainerIter_t,MidletSuiteInfoContainerIter_t> suiteInfoIter;

    suiteInfoIter = mMidletSuiteInfo.equal_range(aMidletSuiteUid);

    MidletSuiteInfoContainerIter_t iter;

    for (iter = suiteInfoIter.first; iter != suiteInfoIter.second; ++iter)

    {

        fillConnectionsOfMidlet(iter->second.mMidletUid,aAllConnsFlag,aListOfPushUris);

    }//end  for

}

/**

 *

 */

const std::wstring& PushDataContainer::getFilterOfPushConn(const Uid& aSuiteUid,

        const std::wstring& aUri)

{

    JELOG2(EJavaPush);

    PushRegistrationData* dataObj = getPushConnOfSuite(aSuiteUid,aUri);

    return dataObj->mFilter;

}

/**

 *

 */

const std::wstring& PushDataContainer::getClassNameOfPushConn(const Uid& aSuiteUid,

        const std::wstring& aUri)

{

    JELOG2(EJavaPush);

    PushRegistrationData* dataObj = getPushConnOfSuite(aSuiteUid,aUri);

    return dataObj->mMidletClass;

}

/**

 *

 */

const Uid& PushDataContainer::getMidletUid(const Uid& aSuiteUid,

        const std::wstring& aClassName)

{

    JELOG2(EJavaPush);

    std::pair<MidletSuiteInfoContainerIter_t,MidletSuiteInfoContainerIter_t> suiteInfoIter;

    suiteInfoIter = mMidletSuiteInfo.equal_range(aSuiteUid);

    MidletSuiteInfoContainerIter_t iter;

    for (iter = suiteInfoIter.first; iter != suiteInfoIter.second; ++iter)

    {

        if (iter->second.mMidletClassName == aClassName)

        {

            return iter->second.mMidletUid;

        }

    }//end  for

    throw PushException(INCORRECT_APP_DATA,

                        "Class name does not match to any MIDlet in the suite",

                        __FILE__,__FUNCTION__,__LINE__);

}

/**

 *

 */

bool PushDataContainer::getSuiteUidByBaseUri(const std::wstring& aBaseUri,

        Uid& aOutputSuiteUid)

{

    JELOG2(EJavaPush);

    PushRegsContainerIter_t iter;

    std::string aBaseUriStr(aBaseUri.begin(),aBaseUri.end());

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

    {

        //size_t found = iter->second.mUri.find(aBaseUri);

        //if(0 == found)

        std::string fullUriStr(iter->second.mUri.begin(),iter->second.mUri.end());

        bool matchFlag = isUriStartingWith(fullUriStr,aBaseUriStr);

        if (true == matchFlag)

        {

            return getSuiteUidByMidletUid(iter->first,aOutputSuiteUid);

        }

    }//end for

    return false;

}

/**

 *

 */

int PushDataContainer::getMediaIdByMidletUid(const Uid& aMidletUid)

{

    JELOG2(EJavaPush);

    MidletSuiteInfoContainerIter_t iter;

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

    {

        if (aMidletUid == iter->second.mMidletUid)

        {

            return iter->second.mMediaId;

        }

    }

    return UNDEFINED_MEDIA_ID;

}

/**

 *

 */

void PushDataContainer::getMidletUidsByMediaId(unsigned int aMediaId,std::list<Uid>& aUidList)

{

    JELOG2(EJavaPush);

    MidletSuiteInfoContainerIter_t iter;

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

    {

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

            aUidList.push_back(iter->second.mMidletUid);

    }

}

/**

 *

 */

void PushDataContainer::loadPushRegs()

{

    JELOG2(EJavaPush);

    if (true == mPushRegsLoaded)

        return;

    //Empty uid means that all push registrations are read from the db.

    java::util::Uid emptyUid;

    readPushRegs(emptyUid);

    //readMidletSuiteInfo(emptyUid);

    mPushDbHandler.getMidletSuiteInfo(emptyUid,mMidletSuiteInfo);

    mPushRegsLoaded = true;

}

/**

 *

 */

void PushDataContainer::readPushRegs(const java::util::Uid& aUid)

{

    JELOG2(EJavaPush);

    LOG1WSTR(EJavaPush,EInfo,"readPushRegs() Uid: %s",aUid.toString());

    JavaStorageApplicationList_t pushRegs;

    mPushDbHandler.getPushRegs(aUid,pushRegs);

    JavaStorageApplicationList_t::iterator iter;

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

    {

        insertPushRegToInternalContainer(iter);

    }//end for

}

/**

 *

 */

void PushDataContainer::insertPushRegToInternalContainer

(JavaStorageApplicationList_t::iterator& aIter)

{

    JavaStorageApplicationEntry_t::iterator multisetIter;

    Uid uid;

    std::wstring uri;

    std::wstring midletClass;

    std::wstring filter;

    PushRegistrationData::RegistrationType_t regType = PushRegistrationData::DYNAMIC_REG;

    int counter = 0;

    for (multisetIter = aIter->begin(); multisetIter != aIter->end(); ++multisetIter)

    {

        try

        {

            if (0 == multisetIter->entryName().compare(ID))

            {

                Uid tmpUid(multisetIter->entryValue());

                uid = tmpUid;

                counter++;

            }

            else if (0 == multisetIter->entryName().compare(URL))

            {

                uri = multisetIter->entryValue();

                counter++;

            }

            else if (0 == multisetIter->entryName().compare(NAME))

            {

                midletClass = multisetIter->entryValue();

                counter++;

            }

            else if (0 == multisetIter->entryName().compare(FILTER))

            {

                filter = multisetIter->entryValue();

                counter++;

            }

            else if (0 == multisetIter->entryName().compare(REGISTRATION_TYPE))

            {

                int tmpInt = JavaCommonUtils::wstringToInt(multisetIter->entryValue());

                if ((tmpInt == PushRegistrationData::DYNAMIC_REG)

                        || (tmpInt == PushRegistrationData::STATIC_REG))

                {

                    regType = (PushRegistrationData::RegistrationType_t) tmpInt;

                    counter++;

                }

            }

            if (5 == counter)

            {

                //All arguments reads successfully.

                PushRegistrationData data(uri,midletClass,filter,regType);

                mPushRegistrations.insert(std::pair<Uid,PushRegistrationData>(uid,data));

                counter = 0;

            }

            else if (5 > counter)

            {

                continue;

            }

            else

            {

                ELOG1(EJavaPush,"ERROR!!! All arguments wasn''t read successfully: %d",counter);

                counter = 0;

            }

        }

        catch (...)

        {

            ELOG(EJavaPush,"ERROR!!! Exception caught in the reading push regs");

        }

    }//end for

}

/**

 *

 */

void PushDataContainer::getPushRegsOfMidlet(const Uid& aUid,std::list<PushRegData>& aOutputList)

{

    JELOG2(EJavaPush);

    loadPushRegs();

    std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

    pushRegsOfMidletIter = mPushRegistrations.equal_range(aUid);

    PushRegsContainerIter_t iter;

    for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

    {

        PushRegData pushData(iter->second.mUri,iter->second.mFilter);

        aOutputList.push_back(pushData);

    }//end for

}

/**

 *

 */

bool PushDataContainer::pushRegExists(const std::wstring& aUri)

{

    JELOG2(EJavaPush);

    for (PushRegsContainerIter_t iter = mPushRegistrations.begin();

            iter != mPushRegistrations.end(); ++iter)

    {

        if (0 == aUri.compare(iter->second.mUri))

            return true;

    }

    return false;

}

/**

 *

 */

void PushDataContainer::fillConnectionsOfMidlet(const java::util::Uid& aMidletUid,

        bool aAllConnsFlag,

        std::list<std::wstring>& aListOfPushUris)

{

    std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;