/*

* 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<liwcommon.h>

#include<liwvariant.h>

#include<liwservicehandler.h>

#include "tcalendaraddtest.h"

#include "calendarheader.h"

#include "calendarconstants.h"

_LIT8(KTestInterface, 	"IDataSource");

_LIT8(KTestContent,		"Service.Calendar");

_LIT8(KCmd,				"Delete");

_LIT8(KMessageId,				"MessageId");

_LIT8(KMap,				"NotificationType");

_LIT8(KMessageList,			"MessageList" );

_LIT8(KMessage,				"Message" );

_LIT(KMsgType,"NewMessage");

//_LIT8(KContentType, 		"Type");

//_LIT8(KCalendarName,        "CalendarName");

//_LIT8(KFilter, 				"Filter");

_LIT(KCalFileName1,"C:Calendar");

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

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

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

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

TInt AddProvAppointmentMonthlyRepeat(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 RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

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

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

enum TFormat

	{

	ETestUnicode = 0x01,

	ETestAscii	 = 0x02,

	};

HBufC* FillBuffer(int size, TFormat encoding)

	{

	HBufC* buffer = NULL;

	if( encoding == ETestUnicode)

		{

		buffer = HBufC::NewL(size);

		for(int i=0;i<size;i++)

			buffer->Des().Append(0xE0FF); //append some unicode character	

		}

	else if(encoding == ETestAscii)

		{

		buffer = HBufC::NewL(size);

		for(int i=0;i<size;i++)

			buffer->Des().Append(0xFF); //append some ascii character	

		}

	return buffer;

	}

class CTestSync : public CBase

{

public:

	static CTestSync* NewL();

	int TestFunc();

	int TestFuncMonthly();

	void GetInterfaceHandle(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam);

	int UpdateRepeatRule();

	int UpdateInstanceWithRepeat();

	int UpdateEntryWithRepeatAndExceptionDates();

	int AddEntryWithVeryLongDescription();

	CTestSync();

	~CTestSync();

private:

	void ConstructL();

private:	

	CLiwServiceHandler* 	iServiceHandler;

	TInt 					iResult;

	MLiwInterface* 			interface ;	

};		

CTestSync* CTestSync::NewL()

	{

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

	self->ConstructL();

	return self;

	}

CTestSync::~CTestSync()

	{

	if( interface )

	interface->Close();

	delete iServiceHandler;

	}

void CTestSync::ConstructL()

	{

	}

CTestSync::CTestSync()

	{

	interface = NULL ;

	}

int CTestSync::TestFunc()

	{

	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, KCalFileName1);

	TUIDSet* uidset1;

    TBuf<50> globaluid;

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

    AddProvAppointmentWeeklyRepeat(inparam, outparam, interface, KCalFileName1 ,uidset1);

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

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

    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("id"),TLiwVariant(globaluid));

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

    pos = 0 ;

    const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

    TInt count = 0;

    CLiwMap* map;

    TInt retvalue = KErrNone;

	if ( finaloutput )     

		{

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

      	if(iterlist)

      		{

		    TLiwVariant data1;

      		while(iterlist->NextL(data1) )

	      		{

				const CLiwMap* res = data1.AsMap();

				if ( res )

					{

					TLiwVariant data;

					if(res->FindL(_L8("Type"), data))

						{

						TPtrC type = data.AsDes();

						if(type.CompareF(_L("Meeting")) != 0 )

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("StartTime"), data))

						{

						TTime ostime(TDateTime(2007,EOctober,23,10,0,0,0));

						TTime stime = data.AsTTime();

						if( ostime != stime)

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("EndTime"), data))

						{

						TTime oetime(TDateTime(2007,EOctober,23,10,30,0,0));

						TTime etime = data.AsTTime();

						if( oetime != etime)

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("Replication"), data))

						{

						TPtrC rep = data.AsDes();

						if(rep.CompareF(_L("Open")) != 0 )

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("Description"), data))

						{

						TPtrC rep = data.AsDes();

						if(rep.CompareF(_L("Meeting")) != 0 )

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("Status"), data))

						{

						TPtrC rep = data.AsDes();

						if(rep.CompareF(_L("Confirmed")) != 0 )

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("Method"), data))

						{

						TPtrC rep = data.AsDes();

						if(rep.CompareF(_L("None")) != 0 )

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("Organizer"), data))

						{

						const CLiwMap* map = data.AsMap();

						TLiwVariant rdata;

						if(map->FindL(_L8("CommonName"), rdata))

							{

							TPtrC cn = rdata.AsDes();

							if( cn.CompareF(_L("sapi")) != 0 )

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						if(map->FindL(_L8("Address"), rdata))

							{

							TPtrC add = rdata.AsDes();

							if( add.CompareF(_L("mdc@nokia.com")) != 0 )

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						rdata.Reset();	

						}

					if(res->FindL(_L8("PhoneOwner"), data))

						{

						TPtrC rep = data.AsDes();

						if(rep.CompareF(_L("h2s@nokia.com")) != 0 )

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("Attendees"), data))

						{

						const CLiwList* list = data.AsList();

						if ( list )

							{

							TInt count = list->Count();

							for ( int index = 0; index < count; index++ )

								{

								TLiwVariant element;

								list->AtL(index, element);

								const CLiwMap* map = element.AsMap();

								TLiwVariant attParam;

								if ( map && map->FindL(_L8("Address"), attParam) )

									{

									TPtrC address = attParam.AsDes();

									if( address.CompareF(_L("h2s@nokia.com")) != 0 )

										{

									    retvalue = KErrGeneral;

									    attParam.Reset();

									    element.Reset();

										break;

										}

									}

								if ( map->FindL( _L8("CommonName"), attParam ) ) 

									{

									TPtrC cn = attParam.AsDes();

									if( cn.CompareF(_L("sapi")) != 0 )

										{

									    retvalue = KErrGeneral;

									    attParam.Reset();

									    element.Reset();

										break;

										}

									}

								attParam.Reset();

		                        element.Reset();

								}

							}

						}

					if(res->FindL(_L8("RepeatRule"), data))

						{

						const CLiwMap* map = data.AsMap();

						TLiwVariant rdata;

						if(map->FindL(_L8("Type"), rdata))

							{

							TInt type = rdata.AsTInt32();

							if( type != 2 )

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						if(map->FindL(_L8("StartDate"), rdata))

							{

							TTime sdate = rdata.AsTTime();

							TTime ostime(TDateTime(2007,EOctober,23,10,0,0,0));

							if( sdate != ostime)

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						if(map->FindL(_L8("UntilDate"), rdata))

							{

							TTime udate = rdata.AsTTime();

							//TTime outime(TDateTime(2007,EOctober,30,10,0,0,0));

							TTime outime(TDateTime(2007,ENovember,27,10,0,0,0));

							if( udate != outime )

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						rdata.Reset();

						}

					data.Reset();	

					}

	      		}

      		data1.Reset();  

      		}

		}

	inparam->Reset();

	outparam->Reset();

	delete uidset1;

    RemoveProvCalendar(inparam, outparam, interface, KCalFileName1);

    return retvalue;

	}

int CTestSync::TestFuncMonthly()

	{

	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, KCalFileName1);

	TUIDSet* uidset1;

    TBuf<50> globaluid;

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

    AddProvAppointmentMonthlyRepeat(inparam, outparam, interface, KCalFileName1 ,uidset1);

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

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

    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("id"),TLiwVariant(globaluid));

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

    pos = 0 ;

    const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

    TInt count = 0;

    CLiwMap* map;

    TInt retvalue = KErrNone;

	if ( finaloutput )     

		{

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

      	if(iterlist)

      		{

		    TLiwVariant data1;

      		while(iterlist->NextL(data1) )

	      		{

				const CLiwMap* res = data1.AsMap();

				if ( res )

					{

					TLiwVariant data;

					if(res->FindL(_L8("StartTime"), data))

						{

						TTime ostime(TDateTime(2007,EOctober,23,10,0,0,0));

						TTime stime = data.AsTTime();

						if( ostime != stime)

							{

						    retvalue = KErrGeneral;

							break;

							}

						}

					if(res->FindL(_L8("RepeatRule"), data))

						{

						const CLiwMap* map = data.AsMap();

						TLiwVariant rdata;

						if(map->FindL(_L8("Type"), rdata))

							{

							TInt type = rdata.AsTInt32();

							if( type != 2 )

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						if(map->FindL(_L8("StartDate"), rdata))

							{

							TTime sdate = rdata.AsTTime();

							TTime ostime(TDateTime(2007,EOctober,23,10,0,0,0));

							if( sdate != ostime)

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						if(map->FindL(_L8("UntilDate"), rdata))

							{

							TTime udate = rdata.AsTTime();

							//TTime outime(TDateTime(2007,EOctober,30,10,0,0,0));

							TTime outime(TDateTime(2007,EDecember,23,10,0,0,0));

							if( udate != outime )

								{

							    retvalue = KErrGeneral;

							    rdata.Reset();

								break;

								}

							}

						rdata.Reset();

						}

					data.Reset();	

					}

	      		}

      		data1.Reset();  

      		}

		}

	inparam->Reset();

	outparam->Reset();

	delete uidset1;

    RemoveProvCalendar(inparam, outparam, interface, KCalFileName1);