/*

* 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

*

*/

// SYSTEM INCLUDE FILES

#include <e32base.h>

#include <f32file.h> //for RFile and Rfs

#include <calentry.h>//for CCalEntry

#include <calinstanceview.h>//for CCalInstance

#include <calcommon.h>//for Filter Type Enum Constants

#include <calinstance.h>

#include <caltime.h>

// USER INCLUDE FILES

#include "cal_delete.h"

#include "calendarheader.h"

#include "calendarservice.h"

#include "entryattributes.h"

#include<ascliclientutils.h>

#include "teststartconsolealarmserver.h"

_LIT(KCalName                 ,"C:Calendar");

TInt AddRepeatingAptEntryL(CCalendarService* aService, const TDesC& name, TUIDSet*& uids);

CCalDelTestCases* CCalDelTestCases::NewL( TInt& aResult) //1 means VCal else ICal

	{

	CCalDelTestCases* self = new(ELeave)CCalDelTestCases( aResult); //1 means VCal else ICal;

	self->ConstructL();

	return self;

	}

CCalDelTestCases::~CCalDelTestCases()

	{

	Cancel();

	if(iWaitSchedular->IsStarted())

		iWaitSchedular->AsyncStop();

	if(iCalendarService)

		delete iCalendarService;

	if(iWaitSchedular)

		delete iWaitSchedular;

	if(iArruids.Count())

		iArruids.ResetAndDestroy();

	}

_LIT(KTestCal1File ,"c:cal1");

_LIT(KTestCal2File ,"c:cal2");	

_LIT(KDelTestInvFile ,"Invalid");

_LIT(KDelTestCalNameDeleteForGuids ,"c:deleteforGuidscal");

TInt CCalDelTestCases::TestDeleteUsingGUidL()

	{

	//No need to set it but for the sake of semanitics set to sync value

	iTestCaseType = KDeleteSync;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForGuids.operator()());

	TRAP( iResult , iCalendarService->AddL( KDelTestCalNameDeleteForGuids.operator()() ) );

	if( iResult == KErrNone )

		{			

		addSomeEntries( KDelTestCalNameDeleteForGuids.operator()() );//adds the entries and fills up iArruids with UIDSets

		CEntryAttributes* entryObj = CEntryAttributes::NewL();

	    entryObj->SetEntryStatusL(KNullStatus); 

	    entryObj->SetLocalUid( iArruids[0]->iLocalUID );

	    TUIDSet* entryUids = NULL;

	    CCalendarFilter *getListfilter1 = CCalendarFilter::NewL();

		RPointerArray<CCalInstance> calInstanceArray;

		getListfilter1->SetFilterTypeL( KIncludeAll );

		iCalendarService->GetListL( KDelTestCalNameDeleteForGuids.operator()(), getListfilter1 , calInstanceArray );		

		delete getListfilter1;

		TInt count = calInstanceArray.Count();

		if ( calInstanceArray.Count() == 0 )

			{

			iResult = KErrGeneral;

			calInstanceArray.ResetAndDestroy();

			return iResult;

			}

	    TRAPD( iResult, iCalendarService->AddL(KDelTestCalNameDeleteForGuids.operator()(),entryObj,entryUids) );

	    if(iResult != KErrNone)

	    {

	    	delete entryObj;

	    	calInstanceArray.ResetAndDestroy();

			RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForGuids.operator()());

			return iResult;

	    }

		CCalendarFilter *filter = CCalendarFilter::NewL();

		filter->AddGuidL( *(iArruids[0])->iGlobalUID );

		TRAP( iResult, iCalendarService->DeleteL( KDelTestCalNameDeleteForGuids.operator()() , filter , NULL) );

		delete filter;		

		if(iResult != KErrNone)

	    {

	    	delete entryObj;

	    	calInstanceArray.ResetAndDestroy();

			RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForGuids.operator()());

			delete entryUids;

			entryUids = NULL;

			return iResult;

	    }

		CCalendarFilter *getListfilter2 = CCalendarFilter::NewL();

		RPointerArray<CCalInstance> calInstanceArray2;

		getListfilter2->SetFilterTypeL( KIncludeAll );

		iCalendarService->GetListL( KDelTestCalNameDeleteForGuids.operator()(), getListfilter2 , calInstanceArray2 );		

		delete getListfilter2;

		delete entryObj;

		delete entryUids;

		entryUids = NULL;	

		TInt new_count = calInstanceArray2.Count();

		if ( calInstanceArray2.Count() != count-1 )

			{

			iResult = KErrGeneral;

			}

		calInstanceArray.ResetAndDestroy();

		calInstanceArray2.ResetAndDestroy();

		}

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForGuids.operator()());

	return iResult;

	}

