/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_stoc.hxx"


#include <cstdarg>
#include <osl/diagnose.h>
#include <osl/process.h>

#include <rtl/process.h>
#include <rtl/ustrbuf.hxx>

#include <uno/environment.h>
#include <uno/mapping.hxx>
#include "com/sun/star/uno/RuntimeException.hpp"

#include <cppuhelper/servicefactory.hxx>

#ifdef LINUX
#undef minor
#undef major
#endif

#include <com/sun/star/java/XJavaVM.hpp>

#include <com/sun/star/lang/XMultiComponentFactory.hpp>

#include "jni.h"

#include <cppuhelper/factory.hxx>
#include <cppuhelper/implementationentry.hxx>

#include <cppuhelper/implbase2.hxx>

#include <com/sun/star/loader/XImplementationLoader.hpp>
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/registry/XRegistryKey.hpp>

#include "jvmaccess/unovirtualmachine.hxx"
#include "jvmaccess/virtualmachine.hxx"

namespace css = com::sun::star;

using namespace ::com::sun::star::java;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::loader;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::registry;

using namespace ::cppu;
using namespace ::rtl;
using namespace ::osl;

namespace stoc_javaloader {

static Mutex & getInitMutex();

static Sequence< OUString > loader_getSupportedServiceNames()
{
    static Sequence < OUString > *pNames = 0;
    if( ! pNames )
    {
        MutexGuard guard( Mutex::getGlobalMutex() );
        if( !pNames )
        {
            static Sequence< OUString > seqNames(2);
            seqNames.getArray()[0] = OUString(
                RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.loader.Java") );
            seqNames.getArray()[1] = OUString(
                RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.loader.Java2") );
            pNames = &seqNames;
        }
    }
    return *pNames;
}
	
static OUString loader_getImplementationName()
{
    static OUString *pImplName = 0;
    if( ! pImplName )
    {
        MutexGuard guard( Mutex::getGlobalMutex() );
        if( ! pImplName )
        {
            static OUString implName(
                RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.stoc.JavaComponentLoader" ) );
            pImplName = &implName;
        }
    }
    return *pImplName;
}

class JavaComponentLoader : public WeakImplHelper2<XImplementationLoader, XServiceInfo>
{
    css::uno::Reference<XComponentContext> m_xComponentContext;
    /** Do not use m_javaLoader directly. Instead use getJavaLoader.
     */ 
    css::uno::Reference<XImplementationLoader> m_javaLoader;
    /** The retured Reference contains a null pointer if the office is not configured
        to run java.
        
        @exception com::sun::star::uno::RuntimeException
        If the Java implementation of the loader could not be obtained, for reasons other
        then that java was not configured the RuntimeException is thrown.
     */
    const css::uno::Reference<XImplementationLoader> & getJavaLoader();
    
    
public:
	JavaComponentLoader(const css::uno::Reference<XComponentContext> & xCtx)
        throw(RuntimeException);
	virtual ~JavaComponentLoader() throw();

public:
	// XServiceInfo
	virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
	virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName)
        throw(RuntimeException);
	virtual Sequence<OUString> SAL_CALL getSupportedServiceNames()
        throw(RuntimeException);

	// XImplementationLoader
	virtual css::uno::Reference<XInterface> SAL_CALL activate(
        const OUString& implementationName, const OUString& implementationLoaderUrl,
        const OUString& locationUrl, const css::uno::Reference<XRegistryKey>& xKey)
        throw(CannotActivateFactoryException, RuntimeException);
	virtual sal_Bool SAL_CALL writeRegistryInfo(
        const css::uno::Reference<XRegistryKey>& xKey,
        const OUString& implementationLoaderUrl, const OUString& locationUrl)
        throw(CannotRegisterImplementationException, RuntimeException);
};

const css::uno::Reference<XImplementationLoader> & JavaComponentLoader::getJavaLoader()
{
    MutexGuard aGuard(getInitMutex());

    if (m_javaLoader.is())
        return m_javaLoader;
    
	uno_Environment * pJava_environment = NULL;
	uno_Environment * pUno_environment = NULL;
	typelib_InterfaceTypeDescription * pType_XImplementationLoader = 0;

	try {
		// get a java vm, where we can create a loader
		css::uno::Reference<XJavaVM> javaVM_xJavaVM(
            m_xComponentContext->getValueByName(
                OUString(RTL_CONSTASCII_USTRINGPARAM(
                             "/singletons/"
                             "com.sun.star.java.theJavaVirtualMachine"))),
            UNO_QUERY_THROW);

        // Use the special protocol of XJavaVM.getJavaVM:  If the passed in
        // process ID has an extra 17th byte of value one, the returned any
        // contains a pointer to a jvmaccess::UnoVirtualMachine, instead of the
        // underlying JavaVM pointer:
		Sequence<sal_Int8> processID(17);
		rtl_getGlobalProcessId(reinterpret_cast<sal_uInt8 *>(processID.getArray()));
        processID[16] = 1;

        // We get a non-refcounted pointer to a jvmaccess::UnoVirtualMachine
        // from the XJavaVM service (the pointer is guaranteed to be valid
        // as long as our reference to the XJavaVM service lasts), and
        // convert the non-refcounted pointer into a refcounted one
        // immediately:
        OSL_ENSURE(sizeof (sal_Int64)
                        >= sizeof (jvmaccess::UnoVirtualMachine *),
                    "Pointer cannot be represented as sal_Int64");
        sal_Int64 nPointer = reinterpret_cast< sal_Int64 >(
            static_cast< jvmaccess::UnoVirtualMachine * >(0));
        javaVM_xJavaVM->getJavaVM(processID) >>= nPointer;
        rtl::Reference< jvmaccess::UnoVirtualMachine > xVirtualMachine(
            reinterpret_cast< jvmaccess::UnoVirtualMachine * >(nPointer));
        if (!xVirtualMachine.is())
            //throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
            //   "javaloader error - JavaVirtualMachine service could not provide a VM")),
            //   css::uno::Reference<XInterface>());
            // We must not throw a RuntimeException, because this might end the applications.
            // It is ok if java components
            // are not working because the office can be installed without Java support.
            return m_javaLoader; // null-ref

        try
        {
            jvmaccess::VirtualMachine::AttachGuard aGuard2(
                xVirtualMachine->getVirtualMachine());
            JNIEnv * pJNIEnv = aGuard2.getEnvironment();

            // instantiate the java JavaLoader
            jclass jcClassLoader = pJNIEnv->FindClass("java/lang/ClassLoader");
            if(pJNIEnv->ExceptionOccurred())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - could not find class java/lang/ClassLoader")),
                    css::uno::Reference<XInterface>());
            jmethodID jmLoadClass = pJNIEnv->GetMethodID(
                jcClassLoader, "loadClass",
                "(Ljava/lang/String;)Ljava/lang/Class;");
            if(pJNIEnv->ExceptionOccurred())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - could not find method java/lang/ClassLoader.loadClass")),
                    css::uno::Reference<XInterface>());
            jvalue arg;
            arg.l = pJNIEnv->NewStringUTF(
                "com.sun.star.comp.loader.JavaLoader");
            if(pJNIEnv->ExceptionOccurred())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - could not create string")),
                    css::uno::Reference<XInterface>());
            jclass jcJavaLoader = static_cast< jclass >(
                pJNIEnv->CallObjectMethodA(
                    static_cast< jobject >(xVirtualMachine->getClassLoader()),
                    jmLoadClass, &arg));
            if(pJNIEnv->ExceptionOccurred())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - could not find class com/sun/star/comp/loader/JavaLoader")),
                    css::uno::Reference<XInterface>());
            jmethodID jmJavaLoader_init = pJNIEnv->GetMethodID(jcJavaLoader, "<init>", "()V");
            if(pJNIEnv->ExceptionOccurred())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - instantiation of com.sun.star.comp.loader.JavaLoader failed")),
                    css::uno::Reference<XInterface>());
            jobject joJavaLoader = pJNIEnv->NewObject(jcJavaLoader, jmJavaLoader_init);
            if(pJNIEnv->ExceptionOccurred())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - instantiation of com.sun.star.comp.loader.JavaLoader failed")),
                    css::uno::Reference<XInterface>());

            // map the java JavaLoader to this environment
            OUString sJava(RTL_CONSTASCII_USTRINGPARAM("java"));
            uno_getEnvironment(&pJava_environment, sJava.pData,
                                xVirtualMachine.get());
            if(!pJava_environment)
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - no Java environment available")), css::uno::Reference<XInterface>());

            // why is there no convinient contructor?
            OUString sCppu_current_lb_name(RTL_CONSTASCII_USTRINGPARAM(CPPU_CURRENT_LANGUAGE_BINDING_NAME));
            uno_getEnvironment(&pUno_environment, sCppu_current_lb_name.pData, NULL);
            if(!pUno_environment)
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - no C++ environment available")), css::uno::Reference<XInterface>());

            Mapping java_curr(pJava_environment, pUno_environment);
            if(!java_curr.is())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - no mapping from java to C++ ")), css::uno::Reference<XInterface>());

            // release java environment
            pJava_environment->release(pJava_environment);
            pJava_environment = NULL;

            // release uno environment
            pUno_environment->release(pUno_environment);
            pUno_environment = NULL;

            getCppuType((css::uno::Reference<XImplementationLoader> *) 0).
                getDescription((typelib_TypeDescription **) & pType_XImplementationLoader);
            if(!pType_XImplementationLoader)
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - no type information for XImplementationLoader")),
                    css::uno::Reference<XInterface>());

            m_javaLoader = css::uno::Reference<XImplementationLoader>(reinterpret_cast<XImplementationLoader *>(
                            java_curr.mapInterface(joJavaLoader, pType_XImplementationLoader)));
            pJNIEnv->DeleteLocalRef( joJavaLoader );
            if(!m_javaLoader.is())
                throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                    "javaloader error - mapping of java XImplementationLoader to c++ failed")),
                    css::uno::Reference<XInterface>());

            typelib_typedescription_release(reinterpret_cast<typelib_TypeDescription *>(pType_XImplementationLoader));
            pType_XImplementationLoader = NULL;
        }
        catch (jvmaccess::VirtualMachine::AttachGuard::CreationException &)
        {
            throw RuntimeException(
                OUString(RTL_CONSTASCII_USTRINGPARAM(
                                "jvmaccess::VirtualMachine::AttachGuard"
                                "::CreationException")),0);
        }

		// set the service manager at the javaloader
		css::uno::Reference<XInitialization> javaLoader_XInitialization(m_javaLoader, UNO_QUERY);
		if(!javaLoader_XInitialization.is())
            throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM(
                "javaloader error - initialization of java javaloader failed, no XInitialization")),
                css::uno::Reference<XInterface>());

		Any any;
		any <<= css::uno::Reference<XMultiComponentFactory>(
            m_xComponentContext->getServiceManager());

		javaLoader_XInitialization->initialize(Sequence<Any>(&any, 1));
	}
	catch(RuntimeException &) {
		if(pJava_environment)
			pJava_environment->release(pJava_environment);

		if(pUno_environment)
			pUno_environment->release(pUno_environment);

		if(pType_XImplementationLoader)
			typelib_typedescription_release(
                reinterpret_cast<typelib_TypeDescription *>(pType_XImplementationLoader));
		throw;
	}
	OSL_TRACE("javaloader.cxx: mapped javaloader - 0x%x", m_javaLoader.get());
    return m_javaLoader;
}

