/*

* 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: Converts Universal Emulator Interface (UEI) arguments to

*              JVM arguments

*

*/

#include <sstream>

#include "ueiargsparser.h"

#include "logger.h"

const wchar_t* const SUPPORTED_UEI_ARGS[] = {L"-Xverbose", L"-Xrunjdwp", 0};

const wchar_t* const SUPPORTED_JVM_ARGS[] = {L"-verbose", L"-Xrunjdwp", 0};

const int INDEX_VERBOSE = 0;

const int INDEX_RUNJDWP = 1;

const wchar_t* const ALL = L"all";

const wchar_t* const GC = L"gc";

const wchar_t* const CLASS = L"class";

const wchar_t* const JVM_SUPPORTED_VERBOSE_OPTIONS = L"gc,class,stack,sizes";

const wchar_t* const OPTION_SEPARATOR = L":";

const wchar_t* const SPACE = L" ";

const wchar_t* const COMMA = L",";

using namespace java::runtime;

std::wstring UeiArgsParser::convertUeiArgsToJvmArgs(const std::wstring& aUeiParameters)

{

    std::vector<std::wstring> args = getArgs(aUeiParameters);

    std::wostringstream jvmArgs;

    for (int i = 0; i < args.size(); ++i)

    {

        LOG2(EDebugApi, EInfo,"args(%S): %d", args.at(i).c_str(), i);

        if (isVerbose(args.at(i)))

        {

            jvmArgs << convertVerbose(args.at(i)) << SPACE;

        }

        else if (isRundjwp(args.at(i)))

        {

            jvmArgs << convertRundjwp(args.at(i)) << SPACE;

        }

    }

    std::wstring result = jvmArgs.str();

    trimTrailingSpaces(result, SPACE);

    LOG2(EDebugApi, EInfo,"convertUeiArgsToJvmArgs(%S): %S", aUeiParameters.c_str(), result.c_str());

    return result;

}

std::vector<std::wstring> UeiArgsParser::getArgs(const std::wstring& aUeiParameters)

{

    std::vector<std::wstring> result;

    std::wstringstream stream;

    stream << aUeiParameters; // codescanner::leave

    std::wstring arg;

    while (stream.good())

    {

        stream >> arg; // codescanner::leave

        if (arg.size() != 0)

        {

            result.push_back(arg);

        }

    }

    LOG2(EDebugApi, EInfo,"getArgs(%S): count=%d", aUeiParameters.c_str(), result.size());

    return result;

}

bool UeiArgsParser::isVerbose(const std::wstring& aUeiArg)

{

    std::wstring verbose(SUPPORTED_UEI_ARGS[INDEX_VERBOSE]);

    if (aUeiArg.compare(0, verbose.length(), verbose) == 0)

    {

        return true;

    }

    return false;

}

bool UeiArgsParser::isRundjwp(const std::wstring& aUeiArg)

{

    std::wstring rundjwp(SUPPORTED_UEI_ARGS[INDEX_RUNJDWP]);

    if (aUeiArg.compare(0, rundjwp.length(), rundjwp) == 0)

    {

        return true;

    }

    return false;

}

// hasOption() assumes that options are separated by ','

bool UeiArgsParser::hasOption(const std::wstring& aArg, const std::wstring& aOption)

{

    // option is in the middle: option,zzz

    size_t found = aArg.find(aOption + COMMA);

    if (found != std::wstring::npos)

    {

        return true;

    }

    // option is the last one: zzz,option

    found = aArg.find(aOption);

    if (found != std::wstring::npos)

    {

        // avoid false alarm: zzz,optionz

        int expectedSize = found + aOption.size();

        if (expectedSize == aArg.size())

        {

            return true;

        }

    }

    return false;

}

std::wstring UeiArgsParser::convertVerbose(const std::wstring& aVerbose)

{

    std::wostringstream arg;

    arg << SUPPORTED_JVM_ARGS[INDEX_VERBOSE];

    if (aVerbose.find(OPTION_SEPARATOR) != std::wstring::npos)

    {

        arg << OPTION_SEPARATOR;

        if (hasOption(aVerbose, ALL))

        {

            arg << JVM_SUPPORTED_VERBOSE_OPTIONS;

        }

        else

        {

            if (hasOption(aVerbose, GC))

            {

                arg << GC << COMMA;

            }

            if (hasOption(aVerbose, CLASS))

            {

                arg << CLASS << COMMA;

            }

        }

    }

    std::wstring result = arg.str();

    std::wostringstream whitespaces;

    whitespaces << OPTION_SEPARATOR << COMMA;

    trimTrailingSpaces(result, whitespaces.str());

    LOG2(EDebugApi, EInfo,"convertVerbose(%S): %S", aVerbose.c_str(), result.c_str());

    return result;

}

std::wstring UeiArgsParser::convertRundjwp(const std::wstring& aRunjdwp)

{

    return aRunjdwp;

}

std::wstring UeiArgsParser::trimTrailingSpaces(std::wstring& aString, const std::wstring& aWhitespaces)

{

    size_t trailingSpace = aString.find_last_not_of(aWhitespaces);

    if (trailingSpace != std::wstring::npos)

    {

        aString.erase(trailingSpace + 1);

    }

    return aString;

}