// 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 <bacntf.h>

// User includes

#include "SCHMAN.H"

#include "SchTimer.h"

#include "SchLogger.h"

#include "SCHEDULE.H"

#include "SCHCLI.H"

#include "SCHSTORE.H"

#include <schtask.h>

#include "SCHLOG.h"

// Constants

const TInt KMinScheduleId = 0;

const TInt KMaxSchedules = 25000;

//Command line argument  

_LIT(KCommandLine, "SYSSTARTSCHEXE");

//SID of SysStart

const TInt KSysStartSID = 0x10205C44; 

#define UNUSED_VAR(a) a = a

//

// Construction/Destruction functions

//

CTaskScheduler::CTaskScheduler()

:	iSchedules(CSchedule::Offset()), 

	iClients(CClientProxy::Offset()),

	iStartupStatePassNonCritical(EFalse)

	{

	}

CTaskScheduler::~CTaskScheduler()

	{

	if (iBackupNotification)

		{

		iBackupNotification->DeRegisterBackupOperationObserver(*this);

		}

	delete iBackupNotification;

	delete iBackupManager;

	delete iNotifier;

	delete iScheduleCriteriaManager;

	delete iSchLogManager;

	//remove clients and schedules as well!!

	TDblQueIter<CClientProxy> clientIter(iClients);

	clientIter.SetToFirst();

	CClientProxy* client=NULL;

	while ((client=clientIter++)!=NULL)

		{

			client->Remove();

			delete client;

		}

	TSglQueIter<CSchedule> schedIter(iSchedules);

	schedIter.SetToFirst();

	CSchedule* schedule=NULL;

	while ((schedule=schedIter++)!=NULL)

		{

			iSchedules.Remove(*schedule);

			delete schedule;

		}	

	}

void CTaskScheduler::ConstructL()

	{

	LOGSTRING("CTaskScheduler::ConstructL - Creating new schedule server log entry");

	User::LeaveIfError(iFsSession.Connect());

	iBackupManager = new(ELeave) CSchBackupManager(iFsSession);

	iBackupManager->ConstructL();

	iNotifier = CEnvironmentChangeNotifier::NewL(CActive::EPriorityHigh, TCallBack(EnvironmentChanged, this));

	iNotifier->Start();

	iScheduleCriteriaManager = CScheduleCriteriaManager::NewL(*this);

	iSchLogManager = CSchLogManager::NewL(iFsSession);

	LOGSTRING("CTaskScheduler::ConstructL - Restoring clients and schedules");

	TRAPD(err, iBackupManager->RestoreL(iClients, iSchedules,*iSchLogManager));

	if	(err != KErrNone) // the file's corrupt or something...

		{

		LOGSTRING2("CTaskScheduler::ConstructL - had to create new store because of error: %d", err);

		iBackupManager->CreateEmptyBackupL();

		}

	//checking the SID of the process which started the Task scheduler	

 	if (User::CreatorSecureId() == KSysStartSID)

	 	{

	    TInt argLen = User::CommandLineLength();

     	if (argLen)

	         {

	         HBufC* arg = HBufC::NewLC(argLen);

	         TPtr argPtr = arg->Des();

	         User::CommandLine(argPtr);

	         argPtr.UpperCase();

	 		 //Checking Comman dLine arg passed to it is same as in SSCForStartupMode0.rss

	 		 //and checking for persisted schedules

	         if((argPtr.Compare(KCommandLine) == 0) && iSchedules.IsEmpty())

	             {

	             //if no schedule leave

				 User::Leave(KErrNone);

	             }

	 	      CleanupStack::PopAndDestroy(arg);

	 	      }

         }

	// Each client now contains a list of associated tasks. We need

	// to now associate those tasks with specific schedules

	CClientProxy* client;

	TDblQueIter<CClientProxy> clientIter(iClients);

	clientIter.SetToFirst();

	while ((client = clientIter++) != NULL)

		{

		// Fetch an iterator for each task owned by this client

		CScheduledTask* task;

		TDblQueIter<CScheduledTask> taskIterator = client->TaskIterator();

		taskIterator.SetToFirst();

		// Iterate through all the tasks owned by this client, trying to find

		// the corresponding schedules.

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

			{

			CSchedule* schedule = NULL;

			schedule = Find(task->ScheduleId());

			if (schedule)

				{

				TScheduledTask* taskRef = new(ELeave) TScheduledTask(*task,*client);

				schedule->AddTask(*taskRef);

				}

			}

		}

	iBackupNotification = CBaBackupSessionWrapper::NewL();

	iBackupNotification->RegisterBackupOperationObserverL(*this);

	}

