// Copyright (c) 1999-2010 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 "SMSSOUTB.H"

#include <s32mem.h>

#include <smuthdr.h>		

#include <smscmds.h>

#include <msvschedulesend.h>

#include <msvsysagentaction.h>

#include <txtrich.h>

#include <logsmspdudata.h>

#include <smsulog.h>

#include <logwraplimits.h>

#include "SMSSendSession.h"

#include "SMSSPAN.H"

CSmsOutboxSend* CSmsOutboxSend::NewL(CMsvServerEntry& aServerEntry, CMsvScheduleSend& aScheduleSend, RFs& aFs)

	{

	CSmsOutboxSend* outboxsend=new(ELeave) CSmsOutboxSend(aServerEntry, aScheduleSend, aFs);

	CleanupStack::PushL(outboxsend);

	outboxsend->ConstructL();

	CleanupStack::Pop();

	return outboxsend;

	} 

CSmsOutboxSend::~CSmsOutboxSend()

	{

	Cancel();

	delete iSendSession;

	delete iMsvEntrySelection;

	delete iLogger;

	delete iSmsHeader;

	delete iRichText;

	delete iParaLayer;

	delete iCharLayer;

#if (defined SYMBIAN_USER_PROMPT_SERVICE)	

	iUpsSubsession.Close();

	iUpsSession.Close();

#endif	

	}

#if (defined SYMBIAN_USER_PROMPT_SERVICE)	

void CSmsOutboxSend::StartL(TRequestStatus& aStatus,const CMsvEntrySelection& aSelection, const TBool aMove, const TDesC8& aParameter, TThreadId aClientThreadId, TBool aHasCapability)	// kicks off the send session

	{

	// Connect to UPS service.....

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

	RThread clientThread;

 	User::LeaveIfError(clientThread.Open(aClientThreadId));

	CleanupClosePushL(clientThread);

 	User::LeaveIfError(iUpsSubsession.Initialise(iUpsSession, clientThread));

	CleanupStack::PopAndDestroy(&clientThread);

	iHasCapability = aHasCapability;

	Start(aStatus, aSelection, aMove, aParameter);

	}

#endif

void CSmsOutboxSend::Start(TRequestStatus& aStatus,const CMsvEntrySelection& aSelection, const TBool aMove, const TDesC8& aParameter)	// kicks off the send session

	{

	__ASSERT_DEBUG(iProgress.iState==ESmsOutboxSendStateWaiting,Panic(KSmssPanicAlreadySending));

	Queue(aStatus);

	iPackage.iParameter = aParameter;

	iMove = aMove;

	iStartTime.UniversalTime(); //used by FailOutstandingMessages

	TRAPD(err, FindOtherMessagesL(aSelection));

	RequestComplete(&iStatus, err, ETrue);

	}

void CSmsOutboxSend::DoSmssCancel()

	{

	switch (iProgress.iState)

		{

		case ESmsOutboxSendStateWaiting:

		case ESmsOutboxSendStateFindingOtherMessages:

		case ESmsOutboxSendStateReScheduling:

		case ESmsOutboxSendStateLogEntryComplete:

		case ESmsOutboxSendStateMovingEntry:

		case ESmsOutboxSendStateComplete:

			{

			break;

			}

#if (defined SYMBIAN_USER_PROMPT_SERVICE)			

		case ESmsOutboxSendAuthoriseState:

			{

			iUpsSubsession.CancelPrompt();

			break;

			}

#endif	

		case ESmsOutboxSendStateAddLogEvent:

		case ESmsOutboxSendStateGetLogEvent:

		case ESmsOutboxSendStateChangeLogEvent:

			{

			SMSSLOG(FLogFormat(_L8("CSmsOutboxSend::DoSmssCancel() cancelling logging for msg %d"), iCurrentMessage));

			iLogger->Cancel();

			break;

			}

		case ESmsOutboxSendStateSending:

			{

			SMSSLOG(FLogFormat(_L8("CSmsOutboxSend::DoSmssCancel() cancelling sending for msg %d"), iCurrentMessage));

			iSendSession->Cancel();

			break;

			}

		default:

			{

			Panic(KSmssPanicUnexpectedState);

			}

		}

	SMSSLOG(FLogFormat(_L8("CSmsOutboxSend::DoSmssCancel() setting sending state to SUSPENDED for unsent msgs")));

	FailOutstandingMessages(KErrCancel, KMsvSendStateSuspended);

	}

