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

#include <com/sun/star/embed/Aspects.hpp>

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

#include <com/sun/star/embed/EmbedStates.hpp>

#include <com/sun/star/embed/EntryInitModes.hpp>

#include <com/sun/star/embed/StorageWrappedTargetException.hpp>

#include <com/sun/star/embed/WrongStateException.hpp>

#include <com/sun/star/embed/XStorage.hpp>

#include <com/sun/star/embed/XOptimizedStorage.hpp>

#include <com/sun/star/embed/ElementModes.hpp>

#include <com/sun/star/embed/EmbedUpdateModes.hpp>

#include <com/sun/star/embed/StorageFactory.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <com/sun/star/chart2/XChartDocument.hpp>

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

#include <comphelper/fileformat.h>

#include <comphelper/storagehelper.hxx>

#include <comphelper/mimeconfighelper.hxx>

#include <comphelper/namedvaluecollection.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/configuration.hxx>

#include <tools/urlobj.hxx>

#include <unotools/mediadescriptor.hxx>

#include <unotools/securityoptions.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <sal/log.hxx>

#include "persistence.hxx"

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

uno::Sequence< beans::PropertyValue > GetValuableArgs_Impl( const uno::Sequence< beans::PropertyValue >& aMedDescr,

                                                            bool bCanUseDocumentBaseURL )

{

    uno::Sequence< beans::PropertyValue > aResult;

    sal_Int32 nResLen = 0;

    for ( beans::PropertyValue const & prop : aMedDescr )

    {

        if ( prop.Name == "ComponentData" || prop.Name == "DocumentTitle"

          || prop.Name == "InteractionHandler" || prop.Name == "JumpMark"

          // || prop.Name == "Password" // makes no sense for embedded objects

          || prop.Name == "Preview" || prop.Name == "ReadOnly"

          || prop.Name == "StartPresentation" || prop.Name == "RepairPackage"

          || prop.Name == "StatusIndicator" || prop.Name == "ViewData"

          || prop.Name == "ViewId" || prop.Name == "MacroExecutionMode"

          || prop.Name == "UpdateDocMode" || prop.Name == "Referer"

          || (prop.Name == "DocumentBaseURL" && bCanUseDocumentBaseURL) )

        {

            aResult.realloc( ++nResLen );

            aResult.getArray()[nResLen-1] = prop;

        }

    }

    return aResult;

}

static uno::Sequence< beans::PropertyValue > addAsTemplate( const uno::Sequence< beans::PropertyValue >& aOrig )

{

    bool bAsTemplateSet = false;

    sal_Int32 nLength = aOrig.getLength();

    uno::Sequence< beans::PropertyValue > aResult( aOrig );

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

    {

        if ( aResult[nInd].Name == "AsTemplate" )

        {

            aResult.getArray()[nInd].Value <<= true;

            bAsTemplateSet = true;

        }

    }

    if ( !bAsTemplateSet )

    {

        aResult.realloc( nLength + 1 );

        auto pResult = aResult.getArray();

        pResult[nLength].Name = "AsTemplate";

        pResult[nLength].Value <<= true;

    }

    return aResult;

}

static uno::Reference< io::XInputStream > createTempInpStreamFromStor(

                                                            const uno::Reference< embed::XStorage >& xStorage,

                                                            const uno::Reference< uno::XComponentContext >& xContext )

{

    SAL_WARN_IF( !xStorage.is(), "embeddedobj.common", "The storage can not be empty!" );

    uno::Reference< io::XInputStream > xResult;

    uno::Reference < io::XStream > xTempStream( io::TempFile::create(xContext), uno::UNO_QUERY_THROW );

    uno::Reference < lang::XSingleServiceFactory > xStorageFactory( embed::StorageFactory::create(xContext) );

    uno::Sequence< uno::Any > aArgs{ uno::Any(xTempStream),

                                     uno::Any(embed::ElementModes::READWRITE) };

    uno::Reference< embed::XStorage > xTempStorage( xStorageFactory->createInstanceWithArguments( aArgs ),

                                                    uno::UNO_QUERY_THROW );

    try

    {

        xStorage->copyToStorage( xTempStorage );

    } catch( const uno::Exception& )

    {

        css::uno::Any anyEx = cppu::getCaughtException();

        throw embed::StorageWrappedTargetException(

                    u"Can't copy storage!"_ustr,

                    uno::Reference< uno::XInterface >(),

                    anyEx );

    }

    try {

        if ( xTempStorage.is() )

            xTempStorage->dispose();

    }

    catch ( const uno::Exception& )

    {

    }

    try {

        uno::Reference< io::XOutputStream > xTempOut = xTempStream->getOutputStream();

        if ( xTempOut.is() )

            xTempOut->closeOutput();

    }

    catch ( const uno::Exception& )

    {

    }

    xResult = xTempStream->getInputStream();

    return xResult;

}

