/* -*- 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 <sal/config.h>

#include <sal/log.hxx>

#include <unotools/configitem.hxx>

#include <unotools/configmgr.hxx>

#include <unotools/configpaths.hxx>

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

#include <com/sun/star/util/XChangesListener.hpp>

#include <com/sun/star/util/XChangesNotifier.hpp>

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

#include <com/sun/star/configuration/XTemplateContainer.hpp>

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

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

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

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

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

#include <com/sun/star/util/XChangesBatch.hpp>

#include <o3tl/deleter.hxx>

#include <osl/diagnose.h>

#include <comphelper/configuration.hxx>

#include <comphelper/sequence.hxx>

#include <comphelper/solarmutex.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/propertyvalue.hxx>

#include <cppuhelper/implbase.hxx>

#include <utility>

using namespace utl;

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

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

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

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

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

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

/*

    The ConfigChangeListener_Impl receives notifications from the configuration about changes that

    have happened. It forwards this notification to the ConfigItem it knows a pParent by calling its

    "CallNotify" method. As ConfigItems are most probably not thread safe, the SolarMutex is acquired

    before doing so.

*/

namespace utl{

    class ConfigChangeListener_Impl : public cppu::WeakImplHelper

    <

        css::util::XChangesListener

    >

    {

        public:

            ConfigItem*                 pParent;

            const Sequence< OUString >  aPropertyNames;

            ConfigChangeListener_Impl(ConfigItem& rItem, const Sequence< OUString >& rNames);

        //XChangesListener

        virtual void SAL_CALL changesOccurred( const ChangesEvent& Event ) override;

        //XEventListener

        virtual void SAL_CALL disposing( const EventObject& Source ) override;

    };

}

namespace {

class ValueCounter_Impl

{

    sal_Int16& rCnt;

public:

    explicit ValueCounter_Impl(sal_Int16& rCounter)

        : rCnt(rCounter)

    {

        rCnt++;

    }

    ~ValueCounter_Impl()

    {

        OSL_ENSURE(rCnt>0, "RefCount < 0 ??");

        rCnt--;

    }

};

}

ConfigChangeListener_Impl::ConfigChangeListener_Impl(

             ConfigItem& rItem, const Sequence< OUString >& rNames) :

    pParent(&rItem),

    aPropertyNames(rNames)

{

}

void ConfigChangeListener_Impl::changesOccurred( const ChangesEvent& rEvent )

{

    Sequence<OUString>  aChangedNames(rEvent.Changes.getLength());

    OUString* pNames = aChangedNames.getArray();

    sal_Int32 nNotify = 0;

    for(const auto& rElementChange : rEvent.Changes)

    {

        OUString sTemp;

        rElementChange.Accessor >>= sTemp;

        //true if the path is completely correct or if it is longer

        //i.e ...Print/Content/Graphic and .../Print

        bool bFound = std::any_of(aPropertyNames.begin(), aPropertyNames.end(),

            [&sTemp](const OUString& rCheckPropertyName) { return isPrefixOfConfigurationPath(sTemp, rCheckPropertyName); });

        if(bFound)

            pNames[nNotify++] = sTemp;

    }

    if( nNotify )

    {

        ::comphelper::SolarMutex *pMutex = ::comphelper::SolarMutex::get();

        if ( pMutex )

        {

            osl::Guard<comphelper::SolarMutex> aMutexGuard( pMutex );

            aChangedNames.realloc(nNotify);

            pParent->CallNotify(aChangedNames);

        }

    }

}

void ConfigChangeListener_Impl::disposing( const EventObject& /*rSource*/ )

{

    pParent->RemoveChangesListener();

}

ConfigItem::ConfigItem(OUString aSubTree, ConfigItemMode nSetMode ) :

    sSubTree(std::move(aSubTree)),

    m_nMode(nSetMode),

    m_bIsModified(false),

    m_bEnableInternalNotification(false),

    m_nInValueChange(0)

