/*

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

//#include "teststartconsolealarmserver3.h"

#include "tcalendarimporttest.h"

#include "startconsolealarmserver.h"

class CCalCallback : public MLiwNotifyCallback

	{

	public:

		static CCalCallback* NewL(CActiveSchedulerWait* aWaitSchedular, TInt& aResult );

		virtual ~CCalCallback(){}

		TInt HandleNotifyL(TInt aCmdId,

	            TInt aEventId,

	            CLiwGenericParamList& aEventParamList,

	            const CLiwGenericParamList& aInParamList);

		TInt			iEntryAdded;

	private:

 		CCalCallback(CActiveSchedulerWait* aWaitSchedular, TInt& aResult ):iWaitSchedular(aWaitSchedular), iResult(aResult){ }

		CActiveSchedulerWait* 	iWaitSchedular;

		TInt& 			iResult;

	};

class CTestAsync : public CActive

{

public:

	static CTestAsync* NewL();

	~CTestAsync();

	void Start(TInt flag, TBool aICalFormat = EFalse, TBool aAsync = EFalse, TBool aWrong = EFalse, TBool aPosBased = EFalse, TBool aInvalidFormat = EFalse  );

	void CancelNotification();

	void ImportInvalidFile();

	TInt Result();

private:

	void ConstructL();

	CTestAsync();

	virtual void DoCancel();

	virtual void RunL();

	void TestFunc();

private:	

	CLiwServiceHandler* 	iServiceHandler;

	CActiveSchedulerWait* 	iWaitSchedular;

	TInt 					iResult;

	TInt 					iEntryAdded;	

	CCalCallback*			iCallback;

	MLiwInterface* 			interface;

	TInt32 					iTransactionId;

	TBool					iICalFormat;

	TBool					iAsync;		

	TInt 					iOption;

	TBool                   iWrongCal;

	TBool                   iPosBased;

	TBool                   iInvalidFormat;

};

_LIT8(KTestInterface, 	"IDataSource");

_LIT8(KTestContent,		"Service.Calendar");

_LIT8(KCmd,				"RequestNotification");

_LIT8(KCmdAdd,			"Add");

_LIT8(KCmdDelete,		"Delete");

_LIT8(KCmdCancel,		"Cancel");

_LIT8(KCmdExport,			"Export");

_LIT8(KCmdImport,			"Import");

_LIT8(KFilter,			"Filter");

_LIT8(KItem,			"Item");

_LIT8(KCalendarName,	"CalendarName");

_LIT(KEntryTypeMeeting,	"Meeting");

const TChar KUidSeparator = ':';

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

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

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

// CTChangeStatusTest::Delete

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

// Called from destructor. 

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

//

void CTCalendarImportTest::Delete() 

    {

    }

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

// CTChangeStatusTest::RunMethodL

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

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

//

TInt CTCalendarImportTest::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( "ImportProviderIter3",    	 CTCalendarImportTest::Import ),

        ENTRY( "ImportProviderIter3File",    	 CTCalendarImportTest::ImportProviderIter3File ),

        ENTRY( "ImportAsyncProviderIter3File",    	 CTCalendarImportTest::ImportAsyncProviderIter3File ),

		ENTRY( "ImportAsyncProviderIter3",    CTCalendarImportTest::ImportAsync ),

		ENTRY( "ICALImportProviderIter3",     CTCalendarImportTest::ICALImport ),

		ENTRY( "ICALImportAsyncProviderIter3",CTCalendarImportTest::ICALImportAsync ),

		ENTRY( "ICALImportProviderIter3File",     CTCalendarImportTest::ICALImportProviderIter3File ),

		ENTRY( "ICALImportAsyncProviderIter3File",CTCalendarImportTest::ICALImportAsyncProviderIter3File ),

		ENTRY( "ImportProviderIter3WrongCal",CTCalendarImportTest::ImportProviderIter3WrongCal ),

		ENTRY( "ImportProviderIter3PositionBased",CTCalendarImportTest::ImportProviderIter3PositionBased ),

		ENTRY( "ImportProviderIter3InvalidFile",CTCalendarImportTest::ImportProviderIter3InvalidFile ),

		ENTRY( "ImportProviderIter3InvalidFormat",CTCalendarImportTest::ImportProviderIter3InvalidFormat ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

class CTestAsync;

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

// CTCalendarImportTest::Import

// Test Method to test the Import(Synchronous)

// Functionality of CalenderService

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

//

TInt  CTCalendarImportTest::Import(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		TInt flag = 0;

		test->Start(flag);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarImportTest::ImportProviderIter3File(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		TInt flag = 1;

		test->Start(flag);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

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

// CTCalendarImportTest::ImportAsync

// Test Method to test the ImportAsync(ASynchronous)

// Functionality of CalenderService

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

//

TInt  CTCalendarImportTest::ImportAsync(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->Start(flag, EFalse, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarImportTest::ImportAsyncProviderIter3File(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		TInt flag = 1;

		test->Start(flag, EFalse, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

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

// CTCalendarImportTest::ICALImport

// Test Method to test the ICALImport(Synchronous)

// Functionality of CalenderService

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

//

TInt  CTCalendarImportTest::ICALImport(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->Start( flag , ETrue );

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarImportTest::ICALImportProviderIter3File(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;

		int flag = 1;	

		CTestAsync* test = CTestAsync::NewL();

		test->Start( flag , ETrue );

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

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

// CTCalendarImportTest::ICALImportAsync

// Test Method to test the ICALImportAsync(ASynchronous)

// Functionality of CalenderService

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

//

TInt  CTCalendarImportTest::ICALImportAsync(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->Start( flag, ETrue, ETrue );

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarImportTest::ICALImportAsyncProviderIter3File(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 1;

		test->Start( flag, ETrue, ETrue );

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

	}

TInt  CTCalendarImportTest::ImportProviderIter3WrongCal(CStifItemParser& /*aItem*/)

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->Start( flag, EFalse, EFalse, ETrue );

		result = test->Result();

		if(result > 0 )

			result = KErrNone;

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

	}

