// Copyright (c) 1999-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 "sendrecv.h"
#include <smuthdr.h>

#include <txtrich.h>
#include <txtfmlyr.h>

#include <bitsids.h>

const TTimeIntervalMicroSeconds32 KWaitForReceiveIteration = 2000000;
const TTimeIntervalMicroSeconds32 KMaxWaitForMsg = 60000000;

CSendReceive::~CSendReceive()
	{
	delete iEntryForObserver;

	iReceived = NULL;
	delete iReceived;
	if (iOperation)
		{
		iOperation->Cancel();
		delete iOperation;
		iOperation = NULL;
		}

	delete iSelection;
	iSelection = NULL;

	if (iTimer)
		{
		iTimer->Cancel();
		delete iTimer;
		iTimer = NULL;
		}
	}


CSendReceive* CSendReceive::NewL(CSmsTestUtils& aTestUtils)
	{
	CSendReceive* self = new (ELeave) CSendReceive(aTestUtils);
	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();
	return self;
	}


void CSendReceive::TestSendingL()
//
//
//
	{
	iSmsTest.Test().Next(_L("Sending"));

	TTime now;
	now.HomeTime();
	now += (TTimeIntervalSeconds) 5;

	iSelection->Reset();

	iSmsTest.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

	TBool read = EFalse;
	iSmsTest.Printf(_L("Creating msgs in outbox from script:"));
	iSmsTest.Printf(KSendRecvScript);
	TRAPD(err, read = iSmsTest.ReadScriptL(KSendRecvScript, KMsvGlobalOutBoxIndexEntryId, *iSelection, now));

	iSmsTest.Test()(!err && read);

	// read any test messages from file
//	CreateWappMessagesL();

	iSmsTest.Printf(_L("Send and Receive %d messages...\n"), iSelection->Count());

	iCurrentMessageNum = -1;
	}
/*
void CSendReceive::CreateWappMessagesL()
	{

	TBufC<KMaxFileName> currentFile;

	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection();
	CleanupStack::PushL(selection);

	TInt err = Session().FileSession().GetDir(KMessageFileDirectory, KEntryAttMatchMask, ESortByName, iDir);
	if (err == KErrPathNotFound)
		{
		TInt makeDirErr = Session().FileSession().MkDirAll(KMessageFileDirectory);	
		makeDirErr==KErrNone ? User::Leave(KErrNotFound): User::Leave(makeDirErr);
		}
	else if (err!=KErrNone)
		{
		User::Leave(err);
		}

	// Set the session path for the RFs
	Session().FileSession().SetSessionPath(KMessageFileDirectory);
	if (iDir) 
		delete iDir;
	User::LeaveIfError(Session().FileSession().GetDir(_L("wapp*.txt"), KEntryAttNormal, ESortByName, iDir));
    TInt count = iDir->Count();
    
	TBuf<60> outputBuf;

	for(TInt loop = 0; loop < count; loop++)
		{
		currentFile=( (*iDir)[loop].iName );
		// Not processed all the messages - so keep the current state
		
		}
	CleanupStack::Pop(); // selection
	}

HBufC* CSendReceive::ReadWappMessageFromFileL(const TDesC& aFile)
	{
	RFile           file;
	TBuf8<1024>     lineBuffer;   // Buffer for Read function.
	TInt			err=KErrNone;

	err = file.Open(Session().FileSession(),aFile,EFileStreamText|EFileRead|EFileShareAny);

    if(err != KErrNone)  // Didn't find the file, so leave - should only get valid filenames!
        {
        User::Leave(KErrNotFound);
		}

	// In real life this is set by the Socket Port Observer, or the SMS server.
	// So,in this test code we must do it by creating a random  telephone number.
	//	iMessageDetails = CreateDummyPhoneNumberL();

    HBufC*	bioBuf=HBufC::NewLC(1024); // Create a new descriptor on the heap.
	HBufC*	copyBuffer=HBufC::NewLC(1024);

    do // Read in the text from file, and also check if there is a name field:
		{
		err = file.Read(lineBuffer);// Read upto 256 chars, '\n' and all...
		//err = ReadLineL(file,lineBuffer);
		if (err==KErrNone)				// Made a valid read,
			if (lineBuffer.Length()==0) // but read 0 chars
				err=KErrEof;			// so set err value to end processing

		if(err == KErrNone)
			{
			copyBuffer->Des().Copy(lineBuffer);// Copy, and overwrite existing text
			if( (bioBuf->Length() + copyBuffer->Length()) > bioBuf->Des().MaxLength() )
					{
					bioBuf = bioBuf->ReAllocL(bioBuf->Length() + copyBuffer->Length());
					}
			bioBuf->Des().Append(*copyBuffer);
            //bioBuf->Des().Append(_L("\n"));
			}
		}
    while(err != KErrEof);

	CleanupStack::PopAndDestroy(); // Destroy the copyBuffer.
	CleanupStack::Pop();// Remove the bioBuf.
    
	file.Close();
	return bioBuf;  // Transfer ownership and responsibility of the buffer.
	}

void CSendReceive::CreateMessageL(const TDesC& aFile)
	{
	CParaFormatLayer* paraFormat = CParaFormatLayer::NewL();
	CleanupStack::PushL(paraFormat);
	CCharFormatLayer* charFormat = CCharFormatLayer::NewL();
	CleanupStack::PushL(charFormat);
	CRichText* richText = CRichText::NewL(paraFormat, charFormat);
	CleanupStack::PushL(richText);

	HBufC* buffer = ReadWappMessageFromFileL(aFile);
	CleanupStack::PushL(richText);
	
	richText->InsertL(0,*buffer);

	CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *richText);
	CleanupStack::PushL(header);

	TTime now;
    now.HomeTime();

	TMsvEntry entry;
	entry.SetSendingState(KMsvSendStateUponRequest);
	entry.iBioType = KUidBIOWAPAccessPointMsg;

	iSmsTest.CreateMessageL(KMsvGlobalInBoxIndexEntryId,entry,*header,*richText,now);

	delete buffer;
	CleanupStack::PopAndDestroy(5);
	}
*/
TBool CSendReceive::SendNextMessageL()
	{
	iCurrentMessageNum++;
	const TInt count = iSelection->Count();

	if (iCurrentMessageNum < count)
		{
		iSmsTest.Printf(_L("Sending message %d of %d\n"), iCurrentMessageNum + 1, count);

		iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);

		delete iOperation;
		iOperation = NULL;

		CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();
		CleanupStack::PushL(sel);
		sel->AppendL(iSelection->At(iCurrentMessageNum));
		iOperation = MsvEntry().CopyL(*sel, iSmsTest.iSmsServiceId, iStatus);
		CleanupStack::PopAndDestroy(); //sel
		
		iState = EStateSending;
		SetActive();
		CActiveScheduler::Start();
		return ETrue;
		}

	return EFalse;
	}