void CSmsOutboxSend::FailOutstandingMessages(TInt aError, TInt aSendingState)

	{

	TInt count = iMsvEntrySelection->Count();

	while (count--)

		{

		const TInt err = iServerEntry.SetEntry(iMsvEntrySelection->At(count));

		if (err == KErrNone)

			{

			TMsvEntry entry(iServerEntry.Entry());

			TBool failMsg = EFalse;

			switch (entry.SendingState())

				{

				case KMsvSendStateSending:

				case KMsvSendStateWaiting:

					failMsg = ETrue;

					break;

				case KMsvSendStateScheduled:

				case KMsvSendStateResend:

					failMsg = (entry.iDate < iStartTime);

					break;

				default:

					//failMsg = EFalse;

					break;

				}

			if (failMsg)

				{

				entry.SetSendingState(aSendingState);

				entry.iError = aError;

				entry.SetFailed(ETrue);

				entry.SetConnected(EFalse);

				entry.SetScheduled(EFalse);

				iServerEntry.ChangeEntry(entry); //ignore error

				}

			} //end if

		} //end while

	}

void CSmsOutboxSend::DoRunL()		// required by PV declaration in CActive

	{

	switch (iProgress.iState)

		{

		case ESmsOutboxSendStateFindingOtherMessages:

		case ESmsOutboxSendStateMovingEntry:

			{

			SendNextHeaderL();

			break;

			}

#if (defined SYMBIAN_USER_PROMPT_SERVICE)			

		case ESmsOutboxSendAuthoriseState:

			{

			if(iDecision == EUpsDecYes || iDecision == EUpsDecSessionYes)

				{

				SendHeader();	

				}

			else

				{

				// The decision from UPS server was NO, so do not send the message.

				iProgress.iState = ESmsOutboxSendStateReScheduling;

				iEntry = iServerEntry.Entry();

				iEntry.SetFailed(ETrue);

				iEntry.SetSendingState(KMsvSendStateFailed);

				TRequestStatus* status=&iStatus;

				iStatus=KRequestPending;

				User::RequestComplete(status,KErrNone);

				SetActive();

				}

			break;

			}

#endif

		case ESmsOutboxSendStateSending:

			{

			if (iCurrentMessage)

				{

				}

			else

				{

				__ASSERT_DEBUG(iProgress.iError == KErrNotFound, Panic(KSmssPanicUnexpectedErrorCode));

				}

			break;

			}

		case ESmsOutboxSendStateReScheduling:

			{

			iProgress.iRcpDone = -1;

			iProgress.iRcpCount = iSmsHeader->Recipients().Count();

			LogEntry();

			break;

			}

		case ESmsOutboxSendStateGetLogEvent:

			{

			if (iLogger->iStatus == KErrNone)

				{

				ChangeLogEvent();

				}

			else

				{

				//Log error has occured

				if (-(iLogger->iStatus.Int()) == KErrNotFound)

					{

					AddLogEvent();

					}

				else

					{

					LogEntry();

					}

				}

			break;

			}

		case ESmsOutboxSendStateAddLogEvent:

			{

			TLogId logId = KLogNullId;

			if (iLogger->iStatus.Int() == KErrNone)

				{

				//No log error has occured

				logId = iLogger->Event().Id();

				}

			iSmsHeader->Recipients()[iProgress.iRcpDone]->SetLogId(logId);

			iSmsHeader->Message().SetLogServerId(logId);

			//do not break here...

			}

		case ESmsOutboxSendStateChangeLogEvent:

			{

			LogEntry();

			break;

			}

		case ESmsOutboxSendStateLogEntryComplete:

			{

			MoveEntryL();

			break;

			}

		case ESmsOutboxSendStateComplete:

			{

			break;

			}

		case ESmsOutboxSendStateWaiting:

		default:

			Panic(KSmssPanicUnexpectedState);

		}

	}

void CSmsOutboxSend::FindOtherMessagesL(const CMsvEntrySelection& aSelection)

