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

#if HAVE_FEATURE_GPGME

#include <com/sun/star/xml/crypto/GPGSEInitializer.hpp>

#include <com/sun/star/xml/crypto/SEInitializer.hpp>

#include <com/sun/star/xml/crypto/XXMLSecurityContext.hpp>

#endif

#include <com/sun/star/security/DocumentDigitalSignatures.hpp>

#include <com/sun/star/security/XCertificate.hpp>

#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>

#include <com/sun/star/ui/dialogs/XAsynchronousExecutableDialog.hpp>

#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>

#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>

#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>

#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>

#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>

#include <com/sun/star/view/XSelectionSupplier.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <guisaveas.hxx>

#include <sal/log.hxx>

#include <svl/itemset.hxx>

#include <svl/eitem.hxx>

#include <tools/debug.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/documentconstants.hxx>

#include <comphelper/namedvaluecollection.hxx>

#include <tools/urlobj.hxx>

#include <tools/json_writer.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertysequence.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <comphelper/mimeconfighelper.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/xmlsechelper.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <utility>

#include <vcl/svapp.hxx>

#include <vcl/vclenum.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <o3tl/char16_t2wchar_t.hxx>

#include <unotools/tempfile.hxx>

#include <unotools/useroptions.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/objsh.hxx>

#include <sfx2/sfxsids.hrc>

#include <sfx2/strings.hrc>

#include <sfx2/sfxresid.hxx>

#include <sfx2/filedlghelper.hxx>

#include <sfx2/app.hxx>

#include <sfx2/sfxuno.hxx>

#include <sfx2/viewsh.hxx>

#include <sfx2/bindings.hxx>

#include <memory>

#include <string_view>

#include <officecfg/Office/Common.hxx>

#include <vcl/FilterConfigItem.hxx>

#include <com/sun/star/system/SystemShellExecute.hpp>

#include <com/sun/star/system/SystemShellExecuteFlags.hpp>

#include <osl/file.hxx>

#include <svl/cryptosign.hxx>

#include <svtools/confirmationdlg.hxx>

#ifdef _WIN32

#include <Shlobj.h>

#ifdef GetTempPath

#undef GetTempPath

#endif

#endif

// flags that specify requested operation

#define EXPORT_REQUESTED            1

#define PDFEXPORT_REQUESTED         2

#define PDFDIRECTEXPORT_REQUESTED   4

#define WIDEEXPORT_REQUESTED        8

#define SAVE_REQUESTED              16

#define SAVEAS_REQUESTED            32

#define SAVEACOPY_REQUESTED         64

#define EPUBEXPORT_REQUESTED       128

#define EPUBDIRECTEXPORT_REQUESTED 256

#define SAVEASREMOTE_REQUESTED      -1

// possible statuses of save operation

#define STATUS_NO_ACTION            0

#define STATUS_SAVE                 1

#define STATUS_SAVEAS               2

#define STATUS_SAVEAS_STANDARDNAME  3

constexpr OUString aFilterNameString = u"FilterName"_ustr;

constexpr OUString aFilterOptionsString = u"FilterOptions"_ustr;

constexpr OUString aFilterDataString = u"FilterData"_ustr;

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

using namespace css::system;

namespace {

sal_uInt16 getSlotIDFromMode( sal_Int16 nStoreMode )

{

    // This is a temporary hardcoded solution must be removed when

    // dialogs do not need parameters in SidSet representation any more

    sal_uInt16 nResult = 0;

    if ( nStoreMode == EXPORT_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | SAVEACOPY_REQUESTED | WIDEEXPORT_REQUESTED ) )

        nResult = SID_EXPORTDOC;

    else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED ) )

        nResult = SID_EXPORTDOCASPDF;

    else if ( nStoreMode == ( EXPORT_REQUESTED | EPUBEXPORT_REQUESTED ) )

        nResult = SID_EXPORTDOCASEPUB;

    else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED ) )

        nResult = SID_DIRECTEXPORTDOCASPDF;

    else if ( nStoreMode == ( EXPORT_REQUESTED | EPUBEXPORT_REQUESTED | EPUBDIRECTEXPORT_REQUESTED ) )

        nResult = SID_DIRECTEXPORTDOCASEPUB;

    else if ( nStoreMode == SAVEAS_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | WIDEEXPORT_REQUESTED ) )

        nResult = SID_SAVEASDOC;

    else if ( nStoreMode == SAVEASREMOTE_REQUESTED )

        nResult = SID_SAVEASREMOTE;

    else {

        SAL_WARN( "sfx.doc", "Unacceptable slot name is provided!" );

    }

    return nResult;

}

