/*

* Copyright (c) 2010 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: MediaIdUpdater

*

*/

#include <algorithm>

#include <memory>

#include "mediaidupdater.h"

#include "logger.h"

#include "javacommonutils.h"

#include "driveutilities.h"

#include "javastorageentry.h"

#include "javastorage.h"

#include "javastoragenames.h"

using namespace java::backup;

using namespace java::storage;

using namespace java::util;

MediaIdUpdater::MediaIdUpdater() : mStorage(0)

{

}

MediaIdUpdater::~MediaIdUpdater()

{

    close();

}

/**

* Ensures that java storage does not contain media ids that are not valid any more.

* Media id updating is done in following steps:

*   - get media ids from storage

*   - get present (valid) media ids

*   - get difference between storage and present ids (result is invalid ids that need to be updated)

*   - update invalid media ids with valid ids

* @param -

* @return -

*/

void MediaIdUpdater::update()

{

    try

    {

        open();

        std::set<std::wstring> storageIds = getMediaIdsFromStorage();

        std::set<std::wstring> presentIds = getPresentMediaIds();

        std::set<std::wstring> invalidIds = removePresentMediaIds(storageIds, presentIds);

        std::set<std::wstring> validIds = getPresentRemovableDriveMediaIds();

        if (isMediaIdUpdateNeeded(invalidIds, validIds))

        {

            updateMediaIds(invalidIds, validIds);

        }

        close();

    }

    catch (JavaStorageException jse)

    {

        ELOG1(EBackup, "MediaIdUpdater::update() failed: %S", jse.toString().c_str());

    }

}

/**

* Gets present media ids. Result includes phone, internal and mass memory drive ids if any

* @param -

* @return present media ids

*/

std::set<std::wstring> MediaIdUpdater::getPresentMediaIds()

{

    std::set<std::wstring> result;

    java::fileutils::driveInfos drives;

    java::fileutils::DriveUtilities::getAccesibleDrives(drives);

    PLOG1(EBackup, "getPresentMediaIds(count=%d)", drives.size());

    for (java::fileutils::driveInfos::const_iterator iter = drives.begin(); iter != drives.end(); iter++)

    {

        PLOG2(EBackup, "  %S - id=%d", (*iter).iRootPath.c_str(), (*iter).iId);

        std::wstring mediaId = JavaCommonUtils::intToWstring((*iter).iId);

        result.insert(mediaId);

    }

    result.insert(L"0"); // default set by javainstaller for internal drives

    return result;

}

/**

* Gets present removable media ids. Result mass memory drive ids if any

* @param -

* @return present removable media ids

*/

std::set<std::wstring> MediaIdUpdater::getPresentRemovableDriveMediaIds()

{

    std::set<std::wstring> result;

    java::fileutils::driveInfos drives;

    java::fileutils::DriveUtilities::getAccesibleDrives(drives);

    PLOG1(EBackup, "getPresentRemovableDriveMediaIds(count=%d)", drives.size());

    for (java::fileutils::driveInfos::const_iterator iter = drives.begin(); iter != drives.end(); iter++)

    {

        if ((*iter).iIsRemovable)

        {

            PLOG2(EBackup, "  %S - id=%d", (*iter).iRootPath.c_str(), (*iter).iId);

            std::wstring mediaId = JavaCommonUtils::intToWstring((*iter).iId);

            result.insert(mediaId);

        }

    }

    return result;

}

/**

* Filters present media ids from given set.

* @param[in] aStorageIds original media ids

* @param[in] aPresentIds present media ids

* @return set of media ids that are invalid i.e. not present at the moment

*/

std::set<std::wstring> MediaIdUpdater::removePresentMediaIds(const std::set<std::wstring>& aStorageIds,

                                           const std::set<std::wstring>& aPresentIds)

{

    std::set<std::wstring> result;

    std::set_difference(aStorageIds.begin(), aStorageIds.end(),

                        aPresentIds.begin(), aPresentIds.end(),

                        std::inserter(result, result.end()));

    return result;

}

/**

* Checks if there is a need for updating given media ids

* @param[in] aInvalidIds media ids to be updated

* @param[in] aValidIds valid ids used during update

* @return true, if media ids need to be updated, false otherwise

*/

bool MediaIdUpdater::isMediaIdUpdateNeeded(const std::set<std::wstring>& aInvalidIds,

                           const std::set<std::wstring>& aValidIds)

{

    if(aInvalidIds.size() > 0 && aValidIds.size() > 0)

    {

        return true;

    }

    return false;

}

/**

* Gets media ids that can be found from java storage.

* @param -

* @return media ids found from java storage

*/

std::set<std::wstring> MediaIdUpdater::getMediaIdsFromStorage()

{

    std::set<std::wstring> result;

    JavaStorageEntry attribute;

    attribute.setEntry(MEDIA_ID, L"");

    JavaStorageApplicationEntry_t findQuery;

    findQuery.insert(attribute);

    JavaStorageApplicationList_t foundEntries;

    mStorage->search(APPLICATION_PACKAGE_TABLE, findQuery, foundEntries);

    PLOG1(EBackup, "getMediaIdsFromStorage(count=%d)", foundEntries.size());

    for (JavaStorageApplicationList_t::const_iterator iter = foundEntries.begin(); iter != foundEntries.end(); iter++)

    {

        std::wstring id = (*iter).begin()->entryValue();

        PLOG1(EBackup, "  id=%S", id.c_str());

        result.insert(id);

    }

    return result;

}

/**

* Updates given media ids with new values and saves the result in java storage.

* @param[in] aInvalidIds media ids to be updated

* @param[in] aValidIds valid ids used during update

* @return -

*/

void MediaIdUpdater::updateMediaIds(const std::set<std::wstring>& aInvalidIds,

                    const std::set<std::wstring>& aValidIds)

{

    if (aValidIds.size() == 0)

    {

        return;

    }

    // use the first present media id for all

    std::wstring newId = *(aValidIds.begin());

    mStorage->startTransaction();

    PLOG1(EBackup, "updateMediaIds(count=%d)", aInvalidIds.size());

    for (std::set<std::wstring>::const_iterator iter = aInvalidIds.begin(); iter != aInvalidIds.end(); ++iter)

    {

        std::wstring origId = (*iter).c_str();

        PLOG2(EBackup, "  origId=%S - newId=%S", origId.c_str(), newId.c_str());

        JavaStorageEntry attribute;

        attribute.setEntry(MEDIA_ID, newId);

        JavaStorageApplicationEntry_t updateEntry;

        updateEntry.insert(attribute);

        JavaStorageApplicationEntry_t matchEntry;

        attribute.setEntry(MEDIA_ID, origId);

        matchEntry.insert(attribute);

        mStorage->update(APPLICATION_PACKAGE_TABLE, updateEntry, matchEntry);

    }

    mStorage->commitTransaction();

}

/**

* Opens java storage connection

* @param -

* @return -

*/

void MediaIdUpdater::open()

{

    close();

    mStorage = JavaStorage::createInstance();

    mStorage->open(JAVA_DATABASE_NAME);

}

/**

* Closes java storage connection

* @param -

* @return -

*/

void MediaIdUpdater::close()

{

    try

    {

        if (mStorage)

        {

            mStorage->close();

            delete mStorage;

            mStorage = 0;

        }

    }

    catch (JavaStorageException jse)

    {

        ELOG1(EBackup, "MediaIdUpdater::close() failed: %S", jse.toString().c_str());

    }

}