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

//

#ifdef _DEBUG

#undef _MSG_NO_LOGGING

#endif

#include <msvschedulesend.h>

#include <msventry.h>

#include <msvids.h>

#include <bautils.h>

#include <e32property.h>

#include <centralrepository.h>

#include <msvschedulesettings.h>

#include <msvoffpeaktime.h>

#include <msvsysagentaction.h>

#include <schsend_panic.h>

#include <tmsvschedulesettingsutils.h>

#include <schinfointernal.h>

#ifndef _MSG_NO_LOGGING

#include <flogger.h>

#endif

_LIT(KSchSendExe, "schsendexe.exe");

LOCAL_C TBool operator==(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions1, const CArrayFixFlat<TTaskSchedulerCondition>& aConditions2)

	{

	TInt count1 = aConditions1.Count();

	TInt count2 = aConditions2.Count();

	// Compare the conditions.	

	if( count1 != count2 )

		{

		// Different number of conditions - no match.

		return EFalse;

		}

	// Search for all the conditions in info1 are in info2

	for( TInt ii = 0; ii < count1; ++ii )

		{

		TTaskSchedulerCondition condition1 = aConditions1[ii];

		TTaskSchedulerCondition condition2;

		TBool found = EFalse;

		TInt jj = 0;

		while( !found && jj < count2 )

			{

			condition2 = aConditions2[jj];

			if( condition2.iKey == condition1.iKey )

				found = ETrue;

			else

				++jj;

			}

		if( !found || condition2.iState != condition1.iState || condition2.iType != condition1.iType )

			{

			// Either aConditions2 has not got this condition or it has but it 

			// does not match - no match.

			return EFalse;

			}

		}

	return ETrue;

	}

/**

Constructor.

@param aServerEntry 

The CMsvServerEntry of the server MTM of which this CMsvScheduleSend 

object is a member.

*/

EXPORT_C CMsvScheduleSend::CMsvScheduleSend(CMsvServerEntry& aServerEntry)

	: iServerEntry(aServerEntry)

	{

	}

/**

Second phase constructor.

This constructor creates instances of the following classes: 

CMsvScheduleSettings, CMsvOffPeakTimes, CMsvSendErrorActions,

CMsvSysAgentActions and CMsvScheduledEntries.

*/

EXPORT_C void CMsvScheduleSend::ConstructL()

	{

	iSettings			= CMsvScheduleSettings::NewL();

	iOffPeakTimes		= new (ELeave) CMsvOffPeakTimes();

	iErrorActions		= CMsvSendErrorActions::NewL();

	iAgentActions		= new (ELeave) CMsvSysAgentActions();

	iSchEntries			= new (ELeave) CMsvScheduledEntries(KMsvSchsendArrayGrowth);

	iSchEntryInfo		= new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(KMsvSchsendArrayGrowth);

	iSchTaskInfo		= new (ELeave) CArrayFixFlat<TTaskInfo>(KMsvSchsendArrayGrowth);

	}

/**

Destructor.

*/

EXPORT_C CMsvScheduleSend::~CMsvScheduleSend()

	{

	delete iSettings;

	delete iOffPeakTimes;

	delete iErrorActions;

	delete iAgentActions;

	if (iScheduler.Handle())

		iScheduler.Close();

	if (iSchEntries)

		iSchEntries->ResetAndDestroy();

	delete iSchEntries;

	delete iSchTaskInfo;

	delete iSchEntryInfo;

	}

/**

Schedules messages on the task scheduler.

Messages that are successfully scheduled have their sending state set to

KMsvSendStateScheduled.

@param aSelection 

Array of message IDs that need to be scheduled. This array cannot be empty.

All the messages identified in the selection must belong to the same MTM;

be scheduled for the same time; have the same setting for their OffPeak() 

flag; have the scheduled time stored in the iDate member of their 

corresponding TMsvEntry. 

@param aPackage 

Scheduling options

@leave Any error code but KErrLocked and KErrNotFound

The method overloading CMsvScheduledEntry::GetMessageL() left with an error,

i.e. the scheduling info of one of the messages from the selection could not

be retrieved from the message server.

@leave Any error code

Unable to reset the previous scheduling info for a message.

@panic ScheduleSend-DLL 0

The array of message IDs is empty.

Debug build only.

@panic ScheduleSend-DLL 1

At least one of the selected messages is scheduled for a different time

as the others.

Debug build only.

@panic ScheduleSend-DLL 2

At least one of the selected messages does not belong to the same MTM.

Debug build only.

@panic ScheduleSend-DLL 3

At least one of the selected messages does not have the same off-peak 

settings as the others.

Debug build only.

*/