sal_Int16 getStoreModeFromSlotName( std::u16string_view aSlotName )

{

    sal_Int16 nResult = 0;

    if ( aSlotName == u"ExportTo" )

        nResult = EXPORT_REQUESTED;

    else if ( aSlotName == u"ExportToPDF" )

        nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED;

    else if ( aSlotName == u"ExportDirectToPDF" )

        nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED;

    else if ( aSlotName == u"ExportToEPUB" )

        nResult = EXPORT_REQUESTED | EPUBEXPORT_REQUESTED;

    else if ( aSlotName == u"ExportDirectToEPUB" )

        nResult = EXPORT_REQUESTED | EPUBEXPORT_REQUESTED | EPUBDIRECTEXPORT_REQUESTED;

    else if ( aSlotName == u"Save" )

        nResult = SAVE_REQUESTED;

    else if ( aSlotName == u"SaveAs" )

        nResult = SAVEAS_REQUESTED;

    else if ( aSlotName == u"SaveAsRemote" )

        nResult = SAVEASREMOTE_REQUESTED;

    else

        throw task::ErrorCodeIOException(

            (OUString::Concat("getStoreModeFromSlotName(\"") + aSlotName

             + "): ERRCODE_IO_INVALIDPARAMETER"),

            uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER) );

    return nResult;

}

SfxFilterFlags getMustFlags( sal_Int16 nStoreMode )

{

    return ( SfxFilterFlags::EXPORT

            | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SfxFilterFlags::NONE : SfxFilterFlags::IMPORT ) );

}

SfxFilterFlags getDontFlags( sal_Int16 nStoreMode )

{

    return ( SfxFilterFlags::INTERNAL

            | SfxFilterFlags::NOTINFILEDLG

            | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SfxFilterFlags::IMPORT : SfxFilterFlags::NONE ) );

}

class DocumentSettingsGuard

{

    uno::Reference< beans::XPropertySet > m_xDocumentSettings;

    bool m_bPreserveReadOnly;

    bool m_bReadOnlySupported;

    bool m_bRestoreSettings;

public:

    DocumentSettingsGuard( const uno::Reference< frame::XModel2 >& xModel, bool bReadOnly, bool bRestore )

    : m_bPreserveReadOnly( false )

    , m_bReadOnlySupported( false )

    , m_bRestoreSettings( bRestore )

    {

        try

        {

            uno::Reference< lang::XMultiServiceFactory > xDocSettingsSupplier( xModel, uno::UNO_QUERY );

            if (xDocSettingsSupplier)

            {

                m_xDocumentSettings.set(

                    xDocSettingsSupplier->createInstance( u"com.sun.star.document.Settings"_ustr ),

                    uno::UNO_QUERY );

                if (m_xDocumentSettings)

                {

                    OUString aLoadReadonlyString( u"LoadReadonly"_ustr );

                    m_xDocumentSettings->getPropertyValue( aLoadReadonlyString ) >>= m_bPreserveReadOnly;

                    m_xDocumentSettings->setPropertyValue( aLoadReadonlyString, uno::Any( bReadOnly ) );

                    m_bReadOnlySupported = true;

                }

            }

        }

        catch( const uno::Exception& )

        {}

        if ( bReadOnly && !m_bReadOnlySupported )

            throw uno::RuntimeException(); // the user could provide the data, so it must be stored

    }

    ~DocumentSettingsGuard()

    {

        if ( m_bRestoreSettings )

        {

            try

            {

                if ( m_bReadOnlySupported )

                    m_xDocumentSettings->setPropertyValue( u"LoadReadonly"_ustr, uno::Any( m_bPreserveReadOnly ) );

            }

            catch( const uno::Exception& )

            {

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

            }

        }

    }

};

} // anonymous namespace

class ModelData_Impl

{

    SfxStoringHelper* m_pOwner;

    uno::Reference< frame::XModel2 > m_xModel;

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

    uno::Reference< frame::XStorable2 > m_xStorable2;

    OUString m_aModuleName;

    std::unique_ptr<::comphelper::SequenceAsHashMap> m_pDocumentPropsHM;

    std::unique_ptr<::comphelper::SequenceAsHashMap> m_pModulePropsHM;

    uno::Reference<beans::XPropertyAccess> m_xFilterProperties;

