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

#include <loadenv/loadenvexception.hxx>

#include <loadenv/targethelper.hxx>

#include <framework/framelistanalyzer.hxx>

#include <interaction/quietinteraction.hxx>

#include <properties.h>

#include <protocols.h>

#include <services.h>

#include <targets.h>

#include <comphelper/interaction.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/namedvaluecollection.hxx>

#include <comphelper/propertysequence.hxx>

#include <framework/interaction.hxx>

#include <comphelper/processfactory.hxx>

#include <officecfg/Office/Common.hxx>

#include <officecfg/Setup.hxx>

#include <com/sun/star/awt/XWindow2.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <utility>

#include <vcl/window.hxx>

#include <vcl/wrkwin.hxx>

#include <vcl/syswin.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <unotools/moduleoptions.hxx>

#include <svtools/sfxecode.hxx>

#include <unotools/ucbhelper.hxx>

#include <comphelper/configurationhelper.hxx>

#include <rtl/bootstrap.hxx>

#include <sal/log.hxx>

#include <comphelper/errcode.hxx>

#include <vcl/svapp.hxx>

#include <cppuhelper/implbase.hxx>

#include <comphelper/profilezone.hxx>

#include <classes/taskcreator.hxx>

#include <tools/fileutil.hxx>

#include <unotools/mediadescriptor.hxx>

constexpr OUString PROP_TYPES = u"Types"_ustr;

constexpr OUString PROP_NAME = u"Name"_ustr;

namespace framework {

using namespace com::sun::star;

namespace {

class LoadEnvListener : public ::cppu::WeakImplHelper< css::frame::XLoadEventListener      ,

                                                        css::frame::XDispatchResultListener >

{

    private:

        std::mutex m_mutex;

        bool m_bWaitingResult;

        LoadEnv* m_pLoadEnv;

    public:

        explicit LoadEnvListener(LoadEnv* pLoadEnv)

            : m_bWaitingResult(true)

            , m_pLoadEnv(pLoadEnv)

        {

        }

        // frame.XLoadEventListener

        virtual void SAL_CALL loadFinished(const css::uno::Reference< css::frame::XFrameLoader >& xLoader) override;

        virtual void SAL_CALL loadCancelled(const css::uno::Reference< css::frame::XFrameLoader >& xLoader) override;

        // frame.XDispatchResultListener

        virtual void SAL_CALL dispatchFinished(const css::frame::DispatchResultEvent& aEvent) override;

        // lang.XEventListener

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

};

}

LoadEnv::LoadEnv(css::uno::Reference< css::uno::XComponentContext >  xContext)

    : m_xContext(std::move(xContext))

    , m_nSearchFlags(0)

    , m_eFeature(LoadEnvFeatures::NONE)

    , m_eContentType(E_UNSUPPORTED_CONTENT)

    , m_bCloseFrameOnError(false)

    , m_bReactivateControllerOnError(false)

