// 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:

//

#ifndef __AGSSESS_H__

#define __AGSSESS_H__

#include <calchangecallback.h>

#include <calentry.h>

#include <calfilechangenotification.h>

#include "agmcalendartime.h"

#include "agsindexiterator.h"

#include <s32mem.h>

#include <badesca.h>

class CAgnCategoryList;

class CAgnEntry;

class CAgnEntryModel;

class CAgnRptDef;

class CAgnServer;

class CAgnServFile;

class CAgnServerSession;

class CAgnInstanceInfo;

struct TAgnChange;

class TAgnEntryDateIterator;

class TAgnEntryId;

class TAgnEntryIter;

class TAgnFilter;

class TAgnInstanceExtractor;

class CAgnSessionFileManager;

class CAgnServFileMgr;

class TAgnMessageToComplete;

class CAgsInstanceIteratorMgr;

/**

Class which controls all notifications made from a calendar session.

This stores the parameters for change notifications enabled through the @see CCalSession::StartChangeNotification APIs.

It stores whether or not pub-sub notifications are enabled, from the  @see CCalSession::EnablePubSubNotificationsL API.

If notification is disabled by another session, it keeps track of whether a change has been made so that the 

appropriate notification can be made when it is re-enabled.

@internalAll

@released

*/

class TAgnChangeFilter

	{

public:

 enum TPubSubChange

	{

	ENoChange		= 0x00,

	ETodoChanged	= 0x01,

	EEventChanged	= 0x02,

	};

	TAgnChangeFilter(CAgnServerSession& aSession);

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

	TBool ChangeBroadcastEnabled () const;

	void SetEnableChangeBroadcast(TBool aBool);

	TBool ChangeMadeWhileDisabled()const;

	void SetChangeMadeWhileDisabled(TBool aHasChaned);

	TBool PubSubEnabled() const;

	void SetEnablePubSubNotification(TBool aEnablePubSubNotification);

	void SetPubSubChange(TPubSubChange aChange);

	TBool TodoChanged() const;

	const CAgnServerSession& Session() const;

	TBool IsValidChangeL(const TAgnChange& aChange) const;

private:

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

private:

	TBool									iChangeBroadcastEnabled;

	TBool									iChangeMadeWhileDisabled;

	CAgnServerSession&						iSession;

	TTime									iStartTimeUtc;

	TTime 									iEndTimeUtc;

	MCalChangeCallBack2::TChangeEntryType	iEntryType;

	TInt									iPubSubChangeMadeDuringDisable;

	TBool									iPubSubEnabled;

	};

//Indicates that the client has already been panicked using RMessage2 object.

//so that RMessage2 object is not used twice.

const TInt KClientHasBeenPanicked = 1;

enum TChangeNotificationState

	{

	/*StartNotification has not been called, or has been cancelled*/

	ENotificationNotRequested,

	/* Request pending*/ 

	ENotificationRequested,

	/* Request completed, awaiting further request*/

	ENotificationAwaitingRequest

	};

/** 

The main Calendar server session class, which receives all IPC calls on the server side.

These calls are handled by DispatchMessageL, which calls the relevant server function.

The session gets a pointer to a CAgnServFile and a CAgnEntryModel when a Calendar file is opened.

Functions are called on these objects in most server calls.

CAgnServerSession also holds information about notifications for the client of this session. 

@internalAll

*/