    uno::Reference<ui::dialogs::XAsynchronousExecutableDialog> m_xFilterDialog;

    ::comphelper::SequenceAsHashMap m_aMediaDescrHM;

    bool m_bRecommendReadOnly;

    bool m_bSignWithDefaultSignature;

    DECL_LINK(OptionsDialogClosedHdl, css::ui::dialogs::DialogClosedEvent*, void);

public:

    ModelData_Impl( SfxStoringHelper& aOwner,

                    uno::Reference< frame::XModel2 > xModel,

                    const uno::Sequence< beans::PropertyValue >& aMediaDescr );

    ~ModelData_Impl();

    void FreeDocumentProps();

    uno::Reference< frame::XModel2 > const & GetModel() const;

    uno::Reference< frame::XStorable > const & GetStorable();

    uno::Reference< frame::XStorable2 > const & GetStorable2();

    ::comphelper::SequenceAsHashMap& GetMediaDescr() { return m_aMediaDescrHM; }

    bool IsRecommendReadOnly() const { return m_bRecommendReadOnly; }

    bool IsSignWithDefaultSignature() const { return m_bSignWithDefaultSignature; }

    const ::comphelper::SequenceAsHashMap& GetDocProps();

    OUString const & GetModuleName();

    const ::comphelper::SequenceAsHashMap& GetModuleProps();

    void CheckInteractionHandler();

    OUString GetDocServiceName();

    uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags nMust, SfxFilterFlags nDont );

    uno::Sequence< beans::PropertyValue > GetDocServiceAnyFilter( SfxFilterFlags nMust, SfxFilterFlags nDont );

    uno::Sequence< beans::PropertyValue > GetPreselectedFilter_Impl( sal_Int16 nStoreMode );

    uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilter();

    bool ExecuteFilterDialog_Impl( const OUString& aFilterName, bool bAsync );

    sal_Int8 CheckSaveAcceptable( sal_Int8 nCurStatus );

    sal_Int8 CheckStateForSave();

    sal_Int8 CheckFilter( const OUString& );

    bool CheckFilterOptionsDialogExistence();

    bool OutputFileDialog( sal_Int16 nStoreMode,

                                const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM,

                                bool bSetStandardName,

                                OUString& aSuggestedName,

                                bool bPreselectPassword,

                                OUString& aSuggestedDir,

                                sal_Int16 nDialog,

                                const css::uno::Sequence<OUString>& rDenyList,

                                SignatureState const nScriptingSignatureState

                                );

    bool ShowDocumentInfoDialog();

    static OUString GetRecommendedExtension( const OUString& aTypeName );

    OUString GetRecommendedName( const OUString& aSuggestedName,

                                        const OUString& aTypeName );

};

