// Copyright (c) 2000-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 "T_SmsRegress.h"
#include <smscmds.h>
_LIT(KSmsScript, "sms.script");

GLDEF_C TInt E32Main()
	{	
	__UHEAP_MARK;
	test.Start(_L("Setup"));
	theCleanup = CTrapCleanup::New();
	TRAPD(ret,doMainL());		
	test(ret==KErrNone);
	delete theCleanup;	
	test.Console()->SetPos(0, 13);
	test.End();
	test.Close();
	__UHEAP_MARKEND;
	return(KErrNone);
	}

LOCAL_C void doMainL()
	{
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);

	CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test);
	CleanupStack::PushL(smsTest);
	TInt nextTest = 0;

	smsTest->NotifySaPhoneOnL();
	
	CSmsRegressTest* SmcmTest = CSmsRegressTest::NewLC(*smsTest, KNullDesC, nextTest);

	smsTest->WaitForInitializeL();

	SmcmTest->StartL();

	CleanupStack::PopAndDestroy(3); //SmcmTest. scheduler
	}

CSmsRegressTest::CSmsRegressTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)
: CSmsTestBase(aSmsTest, aScriptFile, aNextTest), iOperations(aSmsTest)
	{
	CActiveScheduler::Add(this);
	}

void CSmsRegressTest::RunAutoL()
	{
	iNextTest = 0;

	iSmsTest.TestStart(++iNextTest, _L("Test2SMSSInstances"));  
	Test2SMSSInstancesL();
	User::LeaveIfError(iStatus.Int());
	iSmsTest.TestFinish(iNextTest);
	}

void CSmsRegressTest::Test2SMSSInstancesL()
	{
	TTime now;
	now.HomeTime();

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

	iSmsTest(iSmsTest.ReadScriptL(KSmsScript, KMsvGlobalOutBoxIndexEntryId, *sel, now));
	iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);

	CMsvOperationWait* wait = CMsvOperationWait::NewLC();
	wait->Start();

	CMsvOperation* op = iSmsTest.iMsvEntry->CopyL((*sel)[0], KMsvGlobalOutBoxIndexEntryId, wait->iStatus);
	CleanupStack::PushL(op);
	CActiveScheduler::Start();

	TMsvLocalOperationProgress prog;
	TPckgC<TMsvLocalOperationProgress> pkg(prog);
	pkg.Set(op->ProgressL());
	prog = pkg();
	User::LeaveIfError(prog.iError);

	const TMsvId sms1 = (*sel)[0];
	const TMsvId sms2 = prog.iId;

	CleanupStack::PopAndDestroy(2); //wait, op

	_LIT(KDesc1, "Remote");
	_LIT(KDesc2, "Local");

	iSmsTest.SetEntryL(sms1);
	TMsvEntry entry(iSmsTest.Entry());
	entry.iDescription.Set(KDesc1);
	iSmsTest.ChangeEntryL(entry);
	
	iSmsTest.SetEntryL(sms2);
	entry = iSmsTest.Entry();
	entry.iServiceId = KMsvLocalServiceIndexEntryId;
	entry.iDescription.Set(KDesc2);
	iSmsTest.ChangeEntryL(entry);

	iSmsTest.Printf(_L("Test2SMSSInstancesL for 2 messages:\n"));
	iSmsTest.DisplayMessageL(sms1);
	iSmsTest.DisplayMessageL(sms2);

	iOperations.ResetAndDestroy();

	//Start first operation
	COpActive* opActive = new (ELeave) COpActive(iOperations, sms1);
	CleanupStack::PushL(opActive);
	iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);
	opActive->iOperation = iSmsTest.iMsvEntry->CopyL(opActive->Id(), iSmsTest.iSmsServiceId, opActive->Status());
	iOperations.AppendL(opActive);
	CleanupStack::Pop(opActive);
	
	//Start second operation
	opActive = new (ELeave) COpActive(iOperations, sms2);
	CleanupStack::PushL(opActive);
	iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);
	sel->Reset();
	sel->AppendL(opActive->Id());
	opActive->iOperation = iSmsTest.iMsvSession->TransferCommandL(*sel, ESmsMtmCommandScheduleCopy, KNullDesC8, opActive->Status());
	iOperations.AppendL(opActive);
	CleanupStack::Pop(opActive);

	CleanupStack::PopAndDestroy(sel);

	iState = ETest2SMSSInstances;
	iOperations.Start(iStatus);
	SetActive();
	CActiveScheduler::Start();
	}


