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

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

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

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

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

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

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

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

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

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

#include <comphelper/storagehelper.hxx>

#include <unotools/ucbstreamhelper.hxx>

#include <cppuhelper/exc_hlp.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <sot/stg.hxx>

#include <sot/storinfo.hxx>

#include <utility>

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

const sal_Int32 nBytesCount = 32000;

OLESimpleStorage::OLESimpleStorage(

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

        css::uno::Sequence<css::uno::Any> const &aArguments)

: m_bDisposed( false )

, m_xContext(std::move( xContext ))

, m_bNoTemporaryCopy( false )

{

    sal_Int32 nArgNum = aArguments.getLength();

    if ( nArgNum < 1 || nArgNum > 2 )

        throw lang::IllegalArgumentException(); // TODO:

    uno::Reference< io::XStream > xStream;

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

    if ( !( aArguments[0] >>= xStream ) && !( aArguments[0] >>= xInputStream ) )

        throw lang::IllegalArgumentException(); // TODO:

    if ( nArgNum == 2 )

    {

        if ( !( aArguments[1] >>= m_bNoTemporaryCopy ) )

            throw lang::IllegalArgumentException(); // TODO:

    }

    if ( m_bNoTemporaryCopy )

    {

        // TODO: ???

        // If the temporary stream is not created, the original stream must be wrapped

        // since SvStream wrapper closes the stream is owns

        if ( xInputStream.is() )

        {

            // the stream must be seekable for direct access

            uno::Reference< io::XSeekable > xSeek( xInputStream, uno::UNO_QUERY_THROW );

            m_pStream = ::utl::UcbStreamHelper::CreateStream( xInputStream, false );

        }

        else if ( xStream.is() )

        {

            // the stream must be seekable for direct access

            uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );

            m_pStream = ::utl::UcbStreamHelper::CreateStream( xStream, false );

        }

        else

            throw lang::IllegalArgumentException(); // TODO:

    }

    else

    {

        uno::Reference < io::XStream > xTempFile( io::TempFile::create(m_xContext),

                uno::UNO_QUERY_THROW );

        uno::Reference < io::XSeekable > xTempSeek( xTempFile, uno::UNO_QUERY_THROW );

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

        if ( !xTempOut.is() )

            throw uno::RuntimeException();

        if ( xInputStream.is() )

        {

            try

            {

                uno::Reference< io::XSeekable > xSeek( xInputStream, uno::UNO_QUERY );

                if (xSeek)

                    xSeek->seek( 0 );

            }

            catch( uno::Exception& )

            {}

            ::comphelper::OStorageHelper::CopyInputToOutput( xInputStream, xTempOut );

            xTempOut->closeOutput();

            xTempSeek->seek( 0 );

            uno::Reference< io::XInputStream > xTempInput = xTempFile->getInputStream();

            m_pStream = ::utl::UcbStreamHelper::CreateStream( xTempInput, false );

        }

        else if ( xStream.is() )

        {

            // not sure that the storage flashes the stream on commit

            m_xStream = xStream;

            m_xTempStream = xTempFile;

            uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );

            xSeek->seek( 0 );

            uno::Reference< io::XInputStream > xInpStream = xStream->getInputStream();

            if ( !xInpStream.is() || !xStream->getOutputStream().is() )

                throw uno::RuntimeException();

            ::comphelper::OStorageHelper::CopyInputToOutput( xInpStream, xTempOut );

            xTempOut->flush();

            xTempSeek->seek( 0 );

            m_pStream = ::utl::UcbStreamHelper::CreateStream( xTempFile, false );

        }

        else

            throw lang::IllegalArgumentException(); // TODO:

    }

    if ( !m_pStream || m_pStream->GetError() )

        throw io::IOException(); // TODO

    m_pStorage.reset(new Storage( *m_pStream, false ));

}

OLESimpleStorage::~OLESimpleStorage()

{

    try {

        osl_atomic_increment(&m_refCount);

        dispose();

    } catch( uno::Exception& )

    {}

}

void OLESimpleStorage::UpdateOriginal_Impl()