void CSendReceive::TestWaitForReceiveL()
	{
	iSmsTest.Test().Next(_L("Waiting to receive message"));
	iState = EStateWaitingToReceive;
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	SetActive();
	}

CSendReceive::CSendReceive(CSmsTestUtils& aTestUtils)
: CActive(EPriorityStandard),iCurrentMessageNum(-1),iSmsTest(aTestUtils),iState(EStateWaiting)
	{
	}

void CSendReceive::StartL(CMsvEntrySelection* aReceived)
	{
	iCurrentTest = 0;
	iReceived = aReceived;
	
	iSmsTest.TestStart(++iCurrentTest, _L("Read Script"));
	TestSendingL();
	User::LeaveIfError(iStatus.Int());
	iSmsTest.TestFinish(iCurrentTest, KErrNone);

	FOREVER
		{
		iSmsTest.TestStart(++iCurrentTest, _L("Send Message"));
		TBool sendNext = SendNextMessageL();
		if (sendNext)
			{
			User::LeaveIfError(iStatus.Int());
			iSmsTest.TestFinish(iCurrentTest, KErrNone);
			}
		else
			{
			iSmsTest.Printf(_L("No more messages to send!"));
			iSmsTest.TestFinish(iCurrentTest, KErrNone);
			break;
			}
		}

	iSmsTest.TestStart(++iCurrentTest, _L("Wait to receive extra message(s)"));
	User::LeaveIfError(iStatus.Int());
	iSmsTest.TestFinish(iCurrentTest, KErrNone);
	}

void CSendReceive::ConstructL()
	{
	iSelection = new (ELeave) CMsvEntrySelection();
	iTimer = CTestTimer::NewL();
	CActiveScheduler::Add(this);

	iSmsTest.SetCommDbServiceCenterFromScriptL(KSendRecvScript);
	}

void CSendReceive::RunL()
	{
	TRAPD(err, DoRunL());
	if (err && iStatus == KErrNone)
		{
		iStatus = err;
		}
	if(!IsActive())
		CActiveScheduler::Stop();
	}

void CSendReceive::DoRunL()
	{
	switch (iState)
		{
		case EStateSending:
			{
			DoRunSendingL();
			delete iOperation;
			iOperation = NULL;
			break;
			}
		case EStateWaitingToReceive:
			{
			DoRunWaitingToReceiveL();
			break;
			}
		case EStateWaitingToReceiveAnyExtra:
			{
			DoRunWaitForExtraL();
			break;
			}
		case EStateMessageReceived:
			{
			break;
			}
		default:
			{
			break;
			}
		}
	}