{

    if (comphelper::IsFuzzing())

        return;

    if (nSetMode & ConfigItemMode::ReleaseTree)

        ConfigManager::getConfigManager().addConfigItem(*this);

    else

        m_xHierarchyAccess = ConfigManager::getConfigManager().addConfigItem(*this);

}

ConfigItem::ConfigItem(ConfigItem const &) = default;

ConfigItem::ConfigItem(ConfigItem &&) = default;

ConfigItem::~ConfigItem()

{

    suppress_fun_call_w_exception(RemoveChangesListener());

    ConfigManager::getConfigManager().removeConfigItem(*this);

}

void ConfigItem::CallNotify( const css::uno::Sequence<OUString>& rPropertyNames )

{

    // the call is forwarded to the virtual Notify() method

    // it is pure virtual, so all classes deriving from ConfigItem have to decide how they

    // want to notify listeners

    if(m_nInValueChange <= 0 || m_bEnableInternalNotification)

        Notify(rPropertyNames);

}

// In special mode ALL_LOCALES we must support reading/writing of localized cfg entries as Sequence< PropertyValue >.

// These methods are helper to convert given lists of names and Any-values.

// format:  PropertyValue.Name  = <locale as ISO string>

//          PropertyValue.Value = <value; type depends from cfg entry!>

// e.g.

//          LOCALIZED NODE

//          "UIName"

//                      LOCALE      VALUE

//                      "de"        "Mein Name"

//                      "en-US"     "my name"

static void impl_packLocalizedProperties(  const   Sequence< OUString >&   lInNames    ,

                                           const   Sequence< Any >&        lInValues   ,

                                                   Sequence< Any >&        lOutValues  )

{

    // This method should be called for special AllLocales ConfigItem-mode only!

    // Optimise follow algorithm ... A LITTLE BIT :-)

    // There exist two different possibilities:

    //  i ) There exist no localized entries ...                        =>  size of lOutValues will be the same like lInNames/lInValues!

    //  ii) There exist some (mostly one or two) localized entries ...  =>  size of lOutValues will be the same like lInNames/lInValues!

    //  ... Why? If a localized value exist - the any is filled with an XInterface object (is a SetNode-service).

    //      We read all his child nodes and pack it into Sequence< PropertyValue >.

    //      The result list we pack into the return any. We never change size of lists!

    lOutValues.realloc(lInNames.getLength());

    // Algorithm:

    // Copy all names and values from in to out lists.

    // Look for special localized entries ... You can detect it as "XInterface" packed into an Any.

    // Use this XInterface-object to read all localized values and pack it into Sequence< PropertyValue >.

    // Add this list to out lists then.

    std::transform(lInValues.begin(), lInValues.end(), lOutValues.getArray(), [](const Any& value)

    {

        // If item is a special localized one ... convert and pack it ...

        if (value.getValueTypeName() == "com.sun.star.uno.XInterface")

        {

            if (auto xSetAccess = value.query<XNameContainer>())

            {

                // list of all locales for localized entry

                Sequence<OUString> locales = xSetAccess->getElementNames();

                // localized values of a configuration entry packed for return

                Sequence<PropertyValue> lProperties(locales.getLength());

                std::transform(

                    locales.begin(), locales.end(), lProperties.getArray(),

                    [&xSetAccess](const OUString& s)

                    { return comphelper::makePropertyValue(s, xSetAccess->getByName(s)); });

                return Any(lProperties);

            }

        }

        // ... or copy normal items to return lists directly.

        return value;

    });

}

static void impl_unpackLocalizedProperties(    const   Sequence< OUString >&   lInNames    ,

                                               const   Sequence< Any >&        lInValues   ,

                                                       Sequence< OUString >&   lOutNames   ,

                                                       Sequence< Any >&        lOutValues)

