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

 */

/**************************************************************************

                                TODO

 **************************************************************************

 - remove root storage access workaround

 *************************************************************************/

#include <comphelper/diagnose_ex.hxx>

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

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

#include <com/sun/star/reflection/ProxyFactory.hpp>

#include <utility>

#include "tdoc_docmgr.hxx"

#include "tdoc_uri.hxx"

#include "tdoc_stgelems.hxx"

using namespace com::sun::star;

using namespace tdoc_ucp;

// ParentStorageHolder Implementation.

ParentStorageHolder::ParentStorageHolder(

            uno::Reference< embed::XStorage > xParentStorage,

            const OUString & rUri )

: m_xParentStorage(std::move( xParentStorage )),

  m_bParentIsRootStorage( false )

{

    Uri aUri( rUri );

    if ( aUri.isDocument() )

        m_bParentIsRootStorage = true;

}

// Storage Implementation.

Storage::Storage( const uno::Reference< uno::XComponentContext > & rxContext,

                  rtl::Reference< StorageElementFactory > xFactory,

                  const OUString & rUri,

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

                  const uno::Reference< embed::XStorage > & xStorageToWrap )

: ParentStorageHolder( xParentStorage, Uri( rUri ).getParentUri() ),

  m_xFactory(std::move( xFactory )),

  m_xWrappedStorage( xStorageToWrap ),

  m_xWrappedTransObj( xStorageToWrap, uno::UNO_QUERY ), // optional interface

  m_xWrappedComponent( xStorageToWrap ),

  m_xWrappedTypeProv( xStorageToWrap, uno::UNO_QUERY ),

  m_bIsDocumentStorage( Uri( rUri ).isDocument() )

{

    OSL_ENSURE( m_xWrappedStorage.is(),

                "Storage::Storage: No storage to wrap!" );

    OSL_ENSURE( m_xWrappedComponent.is(),

                "Storage::Storage: No component to wrap!" );

    OSL_ENSURE( m_xWrappedTypeProv.is(),

                "Storage::Storage: No Type Provider!" );

    // Use proxy factory service to create aggregatable proxy.

    try

    {

        uno::Reference< reflection::XProxyFactory > xProxyFac =

            reflection::ProxyFactory::create( rxContext );

        m_xAggProxy = xProxyFac->createProxy( m_xWrappedStorage );

    }

    catch ( uno::Exception const & )

    {

        TOOLS_WARN_EXCEPTION("ucb.ucp", "");

    }

    OSL_ENSURE( m_xAggProxy.is(),

                "Storage::Storage: Wrapped storage cannot be aggregated!" );

    if ( !m_xAggProxy.is() )

        return;

    osl_atomic_increment( &m_refCount );

    {

        // Solaris compiler problem:

        // Extra block to enforce destruction of temporary object created

        // in next statement _before_ osl_atomic_decrement is

        // called.  Otherwise 'this' will destroy itself even before ctor

        // is completed (See impl. of XInterface::release())!

        m_xAggProxy->setDelegator(

            getXWeak() );

    }

    osl_atomic_decrement( &m_refCount );

}

// virtual

Storage::~Storage()

{

    if ( m_xAggProxy.is() )

        m_xAggProxy->setDelegator( uno::Reference< uno::XInterface >() );

    // Never dispose a document storage. Not owner!

    if ( m_bIsDocumentStorage )

        return;

    if ( !m_xWrappedComponent.is() )

        return;

    // "Auto-dispose"...

    try

    {

        m_xWrappedComponent->dispose();

    }

    catch ( lang::DisposedException const & )

    {

        // might happen.

    }

    catch ( ... )

    {

        TOOLS_WARN_EXCEPTION( "ucb", "Storage::~Storage - Caught exception!" );

    }

}

// uno::XInterface

// virtual

uno::Any SAL_CALL Storage::queryInterface( const uno::Type& aType )

{

    // First, try to use interfaces implemented by myself and base class(es)

    uno::Any aRet = StorageUNOBase::queryInterface( aType );

    if ( aRet.hasValue() )

        return aRet;

    // Try to use requested interface from aggregated storage

    return m_xAggProxy->queryAggregation( aType );

}

// virtual

void SAL_CALL Storage::acquire()

    noexcept

{

    osl_atomic_increment( &m_refCount );

}

// virtual

void SAL_CALL Storage::release()

    noexcept

