/* -*- 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 <osl/mutex.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <tools/urlobj.hxx>

#include <rtl/uri.hxx>

#include <rtl/ustring.hxx>

#include <sal/log.hxx>

#include <utility>

#include <vcl/svapp.hxx>

#include <vcl/wrkwin.hxx>

#include <unotools/pathoptions.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertysequence.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <comphelper/storagehelper.hxx>

#include <comphelper/string.hxx>

#include <cppuhelper/implbase.hxx>

#include <cppuhelper/supportsservice.hxx>

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

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

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

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

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

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

#include <com/sun/star/ucb/SimpleFileAccess.hpp>

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

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

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

#include <com/sun/star/document/XTypeDetection.hpp>

#include <com/sun/star/document/DocumentProperties.hpp>

#include <com/sun/star/io/TempFile.hpp>

#include <com/sun/star/sdbc/XResultSet.hpp>

#include <com/sun/star/sdbc/XRow.hpp>

#include <com/sun/star/ucb/ContentCreationException.hpp>

#include <com/sun/star/ucb/NameClash.hpp>

#include <com/sun/star/ucb/NameClashException.hpp>

#include <com/sun/star/ucb/XCommandEnvironment.hpp>

#include <com/sun/star/ucb/XContentAccess.hpp>

#include <com/sun/star/frame/ModuleManager.hpp>

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

#include <com/sun/star/task/InteractionHandler.hpp>

#include <com/sun/star/ucb/XProgressHandler.hpp>

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

#include <com/sun/star/frame/XDocumentTemplates.hpp>

#include <com/sun/star/frame/XStorable.hpp>

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

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

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

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

#include <com/sun/star/ucb/XContent.hpp>

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

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

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

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

#include <svtools/templatefoldercache.hxx>

#include <unotools/configmgr.hxx>

#include <unotools/ucbhelper.hxx>

#include <i18nlangtag/languagetag.hxx>

#include <ucbhelper/content.hxx>

#include <o3tl/string_view.hxx>

#include <sfx2/sfxresid.hxx>

#include <sfxurlrelocator.hxx>

#include <doctemplateslocal.hxx>

#include <sfx2/docfac.hxx>

#include <sfx2/strings.hrc>

#include <doctempl.hrc>

#include <memory>

#include <vector>

constexpr OUStringLiteral SERVICENAME_TYPEDETECTION = u"com.sun.star.document.TypeDetection";

constexpr OUStringLiteral TEMPLATE_ROOT_URL = u"vnd.sun.star.hier:/templates";

constexpr OUString TITLE = u"Title"_ustr;

constexpr OUString IS_FOLDER = u"IsFolder"_ustr;

constexpr OUString IS_DOCUMENT = u"IsDocument"_ustr;

constexpr OUString TARGET_URL = u"TargetURL"_ustr;

constexpr OUStringLiteral TEMPLATE_VERSION = u"TemplateComponentVersion";

constexpr OUStringLiteral TEMPLATE_VERSION_VALUE = u"2";

constexpr OUStringLiteral TYPE_FOLDER = u"application/vnd.sun.star.hier-folder";

constexpr OUStringLiteral TYPE_LINK = u"application/vnd.sun.star.hier-link";

constexpr OUString TYPE_FSYS_FOLDER = u"application/vnd.sun.staroffice.fsys-folder"_ustr;

constexpr OUStringLiteral TYPE_FSYS_FILE = u"application/vnd.sun.staroffice.fsys-file";

constexpr OUString PROPERTY_DIRLIST = u"DirectoryList"_ustr;

constexpr OUString PROPERTY_NEEDSUPDATE = u"NeedsUpdate"_ustr;

constexpr OUString PROPERTY_TYPE = u"TypeDescription"_ustr;

constexpr OUString TARGET_DIR_URL = u"TargetDirURL"_ustr;

constexpr OUStringLiteral COMMAND_DELETE = u"delete";

constexpr OUString STANDARD_FOLDER = u"standard"_ustr;

#define C_DELIM                 ';'

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

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

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

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

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

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

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

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

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

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

using namespace ::ucbhelper;

using namespace ::comphelper;

using ::std::vector;

namespace {

class WaitWindow_Impl : public WorkWindow

{

    tools::Rectangle     maRect;

    OUString      maText;

    static constexpr DrawTextFlags gnTextStyle = DrawTextFlags::Center | DrawTextFlags::VCenter | DrawTextFlags::WordBreak | DrawTextFlags::MultiLine;

public:

    WaitWindow_Impl();

    virtual ~WaitWindow_Impl() override;

    virtual void dispose() override;

    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;

};

#define X_OFFSET 15

#define Y_OFFSET 15

struct NamePair_Impl

{

    OUString maShortName;

    OUString maLongName;

};

class DocTemplates_EntryData_Impl;

class GroupData_Impl;

typedef vector< std::unique_ptr<GroupData_Impl> > GroupList_Impl;

class TplTaskEnvironment : public ::cppu::WeakImplHelper< ucb::XCommandEnvironment >

{

    uno::Reference< task::XInteractionHandler >               m_xInteractionHandler;

public:

    explicit TplTaskEnvironment( uno::Reference< task::XInteractionHandler> xInteractionHandler )

                                : m_xInteractionHandler(std::move( xInteractionHandler ))

                            {}

    virtual uno::Reference<task::XInteractionHandler> SAL_CALL getInteractionHandler() override

    { return m_xInteractionHandler; }

    virtual uno::Reference<ucb::XProgressHandler> SAL_CALL    getProgressHandler() override

    { return uno::Reference<ucb::XProgressHandler>(); }

};

class SfxDocTplService : public ::cppu::WeakImplHelper< css::lang::XLocalizable, css::frame::XDocumentTemplates, css::lang::XServiceInfo >

{

public:

    explicit SfxDocTplService( const css::uno::Reference < uno::XComponentContext >& xContext );

    virtual ~SfxDocTplService() override;

    virtual OUString SAL_CALL getImplementationName() override

    {

        return u"com.sun.star.comp.sfx2.DocumentTemplates"_ustr;

    }

    virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override

    {

        return cppu::supportsService(this, ServiceName);

    }

    virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override

    {

        css::uno::Sequence< OUString > aSeq { u"com.sun.star.frame.DocumentTemplates"_ustr };

        return aSeq;

    }

    // --- XLocalizable ---

    void SAL_CALL                   setLocale( const css::lang::Locale & eLocale ) override;

    css::lang::Locale SAL_CALL              getLocale() override;

    // --- XDocumentTemplates ---

    css::uno::Reference< css::ucb::XContent > SAL_CALL  getContent() override;

    sal_Bool SAL_CALL               storeTemplate( const OUString& GroupName,

                                                   const OUString& TemplateName,

                                                   const css::uno::Reference< css::frame::XStorable >& Storable ) override;

    sal_Bool SAL_CALL               addTemplate( const OUString& GroupName,

                                                 const OUString& TemplateName,

                                                 const OUString& SourceURL ) override;

    sal_Bool SAL_CALL               removeTemplate( const OUString& GroupName,

                                                    const OUString& TemplateName ) override;

    sal_Bool SAL_CALL               renameTemplate( const OUString& GroupName,

                                                    const OUString& OldTemplateName,

                                                    const OUString& NewTemplateName ) override;

    sal_Bool SAL_CALL               addGroup( const OUString& GroupName ) override;

    sal_Bool SAL_CALL               removeGroup( const OUString& GroupName ) override;

    sal_Bool SAL_CALL               renameGroup( const OUString& OldGroupName,

                                                 const OUString& NewGroupName ) override;

    void SAL_CALL                   update() override;

private:

    bool                        init() { if ( !mbIsInitialized ) init_Impl(); return mbIsInitialized; }

    void                        doUpdate();

    uno::Reference< XComponentContext >              mxContext;

    rtl::Reference< TplTaskEnvironment >             maCmdEnv;

    uno::Reference< XDocumentProperties>             m_xDocProps;

    uno::Reference< XTypeDetection >                 mxType;

    ::osl::Mutex                maMutex;

    Sequence< OUString >        maTemplateDirs;

    Sequence< OUString >        maInternalTemplateDirs;

    OUString                    maRootURL;

    std::vector< NamePair_Impl > maNames;

    lang::Locale                maLocale;

    Content                     maRootContent;

    bool                        mbIsInitialized : 1;

    bool                        mbLocaleSet     : 1;

    SfxURLRelocator_Impl        maRelocator;

    void                        init_Impl();

    void                        getDefaultLocale();

    void                        getDirList();

    void                        readFolderList();

    bool                        needsUpdate();

    OUString                    getLongName( const OUString& rShortName );

    bool                    setTitleForURL( const OUString& rURL, const OUString& aTitle );

    void                    getTitleFromURL( const OUString& rURL, OUString& aTitle, OUString& aType, bool& bDocHasTitle );

    bool                    addEntry( Content& rParentFolder,

                                          const OUString& rTitle,

                                          const OUString& rTargetURL,

                                          const OUString& rType );

    bool                    createFolder( const OUString& rNewFolderURL,

                                              bool  bCreateParent,

                                              bool  bFsysFolder,

                                              Content   &rNewFolder );

    static bool             CreateNewUniqueFolderWithPrefix( std::u16string_view aPath,

                                                                const OUString& aPrefix,

                                                                OUString& aNewFolderName,

                                                                OUString& aNewFolderURL,

                                                                Content& aNewFolder );

    static OUString         CreateNewUniqueFileWithPrefix( std::u16string_view aPath,

                                                                const OUString& aPrefix,

                                                                std::u16string_view aExt );

    std::vector< beans::StringPair > ReadUINamesForTemplateDir_Impl( std::u16string_view aUserPath );

    bool                    UpdateUINamesForTemplateDir_Impl( std::u16string_view aUserPath,

                                                                  const OUString& aGroupName,

                                                                  const OUString& aNewFolderName );

    bool                    ReplaceUINamesForTemplateDir_Impl( std::u16string_view aUserPath,

                                                                  const OUString& aFsysGroupName,

                                                                  std::u16string_view aOldGroupName,

                                                                  const OUString& aNewGroupName );

    void                    RemoveUINamesForTemplateDir_Impl( std::u16string_view aUserPath,

                                                                  std::u16string_view aGroupName );

    bool                    WriteUINamesForTemplateDir_Impl( std::u16string_view aUserPath,

                                                                const std::vector< beans::StringPair >& aUINames );

    OUString                CreateNewGroupFsys( const OUString& rGroupName, Content& aGroup );

    static bool             removeContent( Content& rContent );

    bool                    removeContent( const OUString& rContentURL );

    bool                    setProperty( Content& rContent,

                                             const OUString& rPropName,

                                             const Any& rPropValue );

    bool                    getProperty( Content& rContent,

                                             const OUString& rPropName,

                                             Any& rPropValue );

    void                        createFromContent( GroupList_Impl& rList,

                                                   Content &rContent,

                                                   bool bHierarchy,

                                                   bool bWriteableContent );

    void                        addHierGroup( GroupList_Impl& rList,

                                              const OUString& rTitle,

                                              const OUString& rOwnURL );

    void                        addFsysGroup( GroupList_Impl& rList,

                                              const OUString& rTitle,

                                              const OUString& rUITitle,

                                              const OUString& rOwnURL,

                                              bool bWriteableGroup );

    void                        removeFromHierarchy( DocTemplates_EntryData_Impl const *pData );

    void                        addToHierarchy( GroupData_Impl const *pGroup,

                                                DocTemplates_EntryData_Impl const *pData );

    void                        removeFromHierarchy( GroupData_Impl const *pGroup );

    void                        addGroupToHierarchy( GroupData_Impl *pGroup );

    void                        updateData( DocTemplates_EntryData_Impl const *pData );

    //See: #i66157# and rhbz#1065807

    //return which template dir the rURL is a subpath of

    OUString                    findParentTemplateDir(const OUString& rURL) const;

    //See: #i66157# and rhbz#1065807

    //return true if rURL is a path (or subpath of) a dir which is not a user path

    //which implies neither it or its contents can be removed

    bool                        isInternalTemplateDir(const OUString& rURL) const;

};

class DocTemplates_EntryData_Impl

{

    OUString            maTitle;

    OUString            maType;

    OUString            maTargetURL;

    OUString            maHierarchyURL;

    bool            mbInHierarchy   : 1;

    bool            mbInUse         : 1;

    bool            mbUpdateType    : 1;

    bool            mbUpdateLink    : 1;

public:

   explicit             DocTemplates_EntryData_Impl( OUString aTitle );

    void                setInUse() { mbInUse = true; }

    void                setHierarchy( bool bInHierarchy ) { mbInHierarchy = bInHierarchy; }

    void                setUpdateLink( bool bUpdateLink ) { mbUpdateLink = bUpdateLink; }

    void                setUpdateType( bool bUpdateType ) { mbUpdateType = bUpdateType; }

    bool                getInUse() const { return mbInUse; }

    bool                getInHierarchy() const { return mbInHierarchy; }

    bool                getUpdateLink() const { return mbUpdateLink; }

    bool                getUpdateType() const { return mbUpdateType; }

    const OUString&     getHierarchyURL() const { return maHierarchyURL; }

    const OUString&     getTargetURL() const { return maTargetURL; }

    const OUString&     getTitle() const { return maTitle; }

    const OUString&     getType() const { return maType; }

    void                setHierarchyURL( const OUString& rURL ) { maHierarchyURL = rURL; }

    void                setTargetURL( const OUString& rURL ) { maTargetURL = rURL; }

    void                setType( const OUString& rType ) { maType = rType; }

};

class GroupData_Impl

{

    std::vector< std::unique_ptr<DocTemplates_EntryData_Impl> > maEntries;

    OUString            maTitle;

    OUString            maHierarchyURL;

    OUString            maTargetURL;

    bool            mbInUse         : 1;

    bool            mbInHierarchy   : 1;

public:

    explicit            GroupData_Impl( OUString aTitle );

    void                setInUse() { mbInUse = true; }

    void                setHierarchy( bool bInHierarchy ) { mbInHierarchy = bInHierarchy; }

    void                setHierarchyURL( const OUString& rURL ) { maHierarchyURL = rURL; }

    void                setTargetURL( const OUString& rURL ) { maTargetURL = rURL; }

    bool            getInUse() const { return mbInUse; }

    bool            getInHierarchy() const { return mbInHierarchy; }

    const OUString&     getHierarchyURL() const { return maHierarchyURL; }

    const OUString&     getTargetURL() const { return maTargetURL; }

    const OUString&     getTitle() const { return maTitle; }

    DocTemplates_EntryData_Impl*     addEntry( const OUString& rTitle,

                                  const OUString& rTargetURL,

                                  const OUString& rType,

                                  const OUString& rHierURL );

    size_t                          count() { return maEntries.size(); }

    DocTemplates_EntryData_Impl*    getEntry( size_t nPos ) { return maEntries[ nPos ].get(); }

};

// private SfxDocTplService_Impl

void SfxDocTplService::init_Impl()

{

    const uno::Reference< uno::XComponentContext >& xContext = ::comphelper::getProcessComponentContext();

    uno::Reference < task::XInteractionHandler > xInteractionHandler(

        task::InteractionHandler::createWithParent(xContext, nullptr), uno::UNO_QUERY_THROW );

    maCmdEnv = new TplTaskEnvironment( xInteractionHandler );

    ::osl::ClearableMutexGuard aGuard( maMutex );

    bool bIsInitialized = false;

    bool bNeedsUpdate   = false;

    if ( !mbLocaleSet )

        getDefaultLocale();

    // convert locale to string

    // set maRootContent to the root of the templates hierarchy. Create the

    // entry if necessary

    maRootURL = TEMPLATE_ROOT_URL + "/" + LanguageTag::convertToBcp47(maLocale);

    const OUString aTemplVersPropName( TEMPLATE_VERSION  );

    const OUString aTemplVers( TEMPLATE_VERSION_VALUE  );

    if ( Content::create( maRootURL, maCmdEnv, comphelper::getProcessComponentContext(), maRootContent ) )

    {

        uno::Any aValue;

        OUString aPropValue;

        if ( getProperty( maRootContent, aTemplVersPropName, aValue )

          && ( aValue >>= aPropValue )

          && aPropValue == aTemplVers )

        {

            bIsInitialized = true;

        }

        else

            removeContent( maRootContent );

    }

    if ( !bIsInitialized )

    {

        if ( createFolder( maRootURL, true, false, maRootContent )

          && setProperty( maRootContent, aTemplVersPropName, uno::Any( aTemplVers ) ) )

            bIsInitialized = true;

        bNeedsUpdate = true;

    }

    if ( bIsInitialized )

    {

        try {

            m_xDocProps.set(document::DocumentProperties::create(

                        ::comphelper::getProcessComponentContext()));

        } catch (uno::RuntimeException const&) {

            TOOLS_WARN_EXCEPTION("sfx.doc", "SfxDocTplService_Impl::init_Impl: cannot create DocumentProperties service:");

        }

        mxType.set( mxContext->getServiceManager()->createInstanceWithContext(SERVICENAME_TYPEDETECTION, mxContext), UNO_QUERY );

        getDirList();

        readFolderList();

        if ( bNeedsUpdate )

        {

            aGuard.clear();

            SolarMutexGuard aSolarGuard;

            [[maybe_unused]] ScopedVclPtrInstance<WaitWindow_Impl> pWin;

            {

                SolarMutexReleaser aSolarReleaser;

                osl::MutexGuard anotherGuard(maMutex);

                doUpdate();

            }

        }

        else if ( needsUpdate() )

            // the UI should be shown only on the first update

            doUpdate();

    }

    else

    {

        SAL_WARN( "sfx.doc", "init_Impl(): Could not create root" );

    }

    mbIsInitialized = bIsInitialized;

}

void SfxDocTplService::getDefaultLocale()

{

    if ( !mbLocaleSet )

    {

        ::osl::MutexGuard aGuard( maMutex );

        if ( !mbLocaleSet )

        {

            maLocale = LanguageTag::convertToLocale( utl::ConfigManager::getUILocale(), false);

            mbLocaleSet = true;

        }

    }

}

const char* const TEMPLATE_SHORT_NAMES_ARY[] =

{

    "standard",

    "styles",

    "officorr",

    "offimisc",

    "personal",

    "presnt",

    "draw",

    "l10n",

};

void SfxDocTplService::readFolderList()

{

    SolarMutexGuard aGuard;

    static_assert( SAL_N_ELEMENTS(TEMPLATE_SHORT_NAMES_ARY) == SAL_N_ELEMENTS(TEMPLATE_LONG_NAMES_ARY), "mismatch array lengths" );

    const size_t nCount = std::min(SAL_N_ELEMENTS(TEMPLATE_SHORT_NAMES_ARY), SAL_N_ELEMENTS(TEMPLATE_LONG_NAMES_ARY));

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

    {

        NamePair_Impl aPair;

        aPair.maShortName  = OUString::createFromAscii(TEMPLATE_SHORT_NAMES_ARY[i]);

        aPair.maLongName   = SfxResId(TEMPLATE_LONG_NAMES_ARY[i]);

        maNames.push_back( aPair );

    }

}

OUString SfxDocTplService::getLongName( const OUString& rShortName )

{

    OUString         aRet;

    for (auto const & rPair : maNames)

    {

        if ( rPair.maShortName == rShortName )

        {

            aRet = rPair.maLongName;

            break;

        }

    }

    if ( aRet.isEmpty() )

        aRet = rShortName;

    return aRet;

}

void SfxDocTplService::getDirList()

{

    Any      aValue;

    // Get the template dir list

    // TODO/LATER: let use service, register listener

    INetURLObject   aURL;

    OUString    aDirs = SvtPathOptions().GetTemplatePath();

    sal_Int32 nCount = comphelper::string::getTokenCount(aDirs, C_DELIM);

    maTemplateDirs = Sequence< OUString >( nCount );

    uno::Reference< util::XMacroExpander > xExpander = util::theMacroExpander::get(mxContext);

    sal_Int32 nIdx{ 0 };

    for (auto& rTemplateDir : asNonConstRange(maTemplateDirs))

    {

        aURL.SetSmartProtocol( INetProtocol::File );

        aURL.SetURL( o3tl::getToken(aDirs, 0, C_DELIM, nIdx ) );

        rTemplateDir = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );

        if (xExpander && rTemplateDir.startsWithIgnoreAsciiCase("vnd.sun.star.expand:", &rTemplateDir))

        {

            rTemplateDir

                = rtl::Uri::decode(rTemplateDir, rtl_UriDecodeStrict, RTL_TEXTENCODING_UTF8);

            rTemplateDir = xExpander->expandMacros( rTemplateDir );

        }

    }

    aValue <<= maTemplateDirs;

    css::uno::Reference< css::util::XPathSettings > xPathSettings =

        css::util::thePathSettings::get(mxContext);

    // load internal paths

    Any aAny = xPathSettings->getPropertyValue( u"Template_internal"_ustr );

    aAny >>= maInternalTemplateDirs;

    for (auto& rInternalTemplateDir : asNonConstRange(maInternalTemplateDirs))

    {

        //expand vnd.sun.star.expand: and remove "..." from them

        //to normalize into the expected url patterns

        maRelocator.makeRelocatableURL(rInternalTemplateDir);

        maRelocator.makeAbsoluteURL(rInternalTemplateDir);

    }

    // Store the template dir list

    setProperty( maRootContent, PROPERTY_DIRLIST, aValue );

}

bool SfxDocTplService::needsUpdate()

{

    bool bNeedsUpdate = true;

    Any      aValue;

    // Get the template dir list

    bool bHasProperty = getProperty( maRootContent, PROPERTY_NEEDSUPDATE, aValue );

    if ( bHasProperty )

        aValue >>= bNeedsUpdate;

    // the old template component also checks this state, but it is initialized from this component

    // so if this component was already updated the old component does not need such an update

    ::svt::TemplateFolderCache aTempCache;

    if ( !bNeedsUpdate )

        bNeedsUpdate = aTempCache.needsUpdate();

    if ( bNeedsUpdate )

        aTempCache.storeState();

    return bNeedsUpdate;

}

bool SfxDocTplService::setTitleForURL( const OUString& rURL, const OUString& aTitle )

{

    if (m_xDocProps.is())

    {

        try

        {

            m_xDocProps->loadFromMedium(rURL, Sequence<PropertyValue>());

            m_xDocProps->setTitle(aTitle);

            uno::Reference< embed::XStorage > xStorage = ::comphelper::OStorageHelper::GetStorageFromURL(

                    rURL, embed::ElementModes::READWRITE);

            uno::Sequence<beans::PropertyValue> medium( comphelper::InitPropertySequence({

                    { "DocumentBaseURL", Any(rURL) },

                    { "URL", Any(rURL) }

                }));

            m_xDocProps->storeToStorage(xStorage, medium);

            return true;

        }

        catch ( Exception& )

        {

        }

    }

    return false;

}

void SfxDocTplService::getTitleFromURL( const OUString& rURL, OUString& aTitle, OUString& aType, bool& bDocHasTitle )

{

    bDocHasTitle = false;

    if (m_xDocProps.is())

    {

        try

        {

            m_xDocProps->loadFromMedium(rURL, Sequence<PropertyValue>());

            aTitle = m_xDocProps->getTitle();

        }

        catch ( Exception& )

        {

        }

    }

    if ( aType.isEmpty() && mxType.is() )

    {

        const OUString aDocType {mxType->queryTypeByURL( rURL )};

        if ( !aDocType.isEmpty() )

            try

            {

                uno::Reference< container::XNameAccess > xTypeDetection( mxType, uno::UNO_QUERY );

                if (xTypeDetection)

                {

                    SequenceAsHashMap aTypeProps( xTypeDetection->getByName( aDocType ) );

                    aType = aTypeProps.getUnpackedValueOrDefault(

                                u"MediaType"_ustr,

                                OUString() );

                }

            }

            catch( uno::Exception& )

            {}

    }

    if ( aTitle.isEmpty() )

    {

        INetURLObject aURL( rURL );

        aURL.CutExtension();

        aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true,

                               INetURLObject::DecodeMechanism::WithCharset );

    }

    else

        bDocHasTitle = true;

}

bool SfxDocTplService::addEntry( Content& rParentFolder,

                                          const OUString& rTitle,

                                          const OUString& rTargetURL,

                                          const OUString& rType )

{

    bool bAddedEntry = false;

    INetURLObject aLinkObj( rParentFolder.getURL() );

    aLinkObj.insertName( rTitle, false,

                      INetURLObject::LAST_SEGMENT,

                      INetURLObject::EncodeMechanism::All );

    const OUString aLinkURL {aLinkObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )};

    Content aLink;

    if ( ! Content::create( aLinkURL, maCmdEnv, comphelper::getProcessComponentContext(), aLink ) )

    {

        Sequence< Any > aValues{ Any(rTitle), Any(false), Any(rTargetURL) };

        try

        {

            rParentFolder.insertNewContent( TYPE_LINK, { TITLE, IS_FOLDER, TARGET_URL }, aValues, aLink );

            setProperty( aLink, PROPERTY_TYPE, Any( rType ) );

            bAddedEntry = true;

        }

        catch( Exception& )

        {}

    }

    return bAddedEntry;

}

bool SfxDocTplService::createFolder( const OUString& rNewFolderURL,

                                              bool  bCreateParent,

                                              bool  bFsysFolder,

                                              Content   &rNewFolder )

{

    Content         aParent;

    bool        bCreatedFolder = false;

    INetURLObject   aParentURL( rNewFolderURL );

    const OUString aFolderName {aParentURL.getName( INetURLObject::LAST_SEGMENT, true,

                                                    INetURLObject::DecodeMechanism::WithCharset )};

    // compute the parent folder url from the new folder url

    // and remove the final slash, because Content::create doesn't

    // like it

    aParentURL.removeSegment();

    if ( aParentURL.getSegmentCount() >= 1 )

        aParentURL.removeFinalSlash();

    // if the parent exists, we can continue with the creation of the

    // new folder, we have to create the parent otherwise ( as long as

    // bCreateParent is set to true )

    if ( Content::create( aParentURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), maCmdEnv, comphelper::getProcessComponentContext(), aParent ) )

    {

        try

        {

            Sequence< Any > aValues{ Any(aFolderName), Any(true) };

            OUString aType;

            if ( bFsysFolder )

                aType = TYPE_FSYS_FOLDER;

            else

                aType = TYPE_FOLDER;

            aParent.insertNewContent( aType, { TITLE, IS_FOLDER }, aValues, rNewFolder );

            bCreatedFolder = true;

        }

        catch( Exception const & )

        {

            TOOLS_WARN_EXCEPTION( "sfx.doc", "createFolder(): Could not create new folder" );

        }

    }

    else if ( bCreateParent )

    {

        // if the parent doesn't exists and bCreateParent is set to true,

        // we try to create the parent and if this was successful, we

        // try to create the new folder again ( but this time, we set

        // bCreateParent to false to avoid endless recursions )

        if ( ( aParentURL.getSegmentCount() >= 1 ) &&

               createFolder( aParentURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), bCreateParent, bFsysFolder, aParent ) )

        {

            bCreatedFolder = createFolder( rNewFolderURL, false, bFsysFolder, rNewFolder );

        }

    }

    return bCreatedFolder;

}

bool SfxDocTplService::CreateNewUniqueFolderWithPrefix( std::u16string_view aPath,

                                                                const OUString& aPrefix,

                                                                OUString& aNewFolderName,

                                                                OUString& aNewFolderURL,

                                                                Content& aNewFolder )

{

    bool bCreated = false;

    INetURLObject aDirPath( aPath );

    Content aParent;

    uno::Reference< XCommandEnvironment > aQuietEnv;

    if ( Content::create( aDirPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aQuietEnv, comphelper::getProcessComponentContext(), aParent ) )

    {

        for ( sal_Int32 nInd = 0; nInd < 32000; nInd++ )

        {

            OUString aTryName = aPrefix;

            if ( nInd )

                aTryName += OUString::number( nInd );

            try

            {

                Sequence< Any > aValues{ Any(aTryName), Any(true) };

                bCreated = aParent.insertNewContent( TYPE_FSYS_FOLDER, { TITLE, IS_FOLDER }, aValues, aNewFolder );

            }

            catch( ucb::NameClashException& )

            {

                // if there is already an element, retry

            }

            catch( Exception& )

            {

                INetURLObject aObjPath( aDirPath );

                aObjPath.insertName( aTryName, false,

                      INetURLObject::LAST_SEGMENT,

                      INetURLObject::EncodeMechanism::All );

                // if there is already an element, retry

                // if there was another error, do not try any more

                if ( !::utl::UCBContentHelper::Exists( aObjPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) )

                    break;

            }

            if ( bCreated )

            {

                aNewFolderName = aTryName;

                aNewFolderURL = aNewFolder.get()->getIdentifier()->getContentIdentifier();

                break;

            }

        }

    }

    return bCreated;

}

OUString SfxDocTplService::CreateNewUniqueFileWithPrefix( std::u16string_view aPath,

                                                                        const OUString& aPrefix,

                                                                        std::u16string_view aExt )

{

    OUString aNewFileURL;

    INetURLObject aDirPath( aPath );

    Content aParent;

    uno::Reference< XCommandEnvironment > aQuietEnv;

    if ( Content::create( aDirPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aQuietEnv, comphelper::getProcessComponentContext(), aParent ) )

    {

        for ( sal_Int32 nInd = 0; nInd < 32000; nInd++ )

        {

            Content aNewFile;

            bool bCreated = false;

            OUString aTryName = aPrefix;

            if ( nInd )

                aTryName += OUString::number( nInd );

            if ( aExt.empty() || aExt[0] != '.' )

                aTryName += ".";

            aTryName += aExt;

            try

            {

                Sequence< Any > aValues{ Any(aTryName), Any(true) };

                bCreated = aParent.insertNewContent( TYPE_FSYS_FILE, { TITLE, IS_DOCUMENT }, aValues, aNewFile );

            }

            catch( ucb::NameClashException& )

            {

                // if there is already an element, retry

            }

            catch( Exception& )

            {

                INetURLObject aObjPath( aPath );

                aObjPath.insertName( aTryName, false,

                      INetURLObject::LAST_SEGMENT,

                      INetURLObject::EncodeMechanism::All );

                // if there is already an element, retry

                // if there was another error, do not try any more

                if ( !::utl::UCBContentHelper::Exists( aObjPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) )

                    break;

            }

            if ( bCreated )

            {

                aNewFileURL = aNewFile.get()->getIdentifier()->getContentIdentifier();

                break;

            }

        }

    }

    return aNewFileURL;

}

bool SfxDocTplService::removeContent( Content& rContent )

{

    bool bRemoved = false;

    try

    {

        Any aArg( true );

        rContent.executeCommand( COMMAND_DELETE, aArg );

        bRemoved = true;

    }

    catch ( RuntimeException& ) {}

    catch ( Exception& ) {}

    return bRemoved;

}

bool SfxDocTplService::removeContent( const OUString& rContentURL )

{

    Content aContent;

    if ( Content::create( rContentURL, maCmdEnv, comphelper::getProcessComponentContext(), aContent ) )

        return removeContent( aContent );

    return false;

}

bool SfxDocTplService::setProperty( Content& rContent,

                                             const OUString& rPropName,

                                             const Any& rPropValue )

{

    bool bPropertySet = false;

    // Store the property

    try

    {

        Any aPropValue( rPropValue );

        uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties();

        // check, whether or not the property exists, create it, when not

        if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) )

        {

            uno::Reference< XPropertyContainer > xProperties( rContent.get(), UNO_QUERY );

            if ( xProperties.is() )

            {

                try

                {

                    xProperties->addProperty( rPropName, PropertyAttribute::MAYBEVOID, rPropValue );

                }

                catch( PropertyExistException& ) {}

                catch( IllegalTypeException& ) {

                    TOOLS_WARN_EXCEPTION( "sfx.doc", "" );

                }

                catch( IllegalArgumentException& ) {

                    TOOLS_WARN_EXCEPTION( "sfx.doc", "" );

                }

            }

        }

        // To ensure a reloctable office installation, the path to the

        // office installation directory must never be stored directly.

        if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) )

        {

            OUString aValue;

            if ( rPropValue >>= aValue )

            {

                maRelocator.makeRelocatableURL( aValue );

                aPropValue <<= aValue;

            }

            else