/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   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 .

 */

#include <unordered_map>

#include <osl/diagnose.h>

#include <sal/log.hxx>

#include <uno/lbnames.h>

#include <uno/mapping.hxx>

#include <cppuhelper/component_context.hxx>

#include <cppuhelper/implbase.hxx>

#include <compbase2.hxx>

#include <com/sun/star/container/XNameContainer.hpp>

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

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

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

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

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/uno/DeploymentException.hpp>

#include <com/sun/star/uno/RuntimeException.hpp>

#include <comphelper/sequence.hxx>

#include <memory>

#include <utility>

constexpr OUString SMGR_SINGLETON = u"/singletons/com.sun.star.lang.theServiceManager"_ustr;

constexpr OUStringLiteral TDMGR_SINGLETON = u"/singletons/com.sun.star.reflection.theTypeDescriptionManager";

constexpr OUStringLiteral AC_SINGLETON = u"/singletons/com.sun.star.security.theAccessController";

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star;

namespace cppu

{

static void try_dispose( std::unique_lock<std::mutex>& rGuard, Reference< XInterface > const & xInstance )

{

    Reference< lang::XComponent > xComp( xInstance, UNO_QUERY );

    if (xComp.is())

    {

        rGuard.unlock();

        xComp->dispose();

        rGuard.lock();

    }

}

static void try_dispose( std::unique_lock<std::mutex>& rGuard, Reference< lang::XComponent > const & xComp )

{

    if (xComp.is())

    {

        rGuard.unlock();

        xComp->dispose();

        rGuard.lock();

    }

}

namespace {

class DisposingForwarder

    : public WeakImplHelper< lang::XEventListener >

{

    Reference< lang::XComponent > m_xTarget;

    explicit DisposingForwarder( Reference< lang::XComponent > const & xTarget )

        : m_xTarget( xTarget )

    {

        OSL_ASSERT( m_xTarget.is() );

    }

public:

    // listens at source for disposing, then disposes target

    static inline void listen(

        Reference< lang::XComponent > const & xSource,

        Reference< lang::XComponent > const & xTarget );

    virtual void SAL_CALL disposing( lang::EventObject const & rSource ) override;

};

}

inline void DisposingForwarder::listen(

    Reference< lang::XComponent > const & xSource,

    Reference< lang::XComponent > const & xTarget )

{

    if (xSource.is())

    {

        xSource->addEventListener( new DisposingForwarder( xTarget ) );

    }

}

void DisposingForwarder::disposing( lang::EventObject const & )

{

    m_xTarget->dispose();

    m_xTarget.clear();

}

namespace {

class ComponentContext

    : public cppuhelper::WeakComponentImplHelper2< XComponentContext,