    , m_bLoaded( false )

{

}

LoadEnv::~LoadEnv()

{

}

css::uno::Reference< css::lang::XComponent > LoadEnv::loadComponentFromURL(const css::uno::Reference< css::frame::XComponentLoader >&    xLoader,

                                                                           const css::uno::Reference< css::uno::XComponentContext >&     xContext  ,

                                                                           const OUString&                                        sURL   ,

                                                                           const OUString&                                        sTarget,

                                                                                 sal_Int32                                               nSearchFlags ,

                                                                           const css::uno::Sequence< css::beans::PropertyValue >&        lArgs  )

{

    css::uno::Reference< css::lang::XComponent > xComponent;

    comphelper::ProfileZone aZone("loadComponentFromURL");

    try

    {

        LoadEnv aEnv(xContext);

        LoadEnvFeatures loadEnvFeatures = LoadEnvFeatures::WorkWithUI;

        // tdf#118238 Only disable UI interaction when loading as hidden

        if (comphelper::NamedValueCollection::get(lArgs, u"Hidden") == uno::Any(true) || Application::IsHeadlessModeEnabled())

            loadEnvFeatures = LoadEnvFeatures::NONE;

        aEnv.startLoading(sURL,

                               lArgs,

                               css::uno::Reference< css::frame::XFrame >(xLoader, css::uno::UNO_QUERY),

                               sTarget,

                               nSearchFlags,

                               loadEnvFeatures);

        aEnv.waitWhileLoading(); // wait for ever!

        xComponent = aEnv.getTargetComponent();

    }

    catch(const LoadEnvException& ex)

    {

        switch(ex.m_nID)

        {

            case LoadEnvException::ID_INVALID_MEDIADESCRIPTOR:

                throw css::lang::IllegalArgumentException(

                    u"Optional list of arguments seem to be corrupted."_ustr, xLoader, 4);

            case LoadEnvException::ID_UNSUPPORTED_CONTENT:

                throw css::lang::IllegalArgumentException(

                    "Unsupported URL <" + sURL + ">: \"" + ex.m_sMessage + "\"",

                    xLoader, 1);

            default:

                SAL_WARN(

                    "fwk.loadenv",

                    "caught LoadEnvException " << +ex.m_nID << " \""

                        << ex.m_sMessage << "\""

                        << (ex.m_exOriginal.has<css::uno::Exception>()

                            ? (", " + ex.m_exOriginal.getValueTypeName() + " \""

                               + (ex.m_exOriginal.get<css::uno::Exception>().

                                  Message)

                               + "\"")

                            : OUString())

                        << " while loading <" << sURL << ">");

                xComponent.clear();

                break;

        }

    }

    // if AbortOnLoadFailure is set and we couldn't load the document, assert, intended for use with crashtesting to

    // detect when we export something we can't import

    assert(xComponent.is() || comphelper::NamedValueCollection::get(lArgs, u"AbortOnLoadFailure") != uno::Any(true));

    return xComponent;

}

namespace {

comphelper::SequenceAsHashMap addModelArgs(const uno::Sequence<beans::PropertyValue>& rDescriptor)

{

    comphelper::SequenceAsHashMap rResult(rDescriptor);

    uno::Reference<frame::XModel> xModel(rResult.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_MODEL, uno::Reference<frame::XModel>()));

    if (xModel.is())

    {

        comphelper::SequenceAsHashMap aModelArgs(xModel->getArgs());

        auto pIt = aModelArgs.find(utl::MediaDescriptor::PROP_MACROEXECUTIONMODE);

        if (pIt != aModelArgs.end())

            rResult[utl::MediaDescriptor::PROP_MACROEXECUTIONMODE] = pIt->second;

    }

    return rResult;

}

}

void LoadEnv::startLoading(const OUString& sURL, const uno::Sequence<beans::PropertyValue>& lMediaDescriptor,

        const uno::Reference<frame::XFrame>& xBaseFrame, const OUString& sTarget,

        sal_Int32 nSearchFlags, LoadEnvFeatures eFeature)

{

    osl::MutexGuard g(m_mutex);

    // Handle still running processes!

    if (m_xAsynchronousJob.is())

        throw LoadEnvException(LoadEnvException::ID_STILL_RUNNING);

    // take over all new parameters.

    m_xTargetFrame.clear();

    m_xBaseFrame = xBaseFrame;

    m_lMediaDescriptor = addModelArgs(lMediaDescriptor);

    m_sTarget = sTarget;

    m_nSearchFlags = nSearchFlags;

    m_eFeature = eFeature;

    m_eContentType = E_UNSUPPORTED_CONTENT;

    m_bCloseFrameOnError = false;

    m_bReactivateControllerOnError = false;

    m_bLoaded = false;

    OUString aRealURL;

    if (!officecfg::Office::Common::Load::DetectWebDAVRedirection::get()

        || !tools::IsMappedWebDAVPath(sURL, &aRealURL))

        aRealURL = sURL;

    // try to find out, if it's really a content, which can be loaded or must be "handled"

    // We use a default value for this in-parameter. Then we have to start a complex check method

    // internally. But if this check was already done outside it can be suppressed to perform

    // the load request. We take over the result then!

    m_eContentType = LoadEnv::classifyContent(aRealURL, lMediaDescriptor);

    if (m_eContentType == E_UNSUPPORTED_CONTENT)

        throw LoadEnvException(LoadEnvException::ID_UNSUPPORTED_CONTENT, u"from LoadEnv::startLoading"_ustr);

    // make URL part of the MediaDescriptor

    // It doesn't matter if it is already an item of it.

    // It must be the same value... so we can overwrite it :-)

    m_lMediaDescriptor[utl::MediaDescriptor::PROP_URL] <<= aRealURL;

    // parse it - because some following code require that

    m_aURL.Complete = aRealURL;

    uno::Reference<util::XURLTransformer> xParser(util::URLTransformer::create(m_xContext));

    xParser->parseStrict(m_aURL);

    // BTW: Split URL and JumpMark ...

    // Because such mark is an explicit value of the media descriptor!

    if (!m_aURL.Mark.isEmpty())

        m_lMediaDescriptor[utl::MediaDescriptor::PROP_JUMPMARK] <<= m_aURL.Mark;

    // By the way: remove the old and deprecated value "FileName" from the descriptor!

    auto pIt = m_lMediaDescriptor.find(utl::MediaDescriptor::PROP_FILENAME);

    if (pIt != m_lMediaDescriptor.end())

        m_lMediaDescriptor.erase(pIt);

    // patch the MediaDescriptor, so it fulfil the outside requirements

    // Means especially items like e.g. UI InteractionHandler, Status Indicator,

    // MacroExecutionMode, etc.

    /*TODO progress is bound to a frame ... How can we set it here? */

    // UI mode

    const bool bUIMode =

        (m_eFeature & LoadEnvFeatures::WorkWithUI) &&

        !m_lMediaDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_HIDDEN, false) &&

        !m_lMediaDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_PREVIEW, false);

    if( comphelper::LibreOfficeKit::isActive() &&

        m_lMediaDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_SILENT, false))

    {

        rtl::Reference<QuietInteraction> pQuietInteraction = new QuietInteraction();

        m_lMediaDescriptor[utl::MediaDescriptor::PROP_INTERACTIONHANDLER] <<=

                uno::Reference<task::XInteractionHandler>(pQuietInteraction);

    }

    initializeUIDefaults(m_xContext, m_lMediaDescriptor, bUIMode, &m_pQuietInteraction);

    start();

}