CTaskScheduler* CTaskScheduler::NewL()

	{

	CTaskScheduler* self = CTaskScheduler::NewLC();

	CleanupStack::Pop();

	return self;	

	}

CTaskScheduler* CTaskScheduler::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//

// Client, Schedule and Task functions

//

CClientProxy* CTaskScheduler::AddClientL(const TDesC& aFilename, TInt aPriority)

	{

	//check we don't already have a client that will do...

	TDblQueIter<CClientProxy> clientIter(iClients);

	clientIter.SetToFirst();

	CClientProxy* client=NULL;

	while ((client=clientIter++)!=NULL)

		{

		if	(client->IsEqual(aFilename, aPriority))

			return client;

		}

	client = CClientProxy::NewL(iFsSession, aFilename, aPriority,*iSchLogManager); 

	iClients.Add(*client);

	return client;

	}

void CTaskScheduler::AddScheduleL(CSchedule& aSchedule)

	{

	LOGSTRING3("CTaskScheduler::AddScheduleL - schedule: %S, %d", &aSchedule.Name(), aSchedule.Id());

	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationAdd, aSchedule);

	iSchedules.AddLast(aSchedule);

	LOGSTRING("CTaskScheduler::AddScheduleL - schedule added");

	}

void CTaskScheduler::EditScheduleL(TInt aScheduleHandle, CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)

	{

	CSchedule* schedule = FindL(aScheduleHandle);

	// remove schedule from condition manager before replacing entries to ensure 

	// its deleted properly.

	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

	schedule->ReplaceEntriesL(aEntryList);

	TRAPD(err, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule));

	if(err)

		{

		schedule->RemoveEntries();

		User::Leave(err);

		}

	// recalculate due time only if schedule is enabled and has tasks to run	

	if (IsScheduleReadyForUpdate(*schedule))

		{

		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);

		}

	}

void CTaskScheduler::DoEditScheduleL(CSchedule& aSchedule, 

							CArrayFixFlat<TTaskSchedulerCondition>& aConditionList,

							const TTsTime& aDefaultTime)

	{

	aSchedule.ReplaceConditionsL(aConditionList);

	//Default Time is represented by a single entry class

	CArrayFixFlat<TScheduleEntryInfo2>* entries 

		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);

	CleanupStack::PushL(entries);

	TScheduleEntryInfo2 info;

	info.SetStartTime(aDefaultTime);

	info.SetInterval(1);

	info.SetIntervalType(EDaily);

	//validityperiod of 24 hours will ensure task is always run

	info.SetValidityPeriod(60*24); 

	entries->AppendL(info);

	aSchedule.ReplaceEntriesL(*entries);

	CleanupStack::Pop(entries);

	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, aSchedule);

	}

void CTaskScheduler::EditScheduleL(TInt aScheduleHandle, 

							CArrayFixFlat<TTaskSchedulerCondition>& aConditionList,

							const TTsTime& aDefaultTime)

	{

	CSchedule* schedule = FindL(aScheduleHandle);

	// remove schedule from condition manager before replacing entries to ensure 

	// its deleted properly.

	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

	TRAPD(err, DoEditScheduleL(*schedule, aConditionList, aDefaultTime));

	if(err)

		{

		schedule->RemoveEntries();

		schedule->RemoveConditions();

		User::Leave(err);

		}

	// recalculate due time only if schedule is enabled and has tasks to run	

	if (IsScheduleReadyForUpdate(*schedule))

		{

		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);

		}

	}	