ModelData_Impl::ModelData_Impl( SfxStoringHelper& aOwner,

                                uno::Reference< frame::XModel2 > xModel,

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

: m_pOwner( &aOwner )

, m_xModel(std::move( xModel ))

, m_aMediaDescrHM( aMediaDescr )

, m_bRecommendReadOnly( false )

, m_bSignWithDefaultSignature( false )

{

    CheckInteractionHandler();

}

ModelData_Impl::~ModelData_Impl()

{

    FreeDocumentProps();

    m_pDocumentPropsHM.reset();

    m_pModulePropsHM.reset();

    if (m_xFilterProperties)

        m_xFilterProperties.clear();

}

void ModelData_Impl::FreeDocumentProps()

{

    m_pDocumentPropsHM.reset();

}

uno::Reference< frame::XModel2 > const & ModelData_Impl::GetModel() const

{

    if ( !m_xModel.is() )

        throw uno::RuntimeException();

    return m_xModel;

}

uno::Reference< frame::XStorable > const & ModelData_Impl::GetStorable()

{

    if ( !m_xStorable.is() )

    {

        m_xStorable.set( m_xModel, uno::UNO_QUERY_THROW );

    }

    return m_xStorable;

}

uno::Reference< frame::XStorable2 > const & ModelData_Impl::GetStorable2()

{

    if ( !m_xStorable2.is() )

    {

        m_xStorable2.set( m_xModel, uno::UNO_QUERY_THROW );

    }

    return m_xStorable2;

}

const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetDocProps()

{

    if ( !m_pDocumentPropsHM )

        m_pDocumentPropsHM.reset( new ::comphelper::SequenceAsHashMap( GetModel()->getArgs() ) );

    return *m_pDocumentPropsHM;

}

OUString const & ModelData_Impl::GetModuleName()

{

    if ( m_aModuleName.isEmpty() )

    {

        m_aModuleName = m_pOwner->GetModuleManager()->identify(

                                                uno::Reference< uno::XInterface >( m_xModel, uno::UNO_QUERY ) );

        if ( m_aModuleName.isEmpty() )

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

    }

    return m_aModuleName;

}

const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetModuleProps()

{

    if ( !m_pModulePropsHM )

    {

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

        m_pOwner->GetModuleManager()->getByName( GetModuleName() ) >>= aModuleProps;

        if ( !aModuleProps.hasElements() )

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

        m_pModulePropsHM.reset( new ::comphelper::SequenceAsHashMap( aModuleProps ) );

    }

    return *m_pModulePropsHM;

}

OUString ModelData_Impl::GetDocServiceName()

{

    return GetModuleProps().getUnpackedValueOrDefault(u"ooSetupFactoryDocumentService"_ustr, OUString());

}

void ModelData_Impl::CheckInteractionHandler()

{

    static constexpr OUString sInteractionHandler {u"InteractionHandler"_ustr};

    ::comphelper::SequenceAsHashMap::const_iterator aInteractIter =

            m_aMediaDescrHM.find( sInteractionHandler );

    if ( aInteractIter == m_aMediaDescrHM.end() )

    {

        try {

            m_aMediaDescrHM[ sInteractionHandler ]

                <<= task::InteractionHandler::createWithParent( comphelper::getProcessComponentContext(), nullptr);

        }

        catch( const uno::Exception& )

        {

        }

    }

    else

    {

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

        DBG_ASSERT( ( aInteractIter->second >>= xInteract ) && xInteract.is(), "Broken interaction handler is provided!\n" );

    }

}

uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilter()

{

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

    const OUString aFilterName = GetModuleProps().getUnpackedValueOrDefault( u"ooSetupFactoryDefaultFilter"_ustr, OUString() );

    m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aProps;

    return aProps;

}

uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags nMust,

                                                                                            SfxFilterFlags nDont )

{

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

    uno::Sequence< beans::PropertyValue > aProps = GetDocServiceDefaultFilter();

    if ( aProps.hasElements() )

    {

        ::comphelper::SequenceAsHashMap aFiltHM( aProps );

        SfxFilterFlags nFlags = static_cast<SfxFilterFlags>(aFiltHM.getUnpackedValueOrDefault(u"Flags"_ustr,

                                                        sal_Int32(0) ));

        if ( ( ( nFlags & nMust ) == nMust ) && !( nFlags & nDont ) )

            aFilterProps = std::move(aProps);

    }

    return aFilterProps;

}

uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceAnyFilter( SfxFilterFlags nMust, SfxFilterFlags nDont )

{

    uno::Sequence< beans::NamedValue > aSearchRequest { { u"DocumentService"_ustr, css::uno::Any(GetDocServiceName()) } };

    return ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );

}

uno::Sequence< beans::PropertyValue > ModelData_Impl::GetPreselectedFilter_Impl( sal_Int16 nStoreMode )

{

    if ( nStoreMode == SAVEASREMOTE_REQUESTED )

        nStoreMode = SAVEAS_REQUESTED;

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

    SfxFilterFlags nMust = getMustFlags( nStoreMode );

    SfxFilterFlags nDont = getDontFlags( nStoreMode );

    if ( ( nStoreMode != SAVEASREMOTE_REQUESTED ) && ( nStoreMode & PDFEXPORT_REQUESTED ) )

    {

        // Preselect PDF-Filter for EXPORT

        uno::Sequence< beans::NamedValue > aSearchRequest

        {

            { u"Type"_ustr, css::uno::Any(u"pdf_Portable_Document_Format"_ustr) },

            { u"DocumentService"_ustr, css::uno::Any(GetDocServiceName()) }

        };

        aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );

    }

    else if ( ( nStoreMode != SAVEASREMOTE_REQUESTED ) && ( nStoreMode & EPUBEXPORT_REQUESTED ) )

    {

        // Preselect EPUB filter for export.

        uno::Sequence<beans::NamedValue> aSearchRequest

        {

            { u"Type"_ustr, css::uno::Any(u"writer_EPUB_Document"_ustr) },

            { u"DocumentService"_ustr, css::uno::Any(GetDocServiceName()) }

        };

        aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );

    }

    else

    {

        aFilterProps = GetDocServiceDefaultFilterCheckFlags( nMust, nDont );

        if ( !aFilterProps.hasElements() )

        {

            // the default filter was not found, use just the first acceptable one

            aFilterProps = GetDocServiceAnyFilter( nMust, nDont );

        }

    }

    return aFilterProps;

}

