/*

* Copyright (c) 2007 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 <e32base.h>

#include <e32def.h>

#include "serviceerrno.h"

#include "calendarheader.h"

#include "entryattributes.h"

#include "calendarservice.h"

#include "calendarinterface.h"

#include "calendarcallback.h"

#include "calendariterableimpl.h"

using namespace LIW;

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

// Two-phased constructor.

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

//

CCalendarInterface* CCalendarInterface::NewL()

	{

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

  	CleanupStack::PushL( self );

  	self->ConstructL();

  	CleanupStack::Pop( self );

	return self;

	}

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

// Destructor.

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

//	

CCalendarInterface::~CCalendarInterface()

	{

	TInt count = iArrayCalEntryList.Count();

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

		{

		iArrayCalEntryList[index]->SetResourceFree();

		}

	iArrayCalEntryList.Reset();

	delete iCalService;

	delete iErrorMessage;

	}

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

// Constructor

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

//

CCalendarInterface::CCalendarInterface()

	{

	}

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

// Symbian Constructor

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

//	

void CCalendarInterface::ConstructL()

	{

	iCalService = CCalendarService::NewL();	

	}

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

//  Executes the SAPI as per params

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

//

void CCalendarInterface::ExecuteCmdL( const TDesC8& aCmdName,

					                       const CLiwGenericParamList& aInParamList,

					                       CLiwGenericParamList& aOutParamList,

					                       TUint aCmdOptions,

					                       MLiwNotifyCallback* aCallback )

	{

	TInt errcode = KErrNotSupported;

	TInt32 transactionId = -1;

	aOutParamList.AppendL(TLiwGenericParam( KErrorCode, 

							TLiwVariant( ErrCodeConversion( KErrNone ))));

	TBool posBased;

	TPtrC contentType = GetContentType( aInParamList, posBased );

	if ( ( contentType.CompareF( KContentCalendar ) != 0 ) && 

			( contentType.CompareF( KContentCalendarEntry ) != 0 ) && 

			( aCmdName.CompareF( KCmdCancel ) != 0) )

		{

		errcode = KErrArgument;

		AppendErrorMessageL( aCmdName, KContentType, KInvalid );

		}

	else if (( aCallback && !( KLiwOptASyncronous & aCmdOptions )) || 

				( !aCallback && ( KLiwOptASyncronous & aCmdOptions )) )

		{

		errcode = KErrArgument;

		AppendErrorMessageL(aCmdName, KNullDesC8, _L("Insufficent arguments for asynchronous request"));

		}

	else if ( aCmdName.CompareF( KCmdAdd ) == 0 ) 

		{

		if( !aCallback )

			{

			if ( contentType.CompareF( KContentCalendar ) == 0 )

				{

				TRAP(errcode, AddCalendarL( aInParamList, aOutParamList, posBased ));

				}

			else if ( contentType.CompareF( KContentCalendarEntry ) == 0 )

				{

				TRAP(errcode, AddCalendarEntryL( aInParamList, aOutParamList, posBased ));

				}

			}

		else

			{

			AppendErrorMessageL(aCmdName, KNullDesC8, KAsyncNotSupported);

			}	

		}

	else if ( aCmdName.CompareF( KCmdDelete ) == 0 ) 

		{

		if( contentType.CompareF( KContentCalendar ) == 0 ) 

			{ 

			if ( !aCallback )//deletion of calendars only synchronous

				{

				TRAP(errcode, DeleteCalendarL( aInParamList, posBased) );

				}

			else

				{

				AppendErrorMessageL(aCmdName, KNullDesC8, KAsyncNotSupported);

				}	

			}

		else if ( contentType.CompareF( KContentCalendarEntry ) == 0) 

			{

			TRAP(errcode, DeleteCalendarEntryL( aInParamList, aOutParamList, aCmdOptions, aCallback, posBased, transactionId ));

			}

		}

	else if ( aCmdName.CompareF( KCmdImport ) == 0 ) 

		{

  		if ( contentType.CompareF( KContentCalendarEntry ) == 0 )	

			{

			TRAP(errcode, ImportCalendarEntryL( aInParamList, aOutParamList, aCmdOptions, aCallback, posBased, transactionId ));

			}

		else

			{

			AppendErrorMessageL( aCmdName, KContentType, KInvalid );

			}	

		}

	else if ( aCmdName.CompareF( KCmdExport ) == 0 ) 

		{

		if ( contentType.CompareF( KContentCalendarEntry ) == 0 )	

			{

			TRAP(errcode, ExportCalendarEntryL( aInParamList, aOutParamList, aCmdOptions, aCallback, posBased, transactionId ));

			}	

		else

			{

			AppendErrorMessageL( aCmdName, KContentType, KInvalid );

			}	

		}

	else if ( aCmdName.CompareF( KCmdGetList ) == 0 ) 

		{

		if( !aCallback )

			{

			if ( contentType.CompareF( KContentCalendar ) == 0 )

				{

				TRAP(errcode, GetListCalendarL( aInParamList, aOutParamList, posBased ));

				}

			else if ( contentType.CompareF( KContentCalendarEntry ) == 0 )

				{

				TRAP(errcode, GetListCalendarEntryL( aInParamList, aOutParamList, posBased ));

				}

			}

		else

			{

			AppendErrorMessageL(aCmdName, KNullDesC8, KAsyncNotSupported);

			}	

		}

	else if ( aCmdName.CompareF( KCmdReqNot ) == 0 ) 

		{

		if (( contentType.CompareF( KContentCalendarEntry ) == 0 ) && 

				aCallback && ( KLiwOptASyncronous & aCmdOptions ) )

			{

			TRAP(errcode, RequestNotificationL(aInParamList, aCallback, posBased, transactionId ));

			}

		else if( !aCallback || !( KLiwOptASyncronous & aCmdOptions ))

			{

			AppendErrorMessageL(aCmdName, KNullDesC8, KInvalidAsyncParam);

			}

		else

			{

			AppendErrorMessageL( aCmdName, KContentType, KInvalid );

			}	

		}

	else if ( aCmdName.CompareF( KCmdCancel ) == 0 ) 

		{

		TInt32 transactionId;

		if( (KLiwOptCancel & aCmdOptions ) && !aCallback )

			{

			TRAP( errcode, GetTransactionIdL( aInParamList, transactionId ) );

			if( errcode == KErrNone )

				{

				errcode = iCalService->Cancel( transactionId );

				if ( errcode == KErrNotFound )

					{

					AppendErrorMessageL( aCmdName, KTransactionID, KInvalid );

					}

				else if( errcode == KErrInUse )

					{

					AppendErrorMessageL( aCmdName, KNullDesC8, KServiceInUse );

					}	

				}

			}

		else

			{

			AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidCancelParam );

			}	

		}

	else

		{

		AppendErrorMessageL(aCmdName, KNullDesC8, KCmdInvalid);

		}	

	// Append transaction id in case of asynchronous requests

	if( aCallback && ( KLiwOptASyncronous & aCmdOptions ) && 

						( errcode == KErrNone ) && ( transactionId != -1 ) )

		{

		aOutParamList.AppendL(TLiwGenericParam( KTransactionID, 

								TLiwVariant( TInt32( transactionId ))));		

		}

	if( errcode != KErrNone )

		{

		aOutParamList.Reset();

		aOutParamList.AppendL(TLiwGenericParam( KErrorCode, 

									TLiwVariant(ErrCodeConversion(errcode))));		

		if ( iErrorMessage )

			{

			aOutParamList.AppendL(TLiwGenericParam( KErrorMessage, 

										TLiwVariant(iErrorMessage->Des())));

			delete iErrorMessage;

			iErrorMessage = NULL;		

			}

		}

	}

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

// Closes the interface

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

//

void CCalendarInterface::Close()

	{

	delete this;

	}

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

// Issues Add Calendar request to Calendar Service

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

//

void CCalendarInterface::AddCalendarL(const CLiwGenericParamList& aInParamList, 

													CLiwGenericParamList& /*aOutParamList*/, 

													const TBool aPosBased )

	{

    HBufC* calName = NULL;

    GetCalendarNameL( aInParamList, KCmdAdd, KItem, aPosBased, calName );

    if ( calName && calName->Des().Length() )

		{

		CleanupStack::PushL(calName);

		iCalService->AddL( calName->Des() );

		CleanupStack::PopAndDestroy(calName);

		}

	else

		{

		AppendErrorMessageL( KCmdAdd, KCalendarName, KMissing );

		User::Leave( KErrArgument );

		}

	}

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