class CAgnServerSession : public CSession2

	{

public:

    static CAgnServerSession* NewL(CAgnServer& aServer);

	~CAgnServerSession();	

	void BulkChangeCompletedL(TInt64 aFileId, TInt aErr);

	void AddChangeL(const TAgnChange& aChange);

	TInt FileIdCount();

	TInt64 FileId(TInt aIndex);

	void CancelAllTask();

	void BackupReStoreChangedL(TInt64 aFileId, const CAgnServFile& aServFile, MCalChangeCallBack2::TChangeType aChangeType);

	void BackupRestoreCancelTask();

	void LockClient(TBool aLock);

private:

	CAgnServerSession(CAgnServer& aServer);

	void ConstrucL();

	CAgnServFile* GetFileL(TInt aSlot);

	TBool DispatchMessageL();

	virtual void ServiceL(const RMessage2 &aMessage);

	void PanicClientL(TInt aPanic) const;	// Panic the client

	HBufC* ReadClientDesLC(TInt aDesNum);

	HBufC8* ReadClientDes8LC(TInt aDesNum);

//Server interface

	void CommitL();

	void RollbackL();

	void OpenAgendaL();

	void CloseAgendaL();

	void FetchEntryL();

	void FetchEntryByUIDL();

	void FetchSimpleEntryL();

	void FetchSimpleEntryByUIDL();

	void FetchSimpleEntriesL();

	void UpdateEntryL();

	void AddEntryL();

	void DeleteEntryL();

	void TransmitBufferL();

	void PreviousInstancesL();

	void NextInstancesL();

	void CreateEntryIteratorL();

	void EntryIteratorNextL();

	void EntryIteratorPositionL();

	void GetEntryUidsSinceDateL();

	void GetFileIdL();

	void RestoreTextL();

	void RestoreAlarmActionL();

	void RequestChangeNotification();

	void RequestChangeNotificationParametersL();

	void CancelChangeNotification();

	void DisableChangeBroadcastL();

	void EnableChangeBroadcastL();

	void StartBuildIndex();

	void CreateAgendaFileL();

	void DeleteAgendaFileL();

	void ListAgendaFilesL();

	void TidyByDateReadParamsL();

	void AgendaFileExistsL();

	void RequestProgressL();

	void GetChangesSinceLastNotificationL();

	void GetFileChangesSinceLastNotificationL();

	void TidyByDateStartL();

	void AsynchCategoryTaskStartL();

	void SetUpdateAlarmL();

	void FetchEntryByGuidL();

	void FetchSimpleEntriesByGuidL();

	void DeleteEntriesByLocalUidL();

	void DeleteEntryByGuidL();

	void SetEnablePubSubNotificationL();

	void FindInstancesL();

	void GetCategoryListCountL();

	void GetCategoryListItemL();

	void AddCategoryToListL();

	void CategoryTaskStartL();

	void FilterCategoryL();

	void CancelTaskL();

	void TransferAttachmentFileToServerL();

	void TransferAttachmentFileToClientL();

	void TransferFileToClientToWriteL();

	void FetchSortedAttachmentsL();

	void EntriesWithAttachmentL();

	void FetchAttachmentByIdL();

	void MoveFileToServerL();

	void TzRulesLastModifiedDateTimeL();

	void CreateInstanceIteratorL();

	void DestroyInstanceIteratorL();

	void InstanceIteratorNextL();

	void InstanceIteratorPreviousL();

	void InstanceIteratorCountL();

	void InstanceIteratorLocateIndexL();

	void GetPropertyValueL();

	void SetCalendarInfoL();

	void GetCalendarInfoL();

private:

	void GetCategoryInfoL(const CBufFlat& aBufFlat,TInt& aCategoryIndex, TCalCollectionId aCollectionId);

	void DeleteEntryL(CAgnEntry& aEntry, TCalCollectionId aCollectionId);

	void ExternalizeEntryToClientL(const CAgnEntry& aEntry, TInt aSlot);

	void DeleteEntryByIdL(TAgnEntryId aEntryId, TCalCollectionId aCollectionId);

	void DeleteEntryByUIdL(TCalLocalUid aEntryId, TCalCollectionId aCollectionId);

	void EnsureStringsLoadedL(CAgnEntry& aEntry, TCalCollectionId aCollectionId);

	void WriteIntArrayToBufferL(const RArray<TUint32>& aArray);

	void CloseAgendas();

	TBool CheckBackupRestore();

	void CalendarFileChangedL(CAgnFileChangeInfo& aFileChangeInfo);

    void AddFileChangeL(CAgnFileChangeInfo& aFileChangeInfo, CAgnServerSession* aSession);

    TBool FileCanBeDeletedL(TInt aSessionId, const CAgnServFile& file);

    TBool IsOwnFileL(TInt aSessionId, const CAgnServFile& file);

    TBool FileHasBeenOpenedL(const CAgnServFile& file);

    void CloseAgendaL(TInt aSessionId);

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	TBool IsReadOnlyOperation();

#endif

	TInt GetFileIndexL(const TDesC& aFileToOpen);

private:

	CAgnServer& 				iAgnServer;

	CBufFlat*					iBuffer;	// used to transmiting streams to client

	RMessage2					iMessage;

	TBool						iSessionReady;

	CAgnSessionFileManager*	    iAgnSessionFileManager;

	TBool                       iBackupRestoreLock;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	CAgsInstanceIteratorMgr*	iInstanceIteratorMgr;

#endif

	};