// Finds any other messages in the outbox that are waiting to send

	{

	iProgress.iState = ESmsOutboxSendStateFindingOtherMessages;

	delete iMsvEntrySelection;

	iMsvEntrySelection = NULL;

	iMsvEntrySelection = aSelection.CopyL();

	SMSSLOG(FLogFormat(_L8("Asked to send %d message(s)"), iMsvEntrySelection->Count()));

	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();

	CleanupStack::PushL(sel);

	User::LeaveIfError(iServerEntry.SetEntry(KMsvGlobalOutBoxIndexEntryId));

	//Find the children of the outbox for the SMS Mtm

	User::LeaveIfError(iServerEntry.GetChildrenWithMtm(KUidMsgTypeSMS, *sel));

	TInt count = sel->Count();

	while (count--)

		{

		TMsvId id = sel->At(count);

		User::LeaveIfError(iServerEntry.SetEntry(id));

		TInt sendState = iServerEntry.Entry().SendingState();

		if (sendState == KMsvSendStateWaiting || sendState == KMsvSendStateUnknown)

			{

			// check that the entry is not already in iMsvEntrySelection

			TBool foundMessage = EFalse;

			TInt numberMessages = iMsvEntrySelection->Count();

			for(TInt a = 0; a < numberMessages; a++)

				{

				if(iMsvEntrySelection->At(a) == id)

					{

					foundMessage = ETrue;

					break;

					}

				}

			// only add the id of the message if it has not been found in iMsvEntrySelection

			if(!foundMessage)

				iMsvEntrySelection->AppendL(id);

			}

		}

	CleanupStack::PopAndDestroy(); //sel

	//Instantiate iSendSession with the updated iMsvEntrySelection

	iSendSession = CSmsSendSession::NewL(iProgress, iServerEntry, iFs, *iSmsHeader, *iRichText, iEntry);

	iSendSession->DivideMessagesL(*iMsvEntrySelection); //Leaves with KErrNotFound if iMsvEntrySelecion.Count() == 0 (on the way in)

	//Leaves with KErrUnknownBioType if iMsvEntrySelection.Count() == 0 (on the way out)

	//Leaves with another error if iServerEntry.SetEntry() failed and iMsvEntrySelection.Count() == 0 (on the way out)

	iProgress.iError = KErrNone;

	iProgress.iMsgCount = iMsvEntrySelection->Count();

	iProgress.iMsgDone= -1;

	__ASSERT_DEBUG(iProgress.iMsgCount, Panic(KSmssPanicNoMessagesInSelection));

	SMSSLOG(FLogFormat(_L8("\tActually sending %d message(s)"), iProgress.iMsgCount));

	TMsvSendErrorAction action;

	iCondMet = ConditionsRightForSending(action); //Checks the system agent

	if (!iCondMet)

		{

		SMSSLOG(FLogFormat(_L8("Conditions NOT right for sending. Scheduling all messages")));

        iProgress.iState = ESmsOutboxSendStateComplete;

		}

	count = iMsvEntrySelection->Count();

	while (count--)

		{

		//Should not leave at this point, as it would have left at DivideMessagesL().

		User::LeaveIfError(iServerEntry.SetEntry(iMsvEntrySelection->At(count)));

		iEntry = iServerEntry.Entry();

		if (!iCondMet)

			{

			iEntry = iServerEntry.Entry();

			iEntry.SetFailed(ETrue);

			iEntry.iError = action.iError;

			DoReScheduleL(&action);

			}

		else if (iEntry.SendingState() != KMsvSendStateWaiting && CanSendMessage(iEntry))

			{

			iEntry.SetSendingState(KMsvSendStateWaiting);

			iServerEntry.ChangeEntry(iEntry);

			}

		}

	}

void CSmsOutboxSend::DoReScheduleL(const TMsvSendErrorAction* aErrorAction)

	{

	__ASSERT_DEBUG(iServerEntry.Entry().Id() == iEntry.Id(), Panic(ESmssEntryNotSet));

	//Log the failed message

	SMSSLOG(FLogFormat(_L8("Sending FAILED for msg %d with error %d. Attempting re-schedule"), iEntry.Id(), iEntry.iError));

	CMsvEntrySelection* reSch = new (ELeave) CMsvEntrySelection();

	CleanupStack::PushL(reSch);

	reSch->AppendL(iEntry.Id());

	TMsvSchedulePackage schPkg;

	schPkg.iCommandId = iMove ? ESmsMtmCommandSendScheduledMove : ESmsMtmCommandSendScheduledCopy;

	//Re-Schedule the failed message

	iScheduleSend.ReScheduleL(*reSch, schPkg, aErrorAction);

	CleanupStack::PopAndDestroy(); //reSch

	//Restore iEntry, because it may have changed while re-scheuling

	User::LeaveIfError(iServerEntry.SetEntry(iEntry.Id()));

	iEntry = iServerEntry.Entry();

	//Restore the iSmsHeader, because it may have changed while re-scheduling

	CMsvStore* store = iServerEntry.ReadStoreL();

	CleanupStack::PushL(store);

	iSmsHeader->RestoreL(*store);

	CleanupStack::PopAndDestroy(); //store

	}

