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

#include <msvstd.h>

#include <msvids.h>

#include <msvuids.h>

#include <msvschedulesettings.h>

#include <csch_cli.h>

#include <msvschedulepackage.h>

#include <msvoffpeaktime.h>

EXPORT_C CSchSendTestUtils::CSchSendTestUtils(RTest& aTest)

: CMsvTestUtils(aTest)

	{

	}

EXPORT_C void CSchSendTestUtils::InstallMtmGroupsL()

	{

	}

EXPORT_C void CSchSendTestUtils::CreateServerMtmRegsL()

	{

//CreateServerMtmRegL(KPigeonMtmUid, _L("Pig"), KUidMsvMtmServerDLL, KUidMsvMtmClientDLL, TMsvTestDllInfo(KUidMsvMtmUiDLL,2), TMsvTestDllInfo(KUidMsvMtmUiDLL,1), KPigeonMtmUid, KDataComponentFileName);

	}

EXPORT_C void CSchSendTestUtils::ConstructL()

	{

	CMsvTestUtils::ConstructL(ETuNone);

	CleanScheduleFolderL();

	CreateAllTestDirectories();

	GoClientSideL();

	InstallMtmGroupL(_L("c:\\system\\mtm\\pigmtmu.dat"));

	iSelection = new(ELeave) CMsvEntrySelection;

	iSchTestActive = CScheduleTestActive::NewL(*this);

	}

EXPORT_C CSchSendTestUtils::~CSchSendTestUtils()

	{

	delete iSchTestActive;

	delete iSelection;

	}

EXPORT_C void CSchSendTestUtils::Panic(TInt aPanic)

	{

	User::Panic(_L("SchSend Test"), aPanic);

	}

EXPORT_C void CSchSendTestUtils::StartL()

	{

	TRAPD(err, RunAutoL());

	if (err)

		{

		if (iCurrentTest)

			{

			TestFinish(iCurrentTest, err);

			}

		TestHarnessFailed(err);

		}

	else

		{

		TestHarnessCompleted();

		}

	}

//Returns approximate difference (rounded down?) in minutes

EXPORT_C TInt CSchSendTestUtils::DiffInMins(TTime d1, TTime d2)

	{

	iRTest<<d1<<d2;

	TInt64 diffUs64 = d1.Int64() - d2.Int64();

	TInt64 diffMins64 = diffUs64 / (1000000 * 60);

	TInt diffMins32 = I64INT(diffMins64);

	return diffMins32;

	}

//Returns approximate difference (rounded down?) in seconds

EXPORT_C TInt CSchSendTestUtils::DiffInSecs(TTime d1, TTime d2)

	{

	iRTest<<d1<<d2;

	TInt64 diffUs64 = d1.Int64() - d2.Int64();

	TInt64 diffSecs64 = diffUs64 / (1000000);

	TInt diffSecs32 = I64INT(diffSecs64);

	return diffSecs32;

	}

EXPORT_C void CSchSendTestUtils::ChangeMessageTimeL(TMsvId aMessage, TTime aTime)

	{

	iMsvEntry->SetEntryL(aMessage);

	TMsvEntry entry = iMsvEntry->Entry();

	iRTest<<entry.iDate<<aTime;

	entry.iDate = aTime;

	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

	wait->Start();

	CMsvOperation*  opert = iMsvEntry->ChangeL(entry, wait->iStatus);

	CleanupStack::PushL(opert);

	CActiveScheduler::Start(); // operation complete

	entry = iMsvEntry->Entry();

	iRTest<<entry.iDate;

	TMsvLocalOperationProgress details;

	TPckgC<TMsvLocalOperationProgress> package(details);	

	package.Set(opert->ProgressL());

	if(wait->iStatus.Int()!=KErrNone)

		User::Leave(wait->iStatus.Int());

	//TInt err = package().iError;

	//if(err != KErrNone);

	//	User::Leave(package().iError);

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

	}

EXPORT_C void CSchSendTestUtils::AssertL(TBool b)

	{

	if(!b)

		{

		User::Leave(KErrAbort);

		}

	}

