// Copyright (c) 2004-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:
// tschsvrsclient1.cpp
// 
//

#include <e32base.h>
#include <e32debug.h>

#include <csch_cli.h>
#include <schinfointernal.h>
#include "Thelpers.h"
#include "TestUtils.h"

_LIT(KTestName,	"Client with different UID test");
RTest TheTest(KTestName);
static RScheduler	TheScheduler;


typedef CArrayFixFlat<TScheduleEntryInfo>	CSchEntryInfoArray;
typedef CArrayFixFlat<TTaskInfo>			CTaskInfoArray;
typedef CArrayFixFlat<TSchedulerItemRef>    CSchItemRefArray;
typedef CArrayFixFlat<TTaskSchedulerCondition>	CSchConditionArray;


static CSchEntryInfoArray* CreateScheduleArrayLC()
	{
	CSchEntryInfoArray* entryList = new (ELeave) CSchEntryInfoArray(3);
	CleanupStack::PushL(entryList);

	TScheduleEntryInfo entry1;
	entry1.iStartTime		= SchSvrHelpers::TimeBasedOnOffset(0, 20); // 20m from "now"
	entry1.iInterval		= 1;
	entry1.iIntervalType	= EDaily;
	entry1.iValidityPeriod	= 20;
	entryList->AppendL(entry1);
	
	return entryList;
	}

static CSchConditionArray* CreateSingleConditionLC()
	{
	CSchConditionArray* conditionList = new (ELeave) CSchConditionArray(3);
	CleanupStack::PushL(conditionList);

	const TUid KTestUid = TUid::Uid(0x12345678);
	
	TTaskSchedulerCondition condition1;
	condition1.iCategory = KTestUid;
	condition1.iKey		= 1;
	condition1.iState	= 10;
	condition1.iType	= TTaskSchedulerCondition::EEquals;
	conditionList->AppendL(condition1);
	
	return conditionList;			
	}	
/**
@SYMTestCaseID          SYSLIB-SCHSVR-CT-1343
@SYMTestCaseDesc	    Client with different UID test
@SYMTestPriority 	    High
@SYMTestActions  	    Connect to Scheduler,
                        Tests RScheduler::EditSchedule(),RScheduler::DisableSchedule(),RScheduler::EnableSchedule()
						RScheduler::ScheduleTask(),RScheduler::GetScheduleRefsL(),RScheduler::GetScheduleL(),
						RScheduler::GetTaskRefsL(),RScheduler::GetTaskDataSize(),RScheduler::GetTaskInfoL(),
						RScheduler::GetScheduleTypeL(),RScheduler::DeleteTask(),RScheduler::DeleteSchedule() functions
@SYMTestExpectedResults Test must not fail
@SYMREQ                 REQ0000
*/			
void DoExecuteL(TInt aScheduleHandle, 
				TInt aTaskHandle, 
				TInt aExpectedError,
				TInt aExpectedScheduleCount,
				TInt aExpectedTaskCount)
	{
	
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1343 Connect to Scheduler "));
	TInt res = TheScheduler.Connect();
	TEST2(res, KErrNone);
	TheTest.Next(_L("Registering Client"));
	TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone);

	//Edit Schedule
	TheTest.Next(_L("Testing EditSchedule"));
	CSchEntryInfoArray* scheduleArray = CreateScheduleArrayLC();
	res = TheScheduler.EditSchedule(aScheduleHandle, *scheduleArray);
	CleanupStack::PopAndDestroy(); //scheduleArray
	TEST2(res, aExpectedError);
	//condition API -  only check if we are expecting an error
	if(aExpectedError != KErrNone)
		{
		CSchConditionArray* conditionList = CreateSingleConditionLC();
		TTime time = SchSvrHelpers::TimeBasedOnOffset(0, 0, 0, 0, 0, 1); //1 year in the future
		res = TheScheduler.EditSchedule(aScheduleHandle, *conditionList, time);
		CleanupStack::PopAndDestroy(); // conditionList
		TEST2(res, aExpectedError);
		}
	//Disable/Enable Schedule
	TheTest.Next(_L("Testing DisableSchedule and EnableSchedule"));
	res = TheScheduler.DisableSchedule(aScheduleHandle);
	TEST2(res, aExpectedError);
	res = TheScheduler.EnableSchedule(aScheduleHandle);
	TEST2(res, aExpectedError);
	
	//ScheduleTask
	TheTest.Next(_L("Testing ScheduleTask"));
	TTaskInfo taskInfo;
	taskInfo.iName = _L("MyTask");
	taskInfo.iPriority = 2;
	taskInfo.iTaskId = 0;
	taskInfo.iRepeat = 1;
	HBufC* data = _L("Task Data I cant schedule").AllocLC();
	res = TheScheduler.ScheduleTask(taskInfo, *data, aScheduleHandle);
	TEST2(res, aExpectedError);
	CleanupStack::PopAndDestroy(); // data
	
	if(res == KErrNone)
		{
		res = TheScheduler.DeleteTask(taskInfo.iTaskId);
		TEST2(res, KErrNone);
		}
		
	//GetScheduleRefs
	TheTest.Next(_L("Testing GetScheduleRefsL"));
	CSchItemRefArray* refs = new (ELeave) CSchItemRefArray(3);
	CleanupStack::PushL(refs);
	res = TheScheduler.GetScheduleRefsL(*refs, EAllSchedules); 
	TEST2(res, KErrNone);
	TInt count = refs->Count();
	TEST2(count, aExpectedScheduleCount); 
	
	//GetSchedule
	TheTest.Next(_L("Testing GetScheduleL"));
	CSchEntryInfoArray* entries = new (ELeave) CSchEntryInfoArray(3);
	CleanupStack::PushL(entries);
	CTaskInfoArray* tasks = new (ELeave) CTaskInfoArray(3);
	CleanupStack::PushL(tasks);
	
	TTime nextTimeScheduleIsDue;
	TScheduleState state;
	res = TheScheduler.GetScheduleL(aScheduleHandle, 
										state, 
										*entries, 
										*tasks, 
										nextTimeScheduleIsDue);
	TEST2(res, aExpectedError);
	//condition API -  only check if we are expecting an error
	if(aExpectedError != KErrNone)
		{
		CSchConditionArray* conditions = new (ELeave) CSchConditionArray(3);
		CleanupStack::PushL(conditions);
		res = TheScheduler.GetScheduleL(aScheduleHandle, 
											state,
											*conditions, 
											nextTimeScheduleIsDue, 
											*tasks);
		CleanupStack::PopAndDestroy(conditions);									
		TEST2(res, aExpectedError);
		}
	
	//GetTaskRefs
	TheTest.Next(_L("Testing GetScheduleL"));
	res = TheScheduler.GetTaskRefsL(*refs, EAllSchedules, EAllTasks);
	TEST2(res, KErrNone);
	count = refs->Count();
	TEST2(count, aExpectedTaskCount); 
	
	// TaskDataSize
	TheTest.Next(_L("Testing GetTaskDataSize"));
	TInt taskSize = 0;
	res = TheScheduler.GetTaskDataSize(aTaskHandle, taskSize);
	TEST2(res, aExpectedError);
	
	// GetTaskInfo
	TheTest.Next(_L("Testing GetTaskInfoL"));
	if(aExpectedError != KErrNone)
		//use dummy size for task as we actually didnt get it from above
		// if we were expected as error
		taskSize = 10; 
	HBufC* taskData = HBufC::NewLC(taskSize);
	TPtr pTaskData = taskData->Des();

	TTime scheduleNextDueTime;
	TTaskInfo taskFromServer;
	TSchedulerItemRef scheduleReference;

	res = TheScheduler.GetTaskInfoL(aTaskHandle,
										taskFromServer, 
									  	pTaskData, 
										scheduleReference, 
										scheduleNextDueTime);
	CleanupStack::PopAndDestroy(taskData);
	TEST2(res, aExpectedError);
	
	TScheduleType scheduleType;
	res = TheScheduler.GetScheduleTypeL(aScheduleHandle, scheduleType);
	TEST2(res, aExpectedError);

	//DeleteTask
	TheTest.Next(_L("Testing TaskSchedule"));
	res = TheScheduler.DeleteTask(aTaskHandle);
	TEST2(res, aExpectedError);

	//Delete Schedule
	TheTest.Next(_L("Testing DeleteSchedule"));
	res = TheScheduler.DeleteSchedule(aScheduleHandle);
	TEST2(res, aExpectedError);
											
	CleanupStack::PopAndDestroy(tasks);
	CleanupStack::PopAndDestroy(entries);
	CleanupStack::PopAndDestroy(refs);
	
	TheScheduler.Close();
	
	}