_LIT(KDelTestCalNameDeleteForLuids ,"c:deleteforLuidscal");

//Asynchronous test cases so setting the iTestCaseType as it is to be handled in RunL

TInt CCalDelTestCases::TestDeleteUsingLocalUidL()

	{

		//No need to set it but for the sake of semanitics set to sync value

	iTestCaseType = KDeleteSync;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForLuids.operator()());

	iCalendarService->AddL( KDelTestCalNameDeleteForLuids.operator()() );

		CEntryAttributes* entryObj = CEntryAttributes::NewL();

		TUIDSet* entryUids = NULL;

		RPointerArray<CCalEntry> entryArray;

		TRAPD(err_apt,AddRepeatingAppointmentEntryL(iCalendarService, KDelTestCalNameDeleteForLuids.operator()(), entryUids));

		iArruids.Append(entryUids);

		entryUids = NULL;

		iCalendarService->GetListL( KDelTestCalNameDeleteForLuids.operator()(), *(iArruids[0]->iGlobalUID) , entryArray );		

		TInt count = entryArray.Count();

		count =0;

		entryArray.ResetAndDestroy();

		TTime stTime(TDateTime(2007, ESeptember, 28, 9, 0, 0, 0));

		entryObj->SetInstanceStartTimeL(stTime);

		TTime startTime(TDateTime(2007, ESeptember, 28, 14, 0, 0, 0));

		entryObj->SetStartTimeL(startTime);

		TTime endTime(TDateTime(2007, ESeptember, 28, 17, 30, 0, 0));

		entryObj->SetEndTimeL(endTime);

		TCalLocalUid luid = iArruids[0]->iLocalUID;

		entryObj->SetLocalUid( iArruids[0]->iLocalUID );

		TRAPD(err_update,iCalendarService->AddL(KDelTestCalNameDeleteForLuids.operator()(),entryObj,entryUids));

		TCalLocalUid modifiedEntryId = entryUids->iLocalUID;

		CCalendarFilter *filter = CCalendarFilter::NewL();

		filter->AddLocalUid( (iArruids[0])->iLocalUID );

		TRAP( iResult, iCalendarService->DeleteL( KDelTestCalNameDeleteForLuids.operator()() , filter , NULL) );

		delete filter;		

		iCalendarService->GetListL( KDelTestCalNameDeleteForLuids.operator()(), *(entryUids->iGlobalUID) , entryArray );		

		count = entryArray.Count();

		if ( count != 0 )

			{

			iResult = KErrGeneral;

			}

		entryArray.ResetAndDestroy();

		delete entryUids;

		entryUids = NULL;

		delete entryObj;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForLuids.operator()());

	return iResult;

	}

_LIT(KDelTestCalNameDeleteForGuidLuidsAndTm ,"c:deleteforGuidLuidsAndTmcal");

