/*

* Copyright (c) 2002 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:   ?Description

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

//#include <SAPI_TEST\testprg.h>

#include <StifTestInterface.h>

#include<liwcommon.h>

#include<liwvariant.h>

#include<liwservicehandler.h>

#include "tcalendarupdatetest.h"

#include "calendarheader.h"

#include "calendarconstants.h"

_LIT8(KTestInterface, 	"IDataSource");

_LIT8(KTestContent,		"Service.Calendar");

_LIT(KKCalFileName11,"C:CalendarFileA");

/*TInt RemoveCalendarFile(void* aInterfaceptr, const wchar_t* aCalname);

TInt AddCalendarFile(void* aInterfaceptr, const wchar_t* aCalname);

TInt AddAnniversary(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);

TInt AddDayEvent(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);

TInt AddReminder(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);

TInt AddTodoEntry(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);

TInt AddAppointmentWithoutRepeat(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);

TInt AddAppointmentWithDailyRepeat(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);

void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );

void GetGlobalUid( const TDesC& aGlobalUid, TDes8& aOutGlobalUid );

wchar_t  KCalFileName1[20] = L"C:CalendarFile1";*/

TInt doAddTest();

void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );

TInt AddProvAppointmentDailyRepeatAndAttendees(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

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

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

TInt AddProvToDo(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

TInt AddProvDayEvent(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

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

TInt AddProvAppointmentWeeklyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

TInt AddProvAppointmentMonthlyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

TInt AddProvAppointmentWithoutRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

TInt AddProvAnni(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

TInt AddProvReminder(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

TInt AddNewCalendar();

class CTestUpdateSync : public CBase

{

public:

	static CTestUpdateSync* NewL();

	int UpdateAppointmentEntryL();

	int UpdateAppointmentEntryWithNewTimeL();

	int UpdateAppointmentEntryWithNewAttendeesL();

	int UpdateAppointmentEntryWithNewRepeatL();

	int UpdateAnniversaryL();

	int UpdateDayEventL();

	int UpdateReminderL();

	int UpdateTodoEntryL();

	int UpdateAppointmentEntryWithGlobalIdL();

    int UpdateAnniversaryWithGlobalIdL();

    int UpdateDayEventWithGlobalIdL();

    int UpdateReminderWithGlobalIdL();

    int UpdateTodoEntryWithGlobalIdL();

    int UpdateAppointmentEntryWithNewTimeAndGlobalIdL();

	CTestUpdateSync();

	~CTestUpdateSync();

private:

	void ConstructL();

private:	

	CLiwServiceHandler* 	iServiceHandler;

	TInt 					iResult;

	MLiwInterface* 			interface ;	

};		

CTestUpdateSync* CTestUpdateSync::NewL()

	{

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

	self->ConstructL();

	return self;

	}

CTestUpdateSync::~CTestUpdateSync()

	{

	if( interface )

	interface->Close();

	delete iServiceHandler;

	}

void CTestUpdateSync::ConstructL()

	{

	}

CTestUpdateSync::CTestUpdateSync()

	{

	interface = NULL ;

	}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CTCalendarUpdateTest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CTCalendarUpdateTest::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// CTChangeStatusTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CTCalendarUpdateTest::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

        //TRY( "SendMessage",    CTDeleteMessageTest::SendMessage ),

        ENTRY( "UpdateAppointmentEntry",    	CTCalendarUpdateTest::UpdateAppointmentEntryL),

        ENTRY( "UpdateAppointmentEntryWithNewTime",    	 CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeL ),

        ENTRY( "UpdateAppointmentEntryWithNewAttendees",    CTCalendarUpdateTest::UpdateAppointmentEntryWithNewAttendeesL),

        ENTRY( "UpdateAppointmentEntryWithNewRepeat",    CTCalendarUpdateTest::UpdateAppointmentEntryWithNewRepeatL),

        ENTRY( "UpdateAnniversary",    CTCalendarUpdateTest::UpdateAnniversaryL),

        ENTRY( "UpdateDayEvent",    CTCalendarUpdateTest::UpdateDayEventL),

        ENTRY( "UpdateReminder",    CTCalendarUpdateTest::UpdateReminderL),

        ENTRY( "UpdateTodoEntry",    CTCalendarUpdateTest::UpdateTodoEntryL),

        ENTRY( "UpdateAppointmentEntryWithGlobalId",        CTCalendarUpdateTest::UpdateAppointmentEntryWithGlobalIdL),

        ENTRY( "UpdateAnniversaryWithGlobalId",    CTCalendarUpdateTest::UpdateAnniversaryWithGlobalIdL),

        ENTRY( "UpdateDayEventWithGlobalId",    CTCalendarUpdateTest::UpdateDayEventWithGlobalIdL),

        ENTRY( "UpdateReminderWithGlobalId",    CTCalendarUpdateTest::UpdateReminderWithGlobalIdL),

        ENTRY( "UpdateTodoEntryWithGlobalId",    CTCalendarUpdateTest::UpdateTodoEntryWithGlobalIdL),

        ENTRY( "UpdateAppointmentEntryWithNewTimeAndGlobalId",      CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeAndGlobalIdL ),

	    };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// CTCalendarUpdateTest::UpdateAppointmentEntryL

// Test Method to test the UpdateAsync(ASynchronous)

// Functionality of CalenderService

// -----------------------------------------------------------------------------

//

TInt  CTCalendarUpdateTest::UpdateAppointmentEntryL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAppointmentEntryL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAppointmentEntryWithNewTimeL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithNewAttendeesL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAppointmentEntryWithNewAttendeesL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateAnniversaryL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAnniversaryL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateDayEventL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateDayEventL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateReminderL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateReminderL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }   

TInt  CTCalendarUpdateTest::UpdateTodoEntryL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateReminderL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }   

TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithNewRepeatL(CStifItemParser& /*aItem*/)

	{

	//__UHEAP_MARK;

	TInt result=KErrNone;

	__UHEAP_MARK;

	CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAppointmentEntryWithNewRepeatL();

	delete test;

	__UHEAP_MARKEND;

	return res;

//	__UHEAP_MARKEND;

    }   

TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithGlobalIdL(CStifItemParser& /*aItem*/)

    {

    //__UHEAP_MARK;

    TInt result=KErrNone;

    __UHEAP_MARK;

    CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAppointmentEntryWithGlobalIdL();

    delete test;

    __UHEAP_MARKEND;

    return res;

//  __UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateAnniversaryWithGlobalIdL(CStifItemParser& /*aItem*/)

    {

    //__UHEAP_MARK;

    TInt result=KErrNone;

    __UHEAP_MARK;

    CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAnniversaryWithGlobalIdL();

    delete test;

    __UHEAP_MARKEND;

    return res;

//  __UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateDayEventWithGlobalIdL(CStifItemParser& /*aItem*/)

    {

    //__UHEAP_MARK;

    TInt result=KErrNone;

    __UHEAP_MARK;

    CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateDayEventWithGlobalIdL();

    delete test;

    __UHEAP_MARKEND;

    return res;

//  __UHEAP_MARKEND;

    }

TInt  CTCalendarUpdateTest::UpdateReminderWithGlobalIdL(CStifItemParser& /*aItem*/)

    {

    //__UHEAP_MARK;

    TInt result=KErrNone;

    __UHEAP_MARK;

    CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateReminderWithGlobalIdL();

    delete test;

    __UHEAP_MARKEND;

    return res;

//  __UHEAP_MARKEND;

    }   

TInt  CTCalendarUpdateTest::UpdateTodoEntryWithGlobalIdL(CStifItemParser& /*aItem*/)

    {

    //__UHEAP_MARK;

    TInt result=KErrNone;

    __UHEAP_MARK;

    CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateReminderWithGlobalIdL();

    delete test;

    __UHEAP_MARKEND;

    return res;

//  __UHEAP_MARKEND;

    }   

TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeAndGlobalIdL(CStifItemParser& /*aItem*/)

    {

    //__UHEAP_MARK;

    TInt result=KErrNone;

    __UHEAP_MARK;

    CTestUpdateSync* test = CTestUpdateSync::NewL();

    int res =  test->UpdateAppointmentEntryWithNewTimeAndGlobalIdL();

    delete test;

    __UHEAP_MARKEND;

    return res;

//  __UHEAP_MARKEND;

    }

TInt CTestUpdateSync::UpdateAppointmentEntryL()

	{

	iServiceHandler = CLiwServiceHandler::NewL();

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

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

	TInt err; 

	RCriteriaArray interest;

    CleanupClosePushL(interest);

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

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

    CleanupStack::PushL(crit);

    interest.AppendL(crit);    

	iServiceHandler->AttachL(interest);

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

	TInt pos = 0;

	outparam->FindFirst( pos, KTestInterface );

	if(pos != KErrNotFound)

		{

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

		}

    CleanupStack::PopAndDestroy(crit);

    CleanupStack::PopAndDestroy(&interest); 

	outparam->Reset();

	inparam->Reset();

	AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

	TUIDSet* uidset1;

    TBuf<50> globaluid;

    TBuf<10> localuid;

    //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

    AddProvAppointmentWithoutRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);

    //localuid.Num(TInt64(uidset1->iLocalUID));

    globaluid.Copy(uidset1->iGlobalUID->Des());

    localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);

   	CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();

	CleanupStack::PushL(map1);

    TLiwVariant content(_L("CalendarEntry"));

	TLiwGenericParam element1;	

	element1.SetNameAndValueL(_L8("Type"),content);

	inparam->AppendL(element1);

	content.Reset();

	element1.Reset();

    map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

    map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));

	map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,10,0,0,0))));

	map1->InsertL(_L8("EndTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,10,30,0,0))));

	map1->InsertL(_L8("AlarmTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,9,30,0,0))));

	TLiwGenericParam element;	

	element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

	inparam->AppendL(element);

	element.Reset();

    map1->DecRef();

    CleanupStack::Pop(map1);

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

	inparam->Reset();

	outparam->Reset();

    TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));

	inparam->AppendL(dsNameParam);

	CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

	TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

	inparam->AppendL(filterParam);

	filterMap->DecRef();

    filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

    filterMap->InsertL(_L8("LocalId"),TLiwVariant(localuid));

	TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));