void LoadEnv::initializeUIDefaults( const css::uno::Reference< css::uno::XComponentContext >& i_rxContext,

                                    comphelper::SequenceAsHashMap& io_lMediaDescriptor, const bool i_bUIMode,

                                    rtl::Reference<QuietInteraction>* o_ppQuietInteraction )

{

    css::uno::Reference< css::task::XInteractionHandler > xInteractionHandler;

    sal_Int16                                             nMacroMode;

    sal_Int16                                             nUpdateMode;

    if ( i_bUIMode )

    {

        nMacroMode  = css::document::MacroExecMode::USE_CONFIG;

        nUpdateMode = css::document::UpdateDocMode::ACCORDING_TO_CONFIG;

        try

        {

            // tdf#154308 At least for the case the document is launched from the StartCenter, put that StartCenter as the

            // parent for any dialogs that may appear during typedetection (once load starts a permanent frame will be set

            // anyway and used as dialog parent, which will be this one if the startcenter was running)

            css::uno::Reference<css::frame::XFramesSupplier> xSupplier = css::frame::Desktop::create(i_rxContext);

            FrameListAnalyzer aTasksAnalyzer(xSupplier, css::uno::Reference<css::frame::XFrame>(), FrameAnalyzerFlags::BackingComponent);

            css::uno::Reference<css::awt::XWindow> xDialogParent(aTasksAnalyzer.m_xBackingComponent ?

                                                                 aTasksAnalyzer.m_xBackingComponent->getContainerWindow() :

                                                                 nullptr);

            xInteractionHandler.set( css::task::InteractionHandler::createWithParent(i_rxContext, xDialogParent), css::uno::UNO_QUERY_THROW );

        }

        catch(const css::uno::RuntimeException&) {throw;}

        catch(const css::uno::Exception&       ) {      }

    }

    // hidden mode

    else

    {

        nMacroMode  = css::document::MacroExecMode::NEVER_EXECUTE;

        nUpdateMode = css::document::UpdateDocMode::NO_UPDATE;

        rtl::Reference<QuietInteraction> pQuietInteraction = new QuietInteraction();

        xInteractionHandler = pQuietInteraction.get();

        if ( o_ppQuietInteraction != nullptr )

        {

            *o_ppQuietInteraction = std::move(pQuietInteraction);

        }

    }

    if ( xInteractionHandler.is() )

    {

        if( io_lMediaDescriptor.find(utl::MediaDescriptor::PROP_INTERACTIONHANDLER) == io_lMediaDescriptor.end() )

        {

            io_lMediaDescriptor[utl::MediaDescriptor::PROP_INTERACTIONHANDLER] <<= xInteractionHandler;

        }

        if( io_lMediaDescriptor.find(utl::MediaDescriptor::PROP_AUTHENTICATIONHANDLER) == io_lMediaDescriptor.end() )

        {

            io_lMediaDescriptor[utl::MediaDescriptor::PROP_AUTHENTICATIONHANDLER] <<= xInteractionHandler;

        }

    }

    if (io_lMediaDescriptor.find(utl::MediaDescriptor::PROP_MACROEXECUTIONMODE) == io_lMediaDescriptor.end())

        io_lMediaDescriptor[utl::MediaDescriptor::PROP_MACROEXECUTIONMODE] <<= nMacroMode;

    if (io_lMediaDescriptor.find(utl::MediaDescriptor::PROP_UPDATEDOCMODE) == io_lMediaDescriptor.end())

        io_lMediaDescriptor[utl::MediaDescriptor::PROP_UPDATEDOCMODE] <<= nUpdateMode;

}