TInt CCalDelTestCases::TestDeleteGuidTmRgLocalUidL()

	{

		//No need to set it but for the sake of semanitics set to sync value

	iTestCaseType = KDeleteSync;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForGuidLuidsAndTm.operator()());

	iCalendarService->AddL( KDelTestCalNameDeleteForGuidLuidsAndTm.operator()() );

		addSomeEntries( KDelTestCalNameDeleteForGuidLuidsAndTm.operator()() );//adds the entries and fills up iArruids with UIDSets

		TUIDSet* entryUids = NULL;

		CCalendarFilter *getListfilter2 = CCalendarFilter::NewL();

		RPointerArray<CCalInstance> calInstanceArray2;

		getListfilter2->SetFilterTypeL( KIncludeAll );		

		AddRepeatingAppointmentEntryL(iCalendarService, KDelTestCalNameDeleteForGuidLuidsAndTm.operator()(), entryUids);

		iArruids.Append(entryUids);

	//	delete entryUids;

		entryUids = NULL;

		iCalendarService->GetListL( KDelTestCalNameDeleteForGuidLuidsAndTm.operator()(), getListfilter2 , calInstanceArray2 );		

		TInt count = calInstanceArray2.Count();

		count =0;

		calInstanceArray2.ResetAndDestroy();

		CCalendarFilter *filter = CCalendarFilter::NewL();

		filter->AddGuidL( *(iArruids[1])->iGlobalUID );

		filter->AddLocalUid( (iArruids[2])->iLocalUID );

		filter->SetStartTimeL( TTime(TDateTime(2007, EAugust, 5, 8, 0, 0, 0)) );

		filter->SetEndTimeL( TTime(TDateTime(2007, EOctober, 2, 0, 0, 0, 0)) );

		TRAPD( err_delete, iCalendarService->DeleteL( KDelTestCalNameDeleteForGuidLuidsAndTm.operator()() , filter , NULL) );

		delete filter;

		iCalendarService->GetListL( KDelTestCalNameDeleteForGuidLuidsAndTm.operator()(), getListfilter2 , calInstanceArray2 );		

		count = calInstanceArray2.Count();

		if ( calInstanceArray2.Count() != 19 )

			{

			iResult = KErrGeneral;

			}

		calInstanceArray2.ResetAndDestroy();

		delete getListfilter2;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForGuidLuidsAndTm.operator()());

	iResult = err_delete;

	return iResult;	

	}

_LIT(KDelTestCalNameDeleteForInvalidGuidLuid ,"c:deleteforInvalidGuidLuid");

_LIT(KDelTestCalNameDelete ,"c:testcal");

TInt CCalDelTestCases::TestDeleteInvalidGUidLuidL()	

	{

		//No need to set it but for the sake of semanitics set to sync value

	iTestCaseType = KDeleteSync;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForInvalidGuidLuid.operator()());

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDelete.operator()());

	iCalendarService->AddL( KDelTestCalNameDeleteForInvalidGuidLuid.operator()() );

	iCalendarService->AddL( KDelTestCalNameDelete.operator()() );

		addSomeEntries( KDelTestCalNameDeleteForInvalidGuidLuid.operator()() );//adds the entries and fills up iArruids with UIDSets

		CCalendarFilter *filter = CCalendarFilter::NewL();

		CCalendarFilter *new_filter = CCalendarFilter::NewL();

		filter->AddGuidL( *(iArruids[0])->iGlobalUID );

		new_filter->AddLocalUid( 3000 );

	//	filter->SetStartTimeL( TTime(TDateTime(2005, EDecember, 30, 0, 0, 0, 0)) );

	//	filter->SetEndTimeL( TTime(TDateTime(2100, EDecember, 30, 0, 0, 0, 0)) );

		TRAPD( err_guid, iCalendarService->DeleteL( KDelTestCalNameDelete.operator()() , filter , NULL) );

		delete filter;

		TRAPD(err_luid,iCalendarService->DeleteL( KDelTestCalNameDeleteForInvalidGuidLuid.operator()() , new_filter , NULL) );

		delete new_filter;

		CCalendarFilter *getListfilter2 = CCalendarFilter::NewL();

		RPointerArray<CCalInstance> calInstanceArray2;

		getListfilter2->SetFilterTypeL( KIncludeAll );

		iCalendarService->GetListL( KDelTestCalNameDeleteForInvalidGuidLuid.operator()(), getListfilter2 , calInstanceArray2 );		

		TInt count = calInstanceArray2.Count();

		if ( calInstanceArray2.Count() != 4 )

			{

			iResult = KErrGeneral;

			}

		calInstanceArray2.ResetAndDestroy();

		delete getListfilter2;

		RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForInvalidGuidLuid.operator()());

		RemoveCalendarFile(iCalendarService, KDelTestCalNameDelete.operator()());

	/*	if(err_guid != KErrNone)

			iResult = err_guid;

		else

			iResult = err_luid; */

	return iResult;		

	}