static void TransferMediaType( const uno::Reference< embed::XStorage >& i_rSource, const uno::Reference< embed::XStorage >& i_rTarget )

{

    try

    {

        const uno::Reference< beans::XPropertySet > xSourceProps( i_rSource, uno::UNO_QUERY_THROW );

        const uno::Reference< beans::XPropertySet > xTargetProps( i_rTarget, uno::UNO_QUERY_THROW );

        static constexpr OUString sMediaTypePropName( u"MediaType"_ustr );

        xTargetProps->setPropertyValue( sMediaTypePropName, xSourceProps->getPropertyValue( sMediaTypePropName ) );

    }

    catch( const uno::Exception& )

    {

        DBG_UNHANDLED_EXCEPTION("embeddedobj.common");

    }

}

static uno::Reference< util::XCloseable > CreateDocument( const uno::Reference< uno::XComponentContext >& _rxContext,

    const OUString& _rDocumentServiceName, bool _bEmbeddedScriptSupport, const bool i_bDocumentRecoverySupport )

{

    static constexpr OUStringLiteral sEmbeddedObject = u"EmbeddedObject";

    static constexpr OUStringLiteral sEmbeddedScriptSupport = u"EmbeddedScriptSupport";

    static constexpr OUStringLiteral sDocumentRecoverySupport = u"DocumentRecoverySupport";

    ::comphelper::NamedValueCollection aArguments;

    aArguments.put( sEmbeddedObject, true );

    aArguments.put( sEmbeddedScriptSupport, _bEmbeddedScriptSupport );

    aArguments.put( sDocumentRecoverySupport, i_bDocumentRecoverySupport );

    uno::Reference< uno::XInterface > xDocument;

    try

    {

        xDocument = _rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(

                        _rDocumentServiceName, aArguments.getWrappedPropertyValues(), _rxContext );

    }

    catch( const uno::Exception& )

    {

        // if an embedded object implementation does not support XInitialization,

        // the default factory from cppuhelper will throw an

        // IllegalArgumentException when we try to create the instance with arguments.

        // Okay, so we fall back to creating the instance without any arguments.

        OSL_FAIL("Consider implementing interface XInitialization to avoid duplicate construction");

        xDocument = _rxContext->getServiceManager()->createInstanceWithContext( _rDocumentServiceName, _rxContext );

    }

    SAL_WARN_IF(!xDocument.is(), "embeddedobj.common", "Service " << _rDocumentServiceName << " is not available?");

    return uno::Reference< util::XCloseable >( xDocument, uno::UNO_QUERY );

}

static void SetDocToEmbedded( const uno::Reference< frame::XModel >& rDocument, const OUString& aModuleName )

{

    if (!rDocument.is())

        return;

    uno::Sequence< beans::PropertyValue > aSeq{ comphelper::makePropertyValue(u"SetEmbedded"_ustr, true) };

    rDocument->attachResource( OUString(), aSeq );

    if ( !aModuleName.isEmpty() )

    {

        try

        {

            uno::Reference< frame::XModule > xModule( rDocument, uno::UNO_QUERY_THROW );

            xModule->setIdentifier( aModuleName );

        }

        catch( const uno::Exception& )

        {}

    }

}

void OCommonEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,

                                                  const uno::Reference< embed::XStorage >& xNewObjectStorage,

                                                  const OUString& aNewName )

{

    if ( xNewParentStorage == m_xParentStorage && aNewName == m_aEntryName )

    {

        SAL_WARN_IF( xNewObjectStorage != m_xObjectStorage, "embeddedobj.common", "The storage must be the same!" );

        return;

    }

    auto xOldObjectStorage = m_xObjectStorage;

    m_xObjectStorage = xNewObjectStorage;

    m_xParentStorage = xNewParentStorage;

    m_aEntryName = aNewName;

    // the linked document should not be switched

    if ( !m_bIsLinkURL )

    {

        uno::Reference< document::XStorageBasedDocument > xDoc( m_xDocHolder->GetComponent(), uno::UNO_QUERY );

        if ( xDoc.is() )

            SwitchDocToStorage_Impl( xDoc, m_xObjectStorage );

    }

    try {

        if ( xOldObjectStorage.is() )

            xOldObjectStorage->dispose();

    }

    catch ( const uno::Exception& )

    {

    }

}

void OCommonEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,

                                                  const OUString& aNewName )

{

    if ( xNewParentStorage == m_xParentStorage && aNewName == m_aEntryName )

        return;

    sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;

    uno::Reference< embed::XStorage > xNewOwnStorage = xNewParentStorage->openStorageElement( aNewName, nStorageMode );

    SAL_WARN_IF( !xNewOwnStorage.is(), "embeddedobj.common", "The method can not return empty reference!" );

    SwitchOwnPersistence( xNewParentStorage, xNewOwnStorage, aNewName );

}

void OCommonEmbeddedObject::EmbedAndReparentDoc_Impl( const uno::Reference< util::XCloseable >& i_rxDocument ) const

{

    SetDocToEmbedded( uno::Reference< frame::XModel >( i_rxDocument, uno::UNO_QUERY ), m_aModuleName );

    try

    {

        uno::Reference < container::XChild > xChild( i_rxDocument, uno::UNO_QUERY );

        if ( xChild.is() )

            xChild->setParent( m_xParent );

    }

    catch( const lang::NoSupportException & )

    {

        SAL_WARN( "embeddedobj.common", "OCommonEmbeddedObject::EmbedAndReparentDoc: cannot set parent at document!" );

    }

}

uno::Reference< util::XCloseable > OCommonEmbeddedObject::InitNewDocument_Impl()

{

    uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),

                                                m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );

    uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY );

    uno::Reference< frame::XLoadable > xLoadable( xModel, uno::UNO_QUERY_THROW );

    try

    {

        // set the document mode to embedded as the first action on document!!!

        EmbedAndReparentDoc_Impl( xDocument );

        // if we have a storage to recover the document from, do not use initNew, but instead load from that storage

        bool bInitNew = true;

        if ( m_xRecoveryStorage.is() )

        {

            uno::Reference< document::XStorageBasedDocument > xDoc( xLoadable, uno::UNO_QUERY );

            SAL_WARN_IF( !xDoc.is(), "embeddedobj.common", "OCommonEmbeddedObject::InitNewDocument_Impl: cannot recover from a storage when the document is not storage based!" );

            if ( xDoc.is() )

            {

                ::comphelper::NamedValueCollection aLoadArgs;

                FillDefaultLoadArgs_Impl( m_xRecoveryStorage, aLoadArgs );

                xDoc->loadFromStorage( m_xRecoveryStorage, aLoadArgs.getPropertyValues() );

                SwitchDocToStorage_Impl( xDoc, m_xObjectStorage );

                bInitNew = false;

            }

        }

        if ( bInitNew )

        {

            // init document as a new

            xLoadable->initNew();

        }

        xModel->attachResource( xModel->getURL(), m_aDocMediaDescriptor );

    }

    catch( const uno::Exception& )

    {

        if ( xDocument.is() )

        {

            try

            {

                xDocument->close( true );

            }

            catch( const uno::Exception& )

            {

            }

        }

        throw; // TODO

    }

    return xDocument;

}

bool OCommonEmbeddedObject::getAllowLinkUpdate() const

{

    // assume we can update if we can't determine a parent

    bool bAllowLinkUpdate(true);

    try

    {

        uno::Reference<container::XChild> xParent(m_xParent, uno::UNO_QUERY);

        while (xParent)

        {

            uno::Reference<container::XChild> xGrandParent(xParent->getParent(), uno::UNO_QUERY);

            if (!xGrandParent)

                break;

            xParent = std::move(xGrandParent);

        }

        uno::Reference<beans::XPropertySet> xPropSet(xParent, uno::UNO_QUERY);

        if (xPropSet.is())

        {

            uno::Any aAny = xPropSet->getPropertyValue(u"AllowLinkUpdate"_ustr);

            aAny >>= bAllowLinkUpdate;

        }

    }

    catch (const uno::Exception&)

    {

    }

    SAL_WARN_IF(!bAllowLinkUpdate, "embeddedobj.common", "getAllowLinkUpdate is false");

    return bAllowLinkUpdate;

}