JavaComponentLoader::JavaComponentLoader(const css::uno::Reference<XComponentContext> & xCtx) throw(RuntimeException) :
    m_xComponentContext(xCtx)
    
{

}

JavaComponentLoader::~JavaComponentLoader() throw()
{
}

// XServiceInfo
OUString SAL_CALL JavaComponentLoader::getImplementationName()
    throw(::com::sun::star::uno::RuntimeException)
{
	return loader_getImplementationName();	
}	

sal_Bool SAL_CALL JavaComponentLoader::supportsService(const OUString & ServiceName)
    throw(::com::sun::star::uno::RuntimeException)
{
	sal_Bool bSupport = sal_False;

	Sequence<OUString> aSNL = getSupportedServiceNames();
	const OUString * pArray = aSNL.getArray();
	for(sal_Int32 i = 0; i < aSNL.getLength() && !bSupport; ++ i)
		bSupport = pArray[i] == ServiceName;

	return bSupport;
}	

Sequence<OUString> SAL_CALL JavaComponentLoader::getSupportedServiceNames()
    throw(::com::sun::star::uno::RuntimeException)
{
	return loader_getSupportedServiceNames();
}


// XImplementationLoader
sal_Bool SAL_CALL JavaComponentLoader::writeRegistryInfo(
    const css::uno::Reference<XRegistryKey> & xKey, const OUString & blabla,
    const OUString & rLibName)
	throw(CannotRegisterImplementationException, RuntimeException)
{
    const css::uno::Reference<XImplementationLoader> & loader = getJavaLoader();
    if (loader.is())
        return loader->writeRegistryInfo(xKey, blabla, rLibName);
    else
        throw CannotRegisterImplementationException(
            OUString(RTL_CONSTASCII_USTRINGPARAM("Could not create Java implementation loader")), NULL);
}