_LIT(KDelTestCalNameDeleteForTm ,"c:deleteforTmcal");	

TInt CCalDelTestCases::TestDeleteTmRgL()	

	{

		//No need to set it but for the sake of semanitics set to sync value

	iTestCaseType = KDeleteSync;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForTm.operator()());

	iCalendarService->AddL( KDelTestCalNameDeleteForTm.operator()() );

		addSomeEntries( KDelTestCalNameDeleteForTm.operator()() );//adds the entries and fills up iArruids with UIDSets

		TUIDSet* entryUids = NULL;

		AddRepeatingAptEntryL(iCalendarService, KDelTestCalNameDeleteForTm.operator()(), entryUids);

		iArruids.Append(entryUids);

	//	delete entryUids;

		entryUids = NULL;

		CCalendarFilter *filter = CCalendarFilter::NewL();

		filter->SetStartTimeL( TTime(TDateTime(2007, EAugust, 7, 8, 0, 0, 0)) );

		filter->SetEndTimeL( TTime(TDateTime(2007, ESeptember, 20, 9, 0, 0, 0)) );

		TRAP( iResult, iCalendarService->DeleteL( KDelTestCalNameDeleteForTm.operator()() , filter , NULL) );

		delete filter;

		CCalendarFilter *getListfilter2 = CCalendarFilter::NewL();

		RPointerArray<CCalInstance> calInstanceArray2;

		getListfilter2->SetFilterTypeL( KIncludeAll );

		iCalendarService->GetListL( KDelTestCalNameDeleteForTm.operator()(), getListfilter2 , calInstanceArray2 );		

		TInt count = calInstanceArray2.Count();

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

		{

	   		TInt day_no = calInstanceArray2[i]->Time().TimeLocalL().DateTime().Day();

	    }

		if ( calInstanceArray2.Count() != 12 )

			{

			iResult = KErrGeneral;

			}

		calInstanceArray2.ResetAndDestroy();

		delete getListfilter2;

	RemoveCalendarFile(iCalendarService, KDelTestCalNameDeleteForTm.operator()());

	return iResult;

	}

_LIT(KDefaultCal ,"C:Calendar");	

TInt CCalDelTestCases::TestDeleteByDefCalL()	

	{

		//No need to set it but for the sake of semanitics set to sync value

  		iTestCaseType = KDeleteSync;

		CCalendarFilter *filter = CCalendarFilter::NewL();

		filter->SetStartTimeL( TTime(TDateTime(2007, EAugust, 7, 8, 0, 0, 0)) );

		filter->SetEndTimeL( TTime(TDateTime(2007, ESeptember, 20, 8, 0, 0, 0)) );

	//	TRAPD( err_delete, iCalendarService->DeleteL( KDefaultCal.operator()() , NULL , NULL) );

		TRAPD( iResult, iCalendarService->DeleteL( KDefaultCal.operator()() , filter , NULL) );

		delete filter;

	return iResult;

	}

_LIT(KDelTestCalNameDeleteForGuidsAsync ,"c:deleteforGuidscalasync");

_LIT(KDelTestCalNameDeleteForLuidsAsync ,"c:deleteforLuidscalasync");

_LIT(KDelTestCalNameDeleteForInvalidGuidAsync ,"c:deleteforInvalidGuidLasync");

_LIT(KDelTestCalNameDeleteForInvalidLuidAsync ,"c:deleteforInvalidLuidLasync");

_LIT(KDelTestCalNameAsync ,"c:testcalasync");

_LIT(KDelTestCalNameDeleteForGuidLuidsAndTmAsync ,"c:deleteforGuidLuidsandtmcalasync");

_LIT(KDelTestCalNameDeleteAllAsync ,"c:deleteallcalasync");

_LIT(KDelTestCalNameDeleteForTmAsync ,"c:deleteforTmcalasync");

//Async things start here ***************************************************