/**************************************************************
 * 
 * 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
//This file is about the conversion of the UOF v2.0 and ODF document format
#include "precompiled_filter.hxx"


#include "uof2storage.hxx"

#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/uno/Exception.hpp>
#include <rtl/ustrbuf.hxx>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/io/XStream.hpp>
#include <comphelper/storagehelper.hxx>
#include <com/sun/star/container/NoSuchElementException.hpp>
#include <com/sun/star/embed/XTransactedObject.hpp>

namespace XSLT{

namespace{

void lclSplitFirstElement( ::rtl::OUString& orElement, ::rtl::OUString& orRemainder, const ::rtl::OUString& rFullName )
{
	sal_Int32 nSlashPos = rFullName.indexOf('/');
	if((0 <= nSlashPos ) && (nSlashPos < rFullName.getLength()))
	{
		orElement = rFullName.copy(0, nSlashPos);
		orRemainder = rFullName.copy(nSlashPos+1);
	}
	else
	{
		orElement = rFullName;
	}
}

}

StorageBase::StorageBase( const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& rxInStream,
						 bool bBaseStreamAccess )
: m_xInStream(rxInStream)
, m_bBaseStreamAccess(bBaseStreamAccess)
, m_bReadOnly(true)
{
	OSL_ENSURE(m_xInStream.is(), "StorageBase::StorageBase - missing base input stream");
}

StorageBase::StorageBase( const ::com::sun::star::uno::Reference< ::com::sun::star::io::XStream >& rxOutStream, bool bBaseStreamAccess )
: m_xOutStream(rxOutStream)
, m_bBaseStreamAccess(bBaseStreamAccess)
, m_bReadOnly(false)
{
	OSL_ENSURE(m_xOutStream.is(), "StorageBase::StorageBase - missing base output stream");
}

StorageBase::StorageBase( const StorageBase& rParentStorage, const ::rtl::OUString& rStorageName, bool bReadOnly )
: m_aParentPath(rParentStorage.getPath())
, m_aStorageName(rStorageName)
, m_bBaseStreamAccess(false)
, m_bReadOnly(bReadOnly)
{
}

StorageBase::~StorageBase()
{
}

bool StorageBase::isStorage() const
{
	return implIsStorage();
}

bool StorageBase::isRootStorage() const
{
	return implIsStorage() && (m_aStorageName.getLength() == 0);
}

bool StorageBase::isReadOnly() const
{
	return m_bReadOnly;
}

::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > StorageBase::getXStorage() const
{
	return implGetXStorage();
}

const ::rtl::OUString& StorageBase::getName() const
{
	return m_aStorageName;
}

::rtl::OUString StorageBase::getPath() const
{
	::rtl::OUStringBuffer aBuffer(m_aParentPath);
	if(aBuffer.getLength() > 0)
	{
		aBuffer.append(sal_Unicode('/'));
	}

	aBuffer.append(m_aStorageName);
	return aBuffer.makeStringAndClear();
}

void StorageBase::getElementNames( ::std::vector< ::rtl::OUString >& orElementNames ) const
{
	orElementNames.clear();
	implGetElementNames(orElementNames);
}

XSLT::StorageRef StorageBase::openSubStorage( const ::rtl::OUString& rStorageName, bool bCreatedMissing )
{
	StorageRef xSubStorage;
	OSL_ENSURE(!bCreatedMissing || !m_bReadOnly, "StorageBase::openSubStorage - can not create substorage in read-only mode");
	if(!bCreatedMissing || !m_bReadOnly)
	{
		::rtl::OUString aElement, aRemainder;
		lclSplitFirstElement(aElement, aRemainder, rStorageName);
		if(aElement.getLength() > 0)
			xSubStorage = getSubStorage(aElement, bCreatedMissing);
		if(xSubStorage.get() && (aRemainder.getLength() > 0))
			xSubStorage = xSubStorage->openSubStorage(aRemainder, bCreatedMissing);
	}

	return xSubStorage;
}

::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > StorageBase::openInputStream( const ::rtl::OUString& rStreamName )
{
	::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > xInStream;
	::rtl::OUString aElement, aRemainder;
	lclSplitFirstElement(aElement, aRemainder, rStreamName);
	if(aElement.getLength() > 0)
	{
		if(aRemainder.getLength() > 0)
		{
			StorageRef xSubStorage = getSubStorage(aElement, false);
			if(xSubStorage.get())
				xInStream = xSubStorage->openInputStream(aRemainder);
		}
		else
		{
			xInStream = implOpenInputStream(aElement);
		}
	}
	else if(m_bBaseStreamAccess)
	{
		xInStream = m_xInStream;
	}

	return xInStream;
}

::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream > StorageBase::openOutputStream( const ::rtl::OUString& rStreamName )
{
	::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream > xOutStream;
	OSL_ENSURE(!m_bReadOnly, "StorageBase::openOutputStream - can not create output stream in read-only mode");
	if(!m_bReadOnly)
	{
		::rtl::OUString aElement, aRemainder;
		lclSplitFirstElement(aElement, aRemainder, rStreamName);
		if(aElement.getLength() > 0)
		{
			if(aRemainder.getLength() > 0)
			{
				StorageRef xSubStorage = getSubStorage(aElement, true);
				if(xSubStorage.get())
					xOutStream = xSubStorage->openOutputStream(aRemainder);
			}
			else
			{
				xOutStream = implOpenOutputStream(aElement);
			}
		}
		else if(m_bBaseStreamAccess)
		{
			xOutStream = m_xOutStream->getOutputStream();
		}
	}

	return xOutStream;
}

void StorageBase::copyToStorage( StorageBase& rDestStrg, const ::rtl::OUString& rElementName )
{
	OSL_ENSURE(rDestStrg.isStorage() && !rDestStrg.isReadOnly(), "StorageBase::copyToStorage - invalid destination");
	OSL_ENSURE(rElementName.getLength() > 0, "StorageBase::copyToStorage - invalid element name");
	if(rDestStrg.isStorage() && !rDestStrg.isReadOnly() && (rElementName.getLength() > 0))
	{
		StorageRef xSubStrg = openSubStorage(rElementName, false);
		if(xSubStrg.get())
		{
			StorageRef xDestSubStrg = rDestStrg.openSubStorage(rElementName, true);
			if(xDestSubStrg.get())
				xSubStrg->copyStorageToStorage(*xDestSubStrg);
		}
		else
		{
			::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > xInStrm = openInputStream(rElementName);
			if(xInStrm.get())
			{
				::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream > xOutStm = rDestStrg.openOutputStream(rElementName);
				if(xOutStm.is())
				{
					/*BinaryXInputStream aInStrm(xInStrm, true);
					BinaryXOutputStream aOutStrm(xOutStm, true);
					aInStrm.copyToStream(aOutStrm);*/
				}
			}
		}
	}
}