void LoadEnv::start()

{

    // SAFE ->

    {

        osl::MutexGuard aReadLock(m_mutex);

        // Handle still running processes!

        if (m_xAsynchronousJob.is())

            throw LoadEnvException(LoadEnvException::ID_STILL_RUNNING);

        // content can not be loaded or handled

        // check "classifyContent()" failed before ...

        if (m_eContentType == E_UNSUPPORTED_CONTENT)

            throw LoadEnvException(LoadEnvException::ID_UNSUPPORTED_CONTENT,

                                   u"from LoadEnv::start"_ustr);

    }

    // <- SAFE

    // detect its type/filter etc.

    // This information will be available by the

    // used descriptor member afterwards and is needed

    // for all following operations!

    // Note: An exception will be thrown, in case operation was not successfully ...

    if (m_eContentType != E_CAN_BE_SET)/* Attention: special feature to set existing component on a frame must ignore type detection! */

        impl_detectTypeAndFilter();

    // start loading the content...

    // Attention: Don't check m_eContentType deeper then UNSUPPORTED/SUPPORTED!

    // Because it was made in the easiest way... may a flat detection was made only.

    // And such simple detection can fail sometimes .-)

    // Use another strategy here. Try it and let it run into the case "loading not possible".

    bool bStarted = false;

    if (

        (m_eFeature & LoadEnvFeatures::AllowContentHandler) &&

        (m_eContentType                        != E_CAN_BE_SET          )   /* Attention: special feature to set existing component on a frame must ignore type detection! */

       )

    {

        bStarted = impl_handleContent();

    }

    if (!bStarted)

        bStarted = impl_loadContent();

    // not started => general error

    // We can't say - what was the reason for.

    if (!bStarted)

        throw LoadEnvException(

            LoadEnvException::ID_GENERAL_ERROR, u"not started"_ustr);

}

/*-----------------------------------------------

    TODO

        First draft does not implement timeout using [ms].

        Current implementation counts yield calls only ...

-----------------------------------------------*/

bool LoadEnv::waitWhileLoading(sal_uInt32 nTimeout)

{

    // Because it's not a good idea to block the main thread

    // (and we can't be sure that we are currently not used inside the

    // main thread!), we can't use conditions here really. We must yield

    // in an intelligent manner :-)

    sal_Int32 nTime = nTimeout;

    while(!Application::IsQuit())

    {

        // SAFE -> ------------------------------

        {

            osl::MutexGuard aReadLock1(m_mutex);

            if (!m_xAsynchronousJob.is())

                break;

        }

        // <- SAFE ------------------------------

        Application::Yield();

        // forever!

        if (nTimeout==0)

            continue;

        // timed out?

        --nTime;

        if (nTime<1)

            break;

    }

    osl::MutexGuard g(m_mutex);

    return !m_xAsynchronousJob.is();

}

css::uno::Reference< css::lang::XComponent > LoadEnv::getTargetComponent() const

{

    osl::MutexGuard g(m_mutex);

    if (!m_xTargetFrame.is())

        return css::uno::Reference< css::lang::XComponent >();

    css::uno::Reference< css::frame::XController > xController = m_xTargetFrame->getController();

    if (!xController.is())

        return m_xTargetFrame->getComponentWindow();

    css::uno::Reference< css::frame::XModel > xModel = xController->getModel();

    if (!xModel.is())

        return xController;

    return xModel;

}

void SAL_CALL LoadEnvListener::loadFinished(const css::uno::Reference< css::frame::XFrameLoader >&)

{

    std::unique_lock g(m_mutex);

    if (m_bWaitingResult)

        m_pLoadEnv->impl_setResult(true);

    m_bWaitingResult = false;

}

void SAL_CALL LoadEnvListener::loadCancelled(const css::uno::Reference< css::frame::XFrameLoader >&)

