// 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 "cimapcommand.h"

#include "cimapsessionconsts.h"

#include "cimapfolderinfo.h"

#include "cimaputils.h"

#include "cimapcharconv.h"

#include "cimaplogger.h"

static const TInt KDefaultNumberOfTaggedResponsesExpected = 1;

CImapCommand::CImapCommand(CImapFolderInfo* aSelectedFolderData, TInt aLogId)

	: iSelectedFolderData(aSelectedFolderData)

	, iLogId(aLogId)

	{}

CImapCommand::~CImapCommand()

	{

	delete iOutputBuffer;

	}

void CImapCommand::SendDataCnfL()

	{}

CImapCommand::TParseState CImapCommand::ParseBlockL(const TDesC8& aData)

	{

#ifdef __IMAP_LOGGING

	// Log the first few bytes only - but enough to tell the difference between untagged FETCH's

	TPtrC8 truncatedData = aData.Left(30);

	__LOG_FORMAT((iLogId, "CImapCommand::ParseBlockL(): [%S] %d octets", &truncatedData, aData.Length()));

#endif //__IMAP_LOGGING

	__ASSERT_DEBUG(iParseState != ECommandComplete, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState2));

	iUnparsedData.Set(aData);

	iLiteralBytesExpected = 0; // Initialise to zero, and only peek in states that read a line.

	switch (iParseState)

		{

		case EWaitStartResponse:

			{

			if (Flushing())

				{

				ParseStartResponseFlushL(aData);

				}

			else

				{

				ParseLineL(aData);

				}

			break;

			}

		case EWaitLineParse:

			{

			ParseLineL(aData);

			}

			break;

		case EWaitLiteralParse:

			{

			ParseLiteralL(aData);

			}

			break;		

		case EWaitLiteralIngore:

			{

			__LOG_TEXT(iLogId, "CImapCommand Ignore Literal");

			// Ignore the literal.

			// A literal is always followed by a line (as part of the same response)

			SetParseState(EWaitLineIgnore);

			}

			break;

		case EWaitLineIgnore:

			{

			__LOG_TEXT(iLogId, "CImapCommand Ignore Line following Literal");

			// Ignore the line, but check whether it indicates that another literal is on its way.

			PeekLiteralRequest(aData);

			TParseState newParseState = (iLiteralBytesExpected > 0) 

				? EWaitLiteralIngore	// a literal has been indicated on the line.  We need to ignore that too!

				: EWaitStartResponse;	// we are not expecting any more data for this response, so wait for the next one.

			SetParseState(newParseState);

			}

			break;

		default:

			{

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState3));

			}

		}

	if (iCompleteOnAnyResponse && iParseState==EWaitStartResponse)

		{

		__LOG_TEXT(iLogId, "CImapCommand - Complete on Any Response");

		__ASSERT_DEBUG(iResponseCode == EImapResponseNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidResponseCode));

		// Simulate command completion so that the session closes this command.		

		iResponseCode = EImapResponseOk;

		SetParseState(ECommandComplete);

		}

	// check some post-conditions: is session getting consistent data?

	// (iParseState == ECommandComplete) implies (iResponseCode != EImapResponseNone)

	__ASSERT_DEBUG(iParseState == ECommandComplete ? iResponseCode != EImapResponseNone : ETrue, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandMismatchedParseStateAndResponseCode));

	// (iParseState != ECommandComplete) implies (iResponseCode == EImapResponseNone)

	__ASSERT_DEBUG(iParseState != ECommandComplete ? iResponseCode == EImapResponseNone : ETrue, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandMismatchedParseStateAndResponseCode));

	return iParseState;

	}

/**

Parses incoming line data.

@param aLine the line to parse.

*/

