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

// MIUTHDR.H

//

/**

 * @file 

 * @publishedAll

 * @released

 */

#ifndef __MIUTHDR_H__

#define __MIUTHDR_H__

#include <s32strm.h>

#include <badesca.h>

#include <pop3cmds.h>

#include <msvstd.h>

#include <msvids.h>			// KMsvNullIndexEntryId

#include <miutstd.hrh>			// KUidMsvEmailTextEntryValue

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "timrfc822datefield.h"

#endif

/** 

 * IMail-specific stream type within an IMail file store for CImHeader

 * @publishedAll

 * @released

 */

const TUid KUidMsgFileMimeHeader	= {0x1000160F};		// 268441103 decimal

/** 

 * IMail-specific stream type within an IMail file store for CImMimeHeader

 * @publishedAll

 * @released

 */

const TUid KUidMsgFileIMailHeader	= {0x100001D8};		// 268435928 decimal

/** 

 * @publishedAll

 * @released

 */

class CMsvStore;

class TMsvEntry;

class RMsvReadStream;

class RMsvWriteStream;

/** 

 * @internalTechnology

 * @released

 */

class CImEncodedHeader;

/** Defines how emails will be encoded when they are sent.

MIME standards are defined in RFC 2045, RFC 2046 and RFC 2047. 

@publishedAll

@released

*/

enum TMsgOutboxBodyEncoding

	{

	/** Emails are sent with the default encoding, which is as for EMsgOutboxMIME. */

	EMsgOutboxDefault,

	/** Emails are sent as plain text RFC822 messages. 

	Attachments are encoded using UUEncoding algorithm. This method would not 

	normally be used unless the sender was sure that the receiving mail clients 

	don't support MIME. */

	EMsgOutboxNoAlgorithm,

	/** Text is encoded using quoted-printable encoding, and all attachments are encoded 

	using BASE64 encoding.

	This is the default setting for this option. */

	EMsgOutboxMIME,

	/** Text parts of the message are sent as MIME TEXT/HTML parts, and are encoded 

	using UTF-8 encoding system. 

	All attachments are encoded using BASE64 encoding. Receiving mail clients 

	that do no support MHTML mail will display the HTML message text to the user 

	including all HTML tags, etc. */

	EMsgOutboxMHTMLAsMIME,

	/** Each text part of the message is sent as two alternative MIME parts.

	The first part is sent as plain text using quoted-printable encoding, the 

	second part is sent as a TEXT/HTML part which is encoded using UTF-8 encoding 

	system. All attachments are encoded using BASE64 encoding. This is the standard 

	encoding method if the user wishes to send MHTML mail. */

	EMsgOutboxMHTMLAlternativeAsMIME

	};

/** Messaging encoding types. 

@publishedAll

@released

*/

enum TImEncodingType 

	{

	/** Unknown. */

	EEncodingTypeUnknown,

	/** None. */

	EEncodingTypeNone,

	/** 7-bit. */

	EEncodingType7Bit,

	/** 8-bit. */

	EEncodingType8Bit,		// ie lines still <1000 chars and terminated by CRLF

	/** Binary. */

	EEncodingTypeBinary,	// ie any length of data, not terminated by CRLF

	/** QP. */

	EEncodingTypeQP,

	/** Base64. */

	EEncodingTypeBASE64,

	/** UU. */

	EEncodingTypeUU

	};

// Class used for storing extracting information (to/from header)..

// regarding the encoding in an incoming email message header.

//----------------------------------------------------------------------------------------

class TImHeaderEncodingInfo

//----------------------------------------------------------------------------------------

/** Stores encoding data found in message headers. 

@publishedAll

@released

*/

	{

public:

	/** Message field types. */

	enum TFieldList 

		{ 

		EFrom, 		/**< "From" field. */

		EReplyTo, 	/**< "Reply To" field. */

		ETo, 		/**< "To" field. */

		ECc, 		/**< "Cc" field. */

		EBcc, 		/**< "Bcc" field. */

		ESubject	/**< Subject field. */

		};

	/** Encoding types. */

	enum TEncodingType 

		{ 

		EBase64, 		/**< Base64. */

		EQP, 			/**< QP. */

		ENoEncoding, 	/**< No encoding */

		EUU				/**< UU. */

		};

public:

	IMPORT_C TImHeaderEncodingInfo();

	IMPORT_C TImHeaderEncodingInfo(const TImHeaderEncodingInfo& aFrom);

	IMPORT_C void ExternalizeL( RWriteStream& aWriteStream ) const;

	IMPORT_C void InternalizeL( RReadStream& aReadStream );

	inline void SetField(const TFieldList aField);

	inline TFieldList Field() const;

	inline void SetOffset(const TInt aOffset);

	inline TInt Offset() const;

	inline void SetLength(const TInt aLength);

	inline TInt Length() const;

	inline void SetCharsetUid(const TUint aUid);

	inline TUint CharsetUid() const;

	inline void SetEncodingType(const TDesC8& aChar);

	inline void SetEncodingType(const TEncodingType aType);

	inline  TEncodingType EncodingType() const;

	inline void SetArrayValue(const TInt aValue);

	inline  TInt ArrayValue() const;

	inline void SetAddSpace(const TBool atrueFalse);

	inline  TBool AddSpace() const;

	inline void SetEncodedLength(const TInt aLength);

	inline TInt EncodedLength() const;

private:

	TFieldList		iField; 

	TUint16			iOffset;

	TUint16			iLength;

	TEncodingType	iType;

	TUint16			iArrayValue;

	TBool	iAddSpace; // A space char needs adding between two adjoining 'encoded-words'

	TUint8	iEncodedLength; // This can be used to determine space needed for buffer.

	TUint	iCharsetUid; 

	};

