// Copyright (c) 2008-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:

//

#include "mppsmoketestlib.h"

#include <flogger.h>

//#include "xmlengtesterdef.h"

//#include <utils/xmlengxestd.h>

/**

 * Utility fcn to compare two files ( skip or not skip white space ).

 * @param aSrcFile full filename of a file you want to check/compare.

 * @param aVerificationFile fill filename of a correct output file, aSrcFile will be compared to this to verify it's validity.

 * @param aSkipWhiteSpace do not include whitespace when comparing the two files.

 * @return Symbian OS error code.

 */

TInt CMultipartTestContainer::CompareFilesL( TPtrC aSrcFile, TPtrC aVerificationFile,

																				 TBool aSkipWhiteSpace)

{

    _LIT(KSourceFileError,"Source file error.");

    _LIT(KPatternFileError,"Pattern file error.");

    _LIT(KComparePassed,"Files compare test PASSED.");

    _LIT(KCompareFailed,"Files compare test FAILED.");

    TInt nResult = KErrNone;

    TBool skipWhite = FALSE;

    TBool foundRes = FALSE;

    TBool foundRef = FALSE;

    RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

    RFile srcFile;

    RFile referenceFile;

    TFileName srcFileName;

	TFileName referenceFileName;

  TPtrC SrcFile = aSrcFile;

  TPtrC ReferenceFile = aVerificationFile;

	if (aSkipWhiteSpace)

	 {

		 skipWhite = TRUE;

	 }	

    if ( nResult == KErrNone )

	{

		srcFileName.Copy(SrcFile);

		referenceFileName.Copy(ReferenceFile);

	    if(srcFile.Open(fs, srcFileName, EFileStream|EFileRead) == KErrNone)

		{

			// Does reference file exist.

			if(referenceFile.Open(fs, referenceFileName, EFileStream|EFileRead) == KErrNone)

		    {

		        // Integer variables for compare to length of files (result and reference).

		        TInt resSize;

		        TInt refSize;

		        srcFile.Size(resSize);

		        referenceFile.Size(refSize);

	            // Next compare one letter at the time, but only if files have same length.

	            if(skipWhite)

		        {

			        TBuf8<1> resBuf;

			        TBuf8<1> refBuf;

			        nResult = KErrNone;

			        TInt j = 0;

			        TInt i = 0;

			        //for(TInt i = 0; i < Size; i++)

			        while (TRUE)

				    {

				    	foundRes = FALSE;

				    	foundRef = FALSE;

				        // Read result file

				        while(i < (resSize + 1))

				        {

				        	i++;

				        	srcFile.Read(resBuf);

				        	resBuf.Trim();	

				        	if ( resBuf.Length() > 0)

				        	{

				        		foundRes = TRUE;

				        		break;

				        	}

				        }

						// Read reference file

				        while(j < (refSize + 1))

				        {

				        	j++;

				        	referenceFile.Read(refBuf);

				        	refBuf.Trim();

				        	if ( refBuf.Length() > 0)

				        	{

				        		foundRef = TRUE;

				        		break;

				        	}

				        }

				        // Compare single letter at the time.

				        if( ( i < resSize ) && ( j < refSize ) && (resBuf[0] != refBuf[0]) )

				        {

					        nResult = KErrGeneral;

					        break;

					    }

					    if( (i == (resSize + 1)) && (j < refSize) && foundRef)

				    	{

					    	nResult = KErrGeneral;

					        break;

				    	}

					    if( (i < resSize) && (j == (refSize + 1)) && foundRes)

				    	{

					    	nResult = KErrGeneral;

					        break;

				    	}

				    	if ((i > resSize) && (j > refSize))

				    		break;

				    }

			    }

		        else

			    {

			        if (resSize != refSize)

			       		nResult = KErrGeneral;

			        else

		        	{

				        TBuf8<1> resBuf;

			        	TBuf8<1> refBuf;

			        	nResult = KErrNone;

			        	for(TInt i = 0; i < resSize; i++)

			        	{

				        	// Read result file

				        	srcFile.Read(resBuf);

					        // Read reference file

					        referenceFile.Read(refBuf);

					        // Compare single letter at the time.

					        if(resBuf[0] != refBuf[0])

					        {

						        nResult = KErrGeneral;

					    	    break;

				        	}

			        	}

		        	}

			    }

	            referenceFile.Close();

	            srcFile.Close();

			}

			else

			{

				nResult = KErrGeneral;

				INFO_PRINTF1(KPatternFileError);

			}

			srcFile.Close();

		}

		else

		{

			nResult = KErrGeneral;

			INFO_PRINTF1(KSourceFileError);

		}

	}

	CleanupStack::PopAndDestroy(&fs);

	if ( nResult == KErrNone)

		{

		INFO_PRINTF1(KComparePassed);

		}

	else

		{

		INFO_PRINTF1(KCompareFailed);

		}

	return nResult;

    }

CMultipartTestContainer::CMultipartTestContainer(CTestExecuteLogger& aLogger)

 : iLog(aLogger)

    {

    }

/**

 * @param aLogger TEF logger from CTestStep.

 */

void CMultipartTestContainer::ConstructL()

	{

	}

/**

 * @param aLogger TEF logger from CTestStep.

 */

CMultipartTestContainer* CMultipartTestContainer::NewLC(CTestExecuteLogger& aLogger)

	{

	CMultipartTestContainer* self = new (ELeave) CMultipartTestContainer(aLogger);

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

/**

 * @param aLogger TEF logger from CTestStep.

 */

CMultipartTestContainer* CMultipartTestContainer::NewL(CTestExecuteLogger &aLogger)

	{

	CMultipartTestContainer* self = NewLC(aLogger );

	CleanupStack::Pop( self );

	return self;

	}

CMultipartTestContainer::~CMultipartTestContainer()

	{ 

	}

/**

 * Read a file from the hard drive.

 * 

 * @param aFileName full filename to read in.

 * @return contents of the file.

 */ 

HBufC8* CMultipartTestContainer::ReadFileLC(const TDesC& aFileName)

    {

    RFs rfs;

    RFile file;

    User::LeaveIfError(rfs.Connect());

    CleanupClosePushL(rfs);

    User::LeaveIfError(file.Open(rfs, aFileName, EFileRead));

    CleanupClosePushL(file);

    TInt size;

    User::LeaveIfError(file.Size(size));

    HBufC8* buf = HBufC8::NewLC(size);

    TPtr8 bufPtr(buf->Des());

    User::LeaveIfError(file.Read(bufPtr));

    CleanupStack::Pop(); // buf

    CleanupStack::PopAndDestroy(2); // file, rfs

    CleanupStack::PushL(buf);

    return buf;

    }

/**

 * Write the file to the hard drive.

 * 

 * @param aFileName 

 * @param aBodyPartArray

 */ 

void CMultipartTestContainer::WriteFileL( const TDesC& aFileName,

                                           RPointerArray<CBodyPart>& aBodyPartArray )

    {

    RFs fs;

    fs.Connect();

    CleanupClosePushL(fs);

    RFile output;

    TInt err = output.Open(fs, aFileName, EFileWrite);

    if (err == KErrNotFound)

    	{

			User::LeaveIfError(output.Create(fs, aFileName, EFileWrite));

			}		

    // output file

    TInt size = aBodyPartArray.Count();

    TInt i;

		_LIT8(KEol, "\r\n");

    for (i = 0; i < size; i++)

        {

        CBodyPart* bodyPart = aBodyPartArray[i];

        if( bodyPart->Url().Ptr() )

            {

            output.Write(_L8("***************Ur"));

            output.Write(KEol);

			RBuf8 narrow;

			err = narrow.Create(bodyPart->Url().Length()*2);

			if (err != KErrNone)

				{

				INFO_PRINTF1(_L("Error printing Url to output file; continueing..."));

				}						

			narrow.Copy(bodyPart->Url());

            output.Write(narrow.Left(narrow.Length()));

            output.Write(KEol);

            }

        if( bodyPart->ContentID().Ptr() )

            {

            output.Write(_L8("***************ContentID"));

            output.Write(KEol);

            output.Write(bodyPart->ContentID() );

            output.Write(KEol);

            }

        if( bodyPart->Charset().Ptr() )

            {

            output.Write(_L8("***************Charset"));

            output.Write(KEol);

            output.Write( bodyPart->Charset() );

            output.Write(KEol);

            }

        if( bodyPart->ContentType().Ptr() )

            {

            output.Write(_L8("***************ContentType"));

            output.Write(KEol);

            output.Write( bodyPart->ContentType() );

            output.Write(KEol);

            }

        if( bodyPart->Headers().Ptr() )

            {

            output.Write(_L8("***************Headers"));

            output.Write(KEol);

            output.Write(bodyPart->Headers() );

            output.Write(KEol);

            }

        if( bodyPart->Body().Ptr() )

            {

            output.Write(_L8("***************Body"));

            output.Write(KEol);

            output.Write(bodyPart->Body() );

            output.Write(KEol);

            }

        output.Write(_L8("=========================================part ends"));

        output.Write(KEol);

        } // end of loop

    output.Close();

    CleanupStack::PopAndDestroy(1, &fs);

    fs.Close();

		}

/**

 * Write the data to a file.

 * 

 * @param aFileName  filename to write the data to.

 * @param aData data to write.

 */

void CMultipartTestContainer::WriteToDiskL( const TDesC& aFileName,

                                            const TDesC8& aData )

    {

    RFs fsSession;

    RFile file;

    TInt status( KErrNone );

    User::LeaveIfError( fsSession.Connect() );

    status = file.Replace( fsSession, aFileName, EFileWrite|EFileShareAny);    

    if( status == KErrNone )

        {

        file.Write( aData );

        }

    file.Close();

    }

/**

 * Parse a file with base64 encoding.

 * 

 * @param aFile filename to be read in.

 * @param aUrl  ???  //DEBUG

 * @param aOutput name out output file.

 */ 

void CMultipartTestContainer::ParseFileL( const TDesC& aFile,

                                          const TDesC& aUrl,

                                          const TDesC& aOutput )

    {

    // body

    HBufC8* data = ReadFileLC( aFile );

    // content type

    _LIT8(KMultipartMixed, "multipart/mixed");

    // boundary

    _LIT8(KBoundary1, "KBoundary");

    // body part array

    RPointerArray<CBodyPart> bodyPartArray;  

    // parse

		TInt err;

    if( aUrl.Ptr() )

        {

        TRAP( err, MultipartParser::ParseL( *data, KMultipartMixed, KBoundary1, aUrl, bodyPartArray ) );

        }

    else

        {

        TRAP( err, MultipartParser::ParseL( *data, KMultipartMixed, KBoundary1, aFile, bodyPartArray ) );

        }

	if (err != KErrNone)

		{

		INFO_PRINTF1(_L("Error parsing file."));

		}			

    // output

    WriteFileL( aOutput, bodyPartArray);

    // clean up memory

    CleanupStack::PopAndDestroy(); // data

    // clean up body part array and its content

    TInt size = bodyPartArray.Count();

    TInt i;

    for (i = 0; i < size; i++)

        {

        delete bodyPartArray[i];

        }

    bodyPartArray.Reset();

    }