// Copyright (c) 2006-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 "cstoreutilities.h"
#include <miuthdr.h>
#include <barsread.h>

// The maximum number of octets to be uuencoded on each line is 45
const TInt KUuDecodedLineLength = 45;	
// Initial size of buffer in which the "Real name <user@host>" strings
// are built before they're put into the CImHeader and the size by
// which to increment the buffer when necessary
const TInt KImapAddressSizeInc=256;
const TInt KKiloByteSize = 1024;
const TInt KBufferExtension = 4;
/**
Constructor.
*/
CStoreUtilities::CStoreUtilities(TImEncodingType aEncodingType,TUint aCharsetId,RFs& aFs)
	:iEncodingType(aEncodingType),iCharsetId(aCharsetId),iFs(aFs)
	{
	}
	
/**
Factory constructors.
Ownership aHeader is taken.
*/	
CStoreUtilities* CStoreUtilities::NewL(TImEncodingType aEncodingType,TUint aCharsetId,RFs& aFs)
	{
	CStoreUtilities* self=new(ELeave) CStoreUtilities(aEncodingType,aCharsetId,aFs);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}
	
void CStoreUtilities::ConstructL()
	{
	User::LeaveIfError(iFs.Connect());
	// Create converter objects
	iCharacterConverter=CCnvCharacterSetConverter::NewL();
	iCharConv=CImConvertCharconv::NewL(*iCharacterConverter, iFs);	
	}

/**
Destructor.
*/	
CStoreUtilities::~CStoreUtilities()
	{
	delete iCharConv;
	delete iCharacterConverter;
	delete iFooterString;
	delete iPartialLine;
	}

/**
Checks if the descriptor contains the UUE begin header
Extracts the file name if it is
*/	
TBool CStoreUtilities::CheckUUEStartL(const TDesC8& aSourceLine)
	{
	
	TInt sourceLength = aSourceLine.Length();
	if(sourceLength < KImcvUueStart().Length()+3) // can't be "begin ###", it's not long enough; 3=length of ###
		return EFalse;

	if(!aSourceLine.Left(KImcvUueStart().Length()).CompareF(KImcvUueStart)) // start of line might be UUE boundary
		{
		// we also need to check that the next three chars are numbers - Unix file access code
		const TUint8* sourceLinePtr = aSourceLine.Ptr();
		TInt length=KImcvUueStart().Length();// this defines length as 6 ie. "b e g i n  " 
		if( TChar(sourceLinePtr[length]).IsDigit() && 
			TChar(sourceLinePtr[length+1]).IsDigit() && 
			TChar(sourceLinePtr[length+2]).IsDigit() )
			{
			// Found 'begin ###' at the start of a line - assume this is a UUencode header
			// The attachment name in this header is ignored. We use the value from the MIME header
			return ETrue;
			}
		}
		
	return EFalse;
	}
	
/**
Appends data to partial line object extening the destination buffer as appropirate 
@param aBufferPtr the destination bufer
@param aText the data to be appended
*/	
	
void CStoreUtilities::AppendExtendL(HBufC8** aBufferPtr, const TDesC8& aText)
	{
	HBufC8 *buffer = *aBufferPtr;
	TInt32 space = buffer->Des().MaxLength() - (buffer->Des().Length() + aText.Length());
	if (space < 0)
		{
		TInt32 inc = (-space) + KImapAddressSizeInc - ((-space) % KImapAddressSizeInc);
		TInt32 newSize = buffer->Des().MaxLength() + inc;
		HBufC8 *newBuf = buffer->ReAllocL(newSize);
		*aBufferPtr = buffer = newBuf;
		}
	buffer->Des().Append(aText);
	}
	
	
