/*
* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
* Definition of the Swi::CCompressedDataProvider
*
*/


#include <ezdecompressor.h>
#include <ezstream.h>

#include "compresseddataprovider.h"

using namespace Swi;

/*static*/ CCompressedDataProvider* CCompressedDataProvider::NewLC(MSisDataProvider& aDataProvider,
															       TInt aBufferSize)
	{
	CCompressedDataProvider* self = new(ELeave) CCompressedDataProvider(aDataProvider);
	CleanupStack::PushL(self);
	self->ConstructL(aBufferSize);
	return self;
	}

/*static*/ CCompressedDataProvider* CCompressedDataProvider::NewL(MSisDataProvider& aDataProvider,
																  TInt aBufferSize)
	{
	CCompressedDataProvider* self = NewLC(aDataProvider, aBufferSize);
	CleanupStack::Pop(self);
	return self;
	}

CCompressedDataProvider::CCompressedDataProvider(MSisDataProvider& aDataProvider) : iDataProvider(aDataProvider), 
																					iInputDescriptor(NULL,0), 
																					iOutputDescriptor(NULL,0),
																					iMore(ETrue)
	{	
	}

void CCompressedDataProvider::ConstructL(TInt aBufferSize)
	{
	TInt bufferSize;
	if (aBufferSize > KDeflateBufferMaxSize)
		{
		bufferSize = KDeflateBufferMaxSize;
		}
	else
		{
		bufferSize = aBufferSize;
		}
	
	iInputBuffer = HBufC8::NewL(bufferSize);
    iOutputBuffer = HBufC8::NewL(bufferSize);
	iInputDescriptor.Set(iInputBuffer->Des());
	iOutputDescriptor.Set(iOutputBuffer->Des());
	iDecompressor = CEZDecompressor::NewL(*this);
	iBuffer = CBufFlat::NewL(bufferSize);
	}

CCompressedDataProvider::~CCompressedDataProvider()
	{
	delete iDecompressor;
    delete iInputBuffer;
    delete iOutputBuffer;
    delete iBuffer;	
	}
    
TInt CCompressedDataProvider::Read(TDes8& aDes)
	{
	return Read(aDes, aDes.MaxSize());
	}

TInt CCompressedDataProvider::Read(TDes8& aDes, TInt aLength)
	{ 	
	if (aLength < 0)                  // Cannot read a negative amount of data!
		{
		return KErrArgument;
		}

	if (aLength > aDes.MaxSize())     // The descriptor is not big enough
		{
		return KErrOverflow;
		}

	TInt needed = aLength;
	
	if (aLength > iBuffer->Size())    // will still need to decompress more
		{
		iBuffer->Read(0, aDes, iBuffer->Size()); // read any buffered data
		needed -= iBuffer->Size();
		iBuffer->Reset(); // all data has been read, free the memory
		}
	else
		{  	                          // enough data in the buffer no need to decompress more
		iBuffer->Read(0, aDes, aLength);	// read the whole length from buffered data
		iBuffer->Delete(0, aLength); // delete the data that has been read from the buffer
		return KErrNone;		
		}
	
	// Not enough data buffered yet... 
	// We need to uncompress more data! (if available)

	if (!iMore)  // no more data to uncompress
		{
		return KErrNone;
		}

	// If we are here we used up all the buffered data!!

	while (iMore)
		{
		TRAPD(error, iMore = iDecompressor->InflateL());
		if(KErrNone != error)
			{
			return error;
			}
		
		TInt currentLength = aDes.Length();	
		
		if (needed > iBuffer->Size())    // will still need to decompress more
			{
			// Append the new data to the descriptor
			aDes.SetLength(currentLength + iBuffer->Size());
			TPtr8 rest = aDes.MidTPtr(currentLength, iBuffer->Size()); 
			iBuffer->Read(0, rest, iBuffer->Size()); // read the buffered data
			needed -= iBuffer->Size();
			iBuffer->Reset(); // all data has been read, free the memory
			}
		else
			{  	                          // enough data in the buffer no need to decompress more
			// Append the new data to the descriptor
			aDes.SetLength(currentLength + needed);
			TPtr8 rest = aDes.MidTPtr(currentLength, needed); 
			iBuffer->Read(0, rest, needed); // read the needed amount from buffered data
			iBuffer->Delete(0, needed); // delete the data that has been read from the buffer
			return KErrNone;		
			}

		if ((!iMore) || (needed==0))  // no more data to uncompress or needed
			{
			return KErrNone;
			}
		}
	return KErrGeneral;
	}

TInt CCompressedDataProvider::Seek(TSeek /*aMode*/, TInt64& /*aPos*/)
	{
	// we cannot seek on a compressed stream at the moment!
	return KErrNotSupported;
	}


void CCompressedDataProvider::InitializeL(CEZZStream& aZStream)
	{
	User::LeaveIfError(iDataProvider.Read(iInputDescriptor));

	aZStream.SetInput(iInputDescriptor);
	aZStream.SetOutput(iOutputDescriptor);
	}

void CCompressedDataProvider::NeedInputL(CEZZStream& aZStream)
	{
	User::LeaveIfError(iDataProvider.Read(iInputDescriptor));
	aZStream.SetInput(iInputDescriptor);
	}

void CCompressedDataProvider::NeedOutputL(CEZZStream& aZStream)
	{
	TPtrC8 od = aZStream.OutputDescriptor();
	iBuffer->InsertL(iBuffer->Size(), od);    // Should really check we are not blowing everything up!!!
	iOutputDescriptor.SetLength(0); // reset since data now stored in buffer
	aZStream.SetOutput(iOutputDescriptor);
	}

void CCompressedDataProvider::FinalizeL(CEZZStream& aZStream)
	{
	TPtrC8 od = aZStream.OutputDescriptor();
	iBuffer->InsertL(iBuffer->Size(), od);
	}