/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 "calendarinterface.h"

#include"notify.h"

_LIT8(KTestInterface, 	"IDataSource");

_LIT8(KTestContent,		"Service.Calendar");

_LIT8(KCmd,				"RequestNotification");

//_LIT8(KCmdAdd,			"Add");

//_LIT8(KCmdDelete,		"Delete");

//_LIT8(KCmdCancel,		"Cancel");

//_LIT8(KFilter,			"Filter");

//_LIT8(KItem,			"Item");

//_LIT8(KCalendarName,	"CalendarName");

_LIT(KEntryTypeMeeting,	"Meeting");

_LIT(KEntryTypeTodo,	"ToDo");

//const TChar KUidSeparator = ':';

_LIT(KTestCalendar, 	"c:CalChangeNotify");

TInt RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

TInt AddProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

TInt AddProvAppointmentDailyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUint& localuid);

TInt AddProvTodo(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUint& localuid);

CCalCallback* CCalCallback::NewL(CActiveSchedulerWait* aWaitSchedular, TInt& aResult)

	{

	return new (ELeave) CCalCallback(aWaitSchedular, aResult);

	}

TInt CCalCallback::HandleNotifyL(TInt aCmdId,

									        TInt aEventId,

									        CLiwGenericParamList& aEventParamList,

									        const CLiwGenericParamList& aInParamList)

	{

	TInt pos = 0;

	TInt result = KErrNone;

    const TLiwGenericParam* output = aEventParamList.FindFirst( pos,_L8("ReturnValue"));

	if(output)

		{

		CLiwIterable* iterlist = output->Value().AsIterable();

	    TLiwVariant data;

        while( iterlist->NextL(data))

			{

			const CLiwMap* Map = data.AsMap(); 

			TLiwVariant varluid;

			TUint luid = 0;

			TInt changetype = -1;

			if( Map->FindL(_L8("LocalId"),varluid))

				{

				TLex lex(varluid.AsDes());

				TInt32 num;

				lex.Val(num);

				luid = TUint(num);

				}

			if( Map->FindL(_L8("ChangeType"),varluid))

				{

				TPtrC tmp = varluid.AsDes();

				if(tmp.CompareF(_L("Add")) == 0)

					changetype = 1;

				else if(tmp.CompareF(_L("Delete")) == 0)

					changetype = 2;

				else if(tmp.CompareF(_L("Modify")) == 0)

					changetype = 3;

				}

			varluid.Reset();

			if( ((luid == iLocalUid) || !iCheckLocalUid ) && (iChangeType == changetype))

				{

				iResult = KErrNone;

				break;

				}

			}

		data.Reset();

		}

	if ( iWaitSchedular && iWaitSchedular->IsStarted())

		{

		iWaitSchedular->AsyncStop();

		}

		return 0;

	}

CTestAsync* CTestAsync::NewL()

	{

	CTestAsync* self = new (ELeave) CTestAsync();

	self->ConstructL();

	return self;

	}

CTestAsync::~CTestAsync()

	{

	Cancel();

	interface->Close();

	delete iServiceHandler;

	delete iCallback;

	if(iWaitSchedular->IsStarted())

		iWaitSchedular->AsyncStop();

	delete iWaitSchedular;

	}

void CTestAsync::ConstructL()

	{

	CActiveScheduler::Add(this);

	iWaitSchedular = new(ELeave) CActiveSchedulerWait();

	}

CTestAsync::CTestAsync() :

CActive(EPriorityStandard)

		{

		interface = NULL ;

		iTestState = ETestIssueRequest;

		iResult = KErrGeneral;

		}

void CTestAsync::DoCancel()

	{

	}

void CTestAsync::RunL()

	{

	if(iTestState == ETestIssueRequest)

		{

		TestFunc();

		iTestState = ETestProcessRequest;

		iStatus = KRequestPending;

		SetActive();

		TRequestStatus* temp = &iStatus;

		User::RequestComplete(temp, KErrNone);

		if(iStopWaitSch && iWaitSchedular->IsStarted())

			iWaitSchedular->AsyncStop();

		}

	else if(iTestState == ETestProcessRequest)

		{

		if ( iChangeType == 1 )

			DoAddChange();

		else if ( iChangeType == 2 )

			DoDeleteChange();

		if ( iChangeType == 3 )

			DoUpdateChange();

		}

	}

void CTestAsync::DoAddChange()

	{

	CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

	CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

	TUint localUid;

	AddProvAppointmentDailyRepeat(inparam, outparam, interface, KTestCalendar, localUid );

	iCallback->iLocalUid = localUid;

	}