class CAgnSessionFile : public CBase

	{

public:

	static CAgnSessionFile* NewL(TInt aSessionId, TInt64 aFileId, CAgnEntryModel& aModel, CAgnServerSession& aAgnServerSessionr);

	static CAgnSessionFile* NewL(TInt aSessionId, CAgnServerSession& aAgnServerSessionr);

	~CAgnSessionFile();

	TInt64 FileId() const;

	void TidyByDateStartL(TAgnMessageToComplete& aMessageToComplete, CAgnServFile& aServerFile);

	void SetEnablePubSubNotificationL(TBool aEnablePubSub);

	void EnableChangeBroadcastL(const CAgnServerSession& aAgnServerSession);

	void DisableChangeBroadcast();

	void RequestChangeNotification(const RMessage2 aMessage);

	void CancelChangeNotification(TUint8 aNotificationType);

	void SetChangeNotificationParametersL(const TTime aStart, const TTime aEnd,MCalChangeCallBack2::TChangeEntryType aChangeType);

	void BulkChangeCompletedL(const CAgnServerSession& aSeesion, TInt aErr);

	TInt GetChangesSinceLastNotificationL(CBufFlat*& aDataBuffer);

    TInt GetFileChangesSinceLastNotificationL(CBufFlat*& aDataBuffer);

	void AddChangeToBufferL(const TAgnChange& aChange, CAgnServerSession* aAgnServerSession);

	void AddFileChangeToBufferL(CAgnFileChangeInfo& aFileChangeInfo);

	void UpdateEntryL(CAgnEntry& aEntry, TBool aDeleteChildren);

	TAgnEntryId StoreEntryL(CAgnEntry& aEntry);

	void DeleteEntryL(CAgnEntry& aEntry);

	void DeleteEntryByGuidL(const TDesC8& aGuid, TBool aCommit);

	TBool CreateEntryIterL();

	TBool IsEntryAvailableAtIteratorL();

	CAgnEntry* FetchEntryAtIteratorL();

	void ResetModel(const CAgnServFile& aServFile);

	TInt SessionId();

	TBool FileNotificationIsReqested();

	void SetFileId(TCalFileId aFileId);

private:

	CAgnSessionFile(TInt aSessionId,TInt64 aFileId, CAgnEntryModel* aModel, CAgnServerSession& aAgnServerSession);

	TBool ToNotifyL(const TAgnChange& aChange, CAgnServerSession* aAgnServerSession);

	void RequestEntryChangeNotification();

	void RequestFileChangeNotification();

private:

    TInt                        iSessionId;

	TInt64						iFileId;

	CAgnEntryModel*				iModel;//Not owned

 	RMessage2					iChangeNotificationMessage;

 	TChangeNotificationState	iChangeNotificationPending;

 	TBool						iBulkChangeInProgress;

 	TAgnChangeFilter			iChangeFilter;

 	TInt						iBufferedNotificationsCount;

	TBool						iNotificationBufferFull;

	CBufFlat*					iBufferedNotification;

	RBufWriteStream				iBufferedNotificationStream;

    TInt                        iFileBufferedNotificationsCount;

    CBufFlat*                   iFileBufferedNotification;

    RBufWriteStream             iFileBufferedNotificationStream;

	TAgnEntryIter*				iEntryIter;	

    TUint8                      iChangeIterested;//The client could interested entry change, file change or both of them.

	};

class CAgnSessionFileManager : public CBase

	{

public:

	static CAgnSessionFileManager* NewL(CAgnServerSession& aAgnServerSession, CAgnServFileMgr& aAgnServer);

	~CAgnSessionFileManager();

	CAgnSessionFile& GetSessionFileL(TInt64 aFileId);

	CAgnSessionFile& GetSessionFileL(TCalCollectionId aCollectionId);

	TInt GetSessionFile(TInt aSessionId);

	CAgnSessionFile& GetSessionFileByIndex(TInt aIndex);

	void DeleteSessionFile(TInt aSessionId);

	void DeleteSessionFileIfFileNotificationNotRequired(TInt aSessionId);

	TBool AddClientL(TInt64 aFileId, TInt aSessionId);

	void AddChangeL(const TAgnChange& aChange);

	void AddFileChangeL(CAgnFileChangeInfo& aFileChangeInfo);

	TInt FileIdCount();

	TInt64 FileId(TInt aIndex);

	static TInt CompareFileId(const CAgnSessionFile& aLeft, const CAgnSessionFile& aRight);

	static TInt CompareFileId(const TInt64* aKey, const CAgnSessionFile& aAgnSessionFile);

	TInt FindL(TInt64 aFileId) const;

	void ReSetModel(TInt64 aFileId, const CAgnServFile& aServFile);

	void RequestChangeNotification(const RMessage2 aMessage);

private:

	CAgnSessionFileManager(CAgnServerSession& aAgnServerSession, CAgnServFileMgr& aAgnServer);

private:

	CAgnServerSession& 					iAgnServerSession;

	CAgnServFileMgr&					iAgnServFileMgr;

	RPointerArray<CAgnSessionFile> 	    iSessionFiles;

	};

class CAgnInstanceInfo : public CBase

	{

public:

	static CAgnInstanceInfo* NewL(const CAgnSimpleEntry& aSimpleEntry);

	static CAgnInstanceInfo* NewLC(const CAgnSimpleEntry& aSimpleEntry);

	~CAgnInstanceInfo();

	CCalEntry::TType Type() const;

	const CAgnRptDef* RptDef() const;

	const TTime& StartTimeUtc() const;

	const TTime& EndTimeUtc() const;

private:

	CAgnInstanceInfo();

	void ConstructL(const CAgnSimpleEntry& aSimpleEntry);

private:

	CCalEntry::TType	iType;

	TTime				iStartTimeUtc;

	TTime				iEndTimeUtc;

	CAgnRptDef*			iRptDef;

	};

#endif