uno::Reference< util::XCloseable > OCommonEmbeddedObject::LoadLink_Impl()

{

    if (!getAllowLinkUpdate())

        return nullptr;

    sal_Int32 nLen = m_bLinkHasPassword ? 3 : 2;

    uno::Sequence< beans::PropertyValue > aArgs( m_aDocMediaDescriptor.getLength() + nLen );

    auto pArgs = aArgs.getArray();

    OUString sURL;

    if (m_aLinkTempFile.is())

        sURL = m_aLinkTempFile->getUri();

    else

        sURL = m_aLinkURL;

    if (INetURLObject(sURL).IsExoticProtocol())

    {

        SAL_WARN("embeddedobj.common", "Ignore exotic protocol: " << pArgs[0].Value);

        return nullptr;

    }

    pArgs[0].Name = "URL";

    pArgs[0].Value <<= sURL;

    pArgs[1].Name = "FilterName";

    pArgs[1].Value <<= m_aLinkFilterName;

    if ( m_bLinkHasPassword )

    {

        pArgs[2].Name = "Password";

        pArgs[2].Value <<= m_aLinkPassword;

    }

    for ( sal_Int32 nInd = 0; nInd < m_aDocMediaDescriptor.getLength(); nInd++ )

    {

        // return early if this document is not trusted to open links

        if (m_aDocMediaDescriptor[nInd].Name == utl::MediaDescriptor::PROP_REFERRER)

        {

            OUString referer;

            m_aDocMediaDescriptor[nInd].Value >>= referer;

            if (SvtSecurityOptions::isUntrustedReferer(referer))

                return nullptr;

        }

        pArgs[nInd+nLen].Name = m_aDocMediaDescriptor[nInd].Name;

        pArgs[nInd+nLen].Value = m_aDocMediaDescriptor[nInd].Value;

    }

    uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),

                                                m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );

    uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY_THROW );

    try

    {

        handleLinkedOLE(CopyBackToOLELink::CopyLinkToTemp);

        // the document is not really an embedded one, it is a link

        EmbedAndReparentDoc_Impl( xDocument );

        // load the document

        xLoadable->load( aArgs );

        if ( !m_bLinkHasPassword )

        {

            // check if there is a password to cache

            uno::Reference< frame::XModel > xModel( xLoadable, uno::UNO_QUERY_THROW );

            const uno::Sequence< beans::PropertyValue > aProps = xModel->getArgs();

            for ( beans::PropertyValue const & prop : aProps )

                if ( prop.Name == "Password" && ( prop.Value >>= m_aLinkPassword ) )

                {

                    m_bLinkHasPassword = true;

                    break;

                }

        }

    }

    catch( const uno::Exception& )

    {

        if ( xDocument.is() )

        {

            try

            {

                xDocument->close( true );

            }

            catch( const uno::Exception& )

            {

            }

        }

        throw; // TODO

    }

    return xDocument;

}

OUString OCommonEmbeddedObject::GetFilterName( sal_Int32 nVersion ) const

{

    OUString aFilterName = GetPresetFilterName();

    if ( aFilterName.isEmpty() )

    {

        OUString sDocumentServiceName = GetDocumentServiceName();

        if (comphelper::IsFuzzing() && nVersion == SOFFICE_FILEFORMAT_CURRENT &&

            sDocumentServiceName == "com.sun.star.chart2.ChartDocument")

        {

            return u"chart8"_ustr;

        }

        try {

            ::comphelper::MimeConfigurationHelper aHelper( m_xContext );

            aFilterName = aHelper.GetDefaultFilterFromServiceName(sDocumentServiceName, nVersion);

            // If no filter is found, fall back to the FileFormatVersion=6200 filter, Base only has that.

            if (aFilterName.isEmpty() && nVersion == SOFFICE_FILEFORMAT_CURRENT)

                aFilterName = aHelper.GetDefaultFilterFromServiceName(GetDocumentServiceName(), SOFFICE_FILEFORMAT_60);

        } catch( const uno::Exception& )

        {}

    }

    return aFilterName;

}

void OCommonEmbeddedObject::FillDefaultLoadArgs_Impl( const uno::Reference< embed::XStorage >& i_rxStorage,

        ::comphelper::NamedValueCollection& o_rLoadArgs ) const