CSmsRegressTest::~CSmsRegressTest()
	{
	Cancel();
	delete iWatchers;

	iSocket.Close();
	iSocketServ.Close();
	}

void CSmsRegressTest::ConstructL()
	{
	iSmsTest.SetLogToFile();
	iTimer = CTestTimer::NewL();

	User::LeaveIfError(iSocketServ.Connect());
	TProtocolDesc protoinfo;
	TProtocolName protocolname(KSmsDatagram);
	User::LeaveIfError(iSocketServ.FindProtocol(protocolname,protoinfo));
	User::LeaveIfError(iSocket.Open(iSocketServ,protoinfo.iAddrFamily,protoinfo.iSockType,protoinfo.iProtocol));
	
	TSmsAddr smsaddr;
	smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly);
	User::LeaveIfError(iSocket.Bind(smsaddr));
	}

void CSmsRegressTest::DoCancel()
	{
	iOperations.Cancel();
	iTimer->Cancel();
	}

void CSmsRegressTest::DoRunTest2SMSSInstancesL()
	{
	TInt count = iOperations.Count();
	
	while (count-- && !IsActive())
		{
		const COpActive& active = *iOperations[count];
		iSmsTest.SetEntryL(active.Id());
		const TMsvEntry& entry = iSmsTest.Entry();
		switch (entry.SendingState())
			{
			case KMsvSendStateSent:
			case KMsvSendStateFailed:
				iSmsTest.Printf(_L("%d Complete [SendingState=%d]\n"), entry.Id(), entry.SendingState());
				break; //do nothing
			default:
				iSmsTest.Printf(_L("%d Active [SendingState=%d]\n"), entry.Id(), entry.SendingState());
				iTimer->AfterReq(2000000, iStatus);
				SetActive();
				break;
			}
		}
	}

void CSmsRegressTest::RunL()
	{
	User::LeaveIfError(iStatus.Int());

	switch (iState)
		{
		case ETest2SMSSInstances:
			DoRunTest2SMSSInstancesL();
			break;
		default:
			iSmsTest(EFalse);
			break;
		}

	if (!IsActive())
		CActiveScheduler::Stop();
	}

TInt CSmsRegressTest::RunError(TInt aError)
	{
	iSmsTest.Printf(_L("CSmsRegressTest::RunError [iStatus=%d aError, iState=%d]\n"), iStatus.Int(), aError, iState);

	if (iStatus.Int() == KErrNone)
		iStatus = aError;

	CActiveScheduler::Stop();
	return KErrNone;
	}

CSmsRegressTest* CSmsRegressTest::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)
	{
	CSmsRegressTest* self = new (ELeave) CSmsRegressTest(aSmsTest, aScriptFile, aNextTest);
	CleanupStack::PushL(self);

	self->ConstructL();

	return self;
	}

void CSmsRegressTest::ShowMenuL()
	{
	iSmsTest.ResetMenu();

	iSmsTest.AppendToMenuL(_L("Start"));

	TInt result = iSmsTest.DisplayMenu(_L("SMS Client MTM Test"));

	if (result <= 0)
		return;

	switch (result)
		{
		case 1:
			RunAutoL();
			break;
		default:
			User::Leave(KErrArgument);
			break;
		}

	if (!iSmsTest.RunAuto())
		{
		iSmsTest.Printf(_L("Press any key to continue...\n"));
		iSmsTest.Test().Getch();
		}

	ShowMenuL();
	}