void CTaskScheduler::RemoveScheduleL(TInt aHandle)

	{

	CSchedule* schedule = FindL(aHandle);

	LOGSTRING3("CTaskScheduler::RemoveScheduleL - schedule: %S, %d", &schedule->Name(), schedule->Id());

	if (!schedule->HasTasks())

		{

		LOGSTRING("CTaskScheduler::RemoveScheduleL - schedule doesn't have any tasks, removing");

		//remove schedule from timer

		iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

		DoRemoveL(schedule);

		}

	else

		{

		// Can't delete a schedule which has tasks

		LOGSTRING("CTaskScheduler::RemoveScheduleL - schedule has tasks, can't delete");

		User::Leave(KErrArgument);

		}

	}

void CTaskScheduler::DisableScheduleL(TInt aHandle)

	{

	CSchedule* schedule = FindL(aHandle);

	schedule->SetEnabled(EFalse);

	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule);

	//remove schedule from timer as its disabled

	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

	}

void CTaskScheduler::EnableScheduleL(TInt aHandle)

	{

	CSchedule* schedule = FindL(aHandle);

	schedule->SetEnabled(ETrue);

	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule);

	// recalculate due time only if schedule has tasks to run	

	if ( IsScheduleReadyForUpdate(*schedule))

		{

		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);

		}

	}

void CTaskScheduler::ScheduleTaskL(CSchedule& aSchedule, CClientProxy& aClient)

	{

	// Backup the task

	if	(aSchedule.Persists())

		{

		iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, aClient);

		}

	// if schedule is enabled then add schedule to timer.

	if (aSchedule.Enabled() && IsStartupStateNonCritical())

		{

		iScheduleCriteriaManager->ReplaceScheduleL(aSchedule);

		}		

	}

void CTaskScheduler::DeleteTaskL(TInt aScheduleHandle, TInt aTaskHandle)

	{

	CSchedule* schedule = FindL(aScheduleHandle);

	TScheduledTask* task = schedule->Task(aTaskHandle);

	if (!task)

		{

		LOGSTRING("CTaskScheduler::DeleteTaskL - task wasn't found");

		User::Leave(KErrNotFound);

		}

	const CClientProxy& clientForTask = task->Client();

	// This deletes the task and removes the CScheduledTask

	// from the CClientProxy's queue of tasks

	task->RemoveInfo();

	// This deletes the TScheduledTask defined above and removes it

	// from CSchedule's queue of TScheduledTask's.

	schedule->RemoveTask(task);

	if (!schedule->HasTasks())	//i.e. it was the last task 

		{

		LOGSTRING("CTaskScheduler::DeleteTaskL - schedule doesn't have any more tasks left");

		//remove scheule from timer as there are no more tasks

		iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

		// If the schedule isn't persistent then we delete it (transient schedules only

		// have one task).

		if (!schedule->Persists())

			DoRemoveL(schedule);

		else

			iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, clientForTask);		

		}

	else

		{

		// Backup the changes to the tasks. Although we are deleting a task, we are not actually

		// deleting the client, so this is actually an edit operation.

		if (schedule->Persists())

			iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, clientForTask);

		}

	}

//

// Utility Functions

//

TInt CTaskScheduler::GenerateId()

	{

	TInt id = KMinScheduleId;

	CSchedule* schedule = Find(id);

	while (schedule!=NULL) 

		{

		id+=KScheduleIdDifferential;//=10 000

		if ((id/KScheduleIdDifferential) > KMaxSchedules)

			return KErrOverflow;

		schedule = Find(id);

		}

	return id;

	}

void CTaskScheduler::DoRemoveL(CSchedule* aSchedule)

	{

	TRAPD(err, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationDelete, *aSchedule));

	if	(err < KErrNone && err != KErrNotFound)

		User::Leave(err);

	iSchedules.Remove(*aSchedule);

	delete aSchedule;

	aSchedule = NULL;

	}

CSchedule* CTaskScheduler::FindL(TInt aHandle)

	{

	CSchedule* schedule = Find(aHandle);

	if (!schedule)

		User::Leave(KErrNotFound);

	return schedule;

	}