{

    std::unique_lock g(m_mutex);

    if (m_bWaitingResult)

        m_pLoadEnv->impl_setResult(false);

    m_bWaitingResult = false;

}

void SAL_CALL LoadEnvListener::dispatchFinished(const css::frame::DispatchResultEvent& aEvent)

{

    std::unique_lock g(m_mutex);

    if (!m_bWaitingResult)

        return;

    switch(aEvent.State)

    {

        case css::frame::DispatchResultState::FAILURE :

            m_pLoadEnv->impl_setResult(false);

            break;

        case css::frame::DispatchResultState::SUCCESS :

            m_pLoadEnv->impl_setResult(false);

            break;

        case css::frame::DispatchResultState::DONTKNOW :

            m_pLoadEnv->impl_setResult(false);

            break;

    }

    m_bWaitingResult = false;

}

void SAL_CALL LoadEnvListener::disposing(const css::lang::EventObject&)

{

    std::unique_lock g(m_mutex);

    if (m_bWaitingResult)

        m_pLoadEnv->impl_setResult(false);

    m_bWaitingResult = false;

}

void LoadEnv::impl_setResult(bool bResult)

{

    osl::MutexGuard g(m_mutex);

    m_bLoaded = bResult;

    impl_reactForLoadingState();

    // clearing of this reference will unblock waitWhileLoading()!

    // So we must be sure, that loading process was really finished.

    // => do it as last operation of this method ...

    m_xAsynchronousJob.clear();

}

/*-----------------------------------------------

    TODO: Is it a good idea to change Sequence<>

          parameter to stl-adapter?

-----------------------------------------------*/

LoadEnv::EContentType LoadEnv::classifyContent(const OUString&                                 sURL            ,

                                               const css::uno::Sequence< css::beans::PropertyValue >& lMediaDescriptor)