EXPORT_C TMsvId CSchSendTestUtils::CreateMessageLC(TMsvEntry& aEntry, TMsvId aDestFolder, TTime aSendTime, TBool aOffPeak)

	{

	//Make a TMsvEntry

	iMsvEntry->SetEntryL(aDestFolder);

	aEntry.iType = KUidMsvMessageEntry;

	aEntry.iMtm = KSchSendTestMtmUid;

	aEntry.iServiceId = KMsvLocalServiceIndexEntryId;

	aEntry.iDate = aSendTime;

	aEntry.SetOffPeak(aOffPeak);

	//Create the entry in the server

	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

	wait->Start();

	CMsvOperation*  opert = iMsvEntry->CreateL(aEntry, wait->iStatus);

	CleanupStack::PushL(opert);

	CActiveScheduler::Start(); // operation complete

	//Find out the ID of the entry we made

	TMsvLocalOperationProgress details;

	TPckgC<TMsvLocalOperationProgress> package(details);	

	package.Set(opert->ProgressL());

	if(wait->iStatus.Int()!=KErrNone)

		User::Leave(wait->iStatus.Int());

	if(package().iError!=KErrNone)

		User::Leave(package().iError);

	*(TMsvId*)&aEntry = package().iId;

	TMsvId testMsvId = aEntry.Id();

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

	iMsvSession->CleanupEntryPushL(testMsvId);

	return testMsvId;

	}

EXPORT_C void CSchSendTestUtils::DisplayAllSchedulesL(TInt& rSchCount, TInt& rSchSize)

	{

	Printf(_L("Displaying all Schedules:\n"));

	rSchCount = 0;

	rSchSize = 0;

	TParse parse;

	TFileName fileName(_L("\\system\\schedules\\")); 

	_LIT(KCDrive, "C:");

	parse.Set(fileName, &KCDrive, NULL);

	CDir* entryList;

	TPtrC drive(parse.DriveAndPath());

	TInt err = iFs.GetDir(drive, KEntryAttNormal, ESortNone, entryList);

	if (err)

		{

		Printf(_L("\tiFs.GetDir(%S) returned %d\n"), &drive, err);

		return;

		}

	CleanupStack::PushL(entryList);

	TInt count = entryList->Count();

	while (count--)

		{

		TEntry entry((*entryList)[count]);

		rSchSize += entry.iSize;

		}

	Printf(_L("\tFiles in %S have total size %d\n"), &drive, rSchSize);

	CleanupStack::PopAndDestroy(entryList);

	RScheduler sch;

	err = sch.Connect();

	if (err)

		{

		Printf(_L("\tRScheduler::Connect() returned %d\n"), err);

		return;

		}

	CleanupClosePushL(sch);

	IMPORT_C TInt GetScheduleL(const TInt aScheduleHandle, TScheduleState& aState, 

			CArrayFixFlat<TScheduleEntryInfo>& aEntries, CArrayFixFlat<TTaskInfo>& aTasks, TTime& aDueTime);

	CArrayFixFlat<TSchedulerItemRef>* schRefArray = new (ELeave) CArrayFixFlat<TSchedulerItemRef>(10);

	CleanupStack::PushL(schRefArray);

	CArrayFixFlat<TScheduleEntryInfo>* schEntries = new (ELeave) CArrayFixFlat<TScheduleEntryInfo>(10);

	CleanupStack::PushL(schEntries);

	CArrayFixFlat<TTaskInfo>* schTasks = new (ELeave) CArrayFixFlat<TTaskInfo>(10);

	CleanupStack::PushL(schTasks);

	err = sch.GetScheduleRefsL(*schRefArray, EAllSchedules);

	if (!err)

		{

		TScheduleState schState;

		TTime schDueTime;

		count = schRefArray->Count();

		rSchCount = count;

		Printf(_L("\t%d schedules in the task scheduler\n"), count);

		while (count--)

			{

			err = sch.GetScheduleL((*schRefArray)[count].iHandle, schState, *schEntries, *schTasks, schDueTime);

			if (!err)

				{

				TInt taskCount = schTasks->Count();

				Printf(_L("\tSchedule %d (\"%S\") has %d tasks\n"), (*schRefArray)[count].iHandle, &(*schRefArray)[count].iName, taskCount);

				while (taskCount--)

					{

					TTaskInfo taskInfo((*schTasks)[taskCount]);

					TInt size;

					err = sch.GetTaskDataSize(taskInfo.iTaskId, size);

					if (!err)

						{

						HBufC* hBuf = HBufC::NewLC(size);

						TPtr ptr(hBuf->Des());

						TSchedulerItemRef schRef;

						err = sch.GetTaskInfoL(taskInfo.iTaskId, taskInfo, ptr, schRef, schDueTime);

						if (!err)

							{

							TPckgBuf<TMsvSchedulePackage> mtmBuf;

							mtmBuf.Copy(*hBuf);

							Printf(_L("\t\tTask %d: msvId %d, commandId %d, pollProgress %d\n"), taskInfo.iTaskId, mtmBuf().iId, mtmBuf().iCommandId, mtmBuf().iPollProgress.Int());

							}

						else

							{

							Printf(_L("\t\tRScheduler::GetTaskInfoL(%d) returned %d\n"), taskInfo.iTaskId, err);

							}

						CleanupStack::PopAndDestroy(hBuf);

						}

					else

						{

						Printf(_L("\t\tRScheduler::GetTaskDataSize(%d) returned %d\n"), taskInfo.iTaskId, err);

						}

					}

				}

			else

				{

				Printf(_L("\tRScheduler::GetScheduleL(%d (\"%S\")) returned %d\n"), (*schRefArray)[count].iHandle, &(*schRefArray)[count].iName, err);

				}

			}

		}

	else

		{

		Printf(_L("RScheduler::GetScheduleRefsL() returned %d"), err);

		}

	CleanupStack::PopAndDestroy(3); //schRefArray, schEntries, schTasks

	CleanupStack::PopAndDestroy(); //sch

	}

