// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "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 "agmsimpleentry.h"
#include "calclient.h"
#include "calcategoryimpl.h"
#include "calentryimpl.h"
#include <calprogresscallback.h>
#include "calsessionimpl.h"
#include "calcategorymanagerimpl.h"
#include "agmdebug.h"

CCalAsyncTaskManager::CCalAsyncTaskManager(CCalSessionImpl& aSessionImpl)
	: CActive(EPriorityStandard),
	iSessionImpl(aSessionImpl)
	{
	CActiveScheduler::Add(this);
	}
	
CCalAsyncTaskManager::~CCalAsyncTaskManager()
	{
	CancelAsynTask();
	iCallBacks.Close();
	delete iEntryIdList;
	}
	
CCalAsyncTaskManager* CCalAsyncTaskManager::NewL(CCalSessionImpl& aSessionImpl)
	{
	CCalAsyncTaskManager* self = new (ELeave) CCalAsyncTaskManager(aSessionImpl);
	return self;
	}

void CCalAsyncTaskManager::StartBuildIndexL(MCalProgressCallBack& aProgressCallBack)
	{
	/*If it is a task of building index, place the callback into the queue, 
	so that all of them can be completed when the building index. 
	*/
	_DBGLOG_ASYNC(AgmDebug::DebugLogTimeStampL("StartBuildIndexL: Commencing async build index");)
	
	if (iAction==EBuildIndex)
		{
		iCallBacks.AppendL(&aProgressCallBack);
		}
	else if (iAction!=ENoAction)
		{
		//The index must have been built if it is doing other asynchronous operations
		aProgressCallBack.Completed(KErrNone);
		}
	else
		{
		iAction = EBuildIndex;
		iCallBacks.AppendL(&aProgressCallBack);

		if (!IsActive())
			{
			SetActive();
			}
		iSessionImpl.Server().StartBuildIndex(aProgressCallBack.NotifyProgress(), iStatus, iSessionImpl.CollectionId());
		}
	}

void CCalAsyncTaskManager::StartDeleteEntryL(MCalProgressCallBack& aProgressCallBack, const CalCommon::TCalTimeRange& aCalTimeRange, CalCommon::TCalViewFilter aFilter)
	{
	/*If it is a task of building index, place the callback into the queue, 
	so that all of them can be completed when the building index. If it is a
	task of deleting entry, simply leave with "busy". 
	*/
	_DBGLOG_ASYNC(AgmDebug::DebugLogTimeStampL("StartDeleteEntryL: Commencing async delete");)
	
	if(iAction!=ENoAction)
		{
		User::Leave(KErrLocked);
		}
		
	TTime todaysDate;
	todaysDate.HomeTime();

	iAction = EDeleteEntry;
	iCallBacks.Append(&aProgressCallBack);

	TAgnFilter agnFilter(aFilter, CalCommon::EFoldedTextSearch);
	TRAPD(err, iSessionImpl.Server().StartTidyByDateL(aProgressCallBack.NotifyProgress(), iStatus, agnFilter, todaysDate, aCalTimeRange, iSessionImpl.CollectionId()));

	if (err != KErrNone)
		{
		iCallBacks.Remove(iCallBacks.Count() - 1);
		iAction = ENoAction;
		User::Leave(err);
		}
	else if (!IsActive())
		{
		SetActive();
		}
	}
	
void CCalAsyncTaskManager::StartCategoryTaskL(MCalProgressCallBack& aProgressCallBack, TAsyncAction aAction, const CCalCategory& aCategory, RPointerArray<CCalEntry>* aFilteredEntry)
	{
	/*If it is a task of building index, place the callback into the queue, 
	so that all of them can be completed when the building index. If it is a
	task of deleting entry, simply leave with "busy". 
	*/
	_DBGLOG_ASYNC(AgmDebug::DebugLogTimeStampL("StartCategoryTaskL: Commencing async category task");)
	
	if(iAction!=ENoAction)
		{
		User::Leave(KErrLocked);
		}
		

	iAction = aAction;
	iCallBacks.Append(&aProgressCallBack);

	if(iAction==EFilterCategory)
		{
		iFilteredEntry = aFilteredEntry;
		}

	TRAPD(err, iSessionImpl.Server().StartCategoryTaskL(aProgressCallBack.NotifyProgress(), iStatus, *(aCategory.Impl()->AgnCategory()), aAction, iSessionImpl.CollectionId()));
	if (err != KErrNone)
		{
		iCallBacks.Remove(iCallBacks.Count() - 1);
		iAction = ENoAction;
		User::Leave(err);
		}
	else if (!IsActive())
		{
		SetActive();
		}
	}

		
void CCalAsyncTaskManager::DoCancel()
	{
	}

void CCalAsyncTaskManager::CancelAsynTask()
	{
	if (iAction != ENoAction)
		{
		iSessionImpl.Server().CancelTask(iSessionImpl.FileId());
		CompleteRequest(KErrCancel);
		Cancel();
		}
	iAction = ENoAction;
	}

void CCalAsyncTaskManager::RunL()
	{
	//If the progress value is 100 or negative it means that the observed process
	//has finished and thereby it should have provided the progress value to report
	//Under normal conditions we use the complete status as a progress parameter (%)
	TInt progress = iStatus.Int();

	//If The ongoing process is not cancelled or finished then request again
	if (progress > 0 && progress < 100)
		{
		TInt count=iCallBacks.Count();
		for(TInt ii=0; ii<count; ++ii)
			{
			if((iCallBacks)[ii])
				{
				(iCallBacks)[ii]->Progress(progress);
				}
			}

		//requesting itself
		if (iAction == EBuildIndex)
			{//When asynchronous operation is to build index, we should call RAgendaServ::StartBuildIndex  for progress requess. 
			iSessionImpl.Server().StartBuildIndex(ETrue, iStatus, iSessionImpl.CollectionId());
			}
		else
			{
			iSessionImpl.Server().RequestProgress(iStatus, iSessionImpl.CollectionId());
			}
		
		SetActive();
		}
	else 
		{
		if (iAction==EFilterCategory && progress==KErrNone)
			{
			TRAP(progress,GetFilteredEntryL());
		     if( progress != KErrNone )
		         {
                 iAction = ENoAction;
		         }
			}
		CompleteRequest(progress);
		}
	}

void CCalAsyncTaskManager::CompleteRequest(TInt aCompleteCode)
	{
	for(TInt ii=0; ii<iCallBacks.Count(); ++ii)
		{
		if((iCallBacks)[ii])
			{
			iCallBacks[ii]->Completed(aCompleteCode);
			}
		}
	iCallBacks.Reset();
	delete iEntryIdList;
	iEntryIdList=NULL;
	iAction = ENoAction;
	}
	
void CCalAsyncTaskManager::GetFilteredEntryL()
	{// Get the light entry by its entry id and fill in it into the array past in by the client
	iEntryIdList = new (ELeave) CArrayFixSeg<TAgnEntryId> (32);
	CCalCategoryManagerImpl::GetFilteredEntryL(*iEntryIdList, *iFilteredEntry, iSessionImpl);
	delete iEntryIdList;
	iEntryIdList=NULL;
	}

TBool CCalAsyncTaskManager::BuildingIndex() const
	{
	return (iAction == EBuildIndex);
	}
	
TBool CCalAsyncTaskManager::IsBusy() const
	{
	return iAction!=ENoAction;	
	}