{

    // This method should be called for special AllLocales ConfigItem-mode only!

    sal_Int32                   nSourceSize;         // marks end of loop over input lists

    sal_Int32                   nDestinationCounter; // actual position in output lists

    sal_Int32                   nPropertiesSize;     // marks end of inner loop

    OUString                    sNodeName;           // base name of node ( e.g. "UIName/" ) ... expand to locale ( e.g. "UIName/de" )

    Sequence< PropertyValue >   lProperties;         // localized values of a configuration entry gotten from lInValues-Any

    // Optimise follow algorithm ... A LITTLE BIT :-)

    // There exist two different possibilities:

    //  i ) There exist no localized entries ...                        =>  size of lOutNames/lOutValues will be the same like lInNames/lInValues!

    //  ii) There exist some (mostly one or two) localized entries ...  =>  size of lOutNames/lOutValues will be some bytes greater than lInNames/lInValues.

    //  =>  I think we should make it fast for i). ii) is a special case and mustn't be SOOOO... fast.

    //      We should reserve same space for output list like input ones first.

    //      Follow algorithm looks for these borders and change it for ii) only!

    //      It will be faster then a "realloc()" call in every loop ...

    nSourceSize = lInNames.getLength();

    lOutNames.realloc   ( nSourceSize );

    auto plOutNames = lOutNames.getArray();

    lOutValues.realloc  ( nSourceSize );

    auto plOutValues = lOutValues.getArray();

    // Algorithm:

    // Copy all names and values from const to return lists.

    // Look for special localized entries ... You can detect it as Sequence< PropertyValue > packed into an Any.

    // Split it ... insert PropertyValue.Name to lOutNames and PropertyValue.Value to lOutValues.

    nDestinationCounter = 0;

    for( sal_Int32 nSourceCounter=0; nSourceCounter<nSourceSize; ++nSourceCounter )

    {

        // If item a special localized one ... split it and insert his parts to output lists ...

        if( lInValues[nSourceCounter].getValueType() == cppu::UnoType<Sequence<PropertyValue>>::get() )

        {

            lInValues[nSourceCounter] >>= lProperties;

            nPropertiesSize = lProperties.getLength();

            sNodeName = lInNames[nSourceCounter] + "/";

            if( (nDestinationCounter+nPropertiesSize) > lOutNames.getLength() )

            {

                lOutNames.realloc   ( nDestinationCounter+nPropertiesSize );

                plOutNames = lOutNames.getArray();

                lOutValues.realloc  ( nDestinationCounter+nPropertiesSize );

                plOutValues = lOutValues.getArray();

            }

            for (const auto& rProperty : lProperties)

            {

                plOutNames [nDestinationCounter] = sNodeName + rProperty.Name;

                plOutValues[nDestinationCounter] = rProperty.Value;

                ++nDestinationCounter;

            }

        }

        // ... or copy normal items to return lists directly.

        else

        {

            if( (nDestinationCounter+1) > lOutNames.getLength() )

            {

                lOutNames.realloc   ( nDestinationCounter+1 );

                plOutNames = lOutNames.getArray();

                lOutValues.realloc  ( nDestinationCounter+1 );

                plOutValues = lOutValues.getArray();

            }

            plOutNames [nDestinationCounter] = lInNames [nSourceCounter];

            plOutValues[nDestinationCounter] = lInValues[nSourceCounter];

            ++nDestinationCounter;

        }

    }

}

Sequence< sal_Bool > ConfigItem::GetReadOnlyStates(const css::uno::Sequence< OUString >& rNames)