{

    //#i120738, Storage::release overrides OWeakObject::release(),

    //need call OWeakObject::release() to release OWeakObject::m_pWeakConnectionPoint

    if ( m_refCount == 1 )

        m_xFactory->releaseElement( this );

    //delete this;

    OWeakObject::release();

}

// lang::XTypeProvider

// virtual

uno::Sequence< uno::Type > SAL_CALL Storage::getTypes()

{

    return m_xWrappedTypeProv->getTypes();

}

// virtual

uno::Sequence< sal_Int8 > SAL_CALL Storage::getImplementationId()

{

    return css::uno::Sequence<sal_Int8>();

}

// lang::XComponent (base of embed::XStorage)

// virtual

void SAL_CALL Storage::dispose()

{

    m_xWrappedStorage->dispose();

    m_xWrappedStorage.clear();

}

// virtual

void SAL_CALL Storage::addEventListener(

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

{

    m_xWrappedStorage->addEventListener( xListener );

}

// virtual

void SAL_CALL Storage::removeEventListener(

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

{

    m_xWrappedStorage->removeEventListener( aListener );

}

// container::XElementAccess (base of container::XNameAccess)

// virtual

uno::Type SAL_CALL Storage::getElementType()

{

    return m_xWrappedStorage->getElementType();

}

// virtual

sal_Bool SAL_CALL Storage::hasElements()

{

    return m_xWrappedStorage->hasElements();

}

// container::XNameAccess (base of embed::XStorage)

// virtual

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

{

    return m_xWrappedStorage->getByName( aName );

}

// virtual

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

{

    return m_xWrappedStorage->getElementNames();

}

// virtual

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

{

    return m_xWrappedStorage->hasByName( aName );

}

// embed::XStorage

// virtual

void SAL_CALL Storage::copyToStorage(

        const uno::Reference< embed::XStorage >& xDest )

{

    m_xWrappedStorage->copyToStorage( xDest );

}

// virtual

uno::Reference< io::XStream > SAL_CALL Storage::openStreamElement(

        const OUString& aStreamName, sal_Int32 nOpenMode )

{

    return m_xWrappedStorage->openStreamElement( aStreamName, nOpenMode );

}

// virtual

uno::Reference< io::XStream > SAL_CALL Storage::openEncryptedStreamElement(

        const OUString& aStreamName,

        sal_Int32 nOpenMode,

        const OUString& aPassword )

{

    return m_xWrappedStorage->openEncryptedStreamElement(

        aStreamName, nOpenMode, aPassword );

}

// virtual

uno::Reference< embed::XStorage > SAL_CALL Storage::openStorageElement(

        const OUString& aStorName, sal_Int32 nOpenMode )

{

    return m_xWrappedStorage->openStorageElement( aStorName, nOpenMode );

}

// virtual

uno::Reference< io::XStream > SAL_CALL Storage::cloneStreamElement(

        const OUString& aStreamName )

{

    return m_xWrappedStorage->cloneStreamElement( aStreamName );

}

// virtual

uno::Reference< io::XStream > SAL_CALL Storage::cloneEncryptedStreamElement(

        const OUString& aStreamName,

        const OUString& aPassword )

{

    return m_xWrappedStorage->cloneEncryptedStreamElement( aStreamName,

                                                           aPassword );

}

// virtual

void SAL_CALL Storage::copyLastCommitTo(

        const uno::Reference< embed::XStorage >& xTargetStorage )

{

    m_xWrappedStorage->copyLastCommitTo( xTargetStorage );

}

// virtual

void SAL_CALL Storage::copyStorageElementLastCommitTo(

        const OUString& aStorName,

        const uno::Reference< embed::XStorage >& xTargetStorage )

{

    m_xWrappedStorage->copyStorageElementLastCommitTo( aStorName, xTargetStorage );

}

// virtual

sal_Bool SAL_CALL Storage::isStreamElement(

        const OUString& aElementName )

{

    return m_xWrappedStorage->isStreamElement( aElementName );

}

// virtual

sal_Bool SAL_CALL Storage::isStorageElement(

        const OUString& aElementName )

{

    return m_xWrappedStorage->isStorageElement( aElementName );

}

// virtual

void SAL_CALL Storage::removeElement( const OUString& aElementName )

{

    m_xWrappedStorage->removeElement( aElementName );

}

// virtual

void SAL_CALL Storage::renameElement( const OUString& aEleName,

                                      const OUString& aNewName )

{

    m_xWrappedStorage->renameElement( aEleName, aNewName );

}

// virtual

void SAL_CALL Storage::copyElementTo(

        const OUString& aElementName,

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

        const OUString& aNewName )

{

    m_xWrappedStorage->copyElementTo( aElementName, xDest, aNewName );

}

// virtual

void SAL_CALL Storage::moveElementTo(

        const OUString& aElementName,

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

        const OUString& rNewName )

{

    m_xWrappedStorage->moveElementTo( aElementName, xDest, rNewName );

}

// embed::XTransactedObject

// virtual

void SAL_CALL Storage::commit()

{

    // Never commit a root storage (-> has no parent)!

    // Would lead in writing the whole document to disk.

    uno::Reference< embed::XStorage > xParentStorage = getParentStorage();

    if ( !xParentStorage.is() )

        return;

    OSL_ENSURE( m_xWrappedTransObj.is(), "No XTransactedObject interface!" );

    if ( !m_xWrappedTransObj.is() )

        return;

    m_xWrappedTransObj->commit();

    if ( !isParentARootStorage() )

    {

        uno::Reference< embed::XTransactedObject > xParentTA(

            xParentStorage, uno::UNO_QUERY );

        OSL_ENSURE( xParentTA.is(), "No XTransactedObject interface!" );

        if ( xParentTA.is() )

            xParentTA->commit();

    }

}

// virtual

void SAL_CALL Storage::revert()

{

    uno::Reference< embed::XStorage > xParentStorage = getParentStorage();

    if ( !xParentStorage.is() )

        return;

    OSL_ENSURE( m_xWrappedTransObj.is(), "No XTransactedObject interface!" );

    if ( !m_xWrappedTransObj.is() )

        return;

    m_xWrappedTransObj->revert();

    if ( !isParentARootStorage() )

    {

        uno::Reference< embed::XTransactedObject > xParentTA(

            xParentStorage, uno::UNO_QUERY );

        OSL_ENSURE( xParentTA.is(), "No XTransactedObject interface!" );

        if ( xParentTA.is() )

            xParentTA->revert();

    }

}

// OutputStream Implementation.

OutputStream::OutputStream(

            const uno::Reference< uno::XComponentContext > & rxContext,

            const OUString & rUri,

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

            const uno::Reference< io::XOutputStream > & xStreamToWrap )

: ParentStorageHolder( xParentStorage, Uri( rUri ).getParentUri() ),

  m_xWrappedStream( xStreamToWrap ),

  m_xWrappedComponent( xStreamToWrap, uno::UNO_QUERY ),

  m_xWrappedTypeProv( xStreamToWrap, uno::UNO_QUERY )

{

    OSL_ENSURE( m_xWrappedStream.is(),

                "OutputStream::OutputStream: No stream to wrap!" );

    OSL_ENSURE( m_xWrappedComponent.is(),

                "OutputStream::OutputStream: No component to wrap!" );

    OSL_ENSURE( m_xWrappedTypeProv.is(),

                "OutputStream::OutputStream: No Type Provider!" );

    // Use proxy factory service to create aggregatable proxy.

    try

    {

        uno::Reference< reflection::XProxyFactory > xProxyFac =

            reflection::ProxyFactory::create( rxContext );

        m_xAggProxy = xProxyFac->createProxy( m_xWrappedStream );

    }

    catch ( uno::Exception const & )

    {

        TOOLS_WARN_EXCEPTION("ucb.ucp", "");

    }

    OSL_ENSURE( m_xAggProxy.is(),

            "OutputStream::OutputStream: Wrapped stream cannot be aggregated!" );

    if ( !m_xAggProxy.is() )

        return;

    osl_atomic_increment( &m_refCount );

    {

        // Solaris compiler problem:

        // Extra block to enforce destruction of temporary object created

        // in next statement _before_ osl_atomic_decrement is

        // called.  Otherwise 'this' will destroy itself even before ctor

        // is completed (See impl. of XInterface::release())!

        m_xAggProxy->setDelegator(

            getXWeak() );

    }

    osl_atomic_decrement( &m_refCount );

}

// virtual

OutputStream::~OutputStream()

{

    if ( m_xAggProxy.is() )

        m_xAggProxy->setDelegator( uno::Reference< uno::XInterface >() );

}

// uno::XInterface

// virtual

uno::Any SAL_CALL OutputStream::queryInterface( const uno::Type& aType )

{

    uno::Any aRet = OutputStreamUNOBase::queryInterface( aType );

    if ( aRet.hasValue() )

        return aRet;

    if ( m_xAggProxy.is() )

        return m_xAggProxy->queryAggregation( aType );

    else

        return uno::Any();

}

// lang::XTypeProvider

// virtual

uno::Sequence< uno::Type > SAL_CALL OutputStream::getTypes()

{

    return m_xWrappedTypeProv->getTypes();

}

// virtual

uno::Sequence< sal_Int8 > SAL_CALL OutputStream::getImplementationId()

{

    return css::uno::Sequence<sal_Int8>();

}

// io::XOutputStream

// virtual

void SAL_CALL

OutputStream::writeBytes( const uno::Sequence< sal_Int8 >& aData )

{

    m_xWrappedStream->writeBytes( aData );

}

// virtual

void SAL_CALL

OutputStream::flush()

{

    m_xWrappedStream->flush();

}

// virtual

void SAL_CALL

OutputStream::closeOutput(  )

{

    m_xWrappedStream->closeOutput();

    // Release parent storage.

    // Now, that the stream is closed/disposed it is not needed any longer.

    clearParentStorage();

}

// lang::XComponent

// virtual

void SAL_CALL

OutputStream::dispose()

{

    m_xWrappedComponent->dispose();

    // Release parent storage.

    // Now, that the stream is closed/disposed it is not needed any longer.

    clearParentStorage();

}

// virtual

void SAL_CALL

OutputStream::addEventListener(

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

{

    m_xWrappedComponent->addEventListener( xListener );

}

// virtual

void SAL_CALL

OutputStream::removeEventListener(

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

{

    m_xWrappedComponent->removeEventListener( aListener );

}

// Stream Implementation.

Stream::Stream(

            const uno::Reference< uno::XComponentContext > & rxContext,

            rtl::Reference<OfficeDocumentsManager> const & docsMgr,

            const OUString & rUri,

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

            const uno::Reference< io::XStream > & xStreamToWrap )

: ParentStorageHolder( xParentStorage, Uri( rUri ).getParentUri() ),

  m_docsMgr(docsMgr),

  m_uri(rUri),

  m_xWrappedStream( xStreamToWrap ),

  m_xWrappedOutputStream( xStreamToWrap->getOutputStream() ), // might be empty

  m_xWrappedTruncate( m_xWrappedOutputStream, uno::UNO_QUERY ), // might be empty

  m_xWrappedInputStream( xStreamToWrap->getInputStream() ),

  m_xWrappedComponent( xStreamToWrap, uno::UNO_QUERY ),

  m_xWrappedTypeProv( xStreamToWrap, uno::UNO_QUERY )

{

    OSL_ENSURE( m_xWrappedStream.is(),

                "OutputStream::OutputStream: No stream to wrap!" );

    OSL_ENSURE( m_xWrappedComponent.is(),

                "OutputStream::OutputStream: No component to wrap!" );

    OSL_ENSURE( m_xWrappedTypeProv.is(),

                "OutputStream::OutputStream: No Type Provider!" );

    // Use proxy factory service to create aggregatable proxy.

    try

    {

        uno::Reference< reflection::XProxyFactory > xProxyFac =

            reflection::ProxyFactory::create( rxContext );

        m_xAggProxy = xProxyFac->createProxy( m_xWrappedStream );

    }

    catch ( uno::Exception const & )

    {

        TOOLS_WARN_EXCEPTION("ucb.ucp", "");

    }

    OSL_ENSURE( m_xAggProxy.is(),

            "OutputStream::OutputStream: Wrapped stream cannot be aggregated!" );

    if ( !m_xAggProxy.is() )

        return;

    osl_atomic_increment( &m_refCount );

    {

        // Solaris compiler problem:

        // Extra block to enforce destruction of temporary object created

        // in next statement _before_ osl_atomic_decrement is

        // called.  Otherwise 'this' will destroy itself even before ctor

        // is completed (See impl. of XInterface::release())!

        m_xAggProxy->setDelegator(

            getXWeak() );

    }

    osl_atomic_decrement( &m_refCount );

}

// virtual

Stream::~Stream()

{

    if ( m_xAggProxy.is() )

        m_xAggProxy->setDelegator( uno::Reference< uno::XInterface >() );

}

// uno::XInterface

// virtual

uno::Any SAL_CALL Stream::queryInterface( const uno::Type& aType )

{

    uno::Any aRet = StreamUNOBase::queryInterface( aType );

    if ( aRet.hasValue() )

        return aRet;

    if ( m_xAggProxy.is() )

        return m_xAggProxy->queryAggregation( aType );

    else

        return uno::Any();

}

// lang::XTypeProvider

// virtual

uno::Sequence< uno::Type > SAL_CALL Stream::getTypes()

{

    return m_xWrappedTypeProv->getTypes();

}

// virtual

uno::Sequence< sal_Int8 > SAL_CALL Stream::getImplementationId()

{

    return css::uno::Sequence<sal_Int8>();

}

// io::XStream.

// virtual

uno::Reference< io::XInputStream > SAL_CALL Stream::getInputStream()

{

    return uno::Reference< io::XInputStream >( this );

}

// virtual

uno::Reference< io::XOutputStream > SAL_CALL Stream::getOutputStream()

{

    return uno::Reference< io::XOutputStream >( this );

}

// io::XOutputStream.

// virtual

void SAL_CALL Stream::writeBytes( const uno::Sequence< sal_Int8 >& aData )

{

    if ( m_xWrappedOutputStream.is() )

    {

        m_xWrappedOutputStream->writeBytes( aData );

        commitChanges();

    }

}

// virtual

void SAL_CALL Stream::flush()

{

    if ( m_xWrappedOutputStream.is() )

    {

        m_xWrappedOutputStream->flush();

        commitChanges();

    }

}

// virtual

void SAL_CALL Stream::closeOutput()

{

    if ( m_xWrappedOutputStream.is() )

    {

        m_xWrappedOutputStream->closeOutput();

        commitChanges();

    }

    // Release parent storage.

    // Now, that the stream is closed/disposed it is not needed any longer.

    clearParentStorage();

}

// io::XTruncate.

// virtual

void SAL_CALL Stream::truncate()

{

    if ( m_xWrappedTruncate.is() )

    {

        m_xWrappedTruncate->truncate();

        commitChanges();

    }

}

// io::XInputStream.

// virtual

sal_Int32 SAL_CALL Stream::readBytes( uno::Sequence< sal_Int8 >& aData,

                                      sal_Int32 nBytesToRead )

{

    return m_xWrappedInputStream->readBytes( aData, nBytesToRead );

}

// virtual

sal_Int32 SAL_CALL Stream::readSomeBytes( uno::Sequence< sal_Int8 >& aData,

                                          sal_Int32 nMaxBytesToRead )

{

    return m_xWrappedInputStream->readSomeBytes( aData, nMaxBytesToRead );

}

// virtual

void SAL_CALL Stream::skipBytes( sal_Int32 nBytesToSkip )

{

    m_xWrappedInputStream->skipBytes( nBytesToSkip );

}

// virtual

sal_Int32 SAL_CALL Stream::available()

{

    return m_xWrappedInputStream->available();

}

// virtual

void SAL_CALL Stream::closeInput()

{

    m_xWrappedInputStream->closeInput();

}

// lang::XComponent

// virtual

void SAL_CALL Stream::dispose()

{

    m_xWrappedComponent->dispose();

    // Release parent storage.

    // Now, that the stream is closed/disposed it is not needed any longer.

    clearParentStorage();

}

// virtual

void SAL_CALL Stream::addEventListener(

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

{

    m_xWrappedComponent->addEventListener( xListener );

}

// virtual

void SAL_CALL Stream::removeEventListener(

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

{

    m_xWrappedComponent->removeEventListener( aListener );

}

// Non-UNO

void Stream::commitChanges()

{

    uno::Reference< embed::XTransactedObject >

        xParentTA( getParentStorage(), uno::UNO_QUERY );

    OSL_ENSURE( xParentTA.is(), "No XTransactedObject interface!" );

    if ( xParentTA.is() )

    {

        try

        {

            xParentTA->commit();

        }

        catch ( lang::WrappedTargetException const & )

        {

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

        }

    }

    m_docsMgr->updateStreamDateModified(m_uri);

}

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