{

    if ( m_bNoTemporaryCopy )

        return;

    uno::Reference< io::XSeekable > xSeek( m_xStream, uno::UNO_QUERY_THROW );

    xSeek->seek( 0 );

    uno::Reference< io::XSeekable > xTempSeek( m_xTempStream, uno::UNO_QUERY_THROW );

    sal_Int64 nPos = xTempSeek->getPosition();

    xTempSeek->seek( 0 );

    uno::Reference< io::XInputStream > xTempInp = m_xTempStream->getInputStream();

    uno::Reference< io::XOutputStream > xOutputStream = m_xStream->getOutputStream();

    if ( !xTempInp.is() || !xOutputStream.is() )

        throw uno::RuntimeException();

    uno::Reference< io::XTruncate > xTrunc( xOutputStream, uno::UNO_QUERY_THROW );

    xTrunc->truncate();

    ::comphelper::OStorageHelper::CopyInputToOutput( xTempInp, xOutputStream );

    xOutputStream->flush();

    xTempSeek->seek( nPos );

}

void OLESimpleStorage::InsertInputStreamToStorage_Impl( BaseStorage* pStorage, const OUString & aName, const uno::Reference< io::XInputStream >& xInputStream )

{

    if ( !pStorage || aName.isEmpty() || !xInputStream.is() )

        throw uno::RuntimeException();

    if ( pStorage->IsContained( aName ) )

        throw container::ElementExistException(); // TODO:

    std::unique_ptr<BaseStorageStream> pNewStream(pStorage->OpenStream( aName ));

    if ( !pNewStream || pNewStream->GetError() || pStorage->GetError() )

    {

        pNewStream.reset();

        pStorage->ResetError();

        throw io::IOException(); // TODO

    }

    try

    {

        uno::Sequence< sal_Int8 > aData( nBytesCount );

        sal_Int32 nRead = 0;

        do

        {

            nRead = xInputStream->readBytes( aData, nBytesCount );

            sal_Int32 nWritten = pNewStream->Write( aData.getConstArray(), nRead );

            if ( nWritten < nRead )

                throw io::IOException();

        } while( nRead == nBytesCount );

    }

    catch( uno::Exception& )

    {

        pNewStream.reset();

        pStorage->Remove( aName );

        throw;

    }

}

void OLESimpleStorage::InsertNameAccessToStorage_Impl( BaseStorage* pStorage, const OUString & aName, const uno::Reference< container::XNameAccess >& xNameAccess )

{

    if ( !pStorage || aName.isEmpty() || !xNameAccess.is() )

        throw uno::RuntimeException();

    if ( pStorage->IsContained( aName ) )

        throw container::ElementExistException(); // TODO:

    std::unique_ptr<BaseStorage> pNewStorage(pStorage->OpenStorage( aName ));

    if ( !pNewStorage || pNewStorage->GetError() || pStorage->GetError() )

    {

        pNewStorage.reset();

        pStorage->ResetError();

        throw io::IOException(); // TODO

    }

    try

    {

        const uno::Sequence< OUString > aElements = xNameAccess->getElementNames();

        for ( const auto& rElement : aElements )

        {

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

            uno::Reference< container::XNameAccess > xSubNameAccess;

            uno::Any aAny = xNameAccess->getByName( rElement );

            if ( aAny >>= xInputStream )

                InsertInputStreamToStorage_Impl( pNewStorage.get(), rElement, xInputStream );

            else if ( aAny >>= xSubNameAccess )

                InsertNameAccessToStorage_Impl( pNewStorage.get(), rElement, xSubNameAccess );

        }

    }

    catch( uno::Exception& )

    {

        pNewStorage.reset();

        pStorage->Remove( aName );

        throw;

    }

}

//  XNameContainer

void SAL_CALL OLESimpleStorage::insertByName( const OUString& aName, const uno::Any& aElement )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    uno::Reference< io::XStream > xStream;

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

    uno::Reference< container::XNameAccess > xNameAccess;

    try

    {

        if ( !m_bNoTemporaryCopy && !m_xStream.is() )

            throw io::IOException(); // TODO

        if ( aElement >>= xStream )

            xInputStream = xStream->getInputStream();

        else if ( !( aElement >>= xInputStream ) && !( aElement >>= xNameAccess ) )

            throw lang::IllegalArgumentException(); // TODO:

        if ( xInputStream.is() )

            InsertInputStreamToStorage_Impl( m_pStorage.get(), aName, xInputStream );

        else if ( xNameAccess.is() )

            InsertNameAccessToStorage_Impl( m_pStorage.get(), aName, xNameAccess );

        else

            throw uno::RuntimeException();

    }

    catch( uno::RuntimeException& )

    {

        throw;

    }

    catch( container::ElementExistException& )

    {

        throw;

    }

    catch( const uno::Exception& )

    {

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

        throw lang::WrappedTargetException(u"Insert has failed!"_ustr,

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

                                            anyEx );

    }

}

