/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_filter.hxx"
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/embed/XEmbedPersist.hpp>
#include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
#include <com/sun/star/embed/EmbedStates.hpp>
#include <com/sun/star/frame/XStorable.hpp>
#include <com/sun/star/awt/Size.hpp>
#include <com/sun/star/embed/Aspects.hpp>
#include <sot/clsids.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/docfac.hxx>
#include <sfx2/docfilt.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/fcontnr.hxx>
#include <sot/formats.hxx>
#include <comphelper/processfactory.hxx>
#include <unotools/streamwrap.hxx>
#include <comphelper/storagehelper.hxx>
#include <svtools/embedhlp.hxx>
#include <filter/msfilter/msdffimp.hxx> // extern sichtbare Header-Datei

#include "filter/msfilter/msoleexp.hxx"

#define CREATE_CONST_ASC(s) String::CreateFromAscii( \
    RTL_CONSTASCII_STRINGPARAM(s))

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

SvGlobalName GetEmbeddedVersion( const SvGlobalName& aAppName )
{
	if ( aAppName == SvGlobalName( SO3_SM_CLASSID_60 ) )
			return SvGlobalName( SO3_SM_OLE_EMBED_CLASSID_8 );
	else if ( aAppName == SvGlobalName( SO3_SW_CLASSID_60 ) )
			return SvGlobalName( SO3_SW_OLE_EMBED_CLASSID_8 );
	else if ( aAppName == SvGlobalName( SO3_SC_CLASSID_60 ) )
			return SvGlobalName( SO3_SC_OLE_EMBED_CLASSID_8 );
	else if ( aAppName == SvGlobalName( SO3_SDRAW_CLASSID_60 ) )
			return SvGlobalName( SO3_SDRAW_OLE_EMBED_CLASSID_8 );
	else if ( aAppName == SvGlobalName( SO3_SIMPRESS_CLASSID_60 ) )
			return SvGlobalName( SO3_SIMPRESS_OLE_EMBED_CLASSID_8 );
	else if ( aAppName == SvGlobalName( SO3_SCH_CLASSID_60 ) )
			return SvGlobalName( SO3_SCH_OLE_EMBED_CLASSID_8 );

	return SvGlobalName();
}

String GetStorageType( const SvGlobalName& aEmbName )
{
	if ( aEmbName == SvGlobalName( SO3_SM_OLE_EMBED_CLASSID_8 ) )
			return String::CreateFromAscii( "opendocument.MathDocument.1" );
	else if ( aEmbName == SvGlobalName( SO3_SW_OLE_EMBED_CLASSID_8 ) )
			return String::CreateFromAscii( "opendocument.WriterDocument.1" );
	else if ( aEmbName == SvGlobalName( SO3_SC_OLE_EMBED_CLASSID_8 ) )
			return String::CreateFromAscii( "opendocument.CalcDocument.1" );
	else if ( aEmbName == SvGlobalName( SO3_SDRAW_OLE_EMBED_CLASSID_8 ) )
			return String::CreateFromAscii( "opendocument.DrawDocument.1" );
	else if ( aEmbName == SvGlobalName( SO3_SIMPRESS_OLE_EMBED_CLASSID_8 ) )
			return String::CreateFromAscii( "opendocument.ImpressDocument.1" );
	else if ( aEmbName == SvGlobalName( SO3_SCH_OLE_EMBED_CLASSID_8 ) )
			return String::CreateFromAscii( "opendocument.ChartDocument.1" );

	return String();
}