{

    o_rLoadArgs.put( u"DocumentBaseURL"_ustr, GetBaseURL_Impl() );

    o_rLoadArgs.put( u"HierarchicalDocumentName"_ustr, m_aEntryName );

    o_rLoadArgs.put( u"ReadOnly"_ustr, m_bReadOnly );

    OUString aFilterName = GetFilterName( ::comphelper::OStorageHelper::GetXStorageFormat( i_rxStorage ) );

    SAL_WARN_IF( aFilterName.isEmpty(), "embeddedobj.common", "OCommonEmbeddedObject::FillDefaultLoadArgs_Impl: Wrong document service name!" );

    if ( aFilterName.isEmpty() )

        throw io::IOException();    // TODO: error message/code

    o_rLoadArgs.put( u"FilterName"_ustr, aFilterName );

}

uno::Reference< util::XCloseable > OCommonEmbeddedObject::LoadDocumentFromStorage_Impl()

{

    ENSURE_OR_THROW( m_xObjectStorage.is(), "no object storage" );

    const uno::Reference< embed::XStorage > xSourceStorage( m_xRecoveryStorage.is() ? m_xRecoveryStorage : m_xObjectStorage );

    uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),

                                                m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );

    //#i103460# ODF: take the size given from the parent frame as default

    uno::Reference< chart2::XChartDocument > xChart( xDocument, uno::UNO_QUERY );

    if( xChart.is() )

    {

        uno::Reference< embed::XVisualObject > xChartVisualObject( xChart, uno::UNO_QUERY );

        if( xChartVisualObject.is() )

            xChartVisualObject->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, m_aDefaultSizeForChart_In_100TH_MM );

    }

    uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY );

    uno::Reference< document::XStorageBasedDocument > xDoc( xDocument, uno::UNO_QUERY );

    if ( !xDoc.is() && !xLoadable.is() )

        throw uno::RuntimeException();

    ::comphelper::NamedValueCollection aLoadArgs;

    FillDefaultLoadArgs_Impl( xSourceStorage, aLoadArgs );

    uno::Reference< io::XInputStream > xTempInpStream;

    if ( !xDoc.is() )

    {

        xTempInpStream = createTempInpStreamFromStor( xSourceStorage, m_xContext );

        if ( !xTempInpStream.is() )

            throw uno::RuntimeException();

        OUString aTempFileURL;

        try

        {

            // no need to let the file stay after the stream is removed since the embedded document

            // can not be stored directly

            uno::Reference< beans::XPropertySet > xTempStreamProps( xTempInpStream, uno::UNO_QUERY_THROW );

            xTempStreamProps->getPropertyValue(u"Uri"_ustr) >>= aTempFileURL;

        }

        catch( const uno::Exception& )

        {

        }

        SAL_WARN_IF( aTempFileURL.isEmpty(), "embeddedobj.common", "Couldn't retrieve temporary file URL!" );

        aLoadArgs.put( u"URL"_ustr, aTempFileURL );

        aLoadArgs.put( u"InputStream"_ustr, xTempInpStream );

    }

    aLoadArgs.merge( m_aDocMediaDescriptor, true );

    try

    {

        // set the document mode to embedded as the first step!!!

        EmbedAndReparentDoc_Impl( xDocument );

        if (m_bReadOnly)

        {

            aLoadArgs.put(u"ReadOnly"_ustr, true);

        }

        if ( xDoc.is() )

        {

            xDoc->loadFromStorage( xSourceStorage, aLoadArgs.getPropertyValues() );

            if ( xSourceStorage != m_xObjectStorage )

                SwitchDocToStorage_Impl( xDoc, m_xObjectStorage );

        }

        else

            xLoadable->load( aLoadArgs.getPropertyValues() );

    }

    catch( const uno::Exception& )

    {

        if ( xDocument.is() )

        {

            try

            {

                xDocument->close( true );

            }

            catch( const uno::Exception& )

            {

                DBG_UNHANDLED_EXCEPTION("embeddedobj.common");

            }

        }

        throw; // TODO

    }

    return xDocument;

}

uno::Reference< io::XInputStream > OCommonEmbeddedObject::StoreDocumentToTempStream_Impl(

                                                                            sal_Int32 nStorageFormat,

                                                                            const OUString& aBaseURL,

                                                                            const OUString& aHierarchName )