EXPORT_C void CMsvScheduleSend::ScheduleL(const CMsvEntrySelection& aSelection, const TMsvSchedulePackage& aPackage)

	{

	__ASSERT_DEBUG(aSelection.Count() > 0, gPanic(EMessageSelectionEmpty));

	iPackage = aPackage;

	GetMessagesL(aSelection);	//Leaves with KErrNotFound if there

																	//are no messages returned in schEntries

	TInt entryCount = iSchEntries->Count();

	SCHSENDLOG(FLog(_L8("Asked to schedule %d msgs"), entryCount));

	if (entryCount)

		{

		TTime startTime;

#if defined(_DEBUG)

		CMsvScheduledEntry* firstEntry = (*iSchEntries)[0];

#endif

		while (entryCount--)

			{

			CMsvScheduledEntry* message = iSchEntries->At(entryCount);

			__ASSERT_DEBUG(firstEntry->ScheduleDate() == message->ScheduleDate(), gPanic(EMessagesNotSameTime));

			startTime = message->ScheduleDate();

			// Reset previous scheduling info

			DeleteScheduleForEntryL(*message);

			ResetScheduleInfoForEntryL(*message, EFalse);

			}

		//Schedule the messages

		DoScheduleL(*iSchEntries, KMsvSendStateScheduled, startTime, EFalse);

		}

	}

/** 

Determines when the messages should be re-scheduled on the task scheduler, 

then schedules the messages at the new time(s).

Messages that are successfully re-scheduled are updated. The pending conditions

flag indicates whether the message has been schedule for a set of conditions 

being met (or a timeout occuring) or scheduled for a specified time/date.

NOTE - conditions scheduling is only supoprted from 8.1 onwards.

In the case of time-scheduling, the date field is the scheduled time/date. In 

the case of conditions-scheduling, the date field reflects the timeout value.

There are several cases when messages are not re-scheduled. If all recipients 

have been sent to - in this case the message's sending state set to 

KMsvSendStateSent. If, more commonly, the message's maximum number of re-tries

has been exceeded or the error action was ESendActionFail then the message is 

not changed.

@param aSelection 

Array of message IDs that need to be re-scheduled. This array cannot be empty. 

All the messages identified must belong to the same MTM. It is not a 

precondition that each message has already been scheduled on the task 

scheduler.

@param aPackage

Scheduling options.

@param aErrorAction

The specific action to take with the messages. If this argument is omitted, 

then ReScheduleL() uses the iError member of each TMsvEntry to find the 

related TMsvSendErrorAction in iErrorActions.

@panic ScheduleSend-DLL 0

The array of message IDs is empty.

Debug build only.

*/

EXPORT_C void CMsvScheduleSend::ReScheduleL(const CMsvEntrySelection& aSelection, const TMsvSchedulePackage& aPackage, const TMsvSendErrorAction* aErrorAction)

	{

	__ASSERT_DEBUG(aSelection.Count() > 0, gPanic(EMessageSelectionEmpty));

	iPackage = aPackage;

	GetMessagesL(aSelection);

	TInt entryCount = iSchEntries->Count();

	SCHSENDLOG(FLog(_L8("Asked to re-schedule %d msgs"), entryCount));

	if (entryCount)

		{

		TTime curTime;

		curTime.UniversalTime();

		curTime += iSettings->Latency();

		while (entryCount--)

			{

			CMsvScheduledEntry* message = iSchEntries->At(entryCount);

			SCHSENDLOG(FLog(_L8("\tAttempting to Re-Schedule msg %d"), message->Id()));

			if (!SetMessageStartTime(*message, curTime, aErrorAction))

				{

				SCHSENDLOG(FLog(_L8("\t\tCannot Re-Schedule msg %d (new sending state %d)"), message->Id(), message->SendingState()));

				DeleteScheduleForEntryL(*message);

				ResetScheduleInfoForEntryL(*message, ETrue);

				delete message;

				iSchEntries->Delete(entryCount);

				}

			}

		//Send the messages if there are any left to send

		if (iSchEntries->Count())

			{

			DoReScheduleL(*iSchEntries);

			}

		else

			{

			SCHSENDLOG(FLog(_L8("\tNo messages to Re-Schedule")));

			}

		}

	}