bool ModelData_Impl::ExecuteFilterDialog_Impl( const OUString& aFilterName, bool bIsAsync )

{

    bool bDialogUsed = false;

    try {

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

        uno::Any aAny = m_pOwner->GetFilterConfiguration()->getByName( aFilterName );

        if ( aAny >>= aProps )

        {

            auto pProp = std::find_if(std::cbegin(aProps), std::cend(aProps),

                [](const beans::PropertyValue& rProp) { return rProp.Name == "UIComponent"; });

            if (pProp != std::cend(aProps))

            {

                OUString aServiceName;

                pProp->Value >>= aServiceName;

                if( !aServiceName.isEmpty() )

                {

                    uno::Sequence<uno::Any> aDialogArgs(comphelper::InitAnyPropertySequence(

                    {

                        {"ParentWindow", uno::Any(SfxStoringHelper::GetModelXWindow(m_xModel))},

                    }));

                    uno::Reference< beans::XPropertyAccess > xFilterProperties;

                    uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog;

                    uno::Reference< ui::dialogs::XAsynchronousExecutableDialog > xAsyncFilterDialog;

                    uno::Reference< document::XExporter > xExporter;

                    if ( bIsAsync )

                    {

                        xAsyncFilterDialog = uno::Reference< ui::dialogs::XAsynchronousExecutableDialog >(

                            comphelper::getProcessServiceFactory()->createInstanceWithArguments( aServiceName, aDialogArgs ), uno::UNO_QUERY );

                        OSL_ENSURE(xAsyncFilterDialog.is(), "ModelData_Impl::ExecuteFilterDialog_Impl: Dialog is not async!");

                        xFilterProperties = uno::Reference< beans::XPropertyAccess >( xAsyncFilterDialog, uno::UNO_QUERY );

                        xExporter = uno::Reference< document::XExporter >( xAsyncFilterDialog, uno::UNO_QUERY );

                    }

                    else

                    {

                        xFilterDialog = uno::Reference< ui::dialogs::XExecutableDialog >(

                            comphelper::getProcessServiceFactory()->createInstanceWithArguments( aServiceName, aDialogArgs ), uno::UNO_QUERY );

                        xFilterProperties = uno::Reference< beans::XPropertyAccess >( xFilterDialog, uno::UNO_QUERY );

                        xExporter = uno::Reference< document::XExporter >( xFilterDialog, uno::UNO_QUERY );

                    }

                    if ( xFilterProperties.is() && ( xFilterDialog.is() || xAsyncFilterDialog.is() ) )

                    {

                        bDialogUsed = true;

                        if( xExporter.is() )

                            xExporter->setSourceDocument( GetModel() );

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

                        GetMediaDescr() >> aPropsForDialog;

                        xFilterProperties->setPropertyValues( aPropsForDialog );

                        if ( bIsAsync )

                        {

                            m_xFilterProperties = std::move(xFilterProperties);

                            m_xFilterDialog = std::move(xAsyncFilterDialog);

                            auto aDialogClosedListener = rtl::Reference(new svt::DialogClosedListener());

                            aDialogClosedListener->SetDialogClosedLink( LINK( this, ModelData_Impl, OptionsDialogClosedHdl ) );

                            m_xFilterDialog->startExecuteModal( aDialogClosedListener );

                        }

                        else

                        {

                            if( !xFilterDialog->execute() )

                            {

                                throw task::ErrorCodeIOException(

                                    (u"ModelData_Impl::ExecuteFilterDialog_Impl:"

                                    " ERRCODE_IO_ABORT"_ustr),

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

                                    sal_uInt32(ERRCODE_IO_ABORT));

                            }

                            const uno::Sequence< beans::PropertyValue > aPropsFromDialog =

                                                                        xFilterProperties->getPropertyValues();

                            for ( const auto& rProp : aPropsFromDialog )

                                GetMediaDescr()[rProp.Name] = rProp.Value;

                        }

                    }

                }

            }

        }

    }

    catch( const container::NoSuchElementException& e )

    {

        // the filter name is unknown

        throw task::ErrorCodeIOException(

            ("ModelData_Impl::ExecuteFilterDialog_Impl: NoSuchElementException"

             " \"" + e.Message + "\": ERRCODE_IO_ABORT"),

            uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER));

    }

    catch( const task::ErrorCodeIOException& )

    {

        throw;

    }

    catch( const uno::Exception& )

    {

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

    }

    return bDialogUsed;

}