void CImapCommand::ParseLineL(const TDesC8& aLine)

	{

	// Should only be calling this method when parsing a line.

	__ASSERT_DEBUG(iParseState == EWaitStartResponse || iParseState == EWaitLineParse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState4));

	PeekLiteralRequest(aLine);

	TParseBlockResult parseBlockResult = DoParseBlockL(aLine);

	if(parseBlockResult ==  ECompleteUntagged && iLiteralBytesExpected != 0)

		return;

	switch (parseBlockResult)

		{

		case ECompleteTagged:

			// No more data expected

			__ASSERT_DEBUG(iLiteralBytesExpected == 0, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandResponseLiteralDataNotZero));

			__ASSERT_DEBUG(iResponseCode != EImapResponseNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidResponseCode));

			SetParseState(ECommandComplete);

			break;

		case ECompleteUntagged:

			// Wait for the next response line to be received

			__ASSERT_DEBUG(iLiteralBytesExpected == 0, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandResponseLiteralDataNotZero));

			SetParseState(EWaitStartResponse);

			break;

		case EResponseIncomplete:

			// Literal data is expected - this needs to be delivered to the subclass

			__ASSERT_DEBUG(iLiteralBytesExpected > 0, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandResponseLiteralDataNotNonZero));

			SetParseState(EWaitLiteralParse);

			break;

		case ENotRecognised:

			if (iParseState == EWaitLineParse)

				{

				__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState5));

				}

			else // EWaitStartResponse

				{

				// The line was not understood by the subclass, so try the generic parsing

				parseBlockResult = ParseUnhandledBlockL(aLine);

				__ASSERT_DEBUG(parseBlockResult != EResponseIncomplete, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseBlockResult)); // Not expected or currently supported

				// If we're swallowing an unsupported response, then we may need to swallow a literal block next

				TParseState newParseState = (iLiteralBytesExpected > 0) 

					? EWaitLiteralIngore	// a literal has been indicated on the line.  We need to ignore that too!

					: EWaitStartResponse;	// we are not expecting any more data for this response	

				SetParseState(newParseState);

				}

			break;

		default:

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseBlockResult));

			break;

		}

	}

/**

Parses incoming literal data.

@param aLiteralBlock the literal block to parse.

*/

void CImapCommand::ParseLiteralL(const TDesC8& aLiteralBlock)

	{

	// Should only be calling this method when parsing a literal blcok.

	__ASSERT_DEBUG(iParseState == EWaitLiteralParse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState6));

	TParseBlockResult parseBlockResult = DoParseBlockL(aLiteralBlock);

	switch (parseBlockResult)

		{

		case ECompleteTagged:					

		case ECompleteUntagged:

			// Literals are always followed by a line, so the response can't be complete yet.

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseBlockResult));

			break;

		case EResponseIncomplete:

			SetParseState(EWaitLineParse);

			break;

		case ENotRecognised: 

			// Subclass asked for the literal block, so it ought to have parsed it.

			// Fall through to default __ASSERT_DEBUG below.

		default:

			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseBlockResult));

			break;

		}

	}

/**

During cancel this method is called whenever the start of a new response is received.

It doesn't do any parsing, other than to detect the closing tagged response, 

which completes the command and means there is no more data to receive.

@param aLine the line containing the start of a new response.

*/

void CImapCommand::ParseStartResponseFlushL(const TDesC8& aLine)

	{

	__LOG_TEXT(iLogId, "CImapCommand::ParseStartResponseFlushL()");

	// should only call this method when parsing an incoming response but not cancelling

	__ASSERT_DEBUG(iParseState == EWaitStartResponse, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState7));

	__ASSERT_DEBUG(iTaggedResponsesToFlush > 0, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandNoTaggedResponsesToFlush));

	TInt tagId = 0;

	switch (GetTagTypeL(tagId))

		{

		case ETagged:

			{

			--iTaggedResponsesToFlush;

			if (iTaggedResponsesToFlush == 0)

				{

				// Don't check the tagId during cancel.

				iResponseCode = GetResponseStateCode();

				SetParseState(ECommandComplete);	

				}

			else

				{

				__LOG_FORMAT((iLogId, "CImapCommand - Still have %d tagged response(s) to flush", iTaggedResponsesToFlush));

				}			

			}

			break;

		case EUntagged:

			{

			// Ignore the untagged response, but check whether it indicates that another literal is on its way.

			PeekLiteralRequest(aLine);

			TParseState newParseState = (iLiteralBytesExpected > 0) 

				? EWaitLiteralIngore	// a literal has been indicated on the line.  We need to ignore that too!

				: EWaitStartResponse;	// we are not expecting any more data for this response, so wait for the next one.

			SetParseState(newParseState);

			}

			break;

		case EContinuation:

			{

			// Not exepecting a continuation response

			CorruptDataL(); 

			}

			break;

		}

	}

/**

Looks for {nnn} at the end of the line, determine whether literal bytes are expected.

If literal bytes are expected, then iLiteralBytesExpected is updated to store the

number of bytes expected.

@return KErrNone if literal bytes are expected, otherwise a system-wide error code.

*/

TInt CImapCommand::PeekLiteralRequest(const TDesC8& aLine)

	{

	// Minimum of 3 chars needed for literal specifier: {n}

	TInt lineLength = aLine.Length();

	if (lineLength < 3)

		{

		return KErrNotFound; // no request found.

		}

	// Last char MUST be a }

	if (aLine[lineLength-1] != '}')

		{

		return KErrNotFound; // no request found.

		}

	// Reverse-Find matching '{'

	TPtrC8 ptrLiteralRequest;

	for (TInt i=lineLength-1; i>=0; --i)

		{

		if (aLine[i] == '{')

			{

			// Found matching brace.  Point at its contents only!

			ptrLiteralRequest.Set(aLine.Mid(i+1, lineLength-i-2));

			break; // from for loop

			}

		}

	if (ptrLiteralRequest.Length() == 0)

		{

		return KErrNotFound; // No matching brace found

		}

	// Extract the value

	TLex8 lex(ptrLiteralRequest);

	TInt err = lex.Val(iLiteralBytesExpected);

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)			

	//	If message body is downloaded using FETCH BINARY. The number of bytes received for previous fetch is recorded here.

	//	This valued is used to make sure that there are no extra body fetch command are issued 

	iPreviousLiteralBytesReceived = iLiteralBytesExpected;

#endif

#ifdef __IMAP_LOGGING

	if (iLiteralBytesExpected > 0)

		{

		__LOG_FORMAT((iLogId, "CImapCommand - Found Literal Request: %d", iLiteralBytesExpected));

		}	

#endif //__IMAP_LOGGING

	return err;

	}

/**

This is called when the session has processed all the blocks in its input buffer, but the 

command is not yet complete (so it is expecting more data).

This allows subclasses of CImapCommand to commit any bulk operations while waiting for the next set of data.

By default, this method does nothing.

*/

void CImapCommand::WaitingForMoreDataL()

	{}

/**

Call this method to stop fully parsing the command.

Instead, discard all incoming server data until no more data is expected for this command.

By default this means that the tagged response has been received.

This method can be overridden.

*/

void CImapCommand::Cancel()

	{

	__LOG_TEXT(iLogId, "CImapCommand::Cancel()");

	EnterFlushingState();

	}

void CImapCommand::EnterFlushingState()

	{

	iFlushing = ETrue;

	iTaggedResponsesToFlush = NumberOfTaggedResponsesExpected();

	__LOG_FORMAT((iLogId, "CImapCommand::EnterFlushingState() - %d tagged response(s) to flush", iTaggedResponsesToFlush));

	if (iParseState == EWaitLiteralParse)

		{

		SetParseState(EWaitLiteralIngore);

		}

	else if (iParseState == EWaitLineParse)

		{

		SetParseState(EWaitLineIgnore);

		}

	}

TBool CImapCommand::Flushing() const

	{

	return iFlushing;

	}

/**

This method tells the session whether the Flush operation is able to complete

the command straight away.

By default, a command that has not already been completed (and so destoyed)

cannot be completed early by Flush, as it is still waiting for the tagged

response.

This method can be overridden by commands that can be completed earlier, such

as commands that do not wait for a tagged response.

@return EFalse.

*/

TBool CImapCommand::CanCompleteFlushNow() const

	{

	// Any command that has completed should have been destroyed before this

	// method is called.

	__ASSERT_DEBUG(iParseState != ECommandComplete, TImapServerPanic::ImapPanic(TImapServerPanic::ECommandInvalidParseState8));

	__ASSERT_DEBUG(Flushing(), TImapServerPanic::ImapPanic(TImapServerPanic::ECommandNotFlushing));

	return EFalse;

	}