void CTestAsync::DoDeleteChange()

	{

	CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

	CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

   	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

	CleanupStack::PushL(map);

	TLiwGenericParam element1;	

	element1.SetNameAndValueL(_L8("Type"),TLiwVariant(_L("CalendarEntry")));

	inparam->AppendL(element1);

	element1.Reset();

    map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCalendar) ); 

    CLiwDefaultList* uidlist = CLiwDefaultList::NewL();

    TBuf<10> luid;

    luid.Num(TInt64(iLocalUid));

    uidlist->AppendL(TLiwVariant(luid));

    map->InsertL(_L8("LocalIdList"), TLiwVariant(uidlist)); 

    uidlist->DecRef();

    TLiwVariant filterparam(map);

	TLiwGenericParam element ;	

	element.SetNameAndValueL(_L8("Data"),filterparam);

	filterparam.Reset();

	inparam->AppendL(element);

	element.Reset();

    map->DecRef();

    CleanupStack::Pop(map);

	TRAPD(err1, interface->ExecuteCmdL(KCmdDelete, *inparam, *outparam ));

	inparam->Reset();

	outparam->Reset();

	}

void CTestAsync::DoUpdateChange()

	{

	CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

	CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

   	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

	CleanupStack::PushL(map);

	TLiwGenericParam element1;	

	element1.SetNameAndValueL(_L8("Type"),TLiwVariant(_L("CalendarEntry")));

	inparam->AppendL(element1);

	element1.Reset();

    map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCalendar) ); 

    //map->InsertL(_L8("LocalUid"), TLiwVariant(iLocalUid) ); 

    TBuf<10> luid;

    luid.Num(TInt64(iLocalUid));

    map->InsertL(_L8("LocalId"), TLiwVariant(luid)); 

    map->InsertL(_L8("Description"), TLiwVariant(_L("New Description") )); 

    TLiwVariant filterparam(map);

	TLiwGenericParam element ;	

	element.SetNameAndValueL(_L8("Item"),filterparam);

	filterparam.Reset();

	inparam->AppendL(element);

	element.Reset();

    map->DecRef();

    CleanupStack::Pop(map);

	TRAPD(err1, interface->ExecuteCmdL(KCmdAdd, *inparam, *outparam ));

	inparam->Reset();

	outparam->Reset();

	}

TInt CTestAsync::Result()

	{

	return iResult;

	}

void CTestAsync::Start( TInt aChangeType, TBool aLocalUid, TBool aPosBased, TBool aStopWaitSch )

	{

	iCheckLocalUid = aLocalUid;

	iChangeType = aChangeType;

	iPosBased = aPosBased;

	iStopWaitSch = aStopWaitSch;

	SetActive();

	TRequestStatus* temp = &iStatus;

	User::RequestComplete(temp, KErrNone);

	iWaitSchedular->Start();	

	}

void CTestAsync::CancelNotification(TBool aResetOutput)

	{

	CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

	CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

	TLiwGenericParam element1;	

	if(iPosBased)

		element1.SetNameAndValueL(KNullDesC8,TLiwVariant(_L("CalendarEntry")));

	else

		element1.SetNameAndValueL(_L8("Type"),TLiwVariant(_L("CalendarEntry")));

	//inparam->AppendL(element1);

	element1.Reset();

	TLiwGenericParam element2;	

	if(iPosBased)

		element2.SetNameAndValueL(KNullDesC8,TLiwVariant(iTransactionId));

	else

		element2.SetNameAndValueL(_L8("TransactionID"), TLiwVariant(iTransactionId));

	inparam->AppendL(element2);

	element2.Reset();

    TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inparam, *outparam, KLiwOptCancel ));

    TInt pos = 0 ;

    const TLiwGenericParam* output = outparam->FindFirst( pos,_L8("ErrorCode"));

	if ( aResetOutput && ( (err1 == KErrNone) && output ))

		{

		iResult = output->Value().AsTInt32();

		}

	inparam->Reset();

	outparam->Reset();

	}