                                      container::XNameContainer >

{

protected:

    Reference< XComponentContext > m_xDelegate;

    struct ContextEntry

    {

        Any value;

        bool lateInit;

        ContextEntry( Any value_, bool lateInit_ )

            : value(std::move( value_ ))

            , lateInit( lateInit_ )

            {}

    };

    typedef std::unordered_map< OUString, ContextEntry  > t_map;

    t_map m_map;

    Reference< lang::XMultiComponentFactory > m_xSMgr;

protected:

    Any lookupMap( OUString const & rName );

    virtual void disposing(std::unique_lock<std::mutex>&) override;

public:

    ComponentContext(

        ContextEntry_Init const * pEntries, sal_Int32 nEntries,

        Reference< XComponentContext > const & xDelegate );

    // XComponentContext

    virtual Any SAL_CALL getValueByName( OUString const & rName ) override;

    virtual Reference<lang::XMultiComponentFactory> SAL_CALL getServiceManager() override;

    // XNameContainer

    virtual void SAL_CALL insertByName(

        OUString const & name, Any const & element ) override;

    virtual void SAL_CALL removeByName( OUString const & name ) override;

    // XNameReplace

    virtual void SAL_CALL replaceByName(

        OUString const & name, Any const & element ) override;

    // XNameAccess

    virtual Any SAL_CALL getByName( OUString const & name ) override;

    virtual Sequence<OUString> SAL_CALL getElementNames() override;

    virtual sal_Bool SAL_CALL hasByName( OUString const & name ) override;

    // XElementAccess

    virtual Type SAL_CALL getElementType() override;

    virtual sal_Bool SAL_CALL hasElements() override;

};

}

// XNameContainer

void ComponentContext::insertByName(

    OUString const & name, Any const & element )

{

    ContextEntry entry(

            element,

            /* lateInit_: */

            name.startsWith( "/singletons/" ) &&

            !element.hasValue() );

    std::unique_lock guard( m_aMutex );

    std::pair<t_map::iterator, bool> insertion( m_map.emplace(

        name, entry ) );

    if (! insertion.second)

        throw container::ElementExistException(

            "element already exists: " + name,

            static_cast<OWeakObject *>(this) );

}

void ComponentContext::removeByName( OUString const & name )

{

    std::unique_lock guard( m_aMutex );

    t_map::iterator iFind( m_map.find( name ) );

    if (iFind == m_map.end())

        throw container::NoSuchElementException(

            "no such element: " + name,

            static_cast<OWeakObject *>(this) );

    m_map.erase(iFind);

}

// XNameReplace

void ComponentContext::replaceByName(

    OUString const & name, Any const & element )

{

    std::unique_lock guard( m_aMutex );

    t_map::iterator iFind( m_map.find( name ) );

    if (iFind == m_map.end())

        throw container::NoSuchElementException(

            "no such element: " + name,

            static_cast<OWeakObject *>(this) );

    if (name.startsWith( "/singletons/" ) &&

        !element.hasValue())

    {

        iFind->second.value.clear();

        iFind->second.lateInit = true;

    }

    else

    {

        iFind->second.value = element;

        iFind->second.lateInit = false;

    }

}

// XNameAccess

Any ComponentContext::getByName( OUString const & name )

{

    return getValueByName( name );

}

Sequence<OUString> ComponentContext::getElementNames()

{

    std::unique_lock guard( m_aMutex );

    return comphelper::mapKeysToSequence(m_map);

}

sal_Bool ComponentContext::hasByName( OUString const & name )

{

    std::unique_lock guard( m_aMutex );

    return m_map.contains( name );

}

// XElementAccess

Type ComponentContext::getElementType()

{

    return cppu::UnoType<void>::get();

}

sal_Bool ComponentContext::hasElements()

{

    std::unique_lock guard( m_aMutex );

    return ! m_map.empty();

}

Any ComponentContext::lookupMap( OUString const & rName )

{

    std::unique_lock guard( m_aMutex );

    t_map::iterator iFind( m_map.find( rName ) );

    if (iFind == m_map.end())

        return Any();

    ContextEntry& rFindEntry = iFind->second;

    if (! rFindEntry.lateInit)

        return rFindEntry.value;

    // late init singleton entry

    Reference< XInterface > xInstance;

    guard.unlock();

    try

    {

        Any usesService( getValueByName( rName + "/service" ) );

        Any args_( getValueByName( rName + "/arguments" ) );

        Sequence<Any> args;

        if (args_.hasValue() && !(args_ >>= args))

        {

            args = { args_ };

        }

        Reference< lang::XSingleComponentFactory > xFac;

        if (usesService >>= xFac) // try via factory

        {

            xInstance = args.hasElements()

                ? xFac->createInstanceWithArgumentsAndContext( args, this )

                : xFac->createInstanceWithContext( this );

        }

        else

        {

            Reference< lang::XSingleServiceFactory > xFac2;

            if (usesService >>= xFac2)

            {

                // try via old XSingleServiceFactory

                xInstance = args.hasElements()

                    ? xFac2->createInstanceWithArguments( args )

                    : xFac2->createInstance();

            }

            else if (m_xSMgr.is()) // optionally service name

            {

                OUString serviceName;

                if ((usesService >>= serviceName) &&

                    !serviceName.isEmpty())

                {

                    xInstance = args.hasElements()

                        ? m_xSMgr->createInstanceWithArgumentsAndContext(

                            serviceName, args, this )

                        : m_xSMgr->createInstanceWithContext(

                            serviceName, this );

                }

            }

        }

    }

    catch (const RuntimeException &)

    {

        throw;

    }

    catch (const Exception & exc)

    {

        SAL_WARN(

            "cppuhelper",

            "exception occurred raising singleton \"" << rName << "\": "

            << exc);

    }

    SAL_WARN_IF(!xInstance.is(),

            "cppuhelper", "no service object raising singleton " << rName);

    Any ret;

    guard.lock();

    iFind = m_map.find( rName );

    if (iFind != m_map.end())

    {

        ContextEntry & rEntry = iFind->second;

        if (rEntry.lateInit)

        {

            rEntry.value <<= xInstance;

            rEntry.lateInit = false;

            return rEntry.value;

        }

        ret = rEntry.value;

    }

    if (ret != xInstance) {

        try_dispose( guard, xInstance );

    }

    return ret;

}

Any ComponentContext::getValueByName( OUString const & rName )

{

    // to determine the root context:

    if ( rName == "_root" )

    {

        if (m_xDelegate.is())

            return m_xDelegate->getValueByName( rName );

        return Any( Reference<XComponentContext>(this) );

    }

    Any ret( lookupMap( rName ) );

    if (!ret.hasValue() && m_xDelegate.is())

    {

        return m_xDelegate->getValueByName( rName );

    }

    return ret;

}

Reference< lang::XMultiComponentFactory > ComponentContext::getServiceManager()

{

    if ( !m_xSMgr.is() )

    {

        throw DeploymentException(

            u"null component context service manager"_ustr,

            static_cast<OWeakObject *>(this) );

    }

    return m_xSMgr;

}

void ComponentContext::disposing(std::unique_lock<std::mutex>& rGuard)

{

    Reference< lang::XComponent > xTDMgr, xAC; // to be disposed separately

    // dispose all context objects

    for ( auto& [rName, rEntry] : m_map )

    {

        // service manager disposed separately

        if (!m_xSMgr.is() ||

            !rName.startsWith( SMGR_SINGLETON ))

        {

            if (rEntry.lateInit)

            {

                rEntry.value.clear(); // release factory

                rEntry.lateInit = false;

                continue;

            }

            Reference< lang::XComponent > xComp;

            rEntry.value >>= xComp;

            if (xComp.is())

            {

                if ( rName == TDMGR_SINGLETON )

                {

                    xTDMgr = std::move(xComp);

                }

                else if ( rName == AC_SINGLETON )

                {

                    xAC = std::move(xComp);

                }

                else // dispose immediately

                {

                    rGuard.unlock();

                    xComp->dispose();

                    rGuard.lock();

                }

            }

        }

    }

    // dispose service manager

    try_dispose( rGuard, m_xSMgr );

    m_xSMgr.clear();

    // dispose ac

    try_dispose( rGuard, xAC );

    // dispose tdmgr; revokes callback from cppu runtime

    try_dispose( rGuard, xTDMgr );

    m_map.clear();

    // Hack to terminate any JNI bridge's AsynchronousFinalizer thread (as JNI

    // proxies get finalized with arbitrary delay, so the bridge typically does

    // not dispose itself early enough before the process exits):

    uno_Environment ** envs;

    sal_Int32 envCount;

    uno_getRegisteredEnvironments(

        &envs, &envCount, &rtl_allocateMemory, u"java"_ustr.pData);

    assert(envCount >= 0);

    assert(envCount == 0 || envs != nullptr);

    if (envs) {

        for (sal_Int32 i = 0; i != envCount; ++i) {

            assert(envs[i] != nullptr);

            assert(envs[i]->dispose != nullptr);

            (*envs[i]->dispose)(envs[i]);

        }

        std::free(envs);

    }

}

ComponentContext::ComponentContext(

    ContextEntry_Init const * pEntries, sal_Int32 nEntries,

    Reference< XComponentContext > const & xDelegate )