void CStoreUtilities::AttachFooterInfoL(TInt32 aBodyPartRemainingSize,CImapSettings& aImapSettings,HBufC8*& aDecodedData)
	{
	const HBufC8* buf= aImapSettings.DefaultPartialMessageFooter();

	_LIT(KIntegerDirective,"%d");
	const TInt KNoOfDigitsInMailSize = 10; // maximum length for no of digits for remaining body parts size
	TResourceReader reader;
	reader.SetBuffer(buf);
	// Check if %d is not found in the resource string (To avoid problems due to localisation)
	if(buf->Find((TDesC8&)KIntegerDirective) == KErrNotFound)
		{
		iFooterString = (reader.ReadTPtrC()).AllocL();
		}
	else
		{
		HBufC* resourceBuf = (reader.ReadTPtrC()).AllocL();
		CleanupStack::PushL(resourceBuf);
		iFooterString = HBufC::NewL(resourceBuf->Length()+KNoOfDigitsInMailSize);
		iFooterString->Des().Format(*resourceBuf,(aBodyPartRemainingSize / KKiloByteSize));
		CleanupStack::PopAndDestroy(resourceBuf);
		}	
	//caller will have left aDecodedData on the cleanupstack
	CleanupStack::Pop(aDecodedData); 
	TInt newSize = aDecodedData->Size() + iFooterString->Size();
	aDecodedData = aDecodedData->ReAlloc(newSize);
	CleanupStack::PushL(aDecodedData);
	aDecodedData->Des().Append(*iFooterString);
	delete iFooterString;
	iFooterString = NULL;
			
	}
	

// convert text from its charset and write to richtext store. aText
// can span multiple and partial lines
void CStoreUtilities::WriteToBodyL(const TDesC8& aText,CRichText* aMessageBody)
	{
	TInt pos = aMessageBody->DocumentLength();

	// Add bits of body text, converting along the way, till no characters left
	// .. to convert.

	// Convert text before writing to body.
	TInt rem = 0;

	// there will be a max of one output char per input byte
	HBufC16* text16=HBufC16::NewLC(aText.Length());
	TPtr16 ptr16=text16->Des();
	
	TBool preparedToConvert = iCharConv->PrepareToConvertToFromOurCharsetL(iCharsetId);
	
	if (!preparedToConvert)
		{
		ptr16.Copy(aText);
		aMessageBody->InsertL(pos, ptr16);
		}
	else
		{
		TInt unconvertedChars, firstPos; // not used 
		rem = iCharConv->ConvertToOurCharsetL(aText, ptr16, 
											  unconvertedChars, firstPos);
		if (rem < 0) // error
			{
			// Copy unconverted characters.
			ptr16.Copy(aText);
			aMessageBody->InsertL(pos, ptr16);
			}
		else if (rem && rem < iLeftOver.MaxLength())
			{
			iLeftOver.Copy(aText.Right(rem));	
			}

		// convert CRLF to ELineBreak
		TInt start = 0;
		TInt length = ptr16.Length();
		
		if (length>0)
			{
			TInt i;
			for (i=1; i<length; i++)
				{
				if (ptr16[i-1] == KImcvCR && ptr16[i] == KImcvLF)
					{
					ptr16[i-1] = CEditableText::ELineBreak;

					// write this line to body
					TPtrC ptr = ptr16.Mid(start, i-start);
					aMessageBody->InsertL(pos, ptr);
					pos += ptr.Length();
					start = i+1;
					}
				}

			if (start != i)
				{
				TPtrC ptr = ptr16.Mid(start, i-start);
				aMessageBody->InsertL(pos, ptr);
				}
			}
		}

	CleanupStack::PopAndDestroy(text16);
	}
	