void StorageBase::copyStorageToStorage( StorageBase& rDestStrg )
{
	OSL_ENSURE(rDestStrg.isStorage() && !rDestStrg.isReadOnly(), "StorageBase::copyStorageToStorage - invalid destination");
	if(rDestStrg.isStorage() && !rDestStrg.isReadOnly())
	{
		::std::vector< ::rtl::OUString > aElements;
		getElementNames(aElements);
		for( ::std::vector< ::rtl::OUString >::iterator aIter = aElements.begin();
			aIter != aElements.end(); ++aIter)
			copyToStorage(rDestStrg, *aIter);
	}
}

void StorageBase::commit()
{
	OSL_ENSURE(!m_bReadOnly, "StorageBase::commit - can not commit in read-only mode");
	if(!m_bReadOnly)
	{
		m_aSubStorages.forEachMem(&StorageBase::commit);
		implCommit();
	}
}

XSLT::StorageRef StorageBase::getSubStorage( const ::rtl::OUString& rElementName, bool bCreateMissing )
{
	StorageRef& rxSubStrg = m_aSubStorages[rElementName];
	if(!rxSubStrg)
		rxSubStrg = implOpenSubStorage(rElementName, bCreateMissing);
	return rxSubStrg;
}

ZipStorage::ZipStorage( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rxFactory, const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& rxInStream )
: StorageBase(rxInStream, false)
{
	OSL_ENSURE(rxFactory.is(), "ZipStorage::ZipStorage - missing service factory");
	//create base storage object
	try
	{
		m_xStorage = ::comphelper::OStorageHelper::GetStorageOfFormatFromInputStream(
			ZIP_STORAGE_FORMAT_STRING, rxInStream, rxFactory, sal_True);
	}
	catch( ::com::sun::star::uno::Exception&)
	{
	}
}

ZipStorage::ZipStorage( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rxFactory, const ::com::sun::star::uno::Reference< ::com::sun::star::io::XStream >& rxStream )
: StorageBase(rxStream, false)
{
	OSL_ENSURE(rxFactory.is(), "ZipStorage::ZipStorage - missing service factory");
	try
	{
		using namespace ::com::sun::star::embed::ElementModes;
		m_xStorage = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream(
			ZIP_STORAGE_FORMAT_STRING, rxStream, READWRITE | TRUNCATE, rxFactory, sal_True);
	}
	catch( ::com::sun::star::uno::Exception& )
	{
		OSL_ENSURE(false, "ZipStorage::ZipStorage - can not open output storage");
	}
}