{

    sal_Int32 i;

    // size of return list is fix!

    // Every item must match to length of incoming name list.

    sal_Int32 nCount = rNames.getLength();

    Sequence< sal_Bool > lStates(nCount);

    sal_Bool* plStates = lStates.getArray();

    // We must be sure to return a valid information every time!

    // Set default to non readonly... similar to the configuration handling of this property.

    std::fill_n(plStates, lStates.getLength(), false);

    // no access - no information...

    Reference< XHierarchicalNameAccess > xHierarchyAccess = GetTree();

    if (!xHierarchyAccess.is())

        return lStates;

    for (i=0; i<nCount; ++i)

    {

        try

        {

            const OUString& sName = rNames[i];

            OUString sPath;

            OUString sProperty;

            (void)::utl::splitLastFromConfigurationPath(sName,sPath,sProperty);

            if (sPath.isEmpty() && sProperty.isEmpty())

            {

                OSL_FAIL("ConfigItem::IsReadonly() split failed");

                continue;

            }

            Reference< XInterface >       xNode;

            Reference< XPropertySet >     xSet;

            Reference< XPropertySetInfo > xInfo;

            if (!sPath.isEmpty())

            {

                Any aNode = xHierarchyAccess->getByHierarchicalName(sPath);

                if (!(aNode >>= xNode) || !xNode.is())

                {

                    OSL_FAIL("ConfigItem::IsReadonly() no set available");

                    continue;

                }

            }

            else

            {

                xNode = xHierarchyAccess;

            }

            xSet.set(xNode, UNO_QUERY);

            if (xSet.is())

            {

                xInfo = xSet->getPropertySetInfo();

                OSL_ENSURE(xInfo.is(), "ConfigItem::IsReadonly() getPropertySetInfo failed ...");

            }

            else

            {

                xInfo.set(xNode, UNO_QUERY);

                OSL_ENSURE(xInfo.is(), "ConfigItem::IsReadonly() UNO_QUERY failed ...");

            }

            if (!xInfo.is())

            {

                OSL_FAIL("ConfigItem::IsReadonly() no prop info available");

                continue;

            }

            Property aProp = xInfo->getPropertyByName(sProperty);

            plStates[i] = (aProp.Attributes & PropertyAttribute::READONLY) == PropertyAttribute::READONLY;

        }

        catch (const Exception&)

        {

        }

    }

    return lStates;

}

Sequence< Any > ConfigItem::GetProperties(const Sequence< OUString >& rNames)

{

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    if(xHierarchyAccess.is())

        return GetProperties(xHierarchyAccess, rNames,

                    (m_nMode & ConfigItemMode::AllLocales ) == ConfigItemMode::AllLocales);

    return Sequence< Any >(rNames.getLength());

}

Sequence< Any > ConfigItem::GetProperties(

        css::uno::Reference<css::container::XHierarchicalNameAccess> const & xHierarchyAccess,

        const Sequence< OUString >& rNames,

        bool bAllLocales)

{

    Sequence< Any > aRet(rNames.getLength());

    const OUString* pNames = rNames.getConstArray();

    Any* pRet = aRet.getArray();

    for(int i = 0; i < rNames.getLength(); i++)

    {

        try

        {

            pRet[i] = xHierarchyAccess->getByHierarchicalName(pNames[i]);

        }

        catch (const Exception&)

        {

            TOOLS_WARN_EXCEPTION(

                "unotools.config",

                "ignoring XHierarchicalNameAccess " << pNames[i]);

        }

    }

    // In special mode "ALL_LOCALES" we must convert localized values to Sequence< PropertyValue >.

    if(bAllLocales)

    {

        Sequence< Any > lValues;

        impl_packLocalizedProperties( rNames, aRet, lValues );

        aRet = std::move(lValues);

    }

    return aRet;

}

bool ConfigItem::PutProperties( const Sequence< OUString >& rNames,

                                                const Sequence< Any>& rValues)