//------------------------------------------------------------------------------

class CImHeader : public CBase

/** Encapsulates an Internet Mail (RFC822) header.

Note that the class contains some obsolete functions that take a narrow descriptor: 

always use the equivalent wide descriptor function instead. 

@publishedAll

@released

*/

	{

public:

/** Flags used to determine where to obtain the ReplyTo address for the header 

field of that name. */

	enum TReplyTo 

		{ 

	/** Get address from originator. */

		EOriginator, 

	/** Get address from sender. */

		ESender, 

	/** Get address from all sources. */

		EAll,

	/** Get address from recipients. */

		ERecipients

		};

	IMPORT_C static CImHeader* NewLC();

	IMPORT_C ~CImHeader();

	IMPORT_C void Reset();

	// streaming operations

	IMPORT_C void InternalizeL(RMsvReadStream& aReadStream);

	IMPORT_C void ExternalizeL(RMsvWriteStream& aWriteStream) const;

	IMPORT_C void RestoreL(CMsvStore& aMessageStore);

	IMPORT_C void StoreL  (CMsvStore& aMessageStore) const;

	IMPORT_C void StoreWithoutCommitL(CMsvStore& aMessageStore) const;

	// the bulk of the member functions are accessors & mutators so we can use

	// objects of the class as data repositories during the data-marshalling stage

	// of getting imail headers to/from the internet

	IMPORT_C const TPtrC Subject() const;

	IMPORT_C void SetSubjectL(const TDesC8& aSubject);

	// Internet message ID

	IMPORT_C const TPtrC8 ImMsgId() const;

	/** Sets the "MessageId" header field.

	@param aImMsgIdL Field value */

	IMPORT_C void SetImMsgIdL(const TDesC8& aImMsgIdL);

	IMPORT_C const TPtrC From() const;

	IMPORT_C void SetFromL(const TDesC8& aFrom);

	IMPORT_C const TPtrC ReplyTo() const;

	IMPORT_C void SetReplyToL(const TDesC8& aReplyTo);

	IMPORT_C const TPtrC ReceiptAddress() const;

	/** Sets the "Receipt" header field. 

	@param aReceiptAddress Field value */

	IMPORT_C void SetReceiptAddressL(const TDesC8& aReceiptAddress);

	IMPORT_C TUint Charset() const;

	IMPORT_C void SetCharset(const TUint aCharset);

#if defined (_UNICODE)

	IMPORT_C void SetFromL(const TDesC16& aFrom);

	IMPORT_C void SetReplyToL(const TDesC16& aReplyTo);

	/** Sets the "Receipt" header field. 

	@param aReceiptAddress Field value */

	IMPORT_C void SetReceiptAddressL(const TDesC16& aReceiptAddress);

	IMPORT_C void SetSubjectL(const TDesC16& aSubject);

#endif

	IMPORT_C TInt DataSize();

	inline const TUint RemoteSize() const;

	inline void SetRemoteSize(TUint aSize);

	inline const TUint16 Version() const;

	inline void SetVersion(TUint16 aVersion);

	// give const access to the recipient lists

	inline const CDesCArray& ToRecipients () const;

	inline const CDesCArray& CcRecipients () const;

	inline const CDesCArray& BccRecipients() const;

	// give non-const access to the recipient lists

	inline CDesCArray& ToRecipients () ;

	inline CDesCArray& CcRecipients () ;

	inline CDesCArray& BccRecipients() ;

	inline CArrayFix<TImHeaderEncodingInfo>& EncodingInfo() ;

	inline const CArrayFix<TImHeaderEncodingInfo>& EncodingInfo() const;

	IMPORT_C void AddEncodingInfoL(TImHeaderEncodingInfo& aInfo);

//-------------------------------------------------------------------------------------

//----------------------Used for forwarding/replying to an email ----------------------

	IMPORT_C const TPtrC8 ResentMsgId() const;

	IMPORT_C void SetResentMsgIdL( const TDesC8& );

	IMPORT_C const TPtrC ResentFrom() const;

	IMPORT_C void SetResentFromL( const TDesC& );

	// give const access to the recipient lists

	inline const CDesCArray& ResentToRecipients () const;

	inline const CDesCArray& ResentCcRecipients () const;

	inline const CDesCArray& ResentBccRecipients() const;

	// give non-const access to the recipient lists

	inline CDesCArray& ResentToRecipients ();

	inline CDesCArray& ResentCcRecipients ();

	inline CDesCArray& ResentBccRecipients();

	IMPORT_C const TPtrC8 InReplyTo() const;

	IMPORT_C void SetInReplyToL(const TDesC8&);

	IMPORT_C TInt CreateForwardL(CImHeader&, TDesC&);

	IMPORT_C TInt CreateReplyL(CImHeader&, TReplyTo, TDesC&);

	IMPORT_C void CreateReceiptL(CImHeader&, TDesC&);

//-------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------

	// Body Encoding (charset) stored on a per message basis

	IMPORT_C TMsgOutboxBodyEncoding BodyEncoding() const;

	IMPORT_C void SetBodyEncoding(TMsgOutboxBodyEncoding aMessageBodyEncoding);

	IMPORT_C void ReDecodeL(RFs& aFS);

	IMPORT_C TUint OverrideCharset() const;

	IMPORT_C void SetOverrideCharset(TUint aCharset);

	IMPORT_C void SaveEncodedHeadersL();

private:

	CImHeader();

	void ConstructL();

	// these four functions keep the line count down as there are several instances

	// of streaming in/out HBufC objects.

	void ReadRecipientsL ( RReadStream&, CDesCArray* );

	void WriteRecipientsL( RWriteStream&, const CDesCArray* ) const;

	void FormatSubjectL(CImHeader&, TDesC&);

	//finds the duplicate recipients in To and Cc list

	TBool IsRecipientPresent(CImHeader& aCImHeader, TPtrC16 newRecipient);

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	void ReStoreDBL(CMsvStore& aMessageStore);

	void StoreDBL  (CMsvStore& aMessageStore) const;

	void CreateImHeaderArrayListL(TDesC16& aStr, CDesCArray& aRecipients);

	void CreateEncodingInfoL(TDesC16& aEncodingStr);

	HBufC16* Convert8to16L(const TDesC8& aStr) const;

	void CreateBufferL( RBuf16& aBuf, CDesCArray& aRecipients)const;

#endif 

private:

	TUint16 iVersion;

	HBufC16* iFrom;

	HBufC* iSubject;

	HBufC8* iImMsgId;

	HBufC16* iReplyTo;

	HBufC16* iReceipt;

	CDesCArray* iTo;

	CDesCArray* iCc;

	CDesCArray* iBcc;

	TUint iRemoteSize;

//-------------------------------------------------------------------------------------

//----------------------Used for forwarding/replying to an email ----------------------

	HBufC* iResentFrom;

	HBufC8* iResentMsgId;

 	CDesCArray* iResentTo;

	CDesCArray* iResentCc;

	CDesCArray* iResentBcc;

	HBufC8* iInReplyTo;

//-------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------

	CArrayFix<TImHeaderEncodingInfo>* iEncodingInfo;

	TMsgOutboxBodyEncoding			iBodyEncoding;

	// The character set to be when sending message.

	// Overrides the charset passed in from the settings.

	TUint							i822HeaderCharset; 

	CImEncodedHeader* iEncodedHeader;

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	friend class CTestEmailHeaderStoreReStore;

#endif 

	};