css::uno::Reference<XInterface> SAL_CALL JavaComponentLoader::activate(
    const OUString & rImplName, const OUString & blabla, const OUString & rLibName,
    const css::uno::Reference<XRegistryKey> & xKey)
    throw(CannotActivateFactoryException, RuntimeException)
{
    const css::uno::Reference<XImplementationLoader> & loader = getJavaLoader();
    if (loader.is())
        return loader->activate(rImplName, blabla, rLibName, xKey);
    else
        throw CannotActivateFactoryException(
            OUString(RTL_CONSTASCII_USTRINGPARAM("Could not create Java implementation loader")), NULL);
}

static Mutex & getInitMutex()
{
    static Mutex * pMutex = 0;
    if( ! pMutex )
    {
        MutexGuard guard( Mutex::getGlobalMutex() );
        if( ! pMutex )
        {
            static Mutex mutex;
            pMutex = &mutex;
        }
    }
    return *pMutex;
}

css::uno::Reference<XInterface> SAL_CALL JavaComponentLoader_CreateInstance(const css::uno::Reference<XComponentContext> & xCtx) throw(Exception)
{
    css::uno::Reference<XInterface> xRet;
    
    try {
        MutexGuard guard( getInitMutex() );
        // The javaloader is never destroyed and there can be only one!
        // Note that the first context wins ....
        static css::uno::Reference< XInterface > *pStaticRef = 0;
        if( pStaticRef )
        {
            xRet = *pStaticRef;
        }
        else
        {
            xRet = *new JavaComponentLoader(xCtx);
            pStaticRef = new css::uno::Reference< XInterface > ( xRet );
        }
    }
    catch(RuntimeException & runtimeException) {
        OString message = OUStringToOString(runtimeException.Message, RTL_TEXTENCODING_ASCII_US);
        osl_trace("javaloader - could not init javaloader cause of %s", message.getStr());
        throw;
    }
    
    return xRet;
}

} //end namespace


using namespace stoc_javaloader;

static struct ImplementationEntry g_entries[] =
{
	{
		JavaComponentLoader_CreateInstance, loader_getImplementationName,
		loader_getSupportedServiceNames, createSingleComponentFactory,
		0 , 0
	},
	{ 0, 0, 0, 0, 0, 0 }
};

extern "C"
{
// NOTE: component_canUnload is not exported, as the library cannot be unloaded.

//==================================================================================================
void SAL_CALL component_getImplementationEnvironment(
	const sal_Char ** ppEnvTypeName, uno_Environment ** )
{
	*ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
}
//==================================================================================================
void * SAL_CALL component_getFactory(
	const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey )
{
	return component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey , g_entries );
}
}