{

    ValueCounter_Impl aCounter(m_nInValueChange);

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    Reference<XNameReplace> xTopNodeReplace(xHierarchyAccess, UNO_QUERY);

    bool bRet = xHierarchyAccess.is() && xTopNodeReplace.is();

    if(bRet)

    {

        Sequence< OUString >    lNames;

        Sequence< Any >         lValues;

        const OUString*         pNames  = nullptr;

        const Any*              pValues = nullptr;

        sal_Int32               nNameCount;

        if(( m_nMode & ConfigItemMode::AllLocales ) == ConfigItemMode::AllLocales )

        {

            // If ConfigItem works in "ALL_LOCALES"-mode ... we must support a Sequence< PropertyValue >

            // as value of a localized configuration entry!

            // How we can do that?

            // We must split all PropertyValues to "Sequence< OUString >" AND "Sequence< Any >"!

            impl_unpackLocalizedProperties( rNames, rValues, lNames, lValues );

            pNames      = lNames.getConstArray  ();

            pValues     = lValues.getConstArray ();

            nNameCount  = lNames.getLength      ();

        }

        else

        {

            // This is the normal mode ...

            // Use given input lists directly.

            pNames      = rNames.getConstArray  ();

            pValues     = rValues.getConstArray ();

            nNameCount  = rNames.getLength      ();

        }

        for(int i = 0; i < nNameCount; i++)

        {

            try

            {

                OUString sNode, sProperty;

                if (splitLastFromConfigurationPath(pNames[i],sNode, sProperty))

                {

                    Any aNode = xHierarchyAccess->getByHierarchicalName(sNode);

                    Reference<XNameAccess> xNodeAcc;

                    aNode >>= xNodeAcc;

                    Reference<XNameReplace>   xNodeReplace(xNodeAcc, UNO_QUERY);

                    Reference<XNameContainer> xNodeCont   (xNodeAcc, UNO_QUERY);

                    bool bExist = (xNodeAcc.is() && xNodeAcc->hasByName(sProperty));

                    if (bExist && xNodeReplace.is())

                        xNodeReplace->replaceByName(sProperty, pValues[i]);

                    else

                        if (!bExist && xNodeCont.is())

                            xNodeCont->insertByName(sProperty, pValues[i]);

                        else

                            bRet = false;

                }

                else //direct value

                {

                    xTopNodeReplace->replaceByName(sProperty, pValues[i]);

                }

            }

            catch (css::uno::Exception &)

            {

                TOOLS_WARN_EXCEPTION("unotools.config", "Exception from PutProperties");

            }

        }

        try

        {

            Reference<XChangesBatch> xBatch(xHierarchyAccess, UNO_QUERY);

            xBatch->commitChanges();

        }

        catch (css::uno::Exception &)

        {

            TOOLS_WARN_EXCEPTION("unotools.config", "Exception from commitChanges");

        }

    }

    return bRet;

}

bool ConfigItem::PutProperties(

        css::uno::Reference<css::container::XHierarchicalNameAccess> const & xHierarchyAccess,

        const Sequence< OUString >& rNames,

        const Sequence< Any>& rValues,

        bool bAllLocales)

{

    Reference<XNameReplace> xTopNodeReplace(xHierarchyAccess, UNO_QUERY);

    bool bRet = xTopNodeReplace.is();

    if(bRet)

    {

        Sequence< OUString >    lNames;

        Sequence< Any >         lValues;

        const OUString*         pNames  = nullptr;

        const Any*              pValues = nullptr;

        sal_Int32               nNameCount;

        if(bAllLocales)

        {

            // If ConfigItem works in "ALL_LOCALES"-mode ... we must support a Sequence< PropertyValue >

            // as value of a localized configuration entry!

            // How we can do that?

            // We must split all PropertyValues to "Sequence< OUString >" AND "Sequence< Any >"!

            impl_unpackLocalizedProperties( rNames, rValues, lNames, lValues );

            pNames      = lNames.getConstArray  ();

            pValues     = lValues.getConstArray ();

            nNameCount  = lNames.getLength      ();

        }

        else

        {

            // This is the normal mode ...

            // Use given input lists directly.

            pNames      = rNames.getConstArray  ();

            pValues     = rValues.getConstArray ();

            nNameCount  = rNames.getLength      ();

        }

        for(int i = 0; i < nNameCount; i++)

        {

            try

            {

                OUString sNode, sProperty;

                if (splitLastFromConfigurationPath(pNames[i],sNode, sProperty))

                {

                    Any aNode = xHierarchyAccess->getByHierarchicalName(sNode);

                    Reference<XNameAccess> xNodeAcc;

                    aNode >>= xNodeAcc;

                    Reference<XNameReplace>   xNodeReplace(xNodeAcc, UNO_QUERY);

                    Reference<XNameContainer> xNodeCont   (xNodeAcc, UNO_QUERY);

                    bool bExist = (xNodeAcc.is() && xNodeAcc->hasByName(sProperty));

                    if (bExist && xNodeReplace.is())

                        xNodeReplace->replaceByName(sProperty, pValues[i]);

                    else

                        if (!bExist && xNodeCont.is())

                            xNodeCont->insertByName(sProperty, pValues[i]);

                        else

                            bRet = false;

                }

                else //direct value

                {

                    xTopNodeReplace->replaceByName(sProperty, pValues[i]);

                }

            }

            catch (css::uno::Exception &)

            {

                TOOLS_WARN_EXCEPTION("unotools.config", "Exception from PutProperties");

            }

        }

        try

        {

            Reference<XChangesBatch> xBatch(xHierarchyAccess, UNO_QUERY);

            xBatch->commitChanges();

        }

        catch (css::uno::Exception &)

        {

            TOOLS_WARN_EXCEPTION("unotools.config", "Exception from commitChanges");

        }

    }

    return bRet;

}