    : m_xDelegate( xDelegate )

{

    for ( sal_Int32 nPos = 0; nPos < nEntries; ++nPos )

    {

        ContextEntry_Init const & rEntry = pEntries[ nPos ];

        if ( rEntry.m_sName == SMGR_SINGLETON )

        {

            rEntry.m_aValue >>= m_xSMgr;

        }

        if (rEntry.m_bLateInitService)

        {

            // singleton entry

            m_map.emplace( rEntry.m_sName, ContextEntry( Any(), true ) );

            // service

            m_map.emplace( rEntry.m_sName + "/service", ContextEntry( rEntry.m_aValue, false ) );

            // initial-arguments are provided as optional context entry

        }

        else

        {

            // only value, no late init factory nor string

            m_map.emplace( rEntry.m_sName, ContextEntry( rEntry.m_aValue, false ) );

        }

    }

    if (m_xSMgr.is() || !m_xDelegate.is())

        return;

    // wrap delegate's smgr XPropertySet into new smgr

    Reference< lang::XMultiComponentFactory > xMgr( m_xDelegate->getServiceManager() );

    if (!xMgr.is())

        return;

    osl_atomic_increment( &m_refCount );

    try

    {

        // create new smgr based on delegate's one

        m_xSMgr.set(

            xMgr->createInstanceWithContext(

                u"com.sun.star.comp.stoc.OServiceManagerWrapper"_ustr, xDelegate ),

            UNO_QUERY );

        // patch DefaultContext property of new one

        Reference< beans::XPropertySet > xProps( m_xSMgr, UNO_QUERY );

        OSL_ASSERT( xProps.is() );

        if (xProps.is())

        {

            Reference< XComponentContext > xThis( this );

            xProps->setPropertyValue( u"DefaultContext"_ustr, Any( xThis ) );

        }

    }

    catch (...)

    {

        osl_atomic_decrement( &m_refCount );

        throw;

    }

    osl_atomic_decrement( &m_refCount );

    OSL_ASSERT( m_xSMgr.is() );

}

extern "C" { static void s_createComponentContext_v(va_list * pParam)

{

    ContextEntry_Init const  * pEntries     = va_arg(*pParam, ContextEntry_Init const *);

    sal_Int32                  nEntries     = va_arg(*pParam, sal_Int32);

    XComponentContext        * pDelegatee   = va_arg(*pParam, XComponentContext *);

    void                    ** ppContext    = va_arg(*pParam, void **);

    uno::Mapping             * pTarget2curr = va_arg(*pParam, uno::Mapping *);

    Reference<XComponentContext> xDelegate(pDelegatee, SAL_NO_ACQUIRE);

    Reference<XComponentContext> xContext;

    if (nEntries > 0)

    {

        try

        {

            ComponentContext * p = new ComponentContext( pEntries, nEntries, xDelegate );

            xContext.set(p);

            // listen delegate for disposing, to dispose this (wrapping) context first.

            DisposingForwarder::listen( Reference< lang::XComponent >::query( xDelegate ), p );

        }

        catch (Exception & exc)

        {

            SAL_WARN( "cppuhelper", exc );

            xContext.clear();

        }

    }

    else

    {

        xContext = std::move(xDelegate);

    }

    *ppContext = pTarget2curr->mapInterface(xContext.get(), cppu::UnoType<decltype(xContext)>::get());

}}

Reference< XComponentContext > SAL_CALL createComponentContext(

    ContextEntry_Init const * pEntries, sal_Int32 nEntries,

    Reference< XComponentContext > const & xDelegate )

{

    uno::Environment curr_env(Environment::getCurrent());

    uno::Environment source_env(CPPU_CURRENT_LANGUAGE_BINDING_NAME);

    uno::Mapping curr2source(curr_env, source_env);

    uno::Mapping source2curr(source_env, curr_env);

    std::unique_ptr<ContextEntry_Init[]> mapped_entries(new ContextEntry_Init[nEntries]);

    for (sal_Int32 nPos = 0; nPos < nEntries; ++ nPos)

    {

        mapped_entries[nPos].m_bLateInitService = pEntries[nPos].m_bLateInitService;

        mapped_entries[nPos].m_sName            = pEntries[nPos].m_sName;

        uno_type_any_constructAndConvert(&mapped_entries[nPos].m_aValue,

                                         const_cast<void *>(pEntries[nPos].m_aValue.getValue()),

                                         pEntries[nPos].m_aValue.getValueTypeRef(),

                                         curr2source.get());

    }

    void * mapped_delegate = curr2source.mapInterface(xDelegate.get(), cppu::UnoType<decltype(xDelegate)>::get());

    XComponentContext * pXComponentContext = nullptr;

    source_env.invoke(s_createComponentContext_v, mapped_entries.get(), nEntries, mapped_delegate, &pXComponentContext, &source2curr);

    mapped_entries.reset();

    return Reference<XComponentContext>(pXComponentContext, SAL_NO_ACQUIRE);

}

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */