// Copyright (c) 1997-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:
// This writes an SMS message and stores the message location number. AT+CMGW=xx
// 
//

#include "NOTIFY.H"
#include "mSMSMESS.H"
#include "mSMSWRIT.H"
#include "mSLOGGER.H"
#include "ATIO.H"
#include "mSMSSTOR.H"
#include "smsutil.h"
#include "et_phone_util.h"

_LIT8(KSmsWriteLengthCommand,"AT+CMGW = %d\r");
_LIT8(KSmsWriteCommand,"AT+CMGW = %d,%d\r");

CATSmsMessagingWrite* CATSmsMessagingWrite::NewL(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit, CPhoneGlobals* aMmStatus)
	{
	CATSmsMessagingWrite* self = new(ELeave) CATSmsMessagingWrite(aIo, aTelObject, aInit, aMmStatus);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CATSmsMessagingWrite::CATSmsMessagingWrite(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit, CPhoneGlobals* aMmStatus)
	:CATSmsCommands(aIo, aTelObject, aInit, aMmStatus)
	,iExpectString(NULL)
	,iSmsEntry(NULL)
	,iCancelled(EFalse)
	,iSmsStore(reinterpret_cast<CMobileSmsStore*>(aTelObject))
	{
	}

CATSmsMessagingWrite::~CATSmsMessagingWrite()
	{}

void CATSmsMessagingWrite::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams)
	{
	__ASSERT_DEBUG(aParams,Panic(EMobileSmsMessagingNullParameter));
	__ASSERT_DEBUG(aTsyReqHandle!=TSY_HANDLE_INIT_VALUE,Panic(EMobileSmsMessagingNullParameter));

	// Save the parameters into our class data
	iReqHandle = aTsyReqHandle;
	iCancelled=EFalse;
	iSmsEntry = reinterpret_cast<RMobileSmsStore::TMobileGsmSmsEntryV1*>(aParams);

	iNextAttempt=iPhoneGlobals->iPhoneTestState;
	// If undefined, try old standard first
	if(iNextAttempt==CPhoneGlobals::EPhoneTestUndefined)
		iNextAttempt=CPhoneGlobals::EPhoneTestOldStandard;

	iPhoneGlobals->iEventSignalActive = ETrue;
	if (ComparePrefMem(iSmsStore->iStoreName))
		StartPduWrite();
	else // Compared memories are different
		{
		SetCurrentPrefMem(iSmsStore->iStoreName);
		iState = EATWaitForSendingPrefMemComplete;
		}
	}

void CATSmsMessagingWrite::EventSignal(TEventSource aSource)
	{
	LOGTEXT2(_L8("CATSmsMessagingWrite:\tiState = %D"), iState);

	if (aSource == ETimeOutCompletion)
		{
		LOGTEXT(_L8("CATSmsMessagingWrite:\tTimeout Error during Sms Messaging Write"));
		iPhoneGlobals->iPhoneStatus.iModemDetected = RPhone::EDetectedNotPresent;
		RemoveStdExpectStrings();
		if ((iState != EATWaitForPrefMemResponse)&&!ComparePrefMem(iSmsStore->iStoreName))
			iPhoneGlobals->iPhonePrefMem = iSmsStore->iStoreName; 
		Complete(KErrTimedOut, aSource);
		return;
		} //if

	switch(iState)
		{
	// the following 3 cases are special cases, occuring only when the PhonePrefMem != ClientPrefMem
	case EATWaitForSendingPrefMemComplete:
		//
		// Finished writing preferred memory, now wait for response
		//
			{
			HandleWriteCompletion(aSource);
			iState = EATWaitForPrefMemResponse;
			}
		break;

	case EATWaitForPrefMemResponse:
		//
		// Got response from writing preferred memory.  Validate response, and if
		// successful, then start the write sequence
		//
			{	
			TInt ret=HandleResponseCompletion(aSource,EFalse);
			if (ret!=KErrNone)
				{
				Complete(ret,aSource);
				return;
				}		
			TInt pos=iIo->BufferFindF(KCPMSResponseString);
			if (pos == KErrNotFound)
				{
				Complete(pos, aSource);
				return;
				}
			LOGTEXT(_L8("CATSmsMessagingWrite:\tPhone's preferred memory successfully set to client's preferred memory."));
			iPhoneGlobals->iPhonePrefMem=iSmsStore->iStoreName;
			if (iCancelled)
				Complete(KErrCancel,aSource);
			else
				StartPduWrite();
			}
		break;

	case EATWaitForSendingPduLengthComplete:
		//
		// Finished sending pdu length command, now wait for response
		//
			{
			HandleWriteCompletion(aSource);
			iExpectString=iIo->AddExpectString(this,KSmsEnterPduModeResponse,ETrue); // Expecting "> "
			iIo->SetTimeOut(this, 5000);
			iState=EATReadPduEnterPduModeResponseCompleted;
			}
		break;
	
	case EATReadPduEnterPduModeResponseCompleted:
		//
		// Received a response to the pdu length command.  Validate, and if successful
		// send the actual pdu in ascii form
		//
			{
			TInt ret=HandleResponseCompletion(aSource,EFalse);
			if (ret!=KErrNone)
				{
				Complete(ret,aSource);
				return;
				}		
			ret=ConvertCMSErrorToKErr(CMSErrorValue());
			iIo->RemoveExpectString(iExpectString);
			iExpectString=NULL;
			if(ret)
				{
				Complete(ret,aSource);
				return;
				}
			iMsgDataAscii.Append(KCtrlZChar); // Adding the CTRL-Z that indicates the end of the PDU
			iIo->Write(this,iMsgDataAscii);
			iIo->SetTimeOut(this, 5000);
			iState=EATWaitForSendingPduComplete;
			}
		break;

	case EATWaitForSendingPduComplete:
		//
		// Finished writing pdu, wait for a response
		//
			{
			HandleWriteCompletion(aSource);
			iState=EATReadSmsRefNumCompleted;
			}
		break;

	case EATReadSmsRefNumCompleted:
		//
		// Received response to pdu write, validate and if successful set preferred
		// memory back to original value if it was changed for this command,
		// otherwise on failure try the new format if the current attempt used the
		// old ETSI format
		//
			{
			TInt ret=HandleResponseCompletion(aSource,EFalse);
			if (ret!=KErrNone)
				{
				Complete(ret,aSource);
				return;
				}		
			TInt err=ConvertCMSErrorToKErr(CMSErrorValue());
			
			if (err==KErrNone)
			 	TRAP(err,ParseResponseL());
			
			if(err!=KErrNone)
				{ 
				if (iCancelled)
					Complete(KErrCancel,aSource);
				else
					{	
					// Try new standard if old standard failed
					LOGTEXT2(_L8("CATSmsMessagingWrite:\tFailed with code %d"),err);
					if (iNextAttempt==CPhoneGlobals::EPhoneTestOldStandard)
						{
						iNextAttempt=CPhoneGlobals::EPhoneTestNewStandard;
						StartPduWrite();
						}
					else
						// Must have tried new standard and this failed too
						Complete(err);
					}
				}
			else
				{
				// If new standard worked then store this is as default for this phone
				if (iNextAttempt==CPhoneGlobals::EPhoneTestNewStandard)
					iPhoneGlobals->iPhoneTestState=CPhoneGlobals::EPhoneTestNewStandard;
				Complete(KErrNone,aSource);
				}
			}
		break;


	case EATCancellingWaitForWriteComplete:
		//
		// Finished writing cancel request, now wait for response
		//
			{
			__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));
			AddStdExpectStrings();
			iIo->SetTimeOut(this);
			iState=EATCancellingReadCompleted;
			}
		break;

	case EATCancellingReadCompleted:
		//
		// Cancel command response received
		//
			{
			__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));
			iIo->WriteAndTimerCancel(this);
			Complete(KErrCancel, aSource);
			}
		break;

	default:
		break;
		}
	}

void CATSmsMessagingWrite::StartPduWrite()
/**
 * Kicks off the writing of the actual pdu. Begins by converting the pdu
 * into ascii form, and writing the pdu length and message status to the phone.
 */
	{
	iMsgDataAscii.Zero();

	// Convert PDU from binary to ASCII
	CATSmsUtils::AppendDataToAscii(iMsgDataAscii,iSmsEntry->iMsgData);
	if(iMsgDataAscii.Length()==0)
		{
		LOGTEXT(_L8("CATSmsMessagingWrite:\tStartPduWrite - Failed to convert binary PDU to ASCII"));
		Complete(KErrCorrupt);
		return;
		}

	// Send PDU length to the phone
	const TInt pduLengthSemiOctets(iMsgDataAscii.Length());
	const TInt pduLengthOctets(pduLengthSemiOctets/2+pduLengthSemiOctets%2);

	if (iNextAttempt==CPhoneGlobals::EPhoneTestNewStandard)
 		{
		// Prepend a zero length SCA to PDU - this forces phone to use default SCA
		// See GSM 07.05 for details
		_LIT8(zeroLengthSca, "00");
		iMsgDataAscii.Insert(0,zeroLengthSca);
		}
	
	iTxBuffer.Zero();
	TInt stat=SetMsgStatus();
	if (stat==KErrNotSupported)
		iTxBuffer.Format(KSmsWriteLengthCommand,pduLengthOctets);
	else
		iTxBuffer.Format(KSmsWriteCommand,pduLengthOctets,stat);
	iIo->Write(this,iTxBuffer);
	iIo->SetTimeOut(this,5000);
	iState=EATWaitForSendingPduLengthComplete;
	}

void CATSmsMessagingWrite::Complete(TInt aError)
	{
	Complete(aError, EReadCompletion);
	}

void CATSmsMessagingWrite::Complete(TInt aError, TEventSource aSource)
	{
	iIo->WriteAndTimerCancel(this);
	iIo->RemoveExpectStrings(this);
	iOKExpectString = NULL;
	iErrorExpectString = NULL;
	iExpectString = NULL;
	iPhoneGlobals->iEventSignalActive = EFalse; 
	if (iReqHandle != 0)
		iTelObject->ReqCompleted(iReqHandle, aError);
	if (aSource == EWriteCompletion)
		iIo->Read();

	//
	// Call our base classes Complete so that
	// we allow it do what ever it needs to do.
	CATCommands::Complete(aError,aSource);

	iState = EATNotInProgress;
	}

void CATSmsMessagingWrite::ParseResponseL()
//
// Parse the message reference number and return in smsEntry.iIndex
//
	{
	LOGTEXT(_L8("CATSmsMessagingWrite:\tRetrieving message reference number"));
	iBuffer.Set(iIo->Buffer());
	TInt pos = iBuffer.FindF(KCMGWResponseString);
	if (pos == KErrNotFound)
		{
		LOGTEXT(_L8("CATSmsMessagingWrite:\tError - Cannot find '+CMGW:' string"));
		pos = iBuffer.FindF(KErrorString);
		if (pos != KErrNotFound)
			User::Leave(KErrGeneral);
		User::Leave(pos);
		}
	pos += 6;
	
	// Place the message reference number into buffer (ie: everything after +CMGW: string)
	TInt woop = iBuffer.Length()-pos;
	iBuffer.Set(iBuffer.Right(woop));
	
	TLex8 yyLex(iBuffer);
	yyLex.Inc();			// steps over the ':' Should always do this....NEVER falls over!
	yyLex.SkipSpace();
	TUint val;
	if(yyLex.Val(val)==KErrNone) // Grab the message reference number.
		{
		iSmsEntry->iIndex = val;
		}
	else
		{
		LOGTEXT(_L8("CATSmsMessagingWrite:\tError. Invalid Message Reference Number."));
		User::Leave(KErrGeneral);
		}
	}

void CATSmsMessagingWrite::Stop(TTsyReqHandle aTsyReqHandle)
//
//	Attempts to halt the process
//
	{
	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle));		
	LOGTEXT(_L8("CATSmsMessagingWrite:\tCancelling Sms Write"));

	if ((iState==EATWaitForSendingPduLengthComplete) ||
		(iState==EATReadPduEnterPduModeResponseCompleted) ||
		(iState==EATWaitForSendingPduComplete) ||
		(iState==EATReadSmsRefNumCompleted))
		{
		// Attempt to cancel write command if we can
		RemoveStdExpectStrings();
		iIo->WriteAndTimerCancel(this);
		iTxBuffer.Format(KEscapeChar);
		iIo->Write(this,iTxBuffer);
		iIo->SetTimeOut(this);
		iState = EATCancellingWaitForWriteComplete;
		}
	else
		// Wait until safe point to cancel the write
		iCancelled=ETrue;
	}

void CATSmsMessagingWrite::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)
	{
	if (iState!=EATNotInProgress)
		{
		iIo->WriteAndTimerCancel(this);
		iTelObject->ReqCompleted(iReqHandle, aStatus);
		iState = EATNotInProgress;
		}
	}

TInt CATSmsMessagingWrite::SetMsgStatus()
//
// Sets the message status
//
	{
	TInt status;
	switch(iSmsEntry->iMsgStatus)
		{
		case (RMobileSmsStore::EStoredMessageUnread): 
			status = 0;
		break;
		
		case (RMobileSmsStore::EStoredMessageRead):
			status = 1;
		break;

		case (RMobileSmsStore::EStoredMessageUnsent):
			status = 2;
		break;

		case (RMobileSmsStore::EStoredMessageSent):  
		case (RMobileSmsStore::EStoredMessageDelivered):   
			status = 3;
		break;

		default:
			status = KErrNotSupported;
		break;
		}
	return status;
	}