void ConfigItem::DisableNotification()

{

    OSL_ENSURE( xChangeLstnr.is(), "ConfigItem::DisableNotification: notifications not enabled currently!" );

    RemoveChangesListener();

}

bool ConfigItem::EnableNotification(const Sequence< OUString >& rNames,

                                    bool bEnableInternalNotification )

{

    OSL_ENSURE(!(m_nMode & ConfigItemMode::ReleaseTree), "notification in ConfigItemMode::ReleaseTree mode not possible");

    m_bEnableInternalNotification = bEnableInternalNotification;

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    Reference<XChangesNotifier> xChgNot(xHierarchyAccess, UNO_QUERY);

    if(!xChgNot.is())

        return false;

    OSL_ENSURE(!xChangeLstnr.is(), "EnableNotification already called");

    if(xChangeLstnr.is())

        xChgNot->removeChangesListener( xChangeLstnr );

    bool bRet = true;

    try

    {

        xChangeLstnr = new ConfigChangeListener_Impl(*this, rNames);

        xChgNot->addChangesListener( xChangeLstnr );

    }

    catch (const RuntimeException&)

    {

        bRet = false;

    }

    return bRet;

}

void ConfigItem::RemoveChangesListener()

{

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    if(!xHierarchyAccess.is())

        return;

    Reference<XChangesNotifier> xChgNot(xHierarchyAccess, UNO_QUERY);

    if(xChgNot.is() && xChangeLstnr.is())

    {

        try

        {

            xChgNot->removeChangesListener( xChangeLstnr );

            xChangeLstnr = nullptr;

        }

        catch (const Exception&)

        {

        }

    }

}

static void lcl_normalizeLocalNames(Sequence< OUString >& _rNames, ConfigNameFormat _eFormat, Reference<XInterface> const& _xParentNode)

{

    switch (_eFormat)

    {

    case ConfigNameFormat::LocalNode:

        // unaltered - this is our input format

        break;

    case ConfigNameFormat::LocalPath:

        {

            Reference<XTemplateContainer> xTypeContainer(_xParentNode, UNO_QUERY);

            if (xTypeContainer.is())

            {

                OUString sTypeName = xTypeContainer->getElementTemplateName();

                sTypeName = sTypeName.copy(sTypeName.lastIndexOf('/')+1);

                std::transform(std::cbegin(_rNames), std::cend(_rNames), _rNames.getArray(),

                    [&sTypeName](const OUString& rName) -> OUString { return wrapConfigurationElementName(rName,sTypeName); });

            }

            else

            {

                Reference<XServiceInfo> xSVI(_xParentNode, UNO_QUERY);

                if (xSVI.is() && xSVI->supportsService(u"com.sun.star.configuration.SetAccess"_ustr))

                {

                    std::transform(std::cbegin(_rNames), std::cend(_rNames), _rNames.getArray(),

                        [](const OUString& rName) -> OUString { return wrapConfigurationElementName(rName); });

                }

            }

        }

        break;

    }

}