// Issues Add Calendar Entry request to Calendar Service

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

//

void CCalendarInterface::AddCalendarEntryL(const CLiwGenericParamList& aInParamList, 

													CLiwGenericParamList& aOutParamList, 

													const TBool aPosBased )

	{

    HBufC* calName = NULL;

    GetCalendarNameL( aInParamList, KCmdAdd, KItem, aPosBased, calName );

    if ( calName )

		{

		CleanupStack::PushL(calName);

		}

	// Get New entry attributes from input param list

   	CEntryAttributes* addAttributes = GetAddParametersL( aInParamList, 

   														calName ? calName->Des() : TPtrC(), 

   														aPosBased );

    CleanupStack::PushL( addAttributes );

    TUIDSet* uidset = NULL;

	iCalService->AddL( calName ? calName->Des() : TPtrC() , addAttributes, uidset );

	// Return Uid of the newly added entry

	if ( uidset )

		{

		CleanupStack::PushL( uidset );

		HBufC* globalUid = HBufC::NewL( uidset->iGlobalUID->Length() + 1 );

		CleanupStack::PushL( globalUid );

		globalUid->Des().Copy( uidset->iGlobalUID->Des() );

		aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant(*globalUid) ));

		CleanupStack::PopAndDestroy( globalUid );

		CleanupStack::Pop( uidset );

		delete uidset;

		CleanupStack::PopAndDestroy( addAttributes );

		}

	else

		{

		AppendErrorMessageL( KCmdAdd, KNullDesC8, KCmdFailed );

		User::Leave( KErrGeneral );

		}

    if ( calName )

		{

		CleanupStack::PopAndDestroy(calName);

		}

	}

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