LOCAL_D TInt Execute(TInt aScheduleHandle, 
					TInt aTaskHandle, 
					TInt aExpectedError,
					TInt aExpectedScheduleCount,
					TInt aExpectedTaskCount)
	{
	TInt err = KErrNoMemory;
	CTrapCleanup* cleanup=CTrapCleanup::New();	//can fail
	if (cleanup)
		{
		
		TheTest.Start(_L("TSchSvrClient"));
		TheTest.Title();
		err = KErrNone;
		TRAP(err, DoExecuteL(aScheduleHandle, 
							aTaskHandle, 
							aExpectedError,
							aExpectedScheduleCount,
							aExpectedTaskCount))
		delete cleanup;

		TheTest.End();
		TheTest.Close();

		}
	return err;
	}


//***********************************************************************************
static TInt Str2Int(const TDesC& aStr)
	{
	TLex16 lex(aStr);
	TInt val = 0;
	lex.Val(val);
	return val;
	}

static TBuf<20> ExtractInt(const TDesC& aBuf, TInt& aExtractedInt)
	{
	TBuf<20> buf = aBuf.Right(aBuf.Length() - aBuf.Locate(':')-1);
	TBuf<5> handle;
	handle.FillZ();
	handle = buf.Left(buf.Locate(':'));
	aExtractedInt = Str2Int(handle);
	return buf;
	}
	
GLDEF_C TInt E32Main()
	{
	TBuf<30> cmd;
	User::CommandLine(cmd);
	// schedule Handle is first
	TInt scheduleHandle=0, taskHandle=0, errCode=0, schCount=0, taskCount=0;
	cmd = ExtractInt(cmd, scheduleHandle);
	// task Handle is second
	cmd = ExtractInt(cmd, taskHandle);
	// expected error code is third
	cmd = ExtractInt(cmd, errCode);
	// expected schedule count (based on this exe UID/Capability is fourth
	cmd = ExtractInt(cmd, schCount);
	// expected task count (based on this exe UID/Capability is fourth
	cmd = ExtractInt(cmd, taskCount);
	
	return Execute(scheduleHandle, taskHandle, errCode, schCount, taskCount);
	}