sal_Bool UseOldMSExport()
{
    uno::Reference< lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory();

	if ( xFactory.is() )
	{
		uno::Reference< lang::XMultiServiceFactory > xProvider( xFactory->createInstance(
                    rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.configuration.ConfigurationProvider"))),
                	uno::UNO_QUERY);
		if ( xProvider.is() )
		{
			try {
				uno::Sequence< uno::Any > aArg( 1 );
				aArg[0] <<= rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Common/InternalMSExport") );
				uno::Reference< container::XNameAccess > xNameAccess(
					xProvider->createInstanceWithArguments(
						rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.configuration.ConfigurationUpdateAccess" ) ),
						aArg ),
					uno::UNO_QUERY );
				if ( xNameAccess.is() )
				{
					uno::Any aResult = xNameAccess->getByName(
									rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseOldExport" ) ) );

					sal_Bool bResult = sal_Bool();
					if ( aResult >>= bResult )
						return bResult;
				}
			}
			catch( uno::Exception& )
			{
			}
		}
	}

	OSL_ENSURE( sal_False, "Could not get access to configuration entry!\n" );
	return sal_False;
}

void SvxMSExportOLEObjects::ExportOLEObject( const com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject>& rObj, SotStorage& rDestStg )
{
    svt::EmbeddedObjectRef aObj( rObj, embed::Aspects::MSOLE_CONTENT );
    ExportOLEObject( aObj, rDestStg );
}

void SvxMSExportOLEObjects::ExportOLEObject( svt::EmbeddedObjectRef& rObj, SvStorage& rDestStg )
{
	SvGlobalName aOwnGlobalName;
    SvGlobalName aObjName( rObj->getClassID() );
	const SfxFilter* pExpFilter = NULL;
	{
		static struct _ObjExpType {
			sal_uInt32 nFlag;
			const char* pFilterNm;
			// GlobalNameId
			struct _GlobalNameIds {
				sal_uInt32 n1;
				sal_uInt16 n2, n3;
				sal_uInt8 b8, b9, b10, b11, b12, b13, b14, b15;
            }
			aGlNmIds[4];
		} aArr[] = {
			{ OLE_STARMATH_2_MATHTYPE, "MathType 3.x",
				{{SO3_SM_CLASSID_60}, {SO3_SM_CLASSID_50},
				 {SO3_SM_CLASSID_40}, {SO3_SM_CLASSID_30 }}},
			{ OLE_STARWRITER_2_WINWORD, "MS Word 97",
				{{SO3_SW_CLASSID_60}, {SO3_SW_CLASSID_50},
				 {SO3_SW_CLASSID_40}, {SO3_SW_CLASSID_30 }}},
			{ OLE_STARCALC_2_EXCEL, "MS Excel 97",
				{{SO3_SC_CLASSID_60}, {SO3_SC_CLASSID_50},
				 {SO3_SC_CLASSID_40}, {SO3_SC_CLASSID_30 }}},
			{ OLE_STARIMPRESS_2_POWERPOINT, "MS PowerPoint 97",
				{{SO3_SIMPRESS_CLASSID_60}, {SO3_SIMPRESS_CLASSID_50},
				 {SO3_SIMPRESS_CLASSID_40}, {SO3_SIMPRESS_CLASSID_30 }}},
			{ 0, "",
				{{SO3_SCH_CLASSID_60}, {SO3_SCH_CLASSID_50},
				 {SO3_SCH_CLASSID_40}, {SO3_SCH_CLASSID_30 }}},
			{ 0, "",
				{{SO3_SDRAW_CLASSID_60}, {SO3_SDRAW_CLASSID_50},	// SJ: !!!! SO3_SDRAW_CLASSID is only available up from
				 {SO3_SDRAW_CLASSID_60}, {SO3_SDRAW_CLASSID_50 }}}, // ver 5.0, it is purpose to have double entrys here.

			{ 0xffff,0,
				{{SO3_SDRAW_CLASSID_60}, {SO3_SDRAW_CLASSID_50},
				{SO3_SDRAW_CLASSID_60}, {SO3_SDRAW_CLASSID_50}}}
		};

        for( const _ObjExpType* pArr = aArr; !pExpFilter && ( pArr->nFlag != 0xffff ); ++pArr )
		{
            for ( int n = 0; n < 4; ++n )
			{
				const _ObjExpType::_GlobalNameIds& rId = pArr->aGlNmIds[ n ];
				SvGlobalName aGlbNm( rId.n1, rId.n2, rId.n3,
							rId.b8, rId.b9, rId.b10, rId.b11,
							rId.b12, rId.b13, rId.b14, rId.b15 );
                if( aObjName == aGlbNm )
				{
					aOwnGlobalName = aGlbNm;

                    // flags for checking if conversion is wanted at all (SaveOptions?!)
					if( GetFlags() & pArr->nFlag )
					{
                        pExpFilter = SfxFilterMatcher().GetFilter4FilterName(String::CreateFromAscii(pArr->pFilterNm));
						break;
					}
				}
			}
		}
	}

	if( pExpFilter )				        // use this filter for the export
	{
        try
        {
            if ( rObj->getCurrentState() == embed::EmbedStates::LOADED )
                rObj->changeState( embed::EmbedStates::RUNNING );
            //TODO/LATER: is stream instead of outputstream a better choice?!
            //TODO/LATER: a "StoreTo" method at embedded object would be nice
            uno::Sequence < beans::PropertyValue > aSeq(2);
            SvStream* pStream = new SvMemoryStream;
            aSeq[0].Name = ::rtl::OUString::createFromAscii( "OutputStream" );
            ::uno::Reference < io::XOutputStream > xOut = new ::utl::OOutputStreamWrapper( *pStream );
            aSeq[0].Value <<= xOut;
            aSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" ) );
            aSeq[1].Value <<= ::rtl::OUString( pExpFilter->GetName() );
            uno::Reference < frame::XStorable > xStor( rObj->getComponent(), uno::UNO_QUERY );
            xStor->storeToURL( ::rtl::OUString::createFromAscii( "private:stream" ), aSeq );
            SotStorageRef xOLEStor = new SotStorage( pStream, sal_True );
            xOLEStor->CopyTo( &rDestStg );
            rDestStg.Commit();
        }
        catch( uno::Exception& )
        {
            // TODO/LATER: Error handling
            DBG_ERROR( "The object could not be exported!" );
        }
	}
	else if( aOwnGlobalName != SvGlobalName() )
	{
        // own format, maybe SO6 format or lower
		SvGlobalName aEmbName = GetEmbeddedVersion( aOwnGlobalName );
		if ( aEmbName != SvGlobalName() && !UseOldMSExport() )
		{
            // this is a SO6 embedded object, save in old binary format
			rDestStg.SetVersion( SOFFICE_FILEFORMAT_31 );
			rDestStg.SetClass( aEmbName,
								SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE,
								GetStorageType( aEmbName ) );
			SotStorageStreamRef xExtStm = rDestStg.OpenSotStream(
											String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "properties_stream" ) ),
											STREAM_STD_READWRITE );

			sal_Bool bExtentSuccess = sal_False;
			if( !xExtStm->GetError() )
			{
				// write extent
                //TODO/MBA: check if writing a size is enough
                if( rObj.GetObject().is() )
                {
                    // MSOLE objects don't need to be in running state for VisualArea access
                    awt::Size aSize;
					try
					{
                        // this is an own object, the content size must be stored in the
                        // extension stream
						aSize = rObj->getVisualAreaSize( embed::Aspects::MSOLE_CONTENT );
					}
					catch( embed::NoVisualAreaSizeException& )
					{
						OSL_ENSURE( sal_False, "Could not get visual area size!\n" );
						aSize.Width = 5000;
						aSize.Height = 5000;
					}
					catch( uno::Exception& )
					{
						OSL_ENSURE( sal_False, "Unexpected exception while getting visual area size!\n" );
						aSize.Width = 5000;
						aSize.Height = 5000;
					}
					
                    //Rectangle aVisArea = xSfxIPObj->GetVisArea( ASPECT_CONTENT );
                    sal_Int32 pRect[4];
                    //pRect[0] = aVisArea.Left();
                    //pRect[1] = aVisArea.Right();
                    //pRect[2] = aVisArea.Top();
                    //pRect[3] = aVisArea.Bottom();
                    pRect[0] = 0;
                    pRect[1] = aSize.Width;
                    pRect[2] = 0;
                    pRect[3] = aSize.Height;

                    sal_Int8 aWriteSet[16];
                    for ( int ind = 0; ind < 4; ind++ )
                    {
                        sal_Int32 nVal = pRect[ind];
                        for ( int nByte = 0; nByte < 4; nByte++ )
                        {
                            aWriteSet[ind*4+nByte] = (sal_Int8) nVal % 0x100;
                            nVal /= 0x100;
                        }
                    }

                    bExtentSuccess = ( xExtStm->Write( aWriteSet, 16 ) == 16 );
                }
			}

			if ( bExtentSuccess )
			{
				SotStorageStreamRef xEmbStm = rDestStg.OpenSotStream(
												String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "package_stream" ) ),
												STREAM_STD_READWRITE );
				if( !xEmbStm->GetError() )
				{
                    try
                    {
                        if ( rObj->getCurrentState() == embed::EmbedStates::LOADED )
                            rObj->changeState( embed::EmbedStates::RUNNING );
                        //TODO/LATER: is stream instead of outputstream a better choice?!
                        //TODO/LATER: a "StoreTo" method at embedded object would be nice
                        uno::Sequence < beans::PropertyValue > aSeq(1);
                        aSeq[0].Name = ::rtl::OUString::createFromAscii( "OutputStream" );
                        ::uno::Reference < io::XOutputStream > xOut = new ::utl::OOutputStreamWrapper( *xEmbStm );
                        aSeq[0].Value <<= xOut;
                        uno::Reference < frame::XStorable > xStor( rObj->getComponent(), uno::UNO_QUERY );
                        xStor->storeToURL( ::rtl::OUString::createFromAscii( "private:stream" ), aSeq );
                    }
                    catch( uno::Exception& )
                    {
                        // TODO/LATER: Error handling
                        DBG_ERROR( "The object could not be exported!" );
                    }
				}
			}
		}
		else
		{
            DBG_ERROR("Own binary format inside own container document!");
		}
	}
	else
	{
        // alien objects
        //TODO/LATER: a "StoreTo" method at embedded object would be nice
		rDestStg.SetVersion( SOFFICE_FILEFORMAT_31 );
        uno::Reference < embed::XStorage > xStor = ::comphelper::OStorageHelper::GetTemporaryStorage();
        uno::Reference < embed::XEmbedPersist > xPers( rObj.GetObject(), uno::UNO_QUERY );
        if ( xPers.is() )
        {
            uno::Sequence < beans::PropertyValue > aEmptySeq;
            ::rtl::OUString aTempName(::rtl::OUString::createFromAscii("bla"));
            try
            {
                xPers->storeToEntry( xStor, aTempName, aEmptySeq, aEmptySeq );
            }
            catch ( uno::Exception& )
            {}

            SotStorageRef xOLEStor = SotStorage::OpenOLEStorage( xStor, aTempName, STREAM_STD_READ );
            xOLEStor->CopyTo( &rDestStg );
            rDestStg.Commit();
        }
	}

    //We never need this stream: See #99809# and #i2179#
    rDestStg.Remove(CREATE_CONST_ASC(SVEXT_PERSIST_STREAM));
}