{

    uno::Reference < io::XOutputStream > xTempOut(

                io::TempFile::create(m_xContext),

                uno::UNO_QUERY_THROW );

    uno::Reference< io::XInputStream > aResult( xTempOut, uno::UNO_QUERY_THROW );

    uno::Reference< frame::XStorable > xStorable;

    {

        osl::MutexGuard aGuard( m_aMutex );

        if ( m_xDocHolder.is() )

            xStorable.set( m_xDocHolder->GetComponent(), uno::UNO_QUERY );

    }

    if( !xStorable.is() )

        throw uno::RuntimeException(u"No storage is provided for storing!"_ustr); // TODO:

    OUString aFilterName = GetFilterName( nStorageFormat );

    SAL_WARN_IF( aFilterName.isEmpty(), "embeddedobj.common", "Wrong document service name!" );

    if ( aFilterName.isEmpty() )

        throw io::IOException(u"No filter name provided / Wrong document service name"_ustr); // TODO:

    uno::Sequence< beans::PropertyValue > aArgs{

        comphelper::makePropertyValue(u"FilterName"_ustr, aFilterName),

        comphelper::makePropertyValue(u"OutputStream"_ustr, xTempOut),

        comphelper::makePropertyValue(u"DocumentBaseURL"_ustr, aBaseURL),

        comphelper::makePropertyValue(u"HierarchicalDocumentName"_ustr, aHierarchName)

    };

    xStorable->storeToURL( u"private:stream"_ustr, aArgs );

    try

    {

        xTempOut->closeOutput();

    }

    catch( const uno::Exception& )

    {

        SAL_WARN( "embeddedobj.common", "Looks like stream was closed already" );

    }

    return aResult;

}

void OCommonEmbeddedObject::SaveObject_Impl()

{

    if ( !m_xClientSite.is() )

        return;

    try

    {

        // check whether the component is modified,

        // if not there is no need for storing

        uno::Reference< util::XModifiable > xModifiable( m_xDocHolder->GetComponent(), uno::UNO_QUERY );

        if ( xModifiable.is() && !xModifiable->isModified() )

            return;

    }

    catch( const uno::Exception& )

    {}

    try {

        m_xClientSite->saveObject();

    }

    catch( const uno::Exception& )

    {

        SAL_WARN( "embeddedobj.common", "The object was not stored!" );

    }

}

OUString OCommonEmbeddedObject::GetBaseURL_Impl() const

{

    OUString aBaseURL;

    if ( m_xClientSite.is() )

    {

        try

        {

            uno::Reference< frame::XModel > xParentModel( m_xClientSite->getComponent(), uno::UNO_QUERY_THROW );

            const uno::Sequence< beans::PropertyValue > aModelProps = xParentModel->getArgs();

            for ( beans::PropertyValue const & prop : aModelProps )

                if ( prop.Name == "DocumentBaseURL" )

                {

                    prop.Value >>= aBaseURL;

                    break;

                }

        }

        catch( const uno::Exception& )

        {}

    }

    if ( aBaseURL.isEmpty() )

    {

        for ( beans::PropertyValue const & prop : m_aDocMediaDescriptor )

            if ( prop.Name == "DocumentBaseURL" )

            {

                prop.Value >>= aBaseURL;

                break;

            }

    }

    if ( aBaseURL.isEmpty() )

        aBaseURL = m_aDefaultParentBaseURL;

    return aBaseURL;

}

OUString OCommonEmbeddedObject::GetBaseURLFrom_Impl(

                    const uno::Sequence< beans::PropertyValue >& lArguments,

                    const uno::Sequence< beans::PropertyValue >& lObjArgs )

{

    OUString aBaseURL;

    for ( beans::PropertyValue const & prop : lArguments )

        if ( prop.Name == "DocumentBaseURL" )

        {

            prop.Value >>= aBaseURL;

            break;

        }

    if ( aBaseURL.isEmpty() )

    {

        for ( beans::PropertyValue const & prop : lObjArgs )

            if ( prop.Name == "DefaultParentBaseURL" )

            {

                prop.Value >>= aBaseURL;

                break;

            }

    }

    return aBaseURL;

}

void OCommonEmbeddedObject::SwitchDocToStorage_Impl( const uno::Reference< document::XStorageBasedDocument >& xDoc, const uno::Reference< embed::XStorage >& xStorage )

