/*
* Copyright (c) 2009 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 "storagetestutils.h"
#include "javastorageexception.h"
#include "javacommonutils.h"
#include "javaoslayer.h"

#include "javastorage.h"
#include "javastorageentry.h"
#include "javastoragenames.h"
#include "javauid.h"

using namespace java::storage;
using namespace java::util;
using namespace std;

OS_EXPORT JavaStorageTestUtils::JavaStorageTestUtils()
{
}

OS_EXPORT JavaStorageTestUtils::~JavaStorageTestUtils()
{
}

/**
 * Compare two JavaStorageEntry to each other.
 *
 * @return true if match.
 */
OS_EXPORT bool JavaStorageTestUtils::compareEntry(
    const JavaStorageEntry& aRef,
    const JavaStorageEntry& aSource)
{
    bool equals = true;
    if (aRef.entryName() != aSource.entryName())
    {
        equals = false;
        printf("[JTU]: Entry name does not match\n");
        char* sqlInUtf = JavaCommonUtils::wstringToUtf8(aRef.entryName());
        printf("[JTU]: Entry Ref Name: '%s'", sqlInUtf);
        delete[] sqlInUtf;

        sqlInUtf = JavaCommonUtils::wstringToUtf8(aSource.entryName());
        printf(" Source Name: '%s'\n", sqlInUtf);
        delete[] sqlInUtf;
    }
    else if (aRef.entryValue() != aSource.entryValue())
    {
        equals = false;
        printf("[JTU]: Entry value does not match\n");
        char* sqlInUtf = JavaCommonUtils::wstringToUtf8(aRef.entryValue());
        printf("[JTU]: Entry Ref val: '%s'", sqlInUtf);
        delete[] sqlInUtf;

        sqlInUtf = JavaCommonUtils::wstringToUtf8(aSource.entryValue());
        printf(" Source val: '%s'\n", sqlInUtf);
        delete[] sqlInUtf;
    }

    return equals;
}

/**
 * Compare two ApplicationEntry to each other.
 *
 * @return true if match.
 */
OS_EXPORT bool JavaStorageTestUtils::compareEntries(
    const JavaStorageApplicationEntry_t& aRef,
    const JavaStorageApplicationEntry_t& aSource)
{
    bool equals = false;

    if (aRef.size() != aSource.size())
    {
        printf("[JTU]: Size does not match. RefSize: %d", aRef.size());
        printf(" SourceSize: %d\n", aSource.size());
        printf("Printing ref entry\n");
        printEntry(aRef);
        printf("Printing source entry\n");
        printEntry(aSource);

        return equals;
    }

    JavaStorageApplicationEntry_t::const_iterator refIter;

    // Go through all reference values.
    for (refIter = aRef.begin(); refIter != aRef.end(); refIter++)
    {
        // printf("[JTU]: Comparing entry\n");

        JavaStorageEntry refEntry = (*refIter);

        // Check source contains same entry.
        JavaStorageApplicationEntry_t::const_iterator sourceIterator =
            aSource.find(refEntry);

        if (sourceIterator != aSource.end())
        {
            JavaStorageEntry sourceEntry = (*sourceIterator);
            // Make sure it definitely is same.
            bool result = compareEntry(refEntry, sourceEntry);
            if (!result)
            {
                printf("[JTU]: Entry did not match\n");
                return equals;
            }
        }
        else
        {
            printf("[JTU]: No similar source entry found\n");
            return equals;
        }
    }
    return true;
}

OS_EXPORT bool JavaStorageTestUtils::populate(
    JavaStorage& aStorage,
    const string& aTableName,
    const JavaStorageApplicationEntry_t& aRef)
{
    bool success = false;

    try
    {
        aStorage.write(aTableName, aRef);
        success = true;
    }
    catch (JavaStorageException& jse)
    {
        printf("[JTU]: JSE while populating: %s\n", jse.toString().c_str());
    }
    catch (...)
    {
        printf("[JTU]: Unexcpedted exception thrown while populating\n");
    }

    return success;
}


OS_EXPORT bool JavaStorageTestUtils::update(
    JavaStorage& aStorage,
    const string& aTableName,
    const JavaStorageApplicationEntry_t& aUpdate,
    const JavaStorageApplicationEntry_t& aMatch)
{
    bool success = false;

    try
    {
        aStorage.update(aTableName, aUpdate, aMatch);
        success = true;
    }
    catch (JavaStorageException& jse)
    {
        printf("[JTU]: JSE while updating: %s\n", jse.toString().c_str());
    }
    catch (...)
    {
        printf("[JTU]: Unexcpedted exception thrown while updating\n");
    }

    return success;
}