CSchedule* CTaskScheduler::Find(TInt aHandle)

	{

	TSglQueIter<CSchedule> scheduleIter(iSchedules);

	scheduleIter.SetToFirst();

	CSchedule* schedule;

	while ((schedule = scheduleIter++)!=NULL)

		{

		if (schedule->Id() == aHandle)

			return schedule;

		}

	return NULL;

	}

// If aRefArray is NULL then only count it returned.

TInt CTaskScheduler::GetScheduleRefsL(CArrayFixFlat<TSchedulerItemRef>* aRefArray, 

									TScheduleFilter aFilter,

									const RMessagePtr2& aMessage)

	{

	TInt count = 0;

	TSglQueIter<CSchedule> iter(iSchedules);

	iter.SetToFirst();

	CSchedule* schedule = NULL;

	while ((schedule = iter++) != NULL)

		{

		if(aFilter == EAllSchedules || (schedule->Enabled() && schedule->HasTasks()))

			{

			//only add information for schedules that the client has permission to alter

			if(schedule->IsAccessAllowed(aMessage))

				{

				if(aRefArray)

					{

					TSchedulerItemRef ref;

					ref.iHandle = schedule->Id();

					ref.iName = schedule->Name();

					aRefArray->AppendL(ref);	

					}

				count++;		

				}

			}

		}

	return count;				

	}

// If aRefArray is NULL then only count it returned.

TInt CTaskScheduler::GetTaskRefsL(CArrayFixFlat<TSchedulerItemRef>* aRefArray, 

									TScheduleFilter aScheduleFilter,

									TTaskFilter aTaskFilter,

									CClientProxy* aClient,

									const RMessagePtr2& aMessage)

	{

	TInt count = 0;

	TSglQueIter<CSchedule> iter(iSchedules);

	iter.SetToFirst();

	CSchedule* schedule = NULL;

	while ((schedule = iter++) != NULL)

		{

		if(aScheduleFilter == EAllSchedules || (schedule->Enabled() && schedule->HasTasks()))

			{

			//only add information for schedules that the client has permission to alter

			if(schedule->IsAccessAllowed(aMessage))

				{

				TSglQueIter<TScheduledTask> taskIter(*(schedule->Tasks()));

				taskIter.SetToFirst();

				TScheduledTask* task;

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

					{

					if (aTaskFilter==EAllTasks||&task->Client() == aClient) // This pointer comparison is a bit rubbish.  Change?

						{

						if(aRefArray)

							{

							TTaskInfo info = task->Info();

							TSchedulerItemRef ref;

							ref.iHandle = info.iTaskId;

							ref.iName = info.iName;

							aRefArray->AppendL(ref);

							}

						count++;

						}

					}

				}

			}

		}

	return count;				

	}

//

// Schedule Execution functions

//

// A schedule is ready to be run

void CTaskScheduler::DueTaskNotifyL(TInt aScheduleHandle)

	{

	CSchedule* schedule = FindL(aScheduleHandle);

	//NotifyTasks() also removes tasks from the schedule if there are no 

	//repeats left.

	schedule->NotifyTasks(); 

	if (!schedule->HasTasks())

		{

		// remove schedule.

		TRAPD(ignore, DoRemoveL(schedule));

		//??error only occurs in relation to persistence!! Do something.  

        UNUSED_VAR(ignore);

		}

	else

		{

		__ASSERT_ALWAYS(IsStartupStateNonCritical(), User::Invariant());

		iScheduleCriteriaManager->ReplaceScheduleL(*schedule,EConditionAndTime,ETrue);

		}

	// Execute all clients.  This method doesn't leave as all errors are either

	// logged in the log engine or handled elsewhere.

	ExecuteClients();

	}

//	Go through all clients, executing their tasks

void CTaskScheduler::ExecuteClients(TBool aUpdateClient)

	{

	if ((BUROperationInProgress() == EBUROperationNoActivity) || !aUpdateClient)

		{

		TDblQueIter<CClientProxy> clientIter(iClients);

		clientIter.SetToFirst();