// 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 "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:

// Implementation of CBufferFileWriter and CBufferReader

// 

//

/**

 @file

*/

#include "sbebufferhandler.h"

#include "sblog.h"

#include <connect/panic.h>

namespace conn

	{

	template<class T>

	TBool ReadFromBufferF(T& aT, TUint8*& appCurrent, const TUint8* apEnd)

	/** Template class to read flat structures from the buffer

	@param aT on return the flat structure.

	@param appCurrent The current point into the buffer.

	@param apEnd The end of the buffer.

	@return ETrue if read succesfully. EFalse if a retry is needed.

	*/

		{

		static TBuf8<sizeof(T)> SBuffer; // Static buffer used for buffering!

		TBool ret = EFalse;

		// Is there anything already in the buffer?

		TUint8* ptr = NULL;

		if (SBuffer.Size() > 0)

			{

			TInt size = SBuffer.Size();

			SBuffer.Append(appCurrent, sizeof(T) - size);

			ptr = const_cast<TUint8*>(SBuffer.Ptr());

			appCurrent += sizeof(T) - size;

			ret = ETrue;

			} // if

		else

			{

			// Is there enough room in current

			if ((apEnd - appCurrent) < static_cast<TInt>(sizeof(T)))

				{

				// Need to buffer

				SBuffer.Copy(appCurrent, apEnd - appCurrent);

				} // if

			else

				{

				ptr = appCurrent;

				appCurrent += sizeof(T);

				ret = ETrue;

				} // else

			} // else

		if (ret)

			{

			// Use a loop to copy to avoid alignment issues

			TUint8* ptrOut = reinterpret_cast<TUint8*>(&aT);

			for (TUint x = 0; x < sizeof(T); x++)

				{

				*ptrOut++ = *ptr++;

				} // for

			SBuffer.SetLength(0);

			}

		return ret;

		}

	template TBool ReadFromBufferF<TFileFixedHeader>(TFileFixedHeader&, TUint8*&, const TUint8*);

	template TBool ReadFromBufferF<TSnapshot>(TSnapshot&, TUint8*&, const TUint8*);

	template<class T>

	TBool WriteToBufferF(T& aT, TPtr8& aPtr)

	/** Writes flat structures to the buffer.

	NOTE: This should _ONLY_ be used to write T classes to the buffer.

	@param aT The flat structure to write to the buffer.

	@param ptr The buffer to write to.

	@return ETrue on success. EFalse on failure.

	*/

		{

		TBool ret = EFalse;

		if ((aPtr.MaxSize() - aPtr.Size()) >= static_cast<TInt>(sizeof(T)))

			{

			aPtr.Append(reinterpret_cast<TUint8*>(&aT), sizeof(T));

			ret = ETrue;

			} // if

		return ret;

		}

	TBool ReadFromBufferV(TPtr8& aT, TInt aSize, TUint8*& appCurrent, const TUint8* apEnd)

	/** Reads from the buffer.

	@param aT on return the data read.

	@param aSize size of the data to read.

	@param appCurrent Pointer to read from.

	@param apEnd the end of the data.

	@return ETrue on success. EFalse on failure.

	*/

		{

		TBool ret = EFalse;

		// Does into already contain data?

		if (aT.Size() > 0)

			{

			TInt tocopy = aSize - aT.Size();

			aT.Append(appCurrent, tocopy);

			appCurrent += tocopy;

			ret = ETrue;

			} // if

		else

			{

			// Is there enough data?

			if ((apEnd - appCurrent) < aSize)

				{

				aT.Copy(appCurrent, apEnd - appCurrent);

				appCurrent = const_cast<TUint8*>(apEnd);

				} // if

			else

				{

				aT.Copy(appCurrent, aSize);

				appCurrent += aSize;

				ret = ETrue;

				} // else

			} // else

		return ret;

		}

	TBool WriteToBufferV(const TPtr8& aPtr, TInt aSize, TPtr8& aBuffer)

	/** Writes some vairable data to the buffer.

	NOTE: This should _ONLY_ be used to write T classes to the buffer.

	@param aPtr buffer to read from.

	@param aSize size of the data to write.

	@param aBuffer the buffer to write to.

	@return ETrue on success. EFalse on failure.

	*/

		{

		TBool ret = EFalse;

		if ((aBuffer.MaxSize() - aBuffer.Size()) >= aSize)

			{

			aBuffer.Append(aPtr.Ptr(), aSize);

			ret = ETrue;

			} // if

		return ret;

		}

	CBufferFileWriter* CBufferFileWriter::NewL(RFs& aFs, CDesCArray* aFileNames)

	/** Symbain constructor

	@param aFs Handle to the Symbian Fs file server

	@param aFileNames list of files to write ownership transfer

	@return a CBufferFileWriter.

	*/

		{

		CBufferFileWriter* self = new(ELeave) CBufferFileWriter(aFs, aFileNames);

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop(self);

		return self;

		} // NewL

	CBufferFileWriter::CBufferFileWriter(RFs& aFs, CDesCArray* aFileNames) :

		iFs(aFs), iFileNames(aFileNames)

	/** Standard C++ constructor

	@param aFs an RFS to use in this class.

	*/

		{

		} // CBufferFileWriter

	CBufferFileWriter::~CBufferFileWriter()

	/** Standard C++ destructor

	*/

		{

		delete iFileNames;

		iFileHandle.Close();

		}

	void CBufferFileWriter::ConstructL()

	/** Symbain second phase constructor

	@param aFileNames list of files to write

	*/

		{

		#if defined(SBE_LOGGING_ENABLED)

		if (iFileNames)

			{

			TUint count = iFileNames->Count();

			while(count--)

				{

				const TDesC& fileName = (*iFileNames)[count];

            	__LOG2("CBufferFileWriter::ConstructL() - file[%04d] is: %S", count, &fileName);

				}

			}

		#endif

		}

	void CBufferFileWriter::StartL(TPtr8& aBuffer, TBool& aCompleted)

	/** Start writing the files to the buffer

	@param aBuffer The buffer to write to.

	@param aCompleted on return if we have finished.

	*/

		{

        __LOG("CBufferFileWriter::StartL() - START");

		WriteToBufferL(aBuffer, aCompleted);

        __LOG("CBufferFileWriter::StartL() - END");

		} // StartL

	void CBufferFileWriter::ContinueL(TPtr8& aBuffer, TBool& aCompleted)

	/** Continue writing the files to the buffer

	@param aBuffer The buffer to write to.

	@param aCompleted on return if we have finished.

	*/

		{

        __LOG("CBufferFileWriter::ContinueL() - START");

		WriteToBufferL(aBuffer, aCompleted);

        __LOG("CBufferFileWriter::ContinueL() - END");

		}

	void CBufferFileWriter::WriteToBufferL(TPtr8& aBuffer, TBool& aCompleted)

	/** Writes files to the buffer

	@param aBuffer The buffer to write to.

	@param aCompleted on return if we have finished.

	*/

		{

		aCompleted = EFalse;

		const TUint count = iFileNames->Count();

		while (iCurrentFile < count)

			{

            const TDesC& name = (*iFileNames)[iCurrentFile];

			_LIT( KTrailingBackSlash, "\\" );

            if (name.Right(1) == KTrailingBackSlash() )

            	{

             	// Directory entry

 	           	__LOG1("CBufferFileWriter::WriteToBufferL() - empty directory: %S ", &name);

 	           	if(!iHeaderWritten)

 	        	   {

 	        	   TFileFixedHeader header(name.Length(), 0, 0, 0);

 	        	   if (WriteToBufferF(header, aBuffer) == EFalse)

 	        		   {

 	        		   __LOG("CBufferFileReader::WriteToBufferL() - WriteToBufferF() returned False so breaking!");

 	        		   break;

 	        		   }

 	        	   iHeaderWritten = ETrue;

 	        	   } // if

				TPtr8 ptr(reinterpret_cast<TUint8*>(const_cast<TUint16*>(name.Ptr())), name.Size(), name.Size());

				if (WriteToBufferV(ptr, ptr.Size(), aBuffer) == EFalse)

					{

					__LOG("CBufferFileReader::WriteToBufferL() - WriteToBufferV() returned False so breaking!");

					break;

					}

 	           	iHeaderWritten = EFalse;

 	           	iFileNameWritten = EFalse;

            	}

            else

            	{

				if (!iFileOpen) // File needs to be opened

					{

	                __LOG1("CBufferFileWriter::WriteToBufferL() - trying to open: %S for reading", &name);

					const TInt error = iFileHandle.Open(iFs, name, EFileRead | EFileShareReadersOnly);

	                if  (error != KErrNone)

	                    {

	                    __LOG2("CBufferFileWriter::WriteToBufferL() - opening: %S for reading failed with error: %d", &name, error);

	                    User::Leave(error);

	                    }

					iFileOpen = ETrue;

					} // if

				if (iFileOpen && !iHeaderWritten)

					{

					// File size

					TInt size;

					TInt err = iFileHandle.Size(size);

	                __LOG2("CBufferFileWriter::WriteToBufferL() - size of file is: %d (err: %d)", size, err);

					TUint att;

					err = iFileHandle.Att(att);

					__LOG2("CBufferFileWriter::WriteToBufferL() - attributes: %d (err: %d)", size, err);

					TTime modified;

					err = iFileHandle.Modified(modified);

					__LOG2("CBufferFileWriter::WriteToBufferL() - modified: %d (err: %d)", size, err);

					TFileFixedHeader header((*iFileNames)[iCurrentFile].Length(), size, att, modified.Int64());

					if (WriteToBufferF(header, aBuffer) == EFalse)

						{

						__LOG("CBufferFileReader::WriteToBufferL() - WriteToBufferF() returned False so breaking!");

						break;

						}

					iHeaderWritten = ETrue;

					} // if

				// Write filename

				if (!iFileNameWritten)

					{

					TPtr8 ptr(reinterpret_cast<TUint8*>(const_cast<TUint16*>(name.Ptr())), name.Size(), name.Size());

					if (WriteToBufferV(ptr, ptr.Size(), aBuffer) == EFalse)

						{

						__LOG("CBufferFileReader::WriteToBufferV() - WriteToBufferF() returned False so breaking!");

						break;

						}

					iFileNameWritten = ETrue;

					}

	            __LOG1("CBufferFileWriter::WriteToBufferL() - buffer is of length: %d", aBuffer.Length());

				TInt bufferLeft = aBuffer.MaxSize() - aBuffer.Size();

				TPtr8 ptr(const_cast<TUint8*>(aBuffer.Ptr()) + aBuffer.Size(), bufferLeft);

				TInt fileSize = 0;

				iFileHandle.Size(fileSize);

				TInt fileLeft = fileSize - iOffset;

				if (bufferLeft < fileLeft)

					{

	                __LOG("CBufferFileWriter::WriteToBufferL() - buffer space available is less than file size!");

	                // Write buffer size

					User::LeaveIfError(iFileHandle.Read(iOffset, ptr, bufferLeft)); // TODO: Is this correct?

					aBuffer.SetLength(aBuffer.Length() + bufferLeft);

					iOffset += bufferLeft;

					break;

					} // if

				else

					{

	                __LOG("CBufferFileWriter::WriteToBufferL() - enough space in buffer for whole file...");

	                // Write file size

					User::LeaveIfError(iFileHandle.Read(ptr, fileLeft)); // TODO: Is this correct?

					aBuffer.SetLength(aBuffer.Length() + fileLeft);

					} // else

	            __LOG1("CBufferFileWriter::WriteToBufferL() - After read from file, buffer is now of length: %d", aBuffer.Length());

				iFileHandle.Close();

				iFileOpen = EFalse;

				iHeaderWritten = EFalse;

				iFileNameWritten = EFalse;

				iOffset = 0;

            	} //else

			++iCurrentFile;

			} // while

		if (iCurrentFile >= count)

			{

			aCompleted = ETrue;

			} // if

		} // WriteToBufferL

	CBufferFileReader* CBufferFileReader::NewL(RFs& aFs, RSnapshots* apSnapshots, MValidationHandler* aValidationHandler)

	/** Symbian OS constructor

	@param aFs File server to use.

	@param apSnapshots list of snapshots.

	*/

		{

        __LOG("CBufferFileReader::NewL() - START");

		CBufferFileReader* self = new(ELeave) CBufferFileReader(aFs, apSnapshots, aValidationHandler);

		CleanupStack::PushL( self );

	#ifdef SBE_LOGGING_ENABLED

        if  (apSnapshots)

            {

		    const TInt count = apSnapshots->Count();

            __LOG1("CBufferFileReader::NewL() - Got %d snapshots to compare against during restore...", count);

		    for(TInt x = 0; x < count; ++x)

			    {

                const TDesC& snapshot = (*apSnapshots)[x]->FileName();

                __LOG3("CBufferFileReader::NewL() -    snapshot[%4d/%4d] is: %S", x+1, count, &snapshot);

			    } // for x

		    }

	#endif

        __LOG("CBufferFileReader::NewL() - END");

        CleanupStack::Pop( self );

		return self;

		} // NewL

	CBufferFileReader::CBufferFileReader(RFs& aFs, RSnapshots* apSnapshots, MValidationHandler* aValidationHandler) :

		iFs(aFs), iSnapshots(apSnapshots), iValidationHandler(aValidationHandler)

	/** C++ constructor

	@param aFs File server to use.

	@param apSnapshots list of snapshots.

	*/

		{

		} // CBufferFileReader

	void CBufferFileReader::StartL(const TDesC8& aBuffer, TBool aLastSection)

	/** Start reading from the buffer.

	@param aBuffer The buffer to read from.

	@param aLastSection Is this the last section?

	*/

		{

        __LOG("CBufferFileReader::StartL() - START");

        if (iSnapshots)

        	{

        	iSnapshots->Sort(CSnapshot::Compare);

        	}

		ReadFromBufferL(aBuffer, aLastSection);

        __LOG("CBufferFileReader::StartL() - END");

		} // StartL

	void CBufferFileReader::ContinueL(const TDesC8& aBuffer, TBool aLastSection)

	/** Continue reading from the buffer.

	@param aBuffer The buffer to read from.

	@param aLastSection Is this the last section?

	*/

		{

        __LOG("CBufferFileReader::ContinueL() - START");

		ReadFromBufferL(aBuffer, aLastSection);

        __LOG("CBufferFileReader::ContinueL() - END");

		} // ContinueL

	void CBufferFileReader::CheckFileInSnapshotL()

	/**

	Checks to see if a given file is in a snapshot.

	*/

		{

        __LOG2("CBufferFileReader::CheckFileInSnapshot() - START - ipSnapshots: 0x%08x, iSnapshotChecked: %d", iSnapshots, iSnapshotChecked);

		iRestore = ETrue;

		if (iSnapshots)

			{

			CSnapshot* snapshot = CSnapshot::NewLC(TTime().Int64(), iFileName);

			TInt res = iSnapshots->Find(snapshot, CSnapshot::Match);

			if (res == KErrNotFound)

				{

				iRestore = EFalse;

				}

			CleanupStack::PopAndDestroy(snapshot);		

			} // if

		iSnapshotChecked = ETrue;

        __LOG2("CBufferFileReader::CheckFileInSnapshot() - END - iSnapshotChecked: %d, iRestore: %d", iSnapshotChecked, iRestore);

		}

	void CBufferFileReader::RecreateDirL()

	/**

	Recreates a directory path on disk.

	*/

		{

        __LOG1("CBufferFileReader::RecreateDirL() - START - iFileName: %S", &iFileName);

		// Create the path

		TInt err = iFs.MkDirAll(iFileName);

		if ((err != KErrNone) && (err != KErrAlreadyExists))

			{

            __LOG1("CBufferFileReader::WriteToFile() - making directory resulted in fatal error: %d", err);

			User::Leave(err);

			} // if

        __LOG("CBufferFileReader::RecreateDirL() - END");

		}

	void CBufferFileReader::RecreateFileL()

	/**

	Recreates a file on disk. Deletes the original if it still exists.

	*/

		{

        __LOG1("CBufferFileReader::RecreateFileL() - START - iFileName: %S", &iFileName);

		// Create the path

		TInt err = iFs.MkDirAll(iFileName);

		if ((err != KErrNone) && (err != KErrAlreadyExists))

			{

            __LOG1("CBufferFileReader::WriteToFile() - making directory resulted in fatal error: %d", err);

			User::Leave(err);

			} // if

        err = iFileHandle.Replace(iFs, iFileName, EFileWrite);

        __LOG1("CBufferFileReader::WriteToFile() - replacing file returned err: %d", err);

        User::LeaveIfError( err );

		iFileOpen = ETrue;

        __LOG("CBufferFileReader::RecreateFileL() - END");

		}

	TBool CBufferFileReader::WriteToFileL(TUint8*& aCurrent, const TUint8* aEnd)

	/**

	Writes data to a file.

	@param aCurrent start point of data to write.

	@param aEnd end point of data to write.

	@return ETrue if write finished. EFalse if there is more data to write.