void SAL_CALL OLESimpleStorage::removeByName( const OUString& aName )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    if ( !m_bNoTemporaryCopy && !m_xStream.is() )

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

    if ( !m_pStorage->IsContained( aName ) )

        throw container::NoSuchElementException(); // TODO:

    m_pStorage->Remove( aName );

    if ( m_pStorage->GetError() )

    {

        m_pStorage->ResetError();

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

    }

}

void SAL_CALL OLESimpleStorage::replaceByName( const OUString& aName, const uno::Any& aElement )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    removeByName( aName );

    try

    {

        insertByName( aName, aElement );

    }

    catch( container::ElementExistException& )

    {

        uno::Any aCaught( ::cppu::getCaughtException() );

        throw lang::WrappedTargetException(u"Can't copy raw stream"_ustr,

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

                                            aCaught );

    }

}

uno::Any SAL_CALL OLESimpleStorage::getByName( const OUString& aName )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    if ( !m_pStorage->IsContained( aName ) )

        throw container::NoSuchElementException(); // TODO:

    uno::Any aResult;

    uno::Reference< io::XStream > xTempFile = io::TempFile::create(m_xContext);

    uno::Reference< io::XSeekable > xSeekable( xTempFile, uno::UNO_QUERY_THROW );

    uno::Reference< io::XOutputStream > xOutputStream = xTempFile->getOutputStream();

    uno::Reference< io::XInputStream > xInputStream = xTempFile->getInputStream();

    if ( !xOutputStream.is() || !xInputStream.is() )

        throw uno::RuntimeException();

    if ( m_pStorage->IsStorage( aName ) )

    {

        std::unique_ptr<BaseStorage> pStrg(m_pStorage->OpenStorage( aName ));

        m_pStorage->ResetError();

        if ( !pStrg )

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

        std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( xTempFile, false ); // do not close the original stream

        if ( !pStream )

            throw uno::RuntimeException();

        std::unique_ptr<BaseStorage> pNewStor(new Storage( *pStream, false ));

        bool bSuccess = ( pStrg->CopyTo( *pNewStor ) && pNewStor->Commit() &&

                          !pNewStor->GetError() && !pStrg->GetError() );

        pNewStor.reset();

        pStrg.reset();

        pStream.reset();

        if ( !bSuccess )

            throw uno::RuntimeException();

        uno::Reference< container::XNameContainer > xResultNameContainer(

            css::embed::OLESimpleStorage::createFromInputStream(m_xContext, xInputStream, true),

            uno::UNO_QUERY_THROW );

        aResult <<= xResultNameContainer;

    }

    else

    {

        std::unique_ptr<BaseStorageStream> pStream(m_pStorage->OpenStream( aName, StreamMode::READ | StreamMode::SHARE_DENYALL | StreamMode::NOCREATE ));

        try

        {

            if ( !pStream || pStream->GetError() || m_pStorage->GetError() )

            {

                m_pStorage->ResetError();

                throw io::IOException(); // TODO

            }

            uno::Sequence< sal_Int8 > aData( nBytesCount );

            sal_Int32 nSize = nBytesCount;

            sal_Int32 nRead = 0;

            while( 0 != ( nRead = pStream->Read( aData.getArray(), nSize ) ) )

            {

                if ( nRead < nSize )

                {

                    nSize = nRead;

                    aData.realloc( nSize );

                }

                xOutputStream->writeBytes( aData );

            }

            if ( pStream->GetError() )

                throw io::IOException(); // TODO

            xOutputStream->closeOutput();

            xSeekable->seek( 0 );

        }

        catch (const uno::RuntimeException&)

        {

            throw;

        }

        catch (const uno::Exception& ex)

        {

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

            throw css::lang::WrappedTargetException( ex.Message,

                    nullptr, anyEx );

        }

        pStream.reset();

        aResult <<= xInputStream;

    }

    return aResult;

}