// Decode and store received data
HBufC8* CStoreUtilities::DecodeL(const TPtrC8& aBodyData, const TBool aEndOfStream)
	{
	// Somewhere to store decoded data, at least as long as source (plus anything we have left
	// in the partial line buffer which may now get consumed)
	TInt outputbuffersize=aBodyData.Length()+KBufferExtension;
	if (iPartialLine)
		outputbuffersize+=iPartialLine->Des().Length();

	HBufC8* decoded=HBufC8::NewL(outputbuffersize);
	TPtr8 decoded_ptr=decoded->Des();

	// Which decoder are we using?
	switch(iEncodingType)
		{
		case EEncodingTypeNone:
		case EEncodingType7Bit:
		case EEncodingType8Bit:
		case EEncodingTypeBinary:
		case EEncodingTypeUnknown:
			// Nothing to do, just copy data
			decoded->Des().Append(aBodyData);
			break;

		case EEncodingTypeBASE64:
			// Decode Base64 data: just filter it through decoder, it
			// ignores line breaks anyway.
			iB64Decoder.Decode(aBodyData,decoded_ptr);
			break;

		case EEncodingTypeUU:
			{
			TPtrC8 bodydata=aBodyData;

			// Got a partial buffer?
			if (!iPartialLine)
				{
				// Allocate buffer
				iPartialLine=HBufC8::NewL(KUuDecodedLineLength);
				iUUDecoding = EFalse;
				}
			
			// Decode UUEncoded data: line by line
			TBool decodeEnded = EFalse;
			TInt position=0;
			while ( bodydata.Length() && !decodeEnded )
				{
				// Find() returns the start of "\r\n". The decoding algorithm
				// requires that the encoded line contains the "\r\n".
				TInt lineEnd = bodydata.Find( _L8("\r\n") );
				if (lineEnd != KErrNotFound)
					{
					lineEnd = lineEnd + 2;
					AppendExtendL( &iPartialLine, bodydata.Left( lineEnd ));
				
					bodydata.Set( bodydata.Mid( lineEnd ) );
				
					// Check for a well-formated  begin-tag
					if ( CheckUUEStartL( iPartialLine->Des() ) )
						{
						iUUDecoding = ETrue;
						}
					else if ( iPartialLine->Compare( KImcvUueEnd ) != 0 && iUUDecoding )
						{
						// Every malformatted string is decoded as an empty string 
						// with length 0. Appending such a string is harmless.
						TPtr8 destination((unsigned char*)decoded_ptr.Ptr()+position,0,outputbuffersize-position);
						iUUDecoder.Decode(*iPartialLine,destination);
						position+=destination.Length();			
						}
					else if ( iUUDecoding )
						{
						decodeEnded = ETrue;
						iUUDecoding = EFalse;	
						}
					
					iPartialLine->Des().Zero();
					}
				else
					{
					AppendExtendL( &iPartialLine, bodydata);
					
					// advance to end of bodydata
  					bodydata.Set(bodydata.Ptr()+bodydata.Length(), 0);
					}
				}
			decoded->Des().SetLength(position);	
			break;
			}

		case EEncodingTypeQP:
			{
			TPtrC8 bodydata=aBodyData;

			// Got a partial buffer?
			if (!iPartialLine)
				{
				// Allocate buffer
				iPartialLine=HBufC8::NewL(256);
				}

			// Build buffer to decode: basically, QP decoder wants CRLF terminated
			// lines, so we build them in the iPartialLine buffer. There may be
			// stuff already there from previous data packet - so we just append.
			TInt position=0;
			while(bodydata.Length())
				{
				// Find a line break
				TInt lineend=bodydata.Find(_L8("\r\n"));

				// No break?
				if (lineend==KErrNotFound && !aEndOfStream)
					{
					// Stick it all in the partialline buffer, we should get a CRLF
					// soon...
					AppendExtendL( &iPartialLine,bodydata);
					break;
					}
				else
					{
					if (lineend==KErrNotFound)
						{
						// Append whole thing left to buffer
						AppendExtendL( &iPartialLine,bodydata);

						// advance to end of bodydata
						bodydata.Set(bodydata.Ptr()+bodydata.Length(), 0);
						}
					else
						{
						// Append to buffer up to that point (including the \r\n)
						AppendExtendL( &iPartialLine,bodydata.Left(lineend+2));

						// Remove from the buffer we're working on (including the \r\n)
						bodydata.Set(bodydata.Ptr()+lineend+2,bodydata.Length()-lineend-2);
						}

					// Decode & skip on in buffer
					TPtr8 destination((unsigned char*)decoded_ptr.Ptr()+position,0,outputbuffersize-position);
					iQPDecoder.Decode(*iPartialLine,destination);
					position+=destination.Length();
					iPartialLine->Des().Zero();
					}
				}

			// Update decoded
			decoded->Des().SetLength(position);
			break;
			}
		}

	// put back any partially converted data
	if (iLeftOver.Length())
		{
		decoded->Des().Insert(0, iLeftOver);
		iLeftOver.SetLength(0);
		}
		
	return decoded;
	}