/**

Returns the number of tagged responses that are currently expected.

This default implementation always returns one, as most commands on send one request

and expect one tagged response.

Pipelined commands that send more than one request at a time should override this method.

@return one.

*/

TInt CImapCommand::NumberOfTaggedResponsesExpected() const

	{

	return KDefaultNumberOfTaggedResponsesExpected;

	}

/**

This API will return the result returned by the remote server to the issued IMAP command.

@return The IMAP result code extracted from the incoming response or EImapResponseNone 

		if the response has not yet been parsed.

*/ 

CImapCommand::TResponseCode CImapCommand::ResponseCode() const

	{

	return iResponseCode;

	}

/**

@return the number of bytes 

*/

TInt CImapCommand::LiteralBytesExpected() const

	{

	return iLiteralBytesExpected;

	}

/**

Static method that should a be called by all classes internal to CImapSession whenever they

detect corrupt data - e.g. missing fields - that means that they can no longer process the 

incoming data.

This method will always leave with KErrCorrupt.

*/

#ifdef __IMAP_LOGGING

void CImapCommand::CorruptDataL(TInt aLogId)

#else

void CImapCommand::CorruptDataL(TInt /*aLogId*/)

#endif //__IMAP_LOGGING

// static method

	{

	__LOG_TEXT(aLogId, "CImapCommand::CorruptDataL() !!!");

	User::Leave(KErrImapCorrupt);

	}

/**

Non-static version of CorruptDataL() that provides the current log id

*/

void CImapCommand::CorruptDataL()

	{

	CorruptDataL(iLogId);

	}

/**

Static method that stores each part of the supplied data into an array based on 

the delimiter value supplied in the aDelimiter argument.

@param aDelimiter 	The character that delimits the end of one part and the begining of the next.

@param aData 		The data that is to be split.

@param aOutDelimitedPartsList Output array that recieves the list of parts.

@param aMaxParts 	If greater than zero, this stops the search when aOutDelimitedPartsList 

					has the specified number of parts.

*/

void CImapCommand::GetDelimitedPartsL(TChar aDelimiter, const TDesC8& aData, RDesParts& aOutDelimitedPartsList, TInt aMaxParts /*=0*/)

// static method

	{

	aOutDelimitedPartsList.Reset();

	TInt dataLength = aData.Length();

	if (dataLength == 0)

		{

		// no data to parse, so nothing to do.

		return;

		}

	TInt currentPos = 0;

	TPtrC8 currentSegment(aData);

	for(;;)

		{

		TInt found = currentSegment.Locate(aDelimiter);

		if (found == KErrNotFound)

			{

			aOutDelimitedPartsList.AppendL(currentSegment);

			break;

			}

		currentSegment.Set(currentSegment.Left(found));

		aOutDelimitedPartsList.AppendL(currentSegment);

		// Check if whether have enough parts yet

		if (aMaxParts > 0 && aOutDelimitedPartsList.Count() >= aMaxParts)

			{

			break;

			}

		// Move past the delimiter and set next segment

		currentPos += (found+1);

		if (currentPos<dataLength)

			{

			currentSegment.Set(aData.Mid(currentPos));

			}

		else

			{

			// No more data

			break;

			}	

		}

	}

/**

Static method that calculates the length in characters of the given tag id

@param aTagId The tag id whose length in characters is to be calculated

@return The length in characters of the given tag id

*/

TInt CImapCommand::TagLength(TInt aTagId)

// static method

	{

	// Count how many characters would be needed to represent aTagId as a string.

	// Do this by count how many times aTagId can be divided by 10.

	TInt tagLength = 1; // values 0 to 9 have a length of 1 character

	while (aTagId > 9)

		{

		aTagId = aTagId / 10;

		++tagLength;

		}

	return tagLength;

	}

/**

Encodes a Unicode mailbox name by:

	- Converting it into ImapUtf7 format

	- Quoting it if necessary

@param aMailboxName the mailbox name in Unicode format.

@return the mailbox name in ImapUtf7, quoted if necessary.

*/

HBufC8* CImapCommand::EncodeMailboxNameForSendL(const TDesC16& aMailboxName)