/** Folder type flags.

The flags correspond to the MIME multipart subtype. 

@publishedAll

@released

*/

enum TImEmailFolderType

	{

	/** Unknown. */

	EFolderTypeUnknown,

	/** Related. */

	EFolderTypeRelated,

	/** Mixed. */

	EFolderTypeMixed,

	/** Parallel. */

	EFolderTypeParallel,

	/** Alternative. */

	EFolderTypeAlternative,

	/** Digest. */

	EFolderTypeDigest,

	/** RFC822. */

	EFolderTypeRFC822,

	/** Partial. */

	EFolderTypePartial,

	/** Directory. */

	EFolderTypeDirectory,

	/** External. */

	EFolderTypeExternal

	};

/** Describes the types of off-line email operations than can occur.

@see TMsvEmailEntry::DisconnectedOperation() 

@publishedAll

@released

*/

enum TImDisconnectedOperationType

	{

	/** No operation. */

	ENoDisconnectedOperations,

	/** Create operation. */

	EDisconnectedCreateOperation,

	/** Delete operation. */

	EDisconnectedDeleteOperation,

	/** Change operation. */

	EDisconnectedChangeOperation,

	/** "Copy to" operation. */

	EDisconnectedCopyToOperation,

	/** "Copy from" operation. */

	EDisconnectedCopyFromOperation,

	/** "Copy within service" operation. */

	EDisconnectedCopyWithinServiceOperation,

	/** "Move to" operation. */

	EDisconnectedMoveToOperation,

	/** "Move from" operation. */

	EDisconnectedMoveFromOperation,

	/** "Move within service" operation. */

	EDisconnectedMoveWithinServiceOperation,

	/** Special operation. */

	EDisconnectedSpecialOperation,

	/** Unknown operation. */

	EDisconnectedUnknownOperation,

	/** Multiple operations. */

	EDisconnectedMultipleOperation

	};