/**

Delete the schedules for the specified messages from the task scheduler. 

The messages themselves are not deleted.

@param aSelection 

Array of message IDs that need to be deleted from the task scheduler.

@leave Any error code

Unable to connect and register with the scheduler.

@leave Any error code but KErrLocked and KErrNotFound

The method overloading CMsvScheduledEntry::GetMessageL() left with an error,

i.e. the scheduling info of one of the messages from the selection could not

be retrieved from the message server.

@leave Any error code

Unable to reset the previous scheduling info for a message.

*/

EXPORT_C void CMsvScheduleSend::DeleteScheduleL(const CMsvEntrySelection& aSelection)

	{

	ConnectAndRegisterL();

	GetMessagesL(aSelection);

	TInt entryCount = iSchEntries->Count();

	SCHSENDLOG(FLog(_L8("Asked to delete schedule of %d msgs"), entryCount));

	while (entryCount--)

		{

		CMsvScheduledEntry* message = iSchEntries->At(entryCount);

		SCHSENDLOG(FLog(_L8("\tDelete schedule for msg %d (mtm %d, oldSendState %d, newSendState %d)"), message->Id(), message->Mtm().iUid, message->SendingState(), KMsvSendStateSuspended));

		message->SetSendingState(KMsvSendStateSuspended);

		DeleteScheduleForEntryL(*message);

		ResetScheduleInfoForEntryL(*message, ETrue);

		}

	}

/*

	Sets the message's scheduled flag to EFalse

	Resets the schedule data associated with each message

	Resets the number of retries for each recipient

	Stores the data and recipients (in a stream associated with the TMsvEntry)

*/

void CMsvScheduleSend::SendingCompleteL(CMsvScheduledEntry& aMessage, const TBool aChangeEntry)

	{

	__ASSERT_DEBUG(iServerEntry.Entry().Id() == aMessage.Id(), gPanic(EServerEntryNotSetToCorrectEntry));

	aMessage.SetScheduled(EFalse);

	aMessage.iData.Reset();

	aMessage.RecipientsResetRetries();

	if (aChangeEntry)

		{

		TMsvEntry entry = iServerEntry.Entry();

		aMessage.Entry(entry);

		User::LeaveIfError(iServerEntry.ChangeEntry(entry));

		}

	CMsvStore* store = iServerEntry.EditStoreL();

	CleanupStack::PushL(store);

	aMessage.StoreL(*store);

	store->CommitL();

	CleanupStack::PopAndDestroy(store); 

	}

/**

Tells the scheduler that sending is complete.

This method sets the messages's scheduled flag to false, resets the schedule

data associated with each message and the number of retries for each 

recipient and stores the data and recipients in a stream associated with 

the TMsvEntry.

@param aSelection 

Messages that were either successfully sent or which failed all the attempts

to send.

*/

EXPORT_C void CMsvScheduleSend::SendingCompleteL(const CMsvEntrySelection& aSelection)

	{

	TInt count = aSelection.Count();

	while (count--)

		{

		CMsvScheduledEntry* schEntry = GetMessageL(aSelection[count]);

		CleanupStack::PushL(schEntry);

		SendingCompleteL(*schEntry, ETrue);

		CleanupStack::PopAndDestroy(); //schEntry

		}

	}

/**

Tells the scheduler that sending is complete.

This function must be called when a message that had previously been scheduled 

is either sent or has failed. This function:

1. Deletes the TMsvEntryScheduleData associated with the message

2. Sets the Scheduled flag to EFalse

3. If required, calls ChangeEntry() on the message server entry

Note: SendingCompleteL() does not change the sending state of each message, 

nor delete each message from the task scheduler.

@param aEntry 

The message which was either successfully sent or which failed (all the 

attempts) to send. It is not a precondition that the message has already 

been scheduled on the task scheduler.

@param aChangeEntry 

If aChangeEntry is ETrue then SendingCompleteL() will call 

CMsvServerEntry::ChangeEntry() to update the message on the message server. 

@panic ScheduleSend-DLL 24

The server entry is not set to the correct entry.

Debug build only.

*/

EXPORT_C void CMsvScheduleSend::SendingCompleteL(TMsvEntry& aEntry, const TBool aChangeEntry)

	{

	__ASSERT_DEBUG(iServerEntry.Entry().Id() == aEntry.Id(), gPanic(EServerEntryNotSetToCorrectEntry));

	CMsvScheduledEntry* schEntry = GetMessageL(aEntry.Id());

	CleanupStack::PushL(schEntry);

	SendingCompleteL(*schEntry, EFalse);

	schEntry->Entry(aEntry);

	if (aChangeEntry)

		{

		User::LeaveIfError(iServerEntry.ChangeEntry(aEntry));

		}

	CleanupStack::PopAndDestroy(); //schEntry

	}

/**

Loads schedule settings from CenRep

@param aRepository 

CenRep repository to load settings from

*/

EXPORT_C void CMsvScheduleSend::LoadScheduleSettingsL(CRepository& aRepository)

	{

	TMsvScheduleSettingsUtils::LoadScheduleSettingsL(*iSettings, aRepository);

	TMsvScheduleSettingsUtils::LoadOffPeakSettingsL(*iOffPeakTimes, aRepository);

	TMsvScheduleSettingsUtils::LoadSendErrorSettingsL(*iErrorActions, aRepository);

	TMsvScheduleSettingsUtils::LoadSysAgentSettingsL(*iAgentActions, aRepository);	

	}

/**

Verifies that the schedule information stored in specified messages is the 

same as that on the task scheduler.

@param aSelection 

Array of message IDs that need to be checked against the task scheduler.

@panic ScheduleSend-DLL 0

The array of message IDs is empty.

Debug build only.

*/

EXPORT_C void CMsvScheduleSend::CheckScheduleL(const CMsvEntrySelection& aSelection)

	{

	__ASSERT_DEBUG(aSelection.Count(), gPanic(EMessageSelectionEmpty));

	GetMessagesL(aSelection);	//Leaves with KErrNotFound if there are no messages returned in iSchEntries

	TInt entryCount = iSchEntries->Count();

	SCHSENDLOG(FLog(_L8("Asked to check schedule for %d msgs"), entryCount));

	ConnectAndRegisterL();

	while (entryCount--)

		{

		TBool found = EFalse;

		TTsTime schTime;

		CMsvScheduledEntry& sEntry = *iSchEntries->At(entryCount);

		if (!sEntry.iData.IsReset())

			{

			TSchedulerItemRef ref;

			TInt size = 0;

			TTaskInfo info;

			TInt err = iScheduler.GetTaskDataSize(sEntry.iData.iTaskId, size);

			if (!err)

				{

				HBufC* buf = HBufC::NewLC(size);

				TPtr ptr = buf->Des();

				User::LeaveIfError(iScheduler.GetTaskInfoL(sEntry.iData.iTaskId, info, ptr, ref, schTime));

				CleanupStack::PopAndDestroy(buf);

				found = ETrue;

				}

			else if (err != KErrNotFound)

				{

				User::Leave(err);

				} 

			} 

		if (iServerEntry.SetEntry(sEntry.Id()) == KErrNone)

			{

			TMsvEntry entry = iServerEntry.Entry();

			TInt sendingState = entry.SendingState();

			if (sendingState == KMsvSendStateScheduled || sendingState == KMsvSendStateResend || entry.Scheduled())

				{

				if (found)

					{

					entry.SetScheduled(ETrue);

					entry.iDate = schTime.GetUtcTime();

					User::LeaveIfError(iServerEntry.ChangeEntry(entry));

					}

				else

					{

					entry.SetScheduled(EFalse);

					entry.SetSendingState(KMsvSendStateUnknown);

					entry.iDate.UniversalTime();

					User::LeaveIfError(iServerEntry.ChangeEntry(entry));

					SendingCompleteL(sEntry, EFalse);

					} 

				} 

			} 

		} 

	}

/**

Determines the schedule time for a message.

The schedule time is determined by the error action. If no error action is

supplied, then the error action is obtained from the iErrorActions. This is a 

list of error codes associated with an error action. The error code with which

the message failed to be sent is used to determine the error action from this

list.