ZipStorage::ZipStorage( const ZipStorage& rParentStorage, const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& rxStorage, const ::rtl::OUString& rElementName )
: StorageBase(rParentStorage, rElementName, rParentStorage.isReadOnly())
, m_xStorage(rxStorage)
{
	OSL_ENSURE(m_xStorage.is(), "ZipStorage::ZipStorage - missing storage");
}

ZipStorage::~ZipStorage()
{

}

bool ZipStorage::implIsStorage() const
{
	return m_xStorage.is();
}

::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > ZipStorage::implGetXStorage() const
{
	return m_xStorage;
}

void ZipStorage::implGetElementNames( ::std::vector< ::rtl::OUString >& orElementNames ) const
{
	::com::sun::star::uno::Sequence< ::rtl::OUString > aNames;
	if(m_xStorage.is())
	{
		try
		{
			aNames = m_xStorage->getElementNames();
			if(aNames.getLength() > 0)
				orElementNames.insert(orElementNames.end(), aNames.getConstArray(), aNames.getConstArray()+aNames.getLength());
		}
		catch( ::com::sun::star::uno::Exception& )
		{
		}
	}
}

XSLT::StorageRef ZipStorage::implOpenSubStorage( const ::rtl::OUString& rElementName, bool bCreatedMissing )
{
	::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > xSubXStorage;
	bool bMissing = false;
	if(m_xStorage.is())
	{
		try
		{
			if(m_xStorage->isStorageElement(rElementName))
			{
				xSubXStorage = m_xStorage->openStorageElement(rElementName, ::com::sun::star::embed::ElementModes::READ);
			}
		}
		catch( ::com::sun::star::container::NoSuchElementException& )
		{
			bMissing = true;
		}
		catch( ::com::sun::star::uno::Exception& )
		{
		}
	}

	if(bMissing && bCreatedMissing)
	{
		try
		{
			xSubXStorage = m_xStorage->openStorageElement(rElementName, ::com::sun::star::embed::ElementModes::READWRITE);
		}
		catch( ::com::sun::star::uno::Exception& )
		{
		}
	}

	StorageRef xSubStorage;
	if(xSubXStorage.is())
		xSubStorage.reset(new ZipStorage( *this, xSubXStorage, rElementName ));

	return xSubStorage;
}

::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > ZipStorage::implOpenInputStream( const ::rtl::OUString& rElementName )
{
	::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > xInStream;
	if(m_xStorage.is())
	{
		try
		{
			xInStream.set(m_xStorage->openStreamElement(
				rElementName, ::com::sun::star::embed::ElementModes::READ), ::com::sun::star::uno::UNO_QUERY);
		}
		catch( ::com::sun::star::uno::Exception& )
		{
		}
	}

	return xInStream;
}

::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream > ZipStorage::implOpenOutputStream( const ::rtl::OUString& rElementName )
{
	::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream > xOutStream;
	if(m_xStorage.is())
	{
		try
		{
			xOutStream.set(m_xStorage->openStreamElement(
				rElementName, ::com::sun::star::embed::ElementModes::READWRITE), ::com::sun::star::uno::UNO_QUERY);
		}
		catch( ::com::sun::star::uno::Exception& )
		{
		}
	}

	return xOutStream;
}

void ZipStorage::implCommit() const
{
	try
	{
		::com::sun::star::uno::Reference< ::com::sun::star::embed::XTransactedObject > (m_xStorage, 
			::com::sun::star::uno::UNO_QUERY_THROW)->commit();
	}
	catch( ::com::sun::star::uno::Exception& )
	{
	}
}


UOF2Storage::UOF2Storage( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rxFactory,
						 const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& rxInStream )
: m_pMainStorage(new ZipStorage(rxFactory, rxInStream))
{
}

UOF2Storage::UOF2Storage( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rxFactory,
						 const ::com::sun::star::uno::Reference< ::com::sun::star::io::XStream >& rxOutStream )
: m_pMainStorage(new ZipStorage(rxFactory, rxOutStream))
{
}

UOF2Storage::~UOF2Storage()
{
}

::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > UOF2Storage::getMetaInputStream() const
{
	return m_pMainStorage->openInputStream(METAELEMNAME);
}

::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream > UOF2Storage::getMetaOutputStream( bool /*bMissingCreate*/ )
{
	return m_pMainStorage->openOutputStream(METAELEMNAME);
}

bool UOF2Storage::isValidUOF2Doc() const
{
	if(!m_pMainStorage->isStorage())
		return false;

	return ((getMetaInputStream().is()) 
		&& (m_pMainStorage->openInputStream(UOFELEMNAME).is())
		&& (m_pMainStorage->openInputStream(CONTENTELEMNAME).is()));
}

}