TInt CTCalendarImportTest::ImportProviderIter3PositionBased(CStifItemParser& /*aItem*/ )

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->Start( flag, EFalse, EFalse, EFalse, ETrue );

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

	}

TInt CTCalendarImportTest::ImportProviderIter3InvalidFile(CStifItemParser& /*aItem*/ )

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->ImportInvalidFile();

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

	}

TInt CTCalendarImportTest::ImportProviderIter3InvalidFormat(CStifItemParser& /*aItem*/ )

	{

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		test->Start( flag, EFalse, EFalse, EFalse, EFalse, ETrue );

		result = test->Result();

		if(result == 1004 )

			result = KErrNone;

		else if(result == KErrNone)

			result = KErrGeneral;

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

	}

/*TInt  CTCalendarImportTest::ImportInvalidParamTest(CStifItemParser& aItem)

	{

	}*/

_LIT(KCalTestImportSync1, "c:importsynctestcal1");

_LIT(KCalTestImportSync2, "c:importsynctestcal2");

/**

 * Callback class for asynchronous SAPI message header

*/	

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();

		TInt returnItems = 0;

      	if(iterlist)

      		{

		    TLiwVariant data;

      		while ( iterlist->NextL(data) )

      			returnItems++;	

      		data.Reset();  

      		}

      	if(iEntryAdded == returnItems)	

      		iResult = KErrNone;

      	else

      		iResult = KErrGeneral;

		}

	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 ;

		iResult = KErrGeneral;

		}

void CTestAsync::DoCancel()

	{

	}

void CTestAsync::RunL()

	{

	TestFunc();

	}

TInt CTestAsync::Result()

	{

	return iResult;

	}

void CTestAsync::Start(TInt flag, TBool aICalFormat, TBool aAsync, TBool aWrongCal, TBool aPosBased, TBool aInvalidFormat )

	{

	iICalFormat = aICalFormat;

	iAsync = aAsync;

	iOption = flag;

	iWrongCal = aWrongCal;

	iPosBased = aPosBased;

	iInvalidFormat = aInvalidFormat;

	if( iAsync )

		{

		SetActive();

		TRequestStatus* temp = &iStatus;

		User::RequestComplete(temp, KErrNone);