uno::Sequence< OUString > SAL_CALL OLESimpleStorage::getElementNames()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    SvStorageInfoList aList;

    m_pStorage->FillInfoList( &aList );

    if ( m_pStorage->GetError() )

    {

        m_pStorage->ResetError();

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

    }

    uno::Sequence< OUString > aSeq( aList.size() );

    auto aSeqRange = asNonConstRange(aSeq);

    for ( size_t nInd = 0; nInd < aList.size(); nInd++ )

        aSeqRange[nInd] = aList[nInd].GetName();

    return aSeq;

}

sal_Bool SAL_CALL OLESimpleStorage::hasByName( const OUString& aName )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    bool bResult = m_pStorage->IsContained( aName );

    if ( m_pStorage->GetError() )

    {

        m_pStorage->ResetError();

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

    }

    return bResult;

}

uno::Type SAL_CALL OLESimpleStorage::getElementType()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    return cppu::UnoType<io::XInputStream>::get();

}

sal_Bool SAL_CALL OLESimpleStorage::hasElements()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    SvStorageInfoList aList;

    m_pStorage->FillInfoList( &aList );

    if ( m_pStorage->GetError() )

    {

        m_pStorage->ResetError();

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

    }

    return !aList.empty();

}

//  XComponent

void SAL_CALL OLESimpleStorage::dispose()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        return;

    if ( m_aListenersContainer.getLength(aGuard) )

    {

        lang::EventObject aSource( getXWeak() );

        m_aListenersContainer.disposeAndClear( aGuard, aSource );

    }

    m_pStorage.reset();

    m_pStream.reset();

    m_xStream.clear();

    m_xTempStream.clear();

    m_bDisposed = true;

}

void SAL_CALL OLESimpleStorage::addEventListener(

            const uno::Reference< lang::XEventListener >& xListener )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    m_aListenersContainer.addInterface( aGuard, xListener );

}

void SAL_CALL OLESimpleStorage::removeEventListener(

            const uno::Reference< lang::XEventListener >& xListener )

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    m_aListenersContainer.removeInterface( aGuard, xListener );

}

//  XTransactedObject

void SAL_CALL OLESimpleStorage::commit()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    if ( !m_bNoTemporaryCopy && !m_xStream.is() )

        throw io::IOException(); // TODO

    if ( !m_pStorage->Commit() || m_pStorage->GetError() )

    {

        m_pStorage->ResetError();

        throw io::IOException(); // TODO

    }

    UpdateOriginal_Impl();

}

void SAL_CALL OLESimpleStorage::revert()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    if ( !m_bNoTemporaryCopy && !m_xStream.is() )

        throw io::IOException(); // TODO

    if ( !m_pStorage->Revert() || m_pStorage->GetError() )

    {

        m_pStorage->ResetError();

        throw io::IOException(); // TODO

    }

    UpdateOriginal_Impl();

}

//  XClassifiedObject

uno::Sequence< sal_Int8 > SAL_CALL OLESimpleStorage::getClassID()

{

    std::unique_lock aGuard( m_aMutex );

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( !m_pStorage )

        throw uno::RuntimeException();

    return m_pStorage->GetClassName().GetByteSequence();

}

OUString SAL_CALL OLESimpleStorage::getClassName()

{

    return OUString();

}

void SAL_CALL OLESimpleStorage::setClassInfo( const uno::Sequence< sal_Int8 >& /*aClassID*/,

                            const OUString& /*sClassName*/ )

{

    throw lang::NoSupportException();

}

//  XServiceInfo

OUString SAL_CALL OLESimpleStorage::getImplementationName()

{

    return u"com.sun.star.comp.embed.OLESimpleStorage"_ustr;

}

sal_Bool SAL_CALL OLESimpleStorage::supportsService( const OUString& ServiceName )

{

    return cppu::supportsService(this, ServiceName);

}

uno::Sequence< OUString > SAL_CALL OLESimpleStorage::getSupportedServiceNames()

{

    return { u"com.sun.star.embed.OLESimpleStorage"_ustr };

}

extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *

com_sun_star_comp_embed_OLESimpleStorage(

    css::uno::XComponentContext *context,

    css::uno::Sequence<css::uno::Any> const &arguments)

{

    return cppu::acquire(new OLESimpleStorage(context, arguments));

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */