// Copyright (c) 1997-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 "agssess.h"

#include "agmattachment.h"

#include "agscategoryindex.h"

#include "agscategorylist.h"

#include "agmentry.h"

#include "agsiterator.h"

#include "agsentrymodel.h"

#include "agmpanic.h"

#include "agmcategory.h"

#include "agmcontent.h"

#include "agmserv.h"

#include "agsfilemanager.h"

#include "agsmain.h"

#include "calcommonimpl.h"

#include "agmdebug.h"

#include "agmtzrules.h"

#include "agssortinstance.h"

#include "agsinstanceiterator.h"

#include "agmsortcriteria.h"

#include "agmdate.h"

#include "agssort.h"

#include "agmcalendarinfo.h"

#include "calsessionimpl.h"

#include "agmfilechangenotification.h"

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

#include "agssystemstateobserver.h"

#endif

#include <apparc.h>

#include <s32file.h>

//

// CAgnServerSession

//

const TInt KGranFilteredEntries = 20;

const TInt KMaxNumberOfBufferedNotifications = 50;

const TInt KGranNotificationBuffer = 64;

const TInt KSlot0 = 0;

const TInt KSlot1 = 1;

const TInt KSlot2 = 2;

const TInt KSlot3 = 3;

void CleanupCloseAgendaImmediately(TAny* aRef)

    {

    if (aRef)

        {

        static_cast<CAgnServFile*>(aRef)->CloseAgenda(ETrue);

        }

    }

TAgnChangeFilter::TAgnChangeFilter(CAgnServerSession& aSession) :

	iChangeBroadcastEnabled(ETrue),

	iSession(aSession),

	iStartTimeUtc(Time::NullTTime()),

	iEndTimeUtc(Time::NullTTime()),

	iPubSubChangeMadeDuringDisable(ENoChange),

	iPubSubEnabled(ETrue)

	{

	}

TBool TAgnChangeFilter::ChangeBroadcastEnabled() const

	{

	return iChangeBroadcastEnabled;

	}

const CAgnServerSession& TAgnChangeFilter::Session() const

	{

	return iSession;

	}

void TAgnChangeFilter::SetEnableChangeBroadcast(TBool aBool)

	{

	iChangeBroadcastEnabled = aBool;

	}

TBool TAgnChangeFilter::ChangeMadeWhileDisabled() const

	{

	return iChangeMadeWhileDisabled;

	}

void TAgnChangeFilter::SetChangeMadeWhileDisabled(TBool aBool)

	{

	iChangeMadeWhileDisabled = aBool;	

	}

void TAgnChangeFilter::SetChangeParameter(const TTime& aStartTime, const TTime& aEndTime, MCalChangeCallBack2::TChangeEntryType aChangeType)

	{

	iStartTimeUtc = aStartTime;

	iEndTimeUtc = aEndTime;

	iEntryType = aChangeType;

	}

TBool TAgnChangeFilter::CheckChangeWithinRangeL(const CAgnRptDef* aRptDef, const TTime& aStartTime, const TTime& aEndTime) const

	{

	TBool entryInTimeRange = ETrue;

	if (aRptDef)

		{

		TTime nudgedNextTimeUtc;

		TBool nextDateExists = aRptDef->NudgeNextInstanceUtcL(iStartTimeUtc, nudgedNextTimeUtc);

		if ( ! nextDateExists || nudgedNextTimeUtc > iEndTimeUtc)

			{

			entryInTimeRange = EFalse;

			}

		}

	else

		{

		if (iStartTimeUtc > aEndTime || iEndTimeUtc < aStartTime)

			{

			entryInTimeRange = EFalse;

			}

		}

	return entryInTimeRange;

	}

TBool TAgnChangeFilter::IsValidChangeL(const TAgnChange& aChange) const

	{

	if (aChange.iOperationType != MCalChangeCallBack2::EChangeUndefined)

		{

		if (iEntryType == MCalChangeCallBack2::EChangeEntryTodo && aChange.iEntryType != CCalEntry::ETodo)

			{

			return EFalse;

			}

		if (iEntryType == MCalChangeCallBack2::EChangeEntryEvent && aChange.iEntryType == CCalEntry::ETodo)

			{

			return EFalse;

			}

		// Check the entry is within the time range specified by the filter

		// aChange.iRepeatRule gives the repeat data for the newly stored entry. If this operation is an update,

		// then aChange.iOriginalRepeatRule gives the repeat data for the old entry.

		TBool entryInTimeRange = CheckChangeWithinRangeL(aChange.iRepeatRule, aChange.iStartTimeOfEntryUtc, aChange.iEndTimeOfEntryUtc);

		TBool originalEntryInTimeRange = CheckChangeWithinRangeL(aChange.iOriginalRepeatRule, aChange.iOriginalStartTimeUtc, aChange.iOriginalEndTimeUtc);

		if (iEntryType != MCalChangeCallBack2::EChangeEntryEvent)

			{

			if (aChange.iEntryType == CCalEntry::ETodo && aChange.iStartTimeOfEntryUtc == Time::NullTTime() &&  aChange.iEndTimeOfEntryUtc == Time::NullTTime())

				{

				return ETrue;

				}

			}

		if ( ! entryInTimeRange && ! originalEntryInTimeRange)

			{

			return EFalse;

			}

		}

	return ETrue;

	}

TBool TAgnChangeFilter::PubSubEnabled() const

	{

	return iPubSubEnabled;

	}

void TAgnChangeFilter::SetPubSubChange(TPubSubChange aChange)

	{

	if(aChange==ENoChange)

		{//clear all bits

		iPubSubChangeMadeDuringDisable = ENoChange; // = 0

		}

	else

		{

		iPubSubChangeMadeDuringDisable = iPubSubChangeMadeDuringDisable | aChange;

		}

	}

TBool TAgnChangeFilter::TodoChanged() const

	{

	return iPubSubChangeMadeDuringDisable & ETodoChanged;

	}

void TAgnChangeFilter::SetEnablePubSubNotification(TBool aEnablePubSubNotification)

	{

	iPubSubEnabled = aEnablePubSubNotification;

	}

CAgnServerSession::CAgnServerSession(CAgnServer& aServer)

    :iAgnServer(aServer), iSessionReady(ETrue)

	{

	iAgnServer.SessionAdded();

	}

CAgnServerSession* CAgnServerSession::NewL(CAgnServer& aServer)

    {

    CAgnServerSession* self = new (ELeave) CAgnServerSession(aServer);

    CleanupStack::PushL(self);

    self->ConstrucL();

    CleanupStack::Pop(self);

    return self;

    }

void CAgnServerSession::ConstrucL()

    {

    iAgnSessionFileManager = CAgnSessionFileManager::NewL(*this, *(iAgnServer.FileMgr()));

    }

void CAgnServerSession::ServiceL(const RMessage2 &aMessage)

	{

	TBool complete = ETrue;

	TInt err = KErrNone;

	iMessage = aMessage;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	if (iAgnServer.SystemStateObserver().IsShutdownInProgress())

		{

		//Shutdown in progress

		err = IsReadOnlyOperation();

		complete = ETrue;

		}

#endif

	if (err == KErrNone)

		{

	    TRAP(err,complete = DispatchMessageL());

	    _DBGLOG_IPC(AgmDebug::DebugLogIPCL(aMessage.Function(), TInt(this), err);)

	    if ( err != KErrNone )

	    	{

	    	if (err == KErrNotReady && 

	    			aMessage.Function() != ETransferAttachmentFileToServer &&

	    			aMessage.Function() != ETransferFileToClientToWrite &&

	    			aMessage.Function() != ETransferAttachmentFileToClient&&

	    			aMessage.Function() != EMoveFileToServer)

	    		{

	    		// If a function has failed with Not ready, then a drive must not be ready

	    		// If it is not an attachment failure, then it must have happened on the drive containing

	    		// the Calendar file. In this case, ensure the session always leaves with KErrNotReady

	    		// until the session is closed and re-opened.

	    		iSessionReady = EFalse;

	    		}

	    	delete iBuffer;

	    	iBuffer = NULL;

	    	}

		}

	if (complete && err != KClientHasBeenPanicked)

		{

		aMessage.Complete(err);

		}

	}

CAgnServerSession::~CAgnServerSession()

	{

	//This is required for robustness. Clients which are incorrectly

	//written can make requests with MCalProgressCallBack callbacks could

	//subsequently panic and cause the session to be destructed. 

	//The task which the client had initiated will be cancelled so it does not

	//attempt to use the session again with further progress information.

	CancelAllTask();

	// Cleanup any resources that have been allocated

	delete iBuffer;

	// Close the calendar file after a delay

	CloseAgendas();

	iAgnServer.SessionClosed();

	delete iAgnSessionFileManager;

	delete iInstanceIteratorMgr;

	}

/** 

* Check to see if an operation can be performed due to backup\restore process

* @return ETrue, if the operation can not be performed, EFalse otherwise. 

*/

TBool CAgnServerSession::CheckBackupRestore()

    {

    if(iBackupRestoreLock  

    //All opeerations apart from the following ones are not allowed when Backup\Restore is in progress. 

    && iMessage.Function() != ECloseAgenda

    && iMessage.Function() != ECancelChangeNotification

    && iMessage.Function() != EDisableChangeBroadcast

    && iMessage.Function() != ETransmitBuffer

    && iMessage.Function() != ERequestChangeNotificationParameters

    && iMessage.Function() != ERequestChangeNotification

    && iMessage.Function() != EEnableChangeBroadcast

    && iMessage.Function() != EGetChangesSinceLastNotification

    && iMessage.Function() != ERequestProgress)

        {

        return ETrue;

        }

  // Return false, if iBackupRestoreLock is false or operations are those above, CAgnServFile::IsLocked()

  // will determine whether or not an operation can be performed.

    return EFalse;

    }

TBool CAgnServerSession::DispatchMessageL()

	{

    TBool operationRequiresFileLock = EFalse;

    TBool callIsAsynchronous = ETrue;

 	if(CheckBackupRestore())

	    {

	    User::Leave(KErrLocked);

	    }

	switch (iMessage.Function())

		{

		case EOpenAgenda:

			{

			OpenAgendaL();

			iSessionReady = ETrue;

			}

			break;

		case ECloseAgenda:

			{

			// Close the calendar file after a delay

			CloseAgendaL();

			iSessionReady = ETrue;

			}

			break;

		case ERequestChangeNotificationParameters:

			{

			RequestChangeNotificationParametersL();

			}			

			break;

		case ERequestChangeNotification:

			{

			RequestChangeNotification();

			callIsAsynchronous = EFalse;

			}

			break;

		case ECancelChangeNotification:

			{

			CancelChangeNotification();

			}

			break;

		case EDisableChangeBroadcast:

			{

			DisableChangeBroadcastL();

			}

			break;

		case EEnableChangeBroadcast:

			{

			EnableChangeBroadcastL();

			}

			break;

		case EAgnHeapSizeCount:

			{

			TInt allocSize;

			User::Heap().AllocSize(allocSize);

			TPckg<TInt> HeapSize(allocSize);

			iMessage.WriteL(KSlot0, HeapSize);			

			}

			break;

		case EAgnResourceCount:

			{

			TPckg<TInt> HeapCells(User::Heap().Count());

			iMessage.WriteL(KSlot0, HeapCells);			

			}

			break;

		case EAgnSetHeapFailure:

			{

			User::__DbgSetAllocFail(RHeap::EUser,(RHeap::TAllocFail)iMessage.Int0(),iMessage.Int1());		

			}

			break;

		case ECreateAgendaFile:

			{

			CreateAgendaFileL();			

			}

  			break;

		case EGetListFileNames:

			{

			ListAgendaFilesL();

			}

			break;

		case EDeleteAgendaFile:

			{

	  		DeleteAgendaFileL();

			}

	  		break;

		case ECancelTask:

			{

			CancelTaskL();

			}

			break;

		case EAgendaFileExists:

			{

			AgendaFileExistsL();

			}

			break;

		case ETransmitBuffer:

			{

			TransmitBufferL();

			}

			break;

		case ESetUpdateAlarm:

			{

			SetUpdateAlarmL();

			}

			break;

		case ESetEnablePubSubNotification:

			{

			SetEnablePubSubNotificationL();

			}

			break;

		case ERequestProgress:

			{

			RequestProgressL();

			callIsAsynchronous = EFalse; 

			}

			break;

		case EGetChangesSinceLastNotification:

			{

			GetChangesSinceLastNotificationL();

			}

			break;

		case EStartBuildIndex:

			{

			//Asynchronous call

			StartBuildIndex();

			callIsAsynchronous = EFalse; 

			}

			break;

		case ETzDbChangedTime:

			{

			TzRulesLastModifiedDateTimeL();

			}

			break;

		case ERollback:

			{

			RollbackL();

			}

			break;

		case EGetFileChangesSinceLastNotification:

		    {

		    GetFileChangesSinceLastNotificationL();

		    }

		    break;

		default:

			{

			operationRequiresFileLock = ETrue;

			}

			break;

		}

	// Most commands are not permitted while the file is locked

    if ( operationRequiresFileLock )

	    {

    	if ( ! iSessionReady)

			{

			User::Leave(KErrNotReady);

			}

		else

			{

			switch ( iMessage.Function() )

				{

				case EFetchEntry:

					{

					FetchEntryL();

					}

					break;

				case EFetchEntryByUID:

					{

					FetchEntryByUIDL();

					}

					break;

				case EFetchSimpleEntry:

					{

					FetchSimpleEntryL();

					}

					break;

				case EFetchSimpleEntries:

					{

					FetchSimpleEntriesL();

					}

					break;

				case EUpdateEntry:

					{

					UpdateEntryL();

					}

					break;

				case EAddEntry:

					{

					AddEntryL();

					}

					break;

				case EDeleteEntry:

					{

					DeleteEntryL();

					}

					break;

				case EPreviousInstances:

					{

					PreviousInstancesL();

					}

					break;

				case ENextInstances:

					{

					NextInstancesL();

					}