EXPORT_C void CSchSendTestUtils::CleanScheduleFolderL()

	{

	CFileMan* fileMan = CFileMan::NewL(iFs); 

	CleanupStack::PushL(fileMan);

	TParse parse;

	TFileName fileName(_L("\\system\\schedules\\")); 

	TBuf<4> drive=_L("C:");

	parse.Set(fileName, &drive, NULL);

	TInt error = fileMan->RmDir(parse.DriveAndPath()); 

	error = iFs.RmDir(parse.DriveAndPath());

	if (!(error==KErrNotFound||error==KErrNone))

		{

        TPtrC driveAndPath = parse.DriveAndPath();

		Printf(_L("Directory %S cannot be removed. Error=%d"), &driveAndPath, error);

		Printf(_L("Please ensure directory is not in use.\n"));

		User::Leave(error);

		}

	iFs.MkDirAll(parse.DriveAndPath());

	CleanupStack::PopAndDestroy(fileMan);

	}

EXPORT_C TBool CSchSendTestUtils::CompareRoundedTimes(const TTime& aLeft, const TTime& aRight) const

	{

	TBool ret = (aLeft == aRight);

	ret = ret || (RoundUpToMinute(aLeft) == RoundUpToMinute(aRight));

	ret = ret || (RoundDownToMinute(aLeft) == RoundDownToMinute(aRight));

	return ret;

	}

EXPORT_C TTime CSchSendTestUtils::RoundUpToMinute(const TTime& aTime) const

	{

	TTime ret(aTime);

	TDateTime dt(ret.DateTime());

	if (dt.Second() != 0 || dt.MicroSecond() != 0)

		{

		dt.SetSecond(0);

		dt.SetMicroSecond(0);

		ret = dt;

		ret += (TTimeIntervalMinutes) 1;

		}

	return ret;

	}

EXPORT_C TTime CSchSendTestUtils::RoundDownToMinute(const TTime& aTime) const

	{

	TTime ret(aTime);

	TDateTime dt(ret.DateTime());

	if (dt.Second() != 0 || dt.MicroSecond() != 0)

		{

		dt.SetSecond(0);

		dt.SetMicroSecond(0);

		ret = dt;

		}

	return ret;

	}

//

//

//

CScheduleTestActive::CScheduleTestActive(CSchSendTestUtils& aTest, TInt aPriority)

: CActive(aPriority), iTest(aTest), iSession(*aTest.iMsvSession)

	{

	CActiveScheduler::Add(this);

	}