void CSendReceive::DoCancel()
	{
	if (iOperation)
		{
		iOperation->Cancel();
		iSmsTest.Printf(_L("Operation Cancelled!\n"));
		}
	delete iOperation;
	iOperation = NULL;
	}

void CSendReceive::DoRunSendingL()
	{
	if (iOperation)
		iSmsTest.SetProgressL(*iOperation);

	TInt count = iSelection->Count();
	TBool wait = EFalse;

	while (iStatus == KErrNone && count--)
		{
		TRAPD(err, iSmsTest.SetEntryL(iSelection->At(count)));

		if (err == KErrNone)
			{
			TMsvEntry entry = MsvEntry().Entry();
			iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);

			TBuf<0x100> output;
			TBuf<0x50>  nowBuf;

			switch (entry.SendingState())
				{
				case KMsvSendStateSending:
					output.AppendFormat(_L("Message %d Sending with error %d\n"), entry.Id(), entry.iError);
					wait = ETrue;
					break;
				case KMsvSendStateResend:
					output.AppendFormat(_L("Message %d Resend at "), entry.Id());
					entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B"));
					output.Append(nowBuf);
					output.Append(_L("\n"));
					wait = ETrue;
					break;
				case KMsvSendStateScheduled:
					output.AppendFormat(_L("Message %d Scheduled at "), entry.Id());					entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B"));
					entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B"));
					output.Append(nowBuf);
					output.Append(_L("\n"));
					wait = ETrue;
					break;
				case KMsvSendStateFailed:
					output.AppendFormat(_L("Message %d Failed with error %d\n"), entry.Id(), entry.iError);
					if (entry.iError)
						iStatus = entry.iError;
					else
						iStatus = KErrGeneral;

					break;
				case KMsvSendStateWaiting:
					output.AppendFormat(_L("Message %d Waiting with error %d\n"), entry.Id(), entry.iError);
					wait = ETrue;
					break;
				case KMsvSendStateSent:
				default:
					break;
					//nothing
				}

			iSmsTest.Printf(output);
			}
		}

	if (wait)
		{
		iTimer->AfterReq(10000000, iStatus);
		SetActive();
		iState = EStateSending;
		}
	else
		{
		iSmsTest.Printf(_L("Sending completed with error %d\n"), iStatus);
		
		if (iStatus == KErrNone)
			{
			TestWaitForReceiveL();
			}
		else
			{
			iState = EStateWaiting;
			}
		}
	}

void CSendReceive::WaitForExtraL()
	{
	iSmsTest.Printf(_L("Waiting for any extra to arrive...\n"));
	iCountWaits = 0;
	iState = EStateWaitingToReceiveAnyExtra;
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	SetActive();
	}

void CSendReceive::DoRunWaitForExtraL()
	{
	iCountWaits++;

	TInt totalSentCount = iSelection->Count();
	TInt recvCount = iReceived->Count();

	if (recvCount > totalSentCount)
		{
		iSmsTest.Printf(_L("Too many messages received:\nSent %d Rcvd %d\n"), totalSentCount, recvCount);
		iStatus = KErrOverflow;
		}
	else
		DoWaitL();
	}

void CSendReceive::DoRunWaitingToReceiveL()
	{
	iCountWaits++;

	TInt totalSentCount = iSelection->Count();
	TInt recvCount = iReceived->Count();

	if (recvCount > totalSentCount || recvCount > (iCurrentMessageNum + 1))
		{
		iSmsTest.Printf(_L("Too many messages received:\nSent %d Rcvd %d\n"), totalSentCount, recvCount);
		iStatus = KErrOverflow;
		}
	else 
		{
		if (totalSentCount == recvCount)
			{
			iSmsTest.Printf(_L("All Messages Received!!\n"));
			}
		else if (recvCount == iCurrentMessageNum + 1)
			{
			//Message received
			iState = EStateMessageReceived;
			iCountWaits = 0;
			TRequestStatus* status = &iStatus;
			User::RequestComplete(status, KErrNone);
			SetActive();
			}
		else
			{
			DoWaitL();
			}
		}
	}

void CSendReceive::DoWaitL()
	{
	TInt totalSentCount = iSelection->Count();
	TInt recvCount = iReceived->Count();

	TInt maxCount = KMaxWaitForMsg.Int() / KWaitForReceiveIteration.Int();
	TInt waitSecs = KWaitForReceiveIteration.Int() * (maxCount - iCountWaits) / 1000000;
	iSmsTest.Printf(_L("Waiting %d secs to recv msg\n"), waitSecs);

	if (iCountWaits < maxCount)
		{
		iTimer->AfterReq(KWaitForReceiveIteration, iStatus);
		SetActive();
		}
	else
		{
		iSmsTest.Printf(_L("Time Out: Message NOT Received\n"));

		if (totalSentCount != recvCount)
			{
			iStatus = KErrTimedOut;
			}
		}
	}