void CTestAsync::TestFunc()

	{

	iServiceHandler = CLiwServiceHandler::NewL();

	CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

	CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

	TInt	err; 

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;

	a.AppendL(crit);    

	iServiceHandler->AttachL(a);

	iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

	a.Reset();

	delete crit;

	TInt pos = 0;

	outparam->FindFirst( pos, KTestInterface );

	if(pos != KErrNotFound)

		{

		interface = (*outparam)[pos].Value().AsInterface();	

		}

	outparam->Reset();

	inparam->Reset();

	// Add one entry and get the LocalUid

	RemoveProvCalendar(inparam, outparam, interface, KTestCalendar);

	if( AddProvCalendar(inparam, outparam, interface, KTestCalendar) != KErrNone)

		{

		if(iWaitSchedular->IsStarted())

			iWaitSchedular->AsyncStop();

		inparam->Reset();

		outparam->Reset();

		return;

		};

	TUint localUid;

	if( AddProvAppointmentDailyRepeat(inparam, outparam, interface, KTestCalendar, localUid ) != KErrNone )

		{

		if(iWaitSchedular->IsStarted())

			iWaitSchedular->AsyncStop();

		inparam->Reset();

		outparam->Reset();

		return;

		};

	inparam->Reset();

	outparam->Reset();

	if( AddProvAppointmentDailyRepeat(inparam, outparam, interface, KTestCalendar, localUid ) != KErrNone )

		{

		if(iWaitSchedular->IsStarted())

			iWaitSchedular->AsyncStop();

		inparam->Reset();

		outparam->Reset();

		return;

		};

	inparam->Reset();

	outparam->Reset();

   	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

	CleanupStack::PushL(map);

	TLiwGenericParam element1;	

	if( iPosBased )

		element1.SetNameAndValueL(KNullDesC8,TLiwVariant(_L("CalendarEntry")));

	else

		element1.SetNameAndValueL(_L8("Type"),TLiwVariant(_L("CalendarEntry")));

	inparam->AppendL(element1);

	element1.Reset();

    map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCalendar) ); 

    CLiwDefaultList* uidlist = CLiwDefaultList::NewL();

    TBuf<10> luid;

    luid.Num(TInt64(localUid));

    //map->InsertL(_L8("LocalUid"), TLiwVariant(luid)); 

    uidlist->AppendL(TLiwVariant(luid));

    if ( iChangeType != 1 )

    	map->InsertL(_L8("LocalIdList"), TLiwVariant(uidlist)); 

    uidlist->DecRef();

    TLiwVariant filterparam(map);

	TLiwGenericParam element ;	

	if( iPosBased )

		element.SetNameAndValueL(KNullDesC8,filterparam);

	else

		element.SetNameAndValueL(_L8("Filter"),filterparam);

	filterparam.Reset();

	inparam->AppendL(element);

	element.Reset();

    map->DecRef();

    CleanupStack::Pop(map);

	iCallback = CCalCallback::NewL(iWaitSchedular, iResult);

	iCallback->iChangeType = iChangeType;

	iCallback->iLocalUid = localUid;

	iCallback->iCheckLocalUid = iCheckLocalUid;

	iLocalUid = localUid;

	TRAPD(err1, interface->ExecuteCmdL(KCmd, *inparam, *outparam, KLiwOptASyncronous, iCallback));

	const TLiwGenericParam* output = outparam->FindFirst( pos,_L8("TransactionID"));

	if(output)

		{

		iTransactionId = output->Value().AsTInt32();

		}

	else

		{

		if(iWaitSchedular->IsStarted())

			iWaitSchedular->AsyncStop();

		}	

	inparam->Reset();

	outparam->Reset();

	}

TInt ReqNotification( TInt aChangeType, TBool aLocalUid, TBool aPosBased  )

	{

	TInt result;

	__UHEAP_MARK;

	TInt cells = User::CountAllocCells();

	CTestAsync* test = CTestAsync::NewL();

	test->Start( aChangeType, aLocalUid, aPosBased );

	result = test->Result();

	test->CancelNotification();

	delete test;

	cells = User::CountAllocCells();

	__UHEAP_MARKEND;

	return result;

	}

TInt ReqNotificationCancel( TInt aChangeType, TBool aLocalUid, TBool aPosBased, TBool aInvalidId, TBool aMultiCancel  )

	{

	TInt result;

	__UHEAP_MARK;

	TInt cells = User::CountAllocCells();

	CTestAsync* test = CTestAsync::NewL();

	test->Start( aChangeType, aLocalUid, aPosBased );

	result = test->Result();

	test->CancelNotification();

	if( aInvalidId )

		{

		test->CancelNotification(ETrue);

		result = test->Result();

		if(result == 1012)

			result = KErrNone;

		}

	if( aMultiCancel )

		{

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

			test->CancelNotification(ETrue);

		result = test->Result();

		if(result == 1012)

			result = KErrNone;

		}

	delete test;

	cells = User::CountAllocCells();

	__UHEAP_MARKEND;

	return result;

	}

TInt ReqNotificationWithoutWaitSch( TInt aChangeType, TBool aLocalUid, TBool aPosBased  )

	{

	__UHEAP_MARK;

	TInt cells = User::CountAllocCells();

	CTestAsync* test = CTestAsync::NewL();

	test->Start( aChangeType, aLocalUid, aPosBased, ETrue );

	//test->CancelNotification();

	delete test;

	cells = User::CountAllocCells();