{

    // (i) Filter some special well known URL protocols,

    //     which can not be handled or loaded in general.

    //     Of course an empty URL must be ignored here too.

    //     Note: These URL schemata are fix and well known ...

    //     But there can be some additional ones, which was not

    //     defined at implementation time of this class :-(

    //     So we have to make sure, that the following code

    //     can detect such protocol schemata too :-)

    if(

        (sURL.isEmpty()                                          ) ||

        (ProtocolCheck::isProtocol(sURL,EProtocol::Uno    )) ||

        (ProtocolCheck::isProtocol(sURL,EProtocol::Slot   )) ||

        (ProtocolCheck::isProtocol(sURL,EProtocol::Macro  )) ||

        (ProtocolCheck::isProtocol(sURL,EProtocol::Service)) ||

        (ProtocolCheck::isProtocol(sURL,EProtocol::MailTo )) ||

        (ProtocolCheck::isProtocol(sURL,EProtocol::News   ))

      )

    {

        return E_UNSUPPORTED_CONTENT;

    }

    // (ii) Some special URLs indicates a given input stream,

    //      a full featured document model directly or

    //      specify a request for opening an empty document.

    //      Such contents are loadable in general.

    //      But we have to check, if the media descriptor contains

    //      all needed resources. If they are missing - the following

    //      load request will fail.

    /* Attention: The following code can't work on such special URLs!

                  It should not break the office... but it makes no sense

                  to start expensive object creations and complex search

                  algorithm if it's clear, that such URLs must be handled

                  in a special way .-)

    */

    // creation of new documents

    if (ProtocolCheck::isProtocol(sURL,EProtocol::PrivateFactory))

        return E_CAN_BE_LOADED;

    // using of an existing input stream

    comphelper::SequenceAsHashMap stlMediaDescriptor(lMediaDescriptor);

    if (ProtocolCheck::isProtocol(sURL,EProtocol::PrivateStream))

    {

        auto pIt = stlMediaDescriptor.find(utl::MediaDescriptor::PROP_INPUTSTREAM);

        css::uno::Reference< css::io::XInputStream > xStream;

        if (pIt != stlMediaDescriptor.end())

            pIt->second >>= xStream;

        if (xStream.is())

            return E_CAN_BE_LOADED;

        SAL_INFO("fwk.loadenv", "LoadEnv::classifyContent(): loading from stream with right URL but invalid stream detected");

        return E_UNSUPPORTED_CONTENT;

    }

    // using of a full featured document

    if (ProtocolCheck::isProtocol(sURL,EProtocol::PrivateObject))

    {

        auto pIt = stlMediaDescriptor.find(utl::MediaDescriptor::PROP_MODEL);

        css::uno::Reference< css::frame::XModel > xModel;

        if (pIt != stlMediaDescriptor.end())

            pIt->second >>= xModel;

        if (xModel.is())

            return E_CAN_BE_SET;

        SAL_INFO("fwk.loadenv", "LoadEnv::classifyContent(): loading with object with right URL but invalid object detected");

        return E_UNSUPPORTED_CONTENT;

    }

    // following operations can work on an internal type name only :-(

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

    css::uno::Reference< css::document::XTypeDetection > xDetect(

         xContext->getServiceManager()->createInstanceWithContext(

             u"com.sun.star.document.TypeDetection"_ustr, xContext),

         css::uno::UNO_QUERY_THROW);

    OUString sType = xDetect->queryTypeByURL(sURL);

    css::uno::Reference< css::frame::XLoaderFactory >      xLoaderFactory;

    css::uno::Reference< css::container::XEnumeration >    xSet;

    // (iii) If a FrameLoader service (or at least

    //      a Filter) can be found, which supports

    //      this URL - it must be a loadable content.

    //      Because both items are registered for types

    //      it's enough to check for frame loaders only.

    //      Most of our filters are handled by our global

    //      default loader. But there exist some specialized

    //      loader, which does not work on top of filters!

    //      So it's not enough to search on the filter configuration.

    //      Further it's not enough to search for types!

    //      Because there exist some types, which are referenced by

    //      other objects... but neither by filters nor frame loaders!

    css::uno::Sequence< OUString > lTypesReg { sType };

    css::uno::Sequence< css::beans::NamedValue >           lQuery

    {

        css::beans::NamedValue(PROP_TYPES, css::uno::Any(lTypesReg))

    };

    xLoaderFactory = css::frame::FrameLoaderFactory::create(xContext);

    xSet       = xLoaderFactory->createSubSetEnumerationByProperties(lQuery);

    // at least one registered frame loader is enough!

    if (xSet->hasMoreElements())

        return E_CAN_BE_LOADED;

    // (iv) Some URL protocols are supported by special services.

    //      E.g. ContentHandler.

    //      Such contents can be handled ... but not loaded.

    xLoaderFactory = css::frame::ContentHandlerFactory::create(xContext);

    xSet       = xLoaderFactory->createSubSetEnumerationByProperties(lQuery);

    // at least one registered content handler is enough!

    if (xSet->hasMoreElements())

        return E_CAN_BE_HANDLED;

    // (v) Last but not least the UCB is used inside office to

    //     load contents. He has a special configuration to know

    //     which URL schemata can be used inside office.

    css::uno::Reference< css::ucb::XUniversalContentBroker > xUCB(css::ucb::UniversalContentBroker::create(xContext));

    if (xUCB->queryContentProvider(sURL).is())

        return E_CAN_BE_LOADED;

    // (TODO) At this point, we have no idea .-)

    //        But it seems to be better, to break all

    //        further requests for this URL. Otherwise

    //        we can run into some trouble.

    return E_UNSUPPORTED_CONTENT;

}

namespace {

bool queryOrcusTypeAndFilter(const uno::Sequence<beans::PropertyValue>& rDescriptor, OUString& rType, OUString& rFilter)

{

    OUString aURL;

    sal_Int32 nSize = rDescriptor.getLength();

    for (sal_Int32 i = 0; i < nSize; ++i)

    {

        const beans::PropertyValue& rProp = rDescriptor[i];

        if (rProp.Name == "URL")

        {

            rProp.Value >>= aURL;

            break;

        }

    }

    if (aURL.isEmpty() || o3tl::equalsIgnoreAsciiCase(aURL.subView(0,8), u"private:"))

        return false;

    // TODO : Type must be set to be generic_Text (or any other type that

    // exists) in order to find a usable loader. Exploit it as a temporary

    // hack.

    // depending on the experimental mode

    if (!officecfg::Office::Common::Misc::ExperimentalMode::get())

    {

        return false;

    }

    OUString aUseOrcus;

    rtl::Bootstrap::get(u"LIBO_USE_ORCUS"_ustr, aUseOrcus);

    bool bUseOrcus = (aUseOrcus == "YES");

    if (!bUseOrcus)

        return false;

    if (aURL.endsWith(".xlsx"))

    {

        rType = "generic_Text";

        rFilter = "xlsx";

        return true;

    }

    else if (aURL.endsWith(".ods"))

    {

        rType = "generic_Text";

        rFilter = "ods";

        return true;

    }

    else if (aURL.endsWith(".csv"))

    {

        rType = "generic_Text";

        rFilter = "csv";

        return true;

    }

    return false;

}

}