Sequence< OUString > ConfigItem::GetNodeNames(const OUString& rNode)

{

    ConfigNameFormat const eDefaultFormat = ConfigNameFormat::LocalNode; // CONFIG_NAME_DEFAULT;

    return GetNodeNames(rNode, eDefaultFormat);

}

Sequence< OUString > ConfigItem::GetNodeNames(const OUString& rNode, ConfigNameFormat eFormat)

{

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    if(xHierarchyAccess.is())

        return GetNodeNames(xHierarchyAccess, rNode, eFormat);

    return Sequence< OUString >();

}

Sequence< OUString > ConfigItem::GetNodeNames(

    css::uno::Reference<css::container::XHierarchicalNameAccess> const & xHierarchyAccess,

    const OUString& rNode,

    ConfigNameFormat eFormat)

{

    Sequence< OUString > aRet;

    try

    {

        Reference<XNameAccess> xCont;

        if(!rNode.isEmpty())

        {

            Any aNode = xHierarchyAccess->getByHierarchicalName(rNode);

            aNode >>= xCont;

        }

        else

            xCont.set(xHierarchyAccess, UNO_QUERY);

        if(xCont.is())

        {

            aRet = xCont->getElementNames();

            lcl_normalizeLocalNames(aRet,eFormat,xCont);

        }

    }

    catch (css::uno::Exception &)

    {

        TOOLS_WARN_EXCEPTION("unotools.config", "Exception from GetNodeNames");

    }

    return aRet;

}

bool ConfigItem::ClearNodeSet(const OUString& rNode)

{

    ValueCounter_Impl aCounter(m_nInValueChange);

    bool bRet = false;

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    if(xHierarchyAccess.is())

        bRet = ClearNodeSet(xHierarchyAccess, rNode);

    return bRet;

}

bool ConfigItem::ClearNodeSet(

    css::uno::Reference<css::container::XHierarchicalNameAccess> const & xHierarchyAccess,

    const OUString& rNode)

{

    bool bRet = false;

    try

    {

        Reference<XNameContainer> xCont;

        if(!rNode.isEmpty())

        {

            Any aNode = xHierarchyAccess->getByHierarchicalName(rNode);

            aNode >>= xCont;

        }

        else

            xCont.set(xHierarchyAccess, UNO_QUERY);

        if(!xCont.is())

            return false;

        const Sequence< OUString > aNames = xCont->getElementNames();

        Reference<XChangesBatch> xBatch(xHierarchyAccess, UNO_QUERY);

        for(const OUString& rName : aNames)

        {

            try

            {

                xCont->removeByName(rName);

            }

            catch (css::uno::Exception &)

            {

                TOOLS_WARN_EXCEPTION("unotools.config", "Exception from removeByName");

            }

        }

        xBatch->commitChanges();

        bRet = true;

    }

    catch (css::uno::Exception &)

    {

        TOOLS_WARN_EXCEPTION("unotools.config", "Exception from ClearNodeSet");

    }

    return bRet;

}

bool ConfigItem::ClearNodeElements(const OUString& rNode, Sequence< OUString > const & rElements)

{

    ValueCounter_Impl aCounter(m_nInValueChange);

    bool bRet = false;

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    if(xHierarchyAccess.is())

    {

        try

        {

            Reference<XNameContainer> xCont;

            if(!rNode.isEmpty())

            {

                Any aNode = xHierarchyAccess->getByHierarchicalName(rNode);

                aNode >>= xCont;

            }

            else

                xCont.set(xHierarchyAccess, UNO_QUERY);

            if(!xCont.is())

                return false;

            try

            {

                for(const OUString& rElement : rElements)

                {

                    xCont->removeByName(rElement);

                }

                Reference<XChangesBatch> xBatch(xHierarchyAccess, UNO_QUERY);

                xBatch->commitChanges();

            }

            catch (css::uno::Exception &)

            {

                TOOLS_WARN_EXCEPTION("unotools.config", "Exception from commitChanges()");

            }

            bRet = true;

        }

        catch (css::uno::Exception &)

        {

            TOOLS_WARN_EXCEPTION("unotools.config", "Exception from GetNodeNames()");

        }

    }

    return bRet;

}