// Remote folder message count limited to TUint16 by using lower 16 bits of "iMtmData3".

// Note: The upper 16 bits of "iMtmData3" are not currently used by "TMsvEmailEntry".

const TUint KMsvRemoteFolderEntriesMask =		0x0000FFFF;

class TMsvEmailEntry : public TMsvEntry

/** Provides storage for and access to extra email specific information for a message.

To get a TMsvEmailEntry, get the entry's TMsvEntry, e.g. using

@c CMsvEntry::Entry(), and use the constructor that takes a TMsvEntry parameter.

Many of the flags are only used by IMAP4 entries. These can be grouped as follows:

- IMAP-specific flags, as defined by the IMAP protocol (see RFC3501, 2.3.2. Flags Message Attribute)

  - GetIMAP4Flags() and SetIMAP4Flags() handle all the flags as a group

  - \\Seen flag: SetSeenIMAP4Flag(), SeenIMAP4Flag(). 

  - \\Answered flag: SetAnsweredIMAP4Flag(), AnsweredIMAP4Flag()

  - \\Flagged flag: SetFlaggedIMAP4Flag(), FlaggedIMAP4Flag()

  - \\Deleted flag: SetDeletedIMAP4Flag(), DeletedIMAP4Flag() 

  - \\Draft flag: SetDraftIMAP4Flag(), DraftIMAP4Flag() 

  - \\Recent flag: SetRecentIMAP4Flag(), RecentIMAP4Flag()

- Folder subscriptions and other folder-related flags: 

  - SetMailbox(), Mailbox(), 

  - SetSubscribed(), Subscribed(), 

  - SetLocalSubscription(), LocalSubscription()

  - SetRemoteFolderEntries(), RemoteFolderEntries()  

- Disconnected operation information:

  - SetDisconnectedOperation(), DisconnectedOperation().

- Partial download flags: these flags allow a client to test if a message or its body has

  been partially downloaded (see TImImap4GetPartialMailInfo)   

  - SetPartialDownloaded(), PartialDownloaded() 

  - SetBodyTextComplete(), BodyTextComplete()

- UID information: IMAP messages have a unique identifier number (see 

  RFC3501, 2.3.1.1. Unique Identifier (UID) Message Attribute)

  - SetValidUID(), ValidUID()

  - SetUID(), UID().

The following flags are set only by the IMAP MTM. They indicate if the 

message contains a vCard, vCalendar (http://www.imc.org), or iCalendar (RFC 2445) attachment.

- VCard(), SetVCard()

- VCalendar(), SetVCalendar() 

- ICalendar(), SetICalendar()

The following flags apply to all email protocols:

- Receipt requested: Receipt(), SetReceipt()

- MHTML content: MHTMLEmail(), SetMHTMLEmail()

Note that the email specific data is stored in the reserved data members @c iMtmData1, 

@c iMtmData2 and @c iMtmData3 of the TMsvEntry base class. These public data members 

must not be directly altered by clients.

@publishedAll

@released

@see CImap4ClientMtm

*/

	{

public: // Public member functions

	IMPORT_C TMsvEmailEntry();	// default constructor

	IMPORT_C TMsvEmailEntry(const TMsvEntry& aGenericEntry); 

	IMPORT_C TBool operator==(const TMsvEntry& aEntry) const;

	IMPORT_C TBool operator==(const TMsvEmailEntry& aEntry) const;

	IMPORT_C void GetIMAP4Flags(TBool& rUnread,TBool& rSeen,TBool& rAnswered,TBool& rFlagged,TBool& rDeleted,TBool& rDraft,TBool& rRecent);

	IMPORT_C void SetIMAP4Flags(TBool aUnread,TBool aSeen,TBool aAnswered,TBool aFlagged,TBool aDeleted,TBool aDraft,TBool aRecent);