// Copyright (c) 2004-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:

//

// System includes

#include <logwraplimits.h>

#include <logwrap.h>

#include <schtask.h>

// User includes

#include "SCHCLI.H"

#include "SchLogger.h"

#include "SCHEXEC.H"

#include "SCHLOG.h"

// Constants

#define KEllipsis 0x2026

const TInt KTaskArrayGranularity = 1;

_LIT(KTaskNameSeparator, ", ");

//

// CClientProxy

//

CClientProxy::CClientProxy(RFs& aFsSession, CSchLogManager& aLogManager)

:	iFsSession(aFsSession), 

	iTasks(CScheduledTask::Offset()),

	iSchLogManager(aLogManager)

	{

	}

CClientProxy::CClientProxy(RFs& aFsSession, TInt aPriority, CSchLogManager& aLogManager)

:	iFsSession(aFsSession), 

	iTasks(CScheduledTask::Offset()),

	iSchLogManager(aLogManager)

	{

	iPriLink.iPriority = aPriority;

	}

CClientProxy::~CClientProxy()

	{

	LOGSTRING("CClientProxy::~CClientProxy - start");

	TDblQueIter<CScheduledTask> taskIter(iTasks);

	taskIter.SetToFirst();

	CScheduledTask* task;

	while ((task = taskIter++) != NULL)

		{

		RemoveTask(task);

		}

	delete iFileName;

	LOGSTRING("CClientProxy::~CClientProxy - end");

	} 

void CClientProxy::ConstructL(const TDesC& aFileName)

	{

	iFileName = aFileName.AllocL();

	}

CClientProxy* CClientProxy::NewL(RFs& aFsSession, 

								const TDesC& aFileName, 

								TInt aPriority,

								CSchLogManager& aLogManager)

	{

	CClientProxy* self = new(ELeave) CClientProxy(aFsSession, aPriority,aLogManager);

	CleanupStack::PushL(self);

	self->ConstructL(aFileName);

	CleanupStack::Pop();

	return self;

	}

CClientProxy* CClientProxy::NewL(RFs& aFsSession, 

								RReadStream& aStream,

								CSchLogManager& aLogManager)

	{

	CClientProxy* self = new(ELeave) CClientProxy(aFsSession,aLogManager);

	CleanupStack::PushL(self);

	aStream >> *self;

	CleanupStack::Pop();

	return self;

	}

TBool CClientProxy::IsEqual(const TDesC& aFilename, TInt aPriority) const

	{

	// Equality here means: same DLL filename, DLL ordinal & priority

	return ((*iFileName == aFilename) && (iPriLink.iPriority == aPriority));

	}

void CClientProxy::AddTask(CScheduledTask& aTask)

	{

	LOGSTRING("CClientProxy::AddTask - start");

	iTasks.Add(aTask);

	iUsers++;

	LOGSTRING("CClientProxy::AddTask - end");

	}

void CClientProxy::RemoveTask(CScheduledTask* aTask)

	{

	LOGSTRING("CClientProxy::RemoveTask - start");

	iUsers--;

	aTask->Remove();

	delete aTask;

	LOGSTRING("CClientProxy::RemoveTask - end");

	}

//

static void BuildTaskErrorMessage(const CArrayPtr<CScheduledTask>& aTasks, TDes& aErrorMessage)

//

//	Establish the names of all the tasks that potentially might fail

//	when executing the task. This is done *before* actually executing the

//	tasks as its not possible to discern (at failure time) which tasks

//	were actually executing (because we don't know at what time the task

//	executor was spawned).

//

	{

	const TInt count = aTasks.Count();

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

		{

		const TDesC& taskName = aTasks.At(i)->Info().iName;

		if	(aErrorMessage.Length() + taskName.Length() > KLogMaxSubjectLength - KTaskNameSeparator().Length())

			{

			// The task name that still needs adding to the subject line (of the

			// log entry) is too big to fit within KLogCallEventTypeUid characters.

			// Trim the task name so that it will fit, and append the ellipsis

			// character to indicate that more tasks were present but unable to be

			// shown.

			TInt lengthOfTaskNameToAccept = (KLogMaxSubjectLength - aErrorMessage.Length()) - KTaskNameSeparator().Length();

			if	(lengthOfTaskNameToAccept <= 0)

				break;

			aErrorMessage += taskName.Left(lengthOfTaskNameToAccept);

			aErrorMessage.Append(KEllipsis);

			// Exit the 'for' loop as there isn't any more room to hold subsequent

			// tasks that potentially failed...

			break;

			}

		else

			{

			aErrorMessage += taskName;

			}

		if	(i<count-1) // not the last taskName

			{

			// Append a comma

			aErrorMessage += KTaskNameSeparator;

			}

		}

	}