EXPORT_C CScheduleTestActive* CScheduleTestActive::NewL(CSchSendTestUtils& aTest, TInt aPriority)

	{

	CScheduleTestActive* self = new (ELeave) CScheduleTestActive(aTest, aPriority);

	CleanupStack::PushL(self);

	self->iSession.AddObserverL(*self);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CScheduleTestActive::~CScheduleTestActive()

	{

	Cancel();

	iSession.RemoveObserver(*this);

	delete iSelection;

	delete iOperation;

	}

//Set aStopAtRunL to true to stop the active scheduler. 

//False will make us wait for someone else to stop it

EXPORT_C const TSchSendTestProgress& CScheduleTestActive::TransferCommandSyncL(TSchSendTestOperation aCommand, const CMsvEntrySelection& aSelection, TBool aStopAtRunL)

	{

	return TransferCommandSyncL(aCommand, aSelection, _L8("aaaa"), aStopAtRunL);

	}

EXPORT_C const TSchSendTestProgress& CScheduleTestActive::TransferCommandSyncL(TSchSendTestOperation aCommand, const CMsvEntrySelection& aSelection, const TDesC8& aParameter, TBool aStopAtRunL)

	{

	iTest.Printf(_L("TransferCommandSyncL Command %d Count %d StopAtRunL %d\n"), aCommand, aSelection.Count(), aStopAtRunL);

	if (IsActive())

		User::Leave(KErrInUse);

	delete iSelection;

	iSelection = NULL;

	iSelection = aSelection.CopyL();

	iCommand = aCommand;

	iStopAtRunL = aStopAtRunL;

	iStatus = KRequestPending;

	SetActive();

	delete iOperation;

	iOperation = NULL;

	iOperation = iSession.TransferCommandL (*iSelection, 

				aCommand,

				aParameter, 

				iStatus);

	CActiveScheduler::Start(); // will not return from this until the command is transferred

	iProgress.iError = iStatus.Int();

	if(iStatus.Int()!=KErrNone)

		User::Leave(iStatus.Int());

	TPckgC<TSchSendTestProgress> pkg(iProgress);

	pkg.Set(iOperation->ProgressL());

	iProgress = pkg();

	return iProgress;

	}

TInt CScheduleTestActive::RunError(TInt aError)

	{

	if (iProgress.iError == KErrNone)

		iProgress.iError = aError;

	CActiveScheduler::Stop();

	return KErrNone;

	}

void CScheduleTestActive::RunL()

	{

	iTest.Printf(_L("CScheduleTestActive::RunL() iStatus %d\n"), iStatus.Int());

	User::LeaveIfError(iStatus.Int());

	if(iStopAtRunL) 

		{

		CActiveScheduler::Stop();

		return;

		}

	switch (iCommand)

		{

		case EScheduleAllL:

		case EReScheduleAllL:

			{

			TInt count = iSelection->Count();

			TBool stopped = EFalse;

			while (!stopped && count--)

				{

				CMsvEntry* entry = iSession.GetEntryL(iSelection->At(count));

				CleanupStack::PushL(entry);

				const TInt state = entry->Entry().SendingState();

				switch(state)

					{

					case KMsvSendStateScheduled:

					case KMsvSendStateResend:

						break;

					default: // The message sent or failed

						stopped = ETrue;

						CActiveScheduler::Stop();

						break;

					}

				CleanupStack::PopAndDestroy(entry);

				}

			break;

			}

		default:

			CActiveScheduler::Stop(); //Added by AA 9/6/2000. Is this correct?

			break;

		}

	}

void CScheduleTestActive::HandleSessionEventL(TMsvSessionEvent eventType, TAny* p1, TAny*, TAny*)

	{

	if (iStopAtRunL) return;

	if (eventType != EMsvEntriesCreated) return;

	CMsvEntrySelection* entries = STATIC_CAST(CMsvEntrySelection*, p1);

	CMsvEntry* cEntry = iSession.GetEntryL((*entries)[0]);

	CleanupStack::PushL(cEntry);

	TMsvEntry entry(cEntry->Entry());

	if(entry.iDetails == KSchSendTestDetails)

		{

		iTest.Printf(_L("Scheduled message has been sent\n"));

		//We found the right message!

		CActiveScheduler::Stop();

		//Delete the new message

		CMsvOperationWait* wait = CMsvOperationWait::NewLC();

		wait->Start();

		cEntry->SetEntryL(entry.Parent());

		CMsvOperation* op = cEntry->DeleteL(entry.Id(), wait->iStatus);

		CActiveScheduler::Start();

		delete op;

		CleanupStack::PopAndDestroy(wait);

		}

	CleanupStack::PopAndDestroy(cEntry);

	}

//

//

//

//

//