void CSmsOutboxSend::ReScheduleFailedMessageL()

	{

	__ASSERT_DEBUG(iCurrentMessage == iEntry.Id(), Panic(ESmssEntryNotSet));

	iProgress.iState = ESmsOutboxSendStateReScheduling;

	TInt err = KErrNone;

	//Check to make sure the message still exits

	if (iServerEntry.Entry().Id() != iEntry.Id())

		{

		err = iServerEntry.SetEntry(iEntry.Id());

		if (err == KErrNone)

			iEntry = iServerEntry.Entry();

		else if (err != KErrNotFound)

			User::Leave(err);

		}

	if (err == KErrNone)

		{

		if (!iEntry.Failed() && iProgress.iError)

			{

			iEntry.SetFailed(ETrue);

			iEntry.iError = iProgress.iError;

			}

		if (iEntry.Failed() && iEntry.SendingState() != KMsvSendStateSuspended)

			{

			DoReScheduleL();

			}

		else

			{

			iScheduleSend.SendingCompleteL(iEntry, EFalse);

			}

		RequestComplete(&iStatus, KErrNone, ETrue);

		}

	else // err == KErrNotFound (the user has deleted the message)

		{

		SendNextHeaderL(); //send the next message

		}

	}

CSmsOutboxSend::CSmsOutboxSend(CMsvServerEntry& aServerEntry, CMsvScheduleSend& aScheduleSend, RFs& aFs)

	:CSmssActive(aFs, aServerEntry, KSmsSessionPriority),

	iProgress(TSmsProgress::ESmsProgressTypeSending),

	iScheduleSend(aScheduleSend)

	{

	CActiveScheduler::Add(this);

	}

void CSmsOutboxSend::ConstructL()

	{

	iLogger = CSmsEventLogger::NewL(iFs);

	// stuff for the body text....

	iParaLayer = CParaFormatLayer::NewL();

	iCharLayer = CCharFormatLayer::NewL();

	iRichText = CRichText::NewL( iParaLayer, iCharLayer, CEditableText::EFlatStorage, 256);

	iSmsHeader = CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText);

	TInt ret = iServerEntry.SetEntry(KMsvSentEntryId);

	if (ret != KErrNotFound)

		{

		User::LeaveIfError(ret);

		iSentFolderExists = ETrue;

		}

	else

		{

		iSentFolderExists = EFalse;

		}

	}

void CSmsOutboxSend::SendNextHeaderL()

	{

	iProgress.iMsgDone++;

	iCurrentMessage = iSendSession->IncSms();

	if(iProgress.iMsgDone >= iProgress.iMsgCount || !iCurrentMessage)

		{

		iProgress.iState = ESmsOutboxSendStateComplete;

		RequestComplete(&iStatus, KErrNone, ETrue);

		}

	else

		{

		iErr = iServerEntry.SetEntry(iCurrentMessage);

#if (defined SYMBIAN_USER_PROMPT_SERVICE)

		iDecision = EUpsDecNo;		

		iProgress.iState = ESmsOutboxSendAuthoriseState;

		//Restore the CSmsHeader

		CMsvStore* store = iServerEntry.ReadStoreL();

		CleanupStack::PushL(store);

		iSmsHeader->RestoreL(*store);

		CleanupStack::PopAndDestroy(); //store

		// Need to create a single TDesC using the the Recipient list

		CArrayPtrFlat<CSmsNumber>& numbers = iSmsHeader->Recipients();

		TInt size = 0;

		TInt num = numbers.Count();

		CSmsNumber* rcpt = NULL;

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

			{

			rcpt = numbers[i];

			size += rcpt->Address().Size();

			}

		_LIT16(KComma, ",");

		RBuf16 buffer;

		if(num > 0)

			{

			rcpt = numbers[0];

			buffer.Append(rcpt->Address());	

			}

		for(TInt i=1;i<num; ++i)

			{

			buffer.Append(KComma);

			rcpt = numbers[i];