void SfxStoringHelper::CallFinishGUIStoreModel()

{

    ::comphelper::SequenceAsHashMap::const_iterator aFileNameIter = m_xModelData->GetMediaDescr().find( u"URL"_ustr );

    uno::Sequence< beans::PropertyValue > aFilterProps = m_xModelData->GetPreselectedFilter_Impl( m_nStoreMode );

    const OUString aFilterFromMediaDescr = m_xModelData->GetMediaDescr().getUnpackedValueOrDefault( aFilterNameString, OUString() );

    const OUString aOldFilterName = m_xModelData->GetDocProps().getUnpackedValueOrDefault( aFilterNameString, OUString() );

    ::comphelper::SequenceAsHashMap aFilterPropsHM( aFilterProps );

    OUString aFilterName = aFilterPropsHM.getUnpackedValueOrDefault( u"Name"_ustr, OUString() );

    SfxStoringHelper::FinishGUIStoreModel(aFileNameIter, *m_xModelData, m_bRemote, m_nStoreMode, aFilterProps,

                                          m_bSetStandardName, m_bPreselectPassword, m_bDialogUsed,

                                          aFilterFromMediaDescr, aOldFilterName, m_aArgsSequence,

                                          aFilterName, m_nScriptingSignatureState);

    if (SfxViewShell::Current())

        SfxViewShell::Current()->SetStoringHelper(nullptr);

}

IMPL_LINK( ModelData_Impl, OptionsDialogClosedHdl, css::ui::dialogs::DialogClosedEvent*, pEvt, void )

{

    SfxViewShell* pNotifier = comphelper::LibreOfficeKit::isActive() ? SfxViewShell::Current() : nullptr;

    if (pEvt->DialogResult == RET_OK && m_xFilterProperties)

    {

        if (pNotifier)

            pNotifier->libreOfficeKitViewCallback( LOK_CALLBACK_EXPORT_FILE, "PENDING"_ostr );

        const uno::Sequence< beans::PropertyValue > aPropsFromDialog = m_xFilterProperties->getPropertyValues();

        for ( const auto& rProp : aPropsFromDialog )

            GetMediaDescr()[rProp.Name] = rProp.Value;

        m_pOwner->CallFinishGUIStoreModel();

    }

    else if (pNotifier)

    {

        pNotifier->libreOfficeKitViewCallback( LOK_CALLBACK_EXPORT_FILE, "ABORT"_ostr );

    }

}

sal_Int8 ModelData_Impl::CheckSaveAcceptable( sal_Int8 nCurStatus )

{

    sal_Int8 nResult = nCurStatus;

    if ( nResult != STATUS_NO_ACTION && GetStorable()->hasLocation() )

    {

        // the saving is acceptable

        // in case the configuration entry is not set or set to false

        // or in case of version creation

        if ( officecfg::Office::Common::Save::Document::AlwaysSaveAs::get()

          && GetMediaDescr().find( u"VersionComment"_ustr ) == GetMediaDescr().end() )

        {

            // notify the user that SaveAs is going to be done

            std::unique_ptr<weld::MessageDialog> xMessageBox(Application::CreateMessageDialog(SfxStoringHelper::GetModelWindow(m_xModel),

                                                             VclMessageType::Question, VclButtonsType::OkCancel, SfxResId(STR_NEW_FILENAME_SAVE)));

            if (xMessageBox->run() == RET_OK)

                nResult = STATUS_SAVEAS;

            else

                nResult = STATUS_NO_ACTION;

        }

    }

    return nResult;

}

sal_Int8 ModelData_Impl::CheckStateForSave()