/*
TBool CSmsRegressTest::CompareSettings(const CSmsSettings& aLeft, const CSmsSettings& aRight, TBool aTestSC)
	{
	TCompare compare(CompareMessageSettings(aLeft, aRight));

	compare(aLeft.CommDbAction() == aRight.CommDbAction());
	compare(aLeft.SmsBearerAction() == aRight.SmsBearerAction());
	compare(aLeft.SmsBearer() == aRight.SmsBearer());
	compare(aLeft.Delivery() == aRight.Delivery());
	compare(CompareBools(aLeft.ReplyQuoted(), aRight.ReplyQuoted()));
	compare(aLeft.SpecialMessageHandling() == aRight.SpecialMessageHandling());
	compare(aLeft.StatusReportHandling() == aRight.StatusReportHandling());

	if (aTestSC)
		{
		compare(aLeft.DefaultSC() == aRight.DefaultSC());
		compare(aLeft.NumSCAddresses() == aRight.NumSCAddresses());

		TInt count = aLeft.NumSCAddresses();

		while (count--)
			{
			compare(CompareNumbers(aLeft.SCAddress(count), aRight.SCAddress(count)));
			}
		}

	return compare;
	}

TBool CSmsRegressTest::CompareMessageSettings(const CSmsMessageSettings& aLeft, const CSmsMessageSettings& aRight)
	{
	TCompare compare(CompareBools(aLeft.CanConcatenate(), aRight.CanConcatenate()));
	compare(aLeft.CharacterSet() == aRight.CharacterSet());
	compare(CompareBools(aLeft.DeliveryReport(), aRight.DeliveryReport()));
	compare(aLeft.MessageConversion() == aRight.MessageConversion());
	compare(CompareBools(aLeft.RejectDuplicate(), aRight.RejectDuplicate()));
	compare(CompareBools(aLeft.ReplyPath(), aRight.ReplyPath()));
	compare(aLeft.ValidityPeriod() == aRight.ValidityPeriod());
	compare(aLeft.ValidityPeriodFormat() == aRight.ValidityPeriodFormat());
	return compare;
	}

TBool CSmsRegressTest::CompareNumbers(const CSmsNumber& aLeft, const CSmsNumber& aRight)
	{
	TCompare compare(aLeft.Name() == aRight.Name());
	compare(aLeft.Address() == aRight.Address());
	compare(aLeft.LogId() == aRight.LogId());
	return compare;
	}
*/
COpActive::COpActive(COpActiveArray& aParent, TMsvId aId, TInt aPriority)
: CActive(aPriority), iParent(aParent), iSmsTest(aParent.iSmsTest), iId(aId)
	{
	CActiveScheduler::Add(this);
	}

COpActive::~COpActive()
	{
	Cancel();
	delete iOperation;
	}

void COpActive::RunL()
	{
	iSmsTest.Printf(_L("COpActive::RunL [iStatus=%d]\n"), iStatus.Int());
	User::LeaveIfError(iStatus.Int());
	iSmsTest.SetProgressL(*iOperation);
	iSmsTest.Printf(_L("COpActive::RunL [Progress.iError=%d]\n"), iSmsTest.iProgress.iError);
	User::LeaveIfError(iSmsTest.iProgress.iError);
	Complete(KErrNone);
	}

void COpActive::DoCancel()
	{
	iOperation->Cancel();
	Complete(KErrCancel);
	}

TInt COpActive::RunError(TInt aError)
	{
	Complete(aError);
	return KErrNone;
	}

void COpActive::Complete(TInt aError)
	{
	iParent.ActiveComplete(*this, aError);
	}

COpActiveArray::COpActiveArray(CSmsTestUtils& aSmsTest)
: CArrayPtrFlat<COpActive>(1), iSmsTest(aSmsTest)
	{
	}

COpActiveArray::~COpActiveArray()
	{
	Cancel();
	ResetAndDestroy();
	}

void COpActiveArray::Cancel()
	{
	TInt count = Count();

	while (count--)
		At(count)->Cancel();
	}

void COpActiveArray::Start(TRequestStatus& aStatus)
	{
	aStatus = KRequestPending;
	iReport = &aStatus;
	}

void COpActiveArray::ActiveComplete(const CActive& aActive, TInt aError)
	{
	iSmsTest.Printf(_L("COpActiveArray::ActiveComplete [Id=aActive.Id() aError=%d]\n"), &aActive, aError);
	
	if (iReport != NULL)
		{
		if (aError != KErrNone)
			User::RequestComplete(iReport, aError);
		else
			{
			TInt count = Count();
			TBool active = EFalse;
			while (!active && count--)
				active = active || At(count)->IsActive();

			if (!active)
				User::RequestComplete(iReport, KErrNone);
			}
		}
	}