// Issues Delete Calendar request to Calendar Service

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

//

void CCalendarInterface::DeleteCalendarL( const CLiwGenericParamList& aInParamList, TBool aPosBased)

	{

    HBufC* calName = NULL;

    GetCalendarNameL( aInParamList, KCmdDelete, KData, aPosBased, calName );

    if ( calName && calName->Length() )

		{

		CleanupStack::PushL( calName );

		if( CheckCalendarInUse( *calName ) )

			{

			AppendErrorMessageL( KCmdDelete, KCalendarName, _L(" in use.") );

			User::Leave( KErrInUse );

			}

		iCalService->DeleteL( calName->Des() );

		CleanupStack::PopAndDestroy( calName );

		}

	else

		{

		AppendErrorMessageL( KCmdDelete, KCalendarName, KMissing );

		User::Leave( KErrArgument );

		}

	}

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

// Issues Delete Calendar Entry request to Calendar Service

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

//

void CCalendarInterface::DeleteCalendarEntryL( const CLiwGenericParamList& aInParamList, 

													CLiwGenericParamList& /*aOutParamList*/,

													TUint aCmdOptions,

					                       			MLiwNotifyCallback* aCallback,

													const TBool aPosBased,

													TInt32& aTransactionId )

	{

    HBufC* calName = NULL;

    GetCalendarNameL( aInParamList, KCmdDelete, KData, aPosBased, calName );

    if ( calName )

		{

		CleanupStack::PushL(calName);

		}

	CCalendarFilter* filter = CCalendarFilter::NewL();

	CleanupStack::PushL(filter);

	// Get filter parameters from input list

	GetDeleteEntryFilterL( aInParamList, *filter, aPosBased );

	// Leave if there was no filter

	if( ! filter->Filter() )

		{

		AppendErrorMessageL( KCmdDelete, KData, KMissing );

		User::Leave( KErrArgument );

		}

	// Issue asynchronous request if Callback present

	if ( aCallback && ( KLiwOptASyncronous & aCmdOptions )) 

		{

		aTransactionId = aCallback->GetTransactionID();

		CCalCallbackInt* callback = CCalCallbackInt::NewL( aCallback, aInParamList, aTransactionId );

		CleanupStack::PushL( callback );

		iCalService->DeleteL(  	calName ? calName->Des() : TPtrC() , filter, callback );				

		CleanupStack::Pop( callback );

		}

	// Synchronous request	

	else 

		{

		iCalService->DeleteL( calName ? calName->Des() : TPtrC(), filter );

		}

	CleanupStack::PopAndDestroy(filter);

    if ( calName )

		{

		CleanupStack::PopAndDestroy(calName);

		}

	}

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

// Issues GetList Calendar request to Calendar Service

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

//

void CCalendarInterface::GetListCalendarL(const CLiwGenericParamList& aInParamList, 

													CLiwGenericParamList& aOutParamList, 

													const TBool aPosBased )

	{

	const TLiwGenericParam* filter = NULL; 

	if ( aPosBased )

		{

		if ( aInParamList.Count() > 1 )

			filter = &aInParamList[1];

		}

	else

		{

		TInt pos = 0 ;

		filter = aInParamList.FindFirst( pos, KFilter );

		}

	TBool defaultCalendar = EFalse;

	// Extracting "Default" input param

	// If True, Only default calendar is returned

	if ( filter )

		{

		const CLiwMap* inputMap = filter->Value().AsMap(); 

		if ( inputMap )

			{

			TLiwVariant defaultvalue;

			if( inputMap->FindL( KDefault, defaultvalue))

				{

				ValidateParamTypeL( defaultvalue, LIW::EVariantTypeTBool, 

									KCmdGetList, KDefault, KInvalid );

				defaultCalendar = defaultvalue.AsTBool();

				}

			defaultvalue.Reset();	

			}

		else

			{

			AppendErrorMessageL( KCmdGetList, KFilter, KInvalid );

			User::Leave(KErrArgument);

			}	

		}

	CDesCArray* returnList = NULL;

	// Issue request to Calendar Service	

	iCalService->GetListL( returnList, defaultCalendar );

	CleanupStack::PushL( returnList );

	// Encapsulate the returned list as Iterable

	CIterableCalendarList* iterList = CIterableCalendarList::NewL( returnList );

	CleanupStack::Pop( returnList );

	CleanupClosePushL( *iterList );

	aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( iterList )));

	CleanupStack::PopAndDestroy( iterList );

	}

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

// Issues GetList Calendar Entry request to Calendar Service

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

//

void CCalendarInterface::GetListCalendarEntryL(const CLiwGenericParamList& aInParamList, 

													CLiwGenericParamList& aOutParamList, 

													const TBool aPosBased )

	{

	const TLiwGenericParam* filterParam = NULL; 

	if ( aPosBased )

		{

		if ( aInParamList.Count() > 1 )

			filterParam = &aInParamList[1];

		}

	else

		{

		TInt pos = 0 ;

		filterParam = aInParamList.FindFirst( pos, KFilter );

		}