void LoadEnv::impl_detectTypeAndFilter()

{

    static const sal_Int32 FILTERFLAG_TEMPLATEPATH  = 16;

    // SAFE ->

    osl::ClearableMutexGuard aReadLock(m_mutex);

    // Attention: Because our stl media descriptor is a copy of a uno sequence

    // we can't use as an in/out parameter here. Copy it before and don't forget to

    // update structure afterwards again!

    css::uno::Sequence< css::beans::PropertyValue >        lDescriptor = m_lMediaDescriptor.getAsConstPropertyValueList();

    css::uno::Reference< css::uno::XComponentContext >     xContext = m_xContext;

    aReadLock.clear();

    // <- SAFE

    OUString sType, sFilter;

    if (queryOrcusTypeAndFilter(lDescriptor, sType, sFilter) && !sType.isEmpty() && !sFilter.isEmpty())

    {

        // SAFE ->

        osl::MutexGuard aWriteLock(m_mutex);

        // Orcus type detected.  Skip the normal type detection process.

        m_lMediaDescriptor << lDescriptor;

        m_lMediaDescriptor[utl::MediaDescriptor::PROP_TYPENAME] <<= sType;

        m_lMediaDescriptor[utl::MediaDescriptor::PROP_FILTERNAME] <<= sFilter;

        m_lMediaDescriptor[utl::MediaDescriptor::PROP_FILTERPROVIDER] <<= u"orcus"_ustr;

        m_lMediaDescriptor[utl::MediaDescriptor::PROP_DOCUMENTSERVICE] <<= u"com.sun.star.sheet.SpreadsheetDocument"_ustr;

        return;

        // <- SAFE

    }

    css::uno::Reference< css::document::XTypeDetection > xDetect(

        xContext->getServiceManager()->createInstanceWithContext(

            u"com.sun.star.document.TypeDetection"_ustr, xContext),

        css::uno::UNO_QUERY_THROW);

    sType = xDetect->queryTypeByDescriptor(lDescriptor, true); /*TODO should deep detection be able for enable/disable it from outside? */

    // no valid content -> loading not possible

    if (sType.isEmpty())

        throw LoadEnvException(

            LoadEnvException::ID_UNSUPPORTED_CONTENT, u"type detection failed"_ustr);

    // SAFE ->

    osl::ResettableMutexGuard aWriteLock(m_mutex);

    // detection was successful => update the descriptor member of this class

    m_lMediaDescriptor << lDescriptor;

    m_lMediaDescriptor[utl::MediaDescriptor::PROP_TYPENAME] <<= sType;

    // Is there an already detected (may be preselected) filter?

    // see below ...

    sFilter = m_lMediaDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_FILTERNAME, OUString());

    aWriteLock.clear();

    // <- SAFE

    // We do have potentially correct type, but the detection process was aborted.

    if (m_lMediaDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_ABORTED, false))

        throw LoadEnvException(

            LoadEnvException::ID_UNSUPPORTED_CONTENT, u"type detection aborted"_ustr);

    // But the type isn't enough. For loading sometimes we need more information.

    // E.g. for our "_default" feature, where we recycle any frame which contains

    // and "Untitled" document, we must know if the new document is based on a template!

    // But this information is available as a filter property only.

    // => We must try(!) to detect the right filter for this load request.

    // On the other side ... if no filter is available .. ignore it.

    // Then the type information must be enough.

    if (sFilter.isEmpty())

    {

        // no -> try to find a preferred filter for the detected type.

        // Don't forget to update the media descriptor.

        css::uno::Reference< css::container::XNameAccess > xTypeCont(xDetect, css::uno::UNO_QUERY_THROW);

        try

        {

            ::comphelper::SequenceAsHashMap lTypeProps(xTypeCont->getByName(sType));

            sFilter = lTypeProps.getUnpackedValueOrDefault(u"PreferredFilter"_ustr, OUString());

            if (!sFilter.isEmpty())

            {

                // SAFE ->

                aWriteLock.reset();

                m_lMediaDescriptor[utl::MediaDescriptor::PROP_FILTERNAME] <<= sFilter;

                aWriteLock.clear();

                // <- SAFE

            }

        }

        catch(const css::container::NoSuchElementException&)

            {}

    }

    // check if the filter (if one exists) points to a template format filter.

    // Then we have to add the property "AsTemplate".

    // We need this information to decide afterwards if we can use a "recycle frame"

    // for target "_default" or has to create a new one every time.

    // On the other side we have to suppress that, if this property already exists

    // and should trigger a special handling. Then the outside call of this method here,

    // has to know, what he is doing .-)

    bool bIsOwnTemplate = false;

    if (!sFilter.isEmpty())

    {

        css::uno::Reference< css::container::XNameAccess > xFilterCont(xContext->getServiceManager()->createInstanceWithContext(SERVICENAME_FILTERFACTORY, xContext), css::uno::UNO_QUERY_THROW);

        try

        {

            ::comphelper::SequenceAsHashMap lFilterProps(xFilterCont->getByName(sFilter));

            sal_Int32 nFlags         = lFilterProps.getUnpackedValueOrDefault(u"Flags"_ustr, sal_Int32(0));

            bIsOwnTemplate = ((nFlags & FILTERFLAG_TEMPLATEPATH) == FILTERFLAG_TEMPLATEPATH);

        }

        catch(const css::container::NoSuchElementException&)

            {}

    }

    if (bIsOwnTemplate)

    {

        // SAFE ->

        aWriteLock.reset();

        // Don't overwrite external decisions! See comments before ...

        auto pAsTemplateItem = m_lMediaDescriptor.find(utl::MediaDescriptor::PROP_ASTEMPLATE);

        if (pAsTemplateItem == m_lMediaDescriptor.end())

            m_lMediaDescriptor[utl::MediaDescriptor::PROP_ASTEMPLATE] <<= true;

        aWriteLock.clear();

        // <- SAFE

    }

}