{

    // if the document is readonly or a new one a SaveAs operation must be used

    if ( !GetStorable()->hasLocation() || GetStorable()->isReadonly() )

        return STATUS_SAVEAS;

    // check acceptable entries for media descriptor

    ::comphelper::SequenceAsHashMap aAcceptedArgs;

    static constexpr OUString aVersionCommentString(u"VersionComment"_ustr);

    static constexpr OUString aAuthorString(u"Author"_ustr);

    static constexpr OUString aDontTerminateEdit(u"DontTerminateEdit"_ustr);

    static constexpr OUString aInteractionHandlerString(u"InteractionHandler"_ustr);

    static constexpr OUString aStatusIndicatorString(u"StatusIndicator"_ustr);

    static constexpr OUString aFailOnWarningString(u"FailOnWarning"_ustr);

    static constexpr OUString aNoFileSync(u"NoFileSync"_ustr);

    if ( GetMediaDescr().find( aVersionCommentString ) != GetMediaDescr().end() )

        aAcceptedArgs[ aVersionCommentString ] = GetMediaDescr()[ aVersionCommentString ];

    if ( GetMediaDescr().find( aAuthorString ) != GetMediaDescr().end() )

        aAcceptedArgs[ aAuthorString ] = GetMediaDescr()[ aAuthorString ];

    if ( GetMediaDescr().find( aDontTerminateEdit ) != GetMediaDescr().end() )

        aAcceptedArgs[ aDontTerminateEdit ] = GetMediaDescr()[ aDontTerminateEdit ];

    if ( GetMediaDescr().find( aInteractionHandlerString ) != GetMediaDescr().end() )

        aAcceptedArgs[ aInteractionHandlerString ] = GetMediaDescr()[ aInteractionHandlerString ];

    if ( GetMediaDescr().find( aStatusIndicatorString ) != GetMediaDescr().end() )

        aAcceptedArgs[ aStatusIndicatorString ] = GetMediaDescr()[ aStatusIndicatorString ];

    if ( GetMediaDescr().find( aFailOnWarningString ) != GetMediaDescr().end() )

        aAcceptedArgs[ aFailOnWarningString ] = GetMediaDescr()[ aFailOnWarningString ];

    if (GetMediaDescr().find(aNoFileSync) != GetMediaDescr().end())

        aAcceptedArgs[aNoFileSync] = GetMediaDescr()[aNoFileSync];

    // remove unacceptable entry if there is any

    DBG_ASSERT( GetMediaDescr().size() == aAcceptedArgs.size(),

                "Unacceptable parameters are provided in Save request!\n" );

    if ( GetMediaDescr().size() != aAcceptedArgs.size() )

        GetMediaDescr() = std::move(aAcceptedArgs);

    // check that the old filter is acceptable

    return CheckFilter( GetDocProps().getUnpackedValueOrDefault(aFilterNameString, OUString()) );

}

sal_Int8 ModelData_Impl::CheckFilter( const OUString& aFilterName )