OS_EXPORT bool JavaStorageTestUtils::checkParams(
    JavaStorage& aStorage,
    const string& aTableName,
    const JavaStorageApplicationEntry_t& aRef,
    int aFoundApps)
{
    bool equals = false;

    try
    {
        JavaStorageApplicationList_t foundApps;

        aStorage.search(aTableName, aRef, foundApps);

        if (foundApps.size() != aFoundApps)
        {
            printf("[JTU]: Invalid amount of applications received: ");
            printf("Expected: %d", aFoundApps);
            printf(" Found: %d\n", foundApps.size());

            /*            // ################################

                        JavaStorageApplicationList_t::const_iterator appIter;
                        appIter = foundApps.begin();

                        if (foundApps.size() > 0)
                        {
                            printEntry((*appIter));
                            appIter++;
                        }
                        if (foundApps.size() > 1)
                        {
                            printEntry((*appIter));
                        }

                        // ##################################
            */
            return false;
        }
        else
        {
            JavaStorageApplicationList_t::const_iterator appIter;

            // Go through all entries
            for (appIter = foundApps.begin(); appIter != foundApps.end(); appIter++)
            {
                // printf("Comparing application\n");
                JavaStorageApplicationEntry_t app = (*appIter);

                equals = compareEntries(aRef, app);
                app.clear();
                if (!equals)
                {
                    printf("Applications did not match\n");
                    return false;
                }
            }
        }
        foundApps.clear();

        equals = true;
    }
    catch (JavaStorageException& jse)
    {
        printf("[JTU]: JSE while checking: %s\n", jse.toString().c_str());
    }
    catch (...)
    {
        printf("[JTU]: Unexcpedted exception thrown while checking\n");
    }

    return equals;
}

OS_EXPORT bool JavaStorageTestUtils::remove(
    JavaStorage& aStorage,
    const string& aTableName,
    const JavaStorageApplicationEntry_t& aRef)
{
    bool success = false;

    try
    {
        aStorage.remove(aTableName, aRef);

        JavaStorageApplicationList_t foundApps;

        // Verify removal
        aStorage.search(aTableName, aRef, foundApps);
        // printf("[JTU]: Entries found: %d\n", foundApps.size());
        if (foundApps.size() == 0)
        {
            success = true;
        }
    }
    catch (JavaStorageException& jse)
    {
        printf("[JTU]: JSE while removing: %s\n", jse.toString().c_str());
    }
    catch (...)
    {
        printf("[JTU]: Unexcpedted exception thrown while removing\n");
    }

    return success;
}

OS_EXPORT void JavaStorageTestUtils::createAppDataEntry(
    JavaStorageApplicationEntry_t& aEntry)
{
    wstring name = PACKAGE_NAME;
    wstring nameValue = L"MyDefaultMIDlet";
    JavaStorageEntry entry;

    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = VENDOR;
    nameValue = L"MyDefaultVendor";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = VERSION;
    nameValue = L"12.12.12";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = ROOT_PATH;
    nameValue = L"/home/default";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = MEDIA_ID;
    nameValue = L"/mnt/DefaultMMC";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = INITIAL_SIZE;
    nameValue = L"1234";
    entry.setEntry(name, nameValue, JavaStorageEntry::INT);
    aEntry.insert(entry);

    name = JAD_PATH;
    nameValue = L"/usr/local/defaultApp/JAD";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = JAR_PATH;
    nameValue = L"/usr/local/defaultApp/JAR";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);

    name = ACCESS_POINT;
    nameValue = L"Default Access Point";
    entry.setEntry(name, nameValue);
    aEntry.insert(entry);
}

OS_EXPORT void JavaStorageTestUtils::createDefaultEntry(
    JavaStorageApplicationEntry_t& aEntry)
{
    JavaStorageEntry entry;
    entry.setEntry(PACKAGE_NAME, L"BasicGame");
    aEntry.insert(entry);

    entry.setEntry(VENDOR, L"GreatVendor");
    aEntry.insert(entry);

    entry.setEntry(VERSION, L"18.01.91");
    aEntry.insert(entry);
}

OS_EXPORT void JavaStorageTestUtils::printEntry(
    JavaStorageApplicationEntry_t aEntry)
{
    JavaStorageApplicationEntry_t::const_iterator iter;

    printf("    [JTU]: Printing entry\n");

    // Go through all reference values.
    for (iter = aEntry.begin(); iter != aEntry.end(); iter++)
    {
        JavaStorageEntry entry = (*iter);
        char* name = JavaCommonUtils::wstringToUtf8(entry.entryName());
        char* value = JavaCommonUtils::wstringToUtf8(entry.entryValue());
        printf("    Entry: %s=", name);
        printf("'%s'\n", value);

        delete[] name;
        delete[] value;
    }
    printf("    [JTU]: Printing entry DONE\n");

}
OS_EXPORT void JavaStorageTestUtils::databasePath(std::string& aDatabasePath)
{
    JavaOsLayer::getOsSpecificJavaRootPath(aDatabasePath);

    int endIdx = (aDatabasePath.size() - 1);

    if (aDatabasePath[endIdx] != '/' && aDatabasePath[endIdx] != '\\')
    {
        // Detect used slash char
        // This do not work if root path is without slashes. Then windows
        // path is expected.
        int idx = aDatabasePath.find("/");

        if (idx != -1)
        {
            aDatabasePath.append("/bin/");
        }
        else
        {
            aDatabasePath.append("\\bin\\");
        }
    }
}