{

    xDoc->switchToStorage( xStorage );

    uno::Reference< util::XModifiable > xModif( xDoc, uno::UNO_QUERY );

    if ( xModif.is() )

        xModif->setModified( false );

    if ( m_xRecoveryStorage.is() )

        m_xRecoveryStorage.clear();

}

namespace {

beans::PropertyValue getStringPropertyValue(const uno::Sequence<beans::PropertyValue>& rProps,

                                            const OUString& rName)

{

    OUString aStr;

    for (beans::PropertyValue const & prop : rProps)

    {

        if (prop.Name == rName)

        {

            prop.Value >>= aStr;

            break;

        }

    }

    return comphelper::makePropertyValue(rName, aStr);

}

}

void OCommonEmbeddedObject::StoreDocToStorage_Impl(

    const uno::Reference<embed::XStorage>& xStorage,

    const uno::Sequence<beans::PropertyValue>& rMediaArgs,

    const uno::Sequence<beans::PropertyValue>& rObjArgs,

    sal_Int32 nStorageFormat,

    const OUString& aHierarchName,

    bool bAttachToTheStorage )

{

    SAL_WARN_IF( !xStorage.is(), "embeddedobj.common", "No storage is provided for storing!" );

    if ( !xStorage.is() )

        throw uno::RuntimeException(); // TODO:

    uno::Reference< document::XStorageBasedDocument > xDoc;

    {

        osl::MutexGuard aGuard( m_aMutex );

        if ( m_xDocHolder.is() )

            xDoc.set( m_xDocHolder->GetComponent(), uno::UNO_QUERY );

    }

    OUString aBaseURL = GetBaseURLFrom_Impl(rMediaArgs, rObjArgs);

    if ( xDoc.is() )

    {

        OUString aFilterName = GetFilterName( nStorageFormat );

        // No filter found? Try the older format, e.g. Base has only that.

        if (aFilterName.isEmpty() && nStorageFormat == SOFFICE_FILEFORMAT_CURRENT)

            aFilterName = GetFilterName( SOFFICE_FILEFORMAT_60 );

        SAL_WARN_IF( aFilterName.isEmpty(), "embeddedobj.common", "Wrong document service name!" );

        if ( aFilterName.isEmpty() )

            throw io::IOException(); // TODO:

        uno::Sequence<beans::PropertyValue> aArgs{

            comphelper::makePropertyValue(u"FilterName"_ustr, aFilterName),

            comphelper::makePropertyValue(u"HierarchicalDocumentName"_ustr, aHierarchName),

            comphelper::makePropertyValue(u"DocumentBaseURL"_ustr, aBaseURL),

            getStringPropertyValue(rObjArgs, u"SourceShellID"_ustr),

            getStringPropertyValue(rObjArgs, u"DestinationShellID"_ustr),

        };

        xDoc->storeToStorage( xStorage, aArgs );

        if ( bAttachToTheStorage )

            SwitchDocToStorage_Impl( xDoc, xStorage );

    }

    else

    {

        // store document to temporary stream based on temporary file

        uno::Reference < io::XInputStream > xTempIn = StoreDocumentToTempStream_Impl( nStorageFormat, aBaseURL, aHierarchName );

        SAL_WARN_IF( !xTempIn.is(), "embeddedobj.common", "The stream reference can not be empty!" );

        // open storage based on document temporary file for reading

        uno::Reference < lang::XSingleServiceFactory > xStorageFactory = embed::StorageFactory::create(m_xContext);

        uno::Sequence< uno::Any > aArgs{ uno::Any(xTempIn) };

        uno::Reference< embed::XStorage > xTempStorage( xStorageFactory->createInstanceWithArguments( aArgs ),

                                                            uno::UNO_QUERY_THROW );

        // object storage must be committed automatically

        xTempStorage->copyToStorage( xStorage );

    }

}

uno::Reference< util::XCloseable > OCommonEmbeddedObject::CreateDocFromMediaDescr_Impl(

                                        const uno::Sequence< beans::PropertyValue >& aMedDescr )

{

    uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),

                                                m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );

    uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY_THROW );

    try

    {

        // set the document mode to embedded as the first action on the document!!!

        EmbedAndReparentDoc_Impl( xDocument );

        xLoadable->load( addAsTemplate( aMedDescr ) );

    }

    catch( const uno::Exception& )

    {

        if ( xDocument.is() )

        {

            try

            {

                xDocument->close( true );

            }

            catch( const uno::Exception& )

            {