bool LoadEnv::impl_handleContent()

{

    // SAFE -> -----------------------------------

    osl::ClearableMutexGuard aReadLock(m_mutex);

    // the type must exist inside the descriptor ... otherwise this class is implemented wrong :-)

    OUString sType = m_lMediaDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_TYPENAME, OUString());

    if (sType.isEmpty())

        throw LoadEnvException(LoadEnvException::ID_INVALID_MEDIADESCRIPTOR);

    // convert media descriptor and URL to right format for later interface call!

    css::uno::Sequence< css::beans::PropertyValue > lDescriptor;

    m_lMediaDescriptor >> lDescriptor;

    css::util::URL aURL = m_aURL;

    // get necessary container to query for a handler object

    css::uno::Reference< css::frame::XLoaderFactory > xLoaderFactory = css::frame::ContentHandlerFactory::create(m_xContext);

    aReadLock.clear();

    // <- SAFE -----------------------------------

    // query

    css::uno::Sequence< OUString > lTypeReg { sType };

    css::uno::Sequence< css::beans::NamedValue > lQuery { { PROP_TYPES, css::uno::Any(lTypeReg) } };

    css::uno::Reference< css::container::XEnumeration > xSet = xLoaderFactory->createSubSetEnumerationByProperties(lQuery);

    while(xSet->hasMoreElements())

    {

        ::comphelper::SequenceAsHashMap lProps   (xSet->nextElement());

        OUString                 sHandler = lProps.getUnpackedValueOrDefault(PROP_NAME, OUString());

        css::uno::Reference< css::frame::XNotifyingDispatch > xHandler;

        try

        {

            xHandler.set(xLoaderFactory->createInstance(sHandler), css::uno::UNO_QUERY);

            if (!xHandler.is())

                continue;

        }

        catch(const css::uno::RuntimeException&)

            { throw; }

        catch(const css::uno::Exception&)

            { continue; }

        // SAFE -> -----------------------------------

        osl::ClearableMutexGuard aWriteLock(m_mutex);

        m_xAsynchronousJob = xHandler;

        rtl::Reference<LoadEnvListener> xListener = new LoadEnvListener(this);

        aWriteLock.clear();

        // <- SAFE -----------------------------------

        xHandler->dispatchWithNotification(aURL, lDescriptor, xListener);

        return true;

    }

    return false;

}

bool LoadEnv::impl_furtherDocsAllowed()

{

    // SAFE ->

    osl::ResettableMutexGuard aReadLock(m_mutex);

    css::uno::Reference< css::uno::XComponentContext > xContext = m_xContext;

    aReadLock.clear();

    // <- SAFE

    bool bAllowed = true;

    try

    {

        std::optional<sal_Int32> x(officecfg::Office::Common::Misc::MaxOpenDocuments::get());

        // NIL means: count of allowed documents = infinite !

        //     => return true

        if ( !x)

            bAllowed = true;

        else

        {