static OUString lcl_extractSetPropertyName( const OUString& rInPath, std::u16string_view rPrefix )

{

    OUString const sSubPath = dropPrefixFromConfigurationPath( rInPath, rPrefix);

    return extractFirstFromConfigurationPath( sSubPath );

}

static

Sequence< OUString > lcl_extractSetPropertyNames( const Sequence< PropertyValue >& rValues, std::u16string_view rPrefix )

{

    Sequence< OUString > aSubNodeNames(rValues.getLength());

    OUString* pSubNodeNames = aSubNodeNames.getArray();

    OUString sLastSubNode;

    sal_Int32 nSubIndex = 0;

    for(const PropertyValue& rProperty : rValues)

    {

        OUString const sSubPath = dropPrefixFromConfigurationPath( rProperty.Name, rPrefix);

        OUString const sSubNode = extractFirstFromConfigurationPath( sSubPath );

        if(sLastSubNode != sSubNode)

        {

            pSubNodeNames[nSubIndex++] = sSubNode;

        }

        sLastSubNode = sSubNode;

    }

    aSubNodeNames.realloc(nSubIndex);

    return aSubNodeNames;

}

// Add or change properties

bool ConfigItem::SetSetProperties(

    const OUString& rNode, const Sequence< PropertyValue >& rValues)

{

    ValueCounter_Impl aCounter(m_nInValueChange);

    Reference<XHierarchicalNameAccess> xHierarchyAccess = GetTree();

    if(!xHierarchyAccess.is())

        return true;

    return SetSetProperties(xHierarchyAccess, rNode, rValues);

}

// Add or change properties

bool ConfigItem::SetSetProperties(

    css::uno::Reference<css::container::XHierarchicalNameAccess> const & xHierarchyAccess,

    const OUString& rNode, const Sequence< PropertyValue >& rValues)

{

    bool bRet = true;

    Reference<XChangesBatch> xBatch(xHierarchyAccess, UNO_QUERY);

    try

    {

        Reference<XNameContainer> xCont;

        if(!rNode.isEmpty())

        {

            Any aNode = xHierarchyAccess->getByHierarchicalName(rNode);

            aNode >>= xCont;

        }

        else

            xCont.set(xHierarchyAccess, UNO_QUERY);

        if(!xCont.is())

            return false;

        Reference<XSingleServiceFactory> xFac(xCont, UNO_QUERY);

        if(xFac.is())

        {

            const Sequence< OUString > aSubNodeNames = lcl_extractSetPropertyNames(rValues, rNode);

            for(const auto& rSubNodeName : aSubNodeNames)

            {

                if(!xCont->hasByName(rSubNodeName))

                {

                    Reference<XInterface> xInst = xFac->createInstance();

                    Any aVal; aVal <<= xInst;

                    xCont->insertByName(rSubNodeName, aVal);

                }

                //set values

            }

            try

            {

                xBatch->commitChanges();

            }

            catch (css::uno::Exception &)

            {

                TOOLS_WARN_EXCEPTION("unotools.config", "Exception from commitChanges()");

            }

            const PropertyValue* pProperties = rValues.getConstArray();

            Sequence< OUString > aSetNames(rValues.getLength());

            OUString* pSetNames = aSetNames.getArray();

            Sequence< Any> aSetValues(rValues.getLength());

            Any* pSetValues = aSetValues.getArray();

            bool bEmptyNode = rNode.isEmpty();

            for(sal_Int32 k = 0; k < rValues.getLength(); k++)

            {