/*
* 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:  This class is meant for starting the JVM.
*
*/


#include <string>

#include "jvmstarterimpl.h"

#include "logger.h"
#include "exception"
#include "runtimeexception.h"
#include "javaoslayer.h"

using namespace java::runtime;
using namespace java::util;

// Platform dependents
extern const wchar_t CLASS_PATH_SEPARATOR;
extern const char PATH_SEPARATOR_FROM;
extern const char PATH_SEPARATOR_TO;

JvmStarterImpl::JvmStarterImpl(): mJitDisabled(false),
        mTheadDumpEnabled(false)
{
    JELOG2(EJavaRuntime);

    DriveId driveId = JavaOsLayer::getMidpDrive();

    // Define JAVA_BIN_ROOT system property
    std::wstring javaBinRoot(L"-DJAVA_BIN_ROOT=");
    std::string binRoot(driveId.getDriveLetter());
    JavaOsLayer::getBinRoot(binRoot, true);
    javaBinRoot.append(binRoot.begin(), binRoot.end());
    mJvmArgs.push_front(javaBinRoot);

    // Define JAVA_RES_ROOT system property
    std::wstring javaResRoot(L"-DJAVA_RES_ROOT=");
    std::string resourceRoot(driveId.getDriveLetter());
    JavaOsLayer::getResRoot(resourceRoot, true);
    javaResRoot.append(resourceRoot.begin(), resourceRoot.end());
    mJvmArgs.push_front(javaResRoot);
}

JvmStarterImpl::~JvmStarterImpl()
{
    JELOG2(EJavaRuntime);
}

void JvmStarterImpl::appendClassPath(const std::wstring& file)
{
    JELOG2(EJavaRuntime);
    appendAndConvertClassPath(file, mClassPath);
}

void JvmStarterImpl::appendBootClassPath(const std::wstring& file)
{
    JELOG2(EJavaRuntime);
    appendAndConvertClassPath(file, mBootClassPathAppend);
}

void JvmStarterImpl::prependBootClassPath(const std::wstring& file)
{
    JELOG2(EJavaRuntime);
    appendAndConvertClassPath(file, mBootClassPathPrepend);
}

void JvmStarterImpl::appendExtensionPath(const std::wstring& extensionPath)
{
    JELOG2(EJavaRuntime);
    appendAndConvertClassPath(extensionPath, mExtensionPath);
}

void JvmStarterImpl::setMainClass(const std::wstring& mainClass)
{
    JELOG2(EJavaRuntime);
    mMainClass = mainClass;
}

void JvmStarterImpl::appendApplicationArgument(const std::wstring& argument)
{
    JELOG2(EJavaRuntime);
    mAppAndArgs.push_back(argument);
}

void JvmStarterImpl::appendSystemProperty(const std::wstring& systemproperty)
{
    JELOG2(EJavaRuntime);
    mJvmArgs.push_back(systemproperty);
}

void JvmStarterImpl::appendRawJvmArgument(const std::wstring& argument)
{
    JELOG2(EJavaRuntime);
    mJvmArgs.push_back(argument);
}

void JvmStarterImpl::disableJit()
{
    JELOG2(EJavaRuntime);
    mJitDisabled = true;
}

void JvmStarterImpl::enableThreadDumping()
{
    JELOG2(EJavaRuntime);
    mTheadDumpEnabled = true;
}

void JvmStarterImpl::appendAndConvertClassPath(const std::wstring& source,
        std::wstring& destination)
{
    JELOG2(EJavaRuntime);
    if (destination.length() > 0)
    {
        // Appending
        destination += CLASS_PATH_SEPARATOR;
    }
    destination += source;
    std::replace(destination.begin(), destination.end(),
                 PATH_SEPARATOR_FROM, PATH_SEPARATOR_TO);
}

void JvmStarterImpl::clear()
{
    JELOG2(EJavaRuntime);
    mIdentifier.clear();
    mClassPath.clear();
    mBootClassPathAppend.clear();
    mBootClassPathPrepend.clear();
    mExtensionPath.clear();
    mMainClass.clear();
    mJvmArgs.clear();
    mAppAndArgs.clear();
}