{

    ::comphelper::SequenceAsHashMap aFiltPropsHM;

    SfxFilterFlags nFiltFlags = SfxFilterFlags::NONE;

    if ( !aFilterName.isEmpty() )

    {

        // get properties of filter

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

        m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aFilterProps;

        aFiltPropsHM = ::comphelper::SequenceAsHashMap( aFilterProps );

        nFiltFlags = static_cast<SfxFilterFlags>(aFiltPropsHM.getUnpackedValueOrDefault(u"Flags"_ustr, sal_Int32(0) ));

    }

    // only a temporary solution until default filter retrieving feature is implemented

    // then GetDocServiceDefaultFilter() must be used

    ::comphelper::SequenceAsHashMap aDefFiltPropsHM = GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags::IMPORT | SfxFilterFlags::EXPORT, SfxFilterFlags::NONE );

    SfxFilterFlags nDefFiltFlags = static_cast<SfxFilterFlags>(aDefFiltPropsHM.getUnpackedValueOrDefault(u"Flags"_ustr, sal_Int32(0) ));

    bool bAsk = false;

    // if the old filter is not acceptable

    // and there is no default filter or it is not acceptable for requested parameters then proceed with saveAs

    if ( ( aFiltPropsHM.empty() || !( nFiltFlags & SfxFilterFlags::EXPORT ) )

      && ( aDefFiltPropsHM.empty() || !( nDefFiltFlags & SfxFilterFlags::EXPORT ) || nDefFiltFlags & SfxFilterFlags::INTERNAL ) )

        return STATUS_SAVEAS;

    // so at this point there is either an acceptable old filter or default one

    if ( aFiltPropsHM.empty() || !( nFiltFlags & SfxFilterFlags::EXPORT ) )

    {

        // so the default filter must be acceptable

        return STATUS_SAVEAS_STANDARDNAME;

    }

    else if ( ( !( nFiltFlags & SfxFilterFlags::OWN ) || ( nFiltFlags & SfxFilterFlags::ALIEN ) )

           && !aDefFiltPropsHM.empty()

           && ( nDefFiltFlags & SfxFilterFlags::EXPORT ) && !( nDefFiltFlags & SfxFilterFlags::INTERNAL ))

    {

        bAsk = true;

    }

    // check if EncryptionData supports this output format

    {

        OUString aSupportedFilters;

        const ::comphelper::SequenceAsHashMap& rDocumentProperties = GetDocProps();

        const css::uno::Sequence<css::beans::NamedValue> aEncryptionData = rDocumentProperties.getUnpackedValueOrDefault(u"EncryptionData"_ustr, css::uno::Sequence<css::beans::NamedValue>());

        if (aEncryptionData != css::uno::Sequence<css::beans::NamedValue>())

        {

            for (const css::beans::NamedValue& aNamedValue : aEncryptionData)

            {

                if (aNamedValue.Name == "SupportedFilters")

                {

                    aNamedValue.Value >>= aSupportedFilters;

                }

            }

        }

        // if 'SupportedFilters' is empty assume that all filters are supported.

        if (!aSupportedFilters.isEmpty())

        {

            const OUString aSelectedFilter = aFiltPropsHM.getUnpackedValueOrDefault(u"UIName"_ustr, OUString());

            aSupportedFilters = ";" + aSupportedFilters + ";";

            const OUString aSearchToken = ";" + aSelectedFilter + ";";

            bAsk = (aSupportedFilters.indexOf(aSearchToken) < 0);

        }

    }

    if (bAsk)

    {

        // the default filter is acceptable and the old filter is alien one

        // so ask to make a saveAs operation

        const OUString aUIName = aFiltPropsHM.getUnpackedValueOrDefault(u"UIName"_ustr, OUString() );

        const OUString aType = aFiltPropsHM.getUnpackedValueOrDefault( u"Type"_ustr, OUString() );

        const OUString aExtension = GetRecommendedExtension(aType);

        const OUString aPreusedFilterName = GetDocProps().getUnpackedValueOrDefault(u"PreusedFilterName"_ustr, OUString() );

        const OUString aDefUIName = aDefFiltPropsHM.getUnpackedValueOrDefault(u"UIName"_ustr, OUString() );

        const OUString aDefType = aDefFiltPropsHM.getUnpackedValueOrDefault( u"Type"_ustr, OUString() );

        const OUString aDefExtension = GetRecommendedExtension( aDefType );

        if ( aPreusedFilterName != aFilterName && aUIName != aDefUIName )

        {

            if ( !SfxStoringHelper::WarnUnacceptableFormat( GetModel(), aUIName,aExtension, aDefExtension,

                                                            static_cast<bool>( nDefFiltFlags & SfxFilterFlags::ALIEN ) ) )

                return STATUS_SAVEAS_STANDARDNAME;

        }

    }

    return STATUS_SAVE;

}

bool ModelData_Impl::CheckFilterOptionsDialogExistence()

{

    uno::Sequence< beans::NamedValue > aSearchRequest { { u"DocumentService"_ustr, css::uno::Any(GetDocServiceName()) } };

    uno::Reference< container::XEnumeration > xFilterEnum =

                                    m_pOwner->GetFilterQuery()->createSubSetEnumerationByProperties( aSearchRequest );

    while ( xFilterEnum->hasMoreElements() )

    {

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

        if ( xFilterEnum->nextElement() >>= aProps )

        {

            ::comphelper::SequenceAsHashMap aPropsHM( aProps );

            if ( !aPropsHM.getUnpackedValueOrDefault(u"UIComponent"_ustr, OUString()).isEmpty() )

                return true;

        }

    }

    return false;

}

bool ModelData_Impl::OutputFileDialog( sal_Int16 nStoreMode,

                                            const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM,

                                            bool bSetStandardName,

                                            OUString& aSuggestedName,

                                            bool bPreselectPassword,

                                            OUString& aSuggestedDir,

                                            sal_Int16 nDialog,

                                            const css::uno::Sequence<OUString>& rDenyList,

                                            SignatureState const nScriptingSignatureState)

{

    if ( nStoreMode == SAVEASREMOTE_REQUESTED )

        nStoreMode = SAVEAS_REQUESTED;

    bool bUseFilterOptions = false;

    ::comphelper::SequenceAsHashMap::const_iterator aOverwriteIter =

                GetMediaDescr().find( u"Overwrite"_ustr );

    // the file name must be specified if overwrite option is set

    if ( aOverwriteIter != GetMediaDescr().end() )

           throw task::ErrorCodeIOException(

               u"ModelData_Impl::OutputFileDialog: ERRCODE_IO_INVALIDPARAMETER"_ustr,