void CClientProxy::ExecuteTasks()

	{

	// generate an array of due tasks

	CArrayPtr<CScheduledTask>* tasks = NULL;

	TRAPD(err, tasks = DueTasksL());

	if(err)

		{

		iSchLogManager.LogError(err);

		return;

		}

	// Create the task error message, just in case an error occurs

	TBuf<KLogMaxSubjectLength> errorMessage;

	BuildTaskErrorMessage(*tasks, errorMessage);

	TInt error =DoExecuteTasks(*tasks, errorMessage);

	if(error)

		iSchLogManager.LogError(errorMessage,error);

	delete tasks;

	}

TInt CClientProxy::DoExecuteTasks(const CArrayPtr<CScheduledTask>& aTasks,

									const TDesC& aErrorMessage)

	{

	// Generate a unique task name

	TTime timenow;

	timenow.UniversalTime();

	TBuf<24> filename; // 20 is the longest decimal char length of a 64-bit number + 4 for extension

	filename.Format(_L("%Ld.tmp"),timenow.Int64());

	// Save & perform execution

	TRAPD(error, DoExecuteTasksL(aTasks, filename, aErrorMessage));

	if (error != KErrNone)

		{

		LOGSTRING2("CClientProxy::ExecuteTasksL - attempted to execute tasks, error was %d", error);

		// Cleanup the file that was created if the execution fails in any way. Note

		// that it might not have been created

		// If a debug build - record error

		TInt fileDeleteErr=iFsSession.Delete(filename);

		if (fileDeleteErr != KErrNone)

			{

			LOGSTRING2("CClientProxy::DoExecuteTasks - Failed to delete file. Error = %d", fileDeleteErr);

			}

		}

	return error;

	}

void CClientProxy::DoExecuteTasksL(const CArrayPtr<CScheduledTask>& aTasks, 

									const TDesC& aFileName,

									const TDesC& aErrorMessage)

	{

	// Save the tasks to disk

	SaveTasksToFileL(aTasks, aFileName);

	// Spawn the task executor active object (deletes itself upon completion)

	CTaskExecutor* executor = CTaskExecutor::NewLC(aErrorMessage,aFileName,*iFileName,iSchLogManager);

	executor->ExecuteL();

	CleanupStack::Pop(executor);

	// Don't delete executor here as it does it itself once 

	// the task has finished (delete this in its RunL() )

	}

CArrayPtr<CScheduledTask>* CClientProxy::DueTasksL()

//

//	Returns a copy of any due tasks

//

	{

	CArrayPtrFlat<CScheduledTask>* tasks = new(ELeave)CArrayPtrFlat<CScheduledTask> (KTaskArrayGranularity);

	CleanupStack::PushL(tasks);

	TDblQueIter<CScheduledTask> taskIter(iTasks);

	taskIter.SetToFirst();

	CScheduledTask* task;

	while ((task=taskIter++)!=NULL)

		{

		if (task->Due())

			{

			tasks->AppendL(task);

			}

		}

	CleanupStack::Pop(tasks);

	return tasks;

	}

CFileStore* CClientProxy::CreateStoreL(const TDesC& aName,TUint aFileMode)

//

//	To make the code clearer - called within a trap frame that shouldn't leave anything 

//	on cleanup stack.

//

	{

	CFileStore* store = CDirectFileStore::CreateLC(iFsSession, aName, aFileMode);

	CleanupStack::Pop(store);

	return store;

	}

void CClientProxy::SaveTasksToFileL(const CArrayPtr<CScheduledTask>& aTasks, const TDesC& aFileName)

	{

	LOGSTRING("CClientProxy::SaveTasksToFileL - start");

	// Create the file store

	LOGSTRING("CClientProxy::SaveTasksToFileL - creating store");

	CFileStore* store = CreateStoreL(aFileName, EFileWrite);

	CleanupStack::PushL(store);

	// Save the actual tasks to the store

	LOGSTRING("CClientProxy::SaveTasksToFileL - saving tasks");

	SaveTasksL(*store, aTasks);

	CleanupStack::PopAndDestroy(store);

	LOGSTRING("CClientProxy::SaveTasksToFileL - end");

	}

void CClientProxy::SaveTasksL(CFileStore& aStore, const CArrayPtr<CScheduledTask>& aTasks)

	{

	LOGSTRING("CClientProxy::SaveTasksL - start");

	aStore.SetTypeL(KDirectFileStoreLayoutUid);	

	// Save the tasks

	RStoreWriteStream outstream;

	TStreamId id = outstream.CreateLC(aStore);

	const TInt count = aTasks.Count();

	LOGSTRING2("CClientProxy::SaveTasksL - saving %d tasks", count);

	outstream.WriteInt32L(count);

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

		{

		CScheduledTask* task = aTasks.At(i);

		task->ExternalizeL(outstream);

		} 

	outstream.CommitL();

	CleanupStack::PopAndDestroy(); // outstream

	aStore.SetRootL(id);							

	aStore.CommitL();							

	LOGSTRING("CClientProxy::SaveTasksL - end");

	}

void CClientProxy::RemoveDueTasks()

	{

	LOGSTRING("CClientProxy::RemoveDueTasks - start");

	TDblQueIter<CScheduledTask> taskIter(iTasks);

	taskIter.SetToFirst();

	CScheduledTask* task;

	//

	while ((task=taskIter++)!=NULL)

		{

		if (task->Due())

			{

			LOGSTRING3("CClientProxy::RemoveDueTasks - found due task %S, %d", &task->Info().iName, task->Info().iTaskId);

			if	(!task->Info().iRepeat)

				{

				LOGSTRING("CClientProxy::RemoveDueTasks - task has no repeats left - it's being removed");

				RemoveTask(task);

				}

			else

				{

				LOGSTRING("CClientProxy::RemoveDueTasks - task still has some repeats, setting as 'no longer due'");

				task->SetDue(EFalse);

				}

			}

		}

	iReadyToExecute = EFalse;

	LOGSTRING("CClientProxy::RemoveDueTasks - end");

	}

void CClientProxy::TransferTasks(CClientProxy& aTargetClient)

	{

	TDblQueIter<CScheduledTask> taskIter(iTasks);

	taskIter.SetToFirst();

	CScheduledTask* task;

	while ((task=taskIter++)!=NULL)

		{

		task->Remove();

		aTargetClient.AddTask(*task);

		}

	}

void CClientProxy::InternalizeL(RReadStream& aReadStream)

	{

	LOGSTRING("CClientProxy::InternalizeL - start");

	HBufC* fileName = HBufC::NewL(aReadStream, KMaxFileName);

	delete iFileName;

	iFileName = fileName;

	//

	iPriLink.iPriority = aReadStream.ReadInt32L();

	const TInt count = aReadStream.ReadInt32L();

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

		{

		CScheduledTask* task = CScheduledTask::NewLC(aReadStream);

		AddTask(*task);

		CleanupStack::Pop(task);

		}

	LOGSTRING("CClientProxy::InternalizeL - end");

	}

void CClientProxy::ExternalizeL(RWriteStream& aWriteStream) const

	{

	LOGSTRING("CClientProxy::ExternalizeL - start");

	aWriteStream << *iFileName;

	aWriteStream.WriteInt32L(iPriLink.iPriority);

	TDblQueIter<CScheduledTask> taskIter(const_cast<CClientProxy*>(this)->iTasks);

	taskIter.SetToFirst();

	CScheduledTask* task;

	// Count tasks

	TInt count = 0;

	while ((task=taskIter++)!=NULL)

		{

		if(task->Persists())

			{	

			count++;

			}

		}

	// Store leading count

	aWriteStream.WriteInt32L(count);

	// Store tasks

	taskIter.SetToFirst();

	while ((task=taskIter++)!=NULL)

		{

		if(task->Persists())

		  {

		  aWriteStream << *task;

		  }

		}

	LOGSTRING("CClientProxy::ExternalizeL - end");

	}

TDblQueIter<CScheduledTask> CClientProxy::TaskIterator()

	{

	return TDblQueIter<CScheduledTask>(iTasks);

	}