/*

* Copyright (c) 2010 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:  Harvester message plugin

*

*/

//  INCLUDES 

#include <e32base.h>

#include <mtclreg.h>

#include <smsclnt.h> // SMS Headers

#include <mmsclient.h> // MMS Headers

#include <mmsvattachmentmanager.h>

#include <impcmtm.h> // IMAP Headers

#include <smtcmtm.h> // SMTP

#include <popcmtm.h> // POP

#include "harvesterserverlogger.h"

#include "cmessagedatahandler.h"

#include "cmessageplugin.h"

#include <csearchdocument.h>

#include <common.h>

#include <ccpixindexer.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmessagedatahandlerTraces.h"

#endif

/** Number of symbols from MsgBody taken to excerpt */

const TInt KMsgBodyExcerptSymbols = 160;

// For Ucs2 detection

const TInt KUtf8BomLength = 3;

const TUint8 KUtf8Bom[KUtf8BomLength] = {0xEF, 0xBB, 0xBF};

// CSearchDocument ID max length

const TUint KMaxDocId = 20;

// Hardcoded limit for the body size to index (and store)

const TInt KMaxDocumentSize = 1024;

_LIT8(KMimeTypeText, "text/plain" );

_LIT(KMimeTypeField, CPIX_MIMETYPE_FIELD);

_LIT(KMimeTypeMessaging, MESSAGING_MIMETYPE);

/** Field names */

_LIT(KToField, TO_FIELD);

_LIT(KCcField, CC_FIELD);

_LIT(KBccField, BCC_FIELD);

_LIT(KFromField, FROM_FIELD);

_LIT(KFolderField, FOLDER_FIELD);

_LIT(KBodyField, BODY_FIELD);

_LIT(KSubjectField, SUBJECT_FIELD);

// ============================ MEMBER FUNCTIONS ===============================

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

// CMessageDataHandler::NewL

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

//

CMessageDataHandler* CMessageDataHandler::NewL(CMessagePlugin& aMessagePlugin,

		CMsvSession& aSession)

	{

		OstTraceFunctionEntry0( CMESSAGEDATAHANDLER_NEWL_ENTRY );

		CPIXLOGSTRING( "CMessageDataHandler::NewL() - enter" );

	CMessageDataHandler* self = new (ELeave) CMessageDataHandler(

			aMessagePlugin, aSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

		CPIXLOGSTRING( "CMessageDataHandler::NewL() - return" );

	OstTraceFunctionExit0( CMESSAGEDATAHANDLER_NEWL_EXIT );

	return self;

	}

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

// CMessageDataHandler::~CMessageDataHandler

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

//

CMessageDataHandler::~CMessageDataHandler()

	{

	Cancel();

	iFs.Close();

	delete iMmsMtm;

	delete iSmsMtm;

	delete iSmtpMtm;

	delete iPop3Mtm;

	delete iImap4Mtm;

	delete iMtmReg;

	}

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

// CMessageDataHandler::CMessageDataHandler

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

//

CMessageDataHandler::CMessageDataHandler(CMessagePlugin& aMessagePlugin, CMsvSession& aSession)

	: CActive(EPriorityLow), iMessagePlugin(aMessagePlugin), iMsvSession(aSession)

	{

	CActiveScheduler::Add(this);

	}

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

// CMessageDataHandler::ConstructL

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

//

void CMessageDataHandler::ConstructL()

	{

	// TODO iFs only used in MMS attachment logic, 

	// from a performance perspective, is it worthwhile connecting here?

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

	iMtmReg = CClientMtmRegistry::NewL(iMsvSession);

	TRAPD(err,iSmsMtm = static_cast<CSmsClientMtm*> (iMtmReg->NewMtmL(KUidMsgTypeSMS)));

	OstTrace1( TRACE_NORMAL, CMESSAGEDATAHANDLER_CONSTRUCTL, "CMessageDataHandler::ConstructL;iSmsMtm err=%d",err );

	CPIXLOGSTRING2( "CMessageDataHandler::ConstructL() iSmsMtm err = %d",err);

	TRAP(err,iMmsMtm = static_cast<CMmsClientMtm*> (iMtmReg->NewMtmL(KUidMsgTypeMultimedia)));

	OstTrace1( TRACE_NORMAL, DUP1_CMESSAGEDATAHANDLER_CONSTRUCTL, "CMessageDataHandler::ConstructL;iMmsMtm err=%d", err );

	CPIXLOGSTRING2( "CMessageDataHandler::ConstructL() iMmsMtm err = %d",err);

	/*

	TRAP(err,iSmtpMtm = static_cast<CSmtpClientMtm*> (iMtmReg->NewMtmL(KUidMsgTypeSMTP)));

	CPIXLOGSTRING2( "CMessageDataHandler::ConstructL() iSmtpMtm err = %d",err);

	TRAP(err, iPop3Mtm = static_cast<CPop3ClientMtm*> (iMtmReg->NewMtmL(KUidMsgTypePOP3)));

	CPIXLOGSTRING2( "CMessageDataHandler::ConstructL() iPop3Mtm err = %d",err);

	TRAP(err,iImap4Mtm = static_cast<CImap4ClientMtm*> (iMtmReg->NewMtmL(KUidMsgTypeIMAP4)));

	CPIXLOGSTRING2( "CMessageDataHandler::ConstructL() iImap4Mtm err = %d",err);

	*/

	}

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

// CMessageDataHandler::GatherData

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

//

void CMessageDataHandler::GatherDataL(TMsvId& aMessageId,

		TCPixActionType aActionType, TMsvId& aFolderId)

	{

	TMessageItem item(aMessageId, aActionType, aFolderId);

	iMessageArray.AppendL(item);

	HandleNextRequest();

	}

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

// CMessageDataHandler::IsValidMessageTypeL

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

//	    

TInt CMessageDataHandler::IsValidMessageType(TMsvId aIdToCheck,

		TMsgType& aMessageType)

	{

		OstTraceFunctionEntry0( CMESSAGEDATAHANDLER_ISVALIDMESSAGETYPE_ENTRY );

		CPIXLOGSTRING("ENTER CMessageDataHandler::IsValidMessageType");

	TMsvEntry entry;

	TMsvId service = 0;

	TInt err = iMsvSession.GetEntry(aIdToCheck, service, entry);

		OstTrace1( TRACE_NORMAL, CMESSAGEDATAHANDLER_ISVALIDMESSAGETYPE, "CMessageDataHandler::IsValidMessageType;GetEntry Error=%d", err );

		CPIXLOGSTRING2("CMessageDataHandler::IsValidMessageType GetEntry: %d", err);

	if (!err)

		{

		aMessageType = iMessagePlugin.CalculateMessageType(entry);

			OstTrace1( TRACE_NORMAL, DUP1_CMESSAGEDATAHANDLER_ISVALIDMESSAGETYPE, "CMessageDataHandler::IsValidMessageType;Message Type=%d", aMessageType );

			CPIXLOGSTRING2("CMessageDataHandler::IsValidMessageType type: %d", aMessageType );

		}

		CPIXLOGSTRING("END CMessageDataHandler::IsValidMessageType");

	OstTraceFunctionExit0( CMESSAGEDATAHANDLER_ISVALIDMESSAGETYPE_EXIT );

	return err;

	}

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

// CMessageDataHandler::CreateSmsIndexItemLC

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

//	    

void CMessageDataHandler::CreateMessageIndexItemL(const TMsvId& aMsvId,

		TCPixActionType aActionType, const TMsvId& aFolderId)

	{

	OstTrace1( TRACE_NORMAL, CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;aMsvId=%d", aMsvId );

	CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): aMsvId = %d ", aMsvId );

	// Index an empty item if removal action

	if (aActionType == ECPixRemoveAction)

		{

		TBuf<20> docid_str;

		docid_str.AppendNum(aMsvId);

		if (iMessagePlugin.GetIndexer())

			{

			TRAPD(err, iMessagePlugin.GetIndexer()->DeleteL(docid_str));

			if (err == KErrNone)

				{

				OstTrace0( TRACE_NORMAL, DUP1_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): Document deleted." );

				CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): Document deleted.");

				}

			else

				{

				OstTrace1( TRACE_NORMAL, DUP2_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;Error in deleting the doc=%d", err );

				CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): Error %d in deleting the document.", err);				

				}

			}

		return;

		}

	// Check message type

	TMsgType messageType = EMsgTypeInvalid; // initialisation

	TInt error = IsValidMessageType(aMsvId, messageType);

	// creating CSearchDocument object with unique ID for this application

	CSearchDocument* index_item = NULL;

	switch (messageType)

		{

		case EMsgTypeSms:

			{

			TRAPD(err, index_item = CreateSmsDocumentL(aMsvId, aFolderId));

			if (err == KErrNone)

				{

				OstTrace0( TRACE_NORMAL, DUP3_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): SMS document created." );

				CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): SMS document created.");

				}

			else

				{

				OstTrace1( TRACE_NORMAL, DUP4_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;Error in creating the sms doc=%d", err );

				CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): Error %d in creating SMS document.", err);

				}

			break;

			}

		case EMsgTypeMms:

			{

			TRAPD(err, index_item = CreateMmsDocumentL(aMsvId, aFolderId));

			if (err == KErrNone)

				{

				OstTrace0( TRACE_NORMAL, DUP5_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): MMS document created." );

				CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): MMS document created.");

				}

			else

				{

				OstTrace1( TRACE_NORMAL, DUP6_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;Error in creating the mms doc=%d", err );

				CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): Error %d in creating MMS document.", err);

				}

			break;

			}

		case EMsgTypeEmailPop3:

		case EMsgTypeEmailImap4:

		case EMsgTypeEmailSmtp:

			{

			TRAPD(err, index_item = CreateEmailDocumentL(aMsvId, aFolderId));

			if (err == KErrNone)

				{

				OstTrace0( TRACE_NORMAL, DUP7_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): E-mail document created." );

				CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): E-mail document created.");

				}

			else

				{

				OstTrace1( TRACE_NORMAL, DUP8_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;Error in ccreating the email doc=%d", err );

				CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): Error %d in creating e-mail document.", err);

				}

			break;

			}

		case EMsgTypeInvalid:

		// For EMsgTypeDraft there is no way to tell if it was a SMS, MMS or email,

		// so don't create index_item.

		case EMsgTypeDraft:

		default:

			// Error occurred

			break;

		}

	// Exit if wrong message type

	if (index_item == NULL)

		{

		OstTrace0( TRACE_NORMAL, DUP9_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): Document was not created." );

		CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): Document was not created.");

		return;

		}

	CleanupStack::PushL(index_item);

	// Folder field

	TMsvEntry entry;

	TMsvId service = 0;

	iMsvSession.GetEntry(aFolderId, service, entry);

	HBufC *folder_str = entry.iDetails.AllocLC();

	index_item->AddFieldL(KFolderField, *folder_str, CDocumentField::EStoreYes | CDocumentField::EIndexNo);

	// Mime type field

	index_item->AddFieldL(KMimeTypeField, KMimeTypeMessaging, CDocumentField::EStoreYes | CDocumentField::EIndexUnTokenized);		

		// Send for indexing

	if (iMessagePlugin.GetIndexer())

		{

		if (aActionType == ECPixAddAction)

			{

			TRAPD(err, iMessagePlugin.GetIndexer()->AddL(*index_item));

			if (err == KErrNone)

				{

				OstTrace0( TRACE_NORMAL, DUP10_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): Added." );

				CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): Added.");

				}

			else

				{

				OstTrace1( TRACE_NORMAL, DUP11_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;Error in Adding=%d", err );

				CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): Error %d in adding.", err);

				}

			}

		else if (aActionType == ECPixUpdateAction)

			{

			TRAPD(err, iMessagePlugin.GetIndexer()->UpdateL(*index_item));

			if (err == KErrNone)

				{

				OstTrace0( TRACE_NORMAL, DUP12_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL(): Updated." );

				CPIXLOGSTRING("CMessageDataHandler::CreateMessageIndexItemL(): Updated.");

				}

			else

				{

				OstTrace1( TRACE_NORMAL, DUP13_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "CMessageDataHandler::CreateMessageIndexItemL;Error in Updating=%d", err );

				CPIXLOGSTRING2("CMessageDataHandler::CreateMessageIndexItemL(): Error %d in updating.", err);

				}

			}

		}

	else

		{

		OstTrace0( TRACE_NORMAL, DUP14_CMESSAGEDATAHANDLER_CREATEMESSAGEINDEXITEML, "END CMessageDataHandler::CreateMessageIndexItemL(): No indexer present." );

		CPIXLOGSTRING("END CMessageDataHandler::CreateMessageIndexItemL(): No indexer present.");

		}

	CleanupStack::PopAndDestroy(folder_str);

	CleanupStack::PopAndDestroy(index_item);

	}

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

// CMessageDataHandler::CreateSmsDocumentL

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

//

CSearchDocument* CMessageDataHandler::CreateSmsDocumentL(const TMsvId& aMsvId, const TMsvId& aFolderId)

	{

	// Select mtm for this type

	iSmsMtm->SwitchCurrentEntryL(aMsvId);

	iSmsMtm->LoadMessageL();

	// creating CSearchDocument object with unique ID for this application

	TBuf<KMaxDocId> docid_str;

	docid_str.AppendNum(aMsvId);

	CSearchDocument* index_item = CSearchDocument::NewLC(docid_str, _L(SMSAPPCLASS));

	// Add from field use the name instead of number if in the contacts db.

	// (iSmsMtm->SmsHeader().FromAddress() - only returns the number)

	TMsvEntry entry;

	TMsvId service = 0;

	iMsvSession.GetEntry(aMsvId, service, entry);

	HBufC *fromNameOrNumberBuf = entry.iDetails.AllocLC();

	// Add the recipients as content items

	TBuf<64> to_field;

	const CDesCArray

			& recipientArray =

					static_cast<const CDesCArray&> (iSmsMtm->AddresseeList().RecipientList());

	for (TInt i = 0; i < recipientArray.MdcaCount(); i++)

		{

		to_field = KToField;

		if (i>0)

			to_field.AppendNum(i);

		}

	// Add the body text as a content item

	TInt msgLength = iSmsMtm->Body().DocumentLength();

	HBufC* bodyText = HBufC::NewLC(msgLength);

	TPtr body_ptr = bodyText->Des();

	iSmsMtm->Body().Extract(body_ptr);

	index_item->AddFieldL(KBodyField, *bodyText);

	// Add excerpt

	// Note SMS does not have a subject field.

	HBufC* excerpt = CreateExcerptLC(*fromNameOrNumberBuf, recipientArray, KNullDesC(), body_ptr, aFolderId);

	index_item->AddExcerptL(*excerpt);

	CleanupStack::PopAndDestroy(excerpt);	

	CleanupStack::PopAndDestroy(bodyText);

	CleanupStack::PopAndDestroy(fromNameOrNumberBuf);

	// Pop the item

	CleanupStack::Pop(index_item);

	return index_item;

	}

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

// CMessageDataHandler::CreateMmsDocumentL

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

//

CSearchDocument* CMessageDataHandler::CreateMmsDocumentL(const TMsvId& aMsvId, const TMsvId& aFolderId)

	{

	// Select mtm for this type

 	iMmsMtm->SwitchCurrentEntryL(aMsvId);

	iMmsMtm->LoadMessageL();

	// creating CSearchDocument object with unique ID for this application

	TBuf<KMaxDocId> docid_str;

	docid_str.AppendNum(aMsvId);

	CSearchDocument* index_item = CSearchDocument::NewLC(docid_str, _L(MMSAPPCLASS));

	// Add from field

	index_item->AddFieldL(KFromField, iMmsMtm->Sender());

	// Add the recipients as content items

	TBuf<64> to_field;

	const CDesCArray

			& recipientArray =

					static_cast<const CDesCArray&> (iMmsMtm->AddresseeList().RecipientList());

	for (TInt i = 0; i < recipientArray.MdcaCount(); i++)

		{

		to_field = KToField;

		if (i>0)

			to_field.AppendNum(i);

		index_item->AddFieldL(to_field, recipientArray.MdcaPoint(i));

		}

	// Add subject

	TPtrC subject(iMmsMtm->SubjectL());

	index_item->AddFieldL(KSubjectField, subject);

	// Add the body parts as a content items

    // See if the MMS contains a text file attachment

    TBool excerptFieldAdded(EFalse);

    TInt bodycount = 0;

    CMsvStore* msvStore = iMmsMtm->Entry().ReadStoreL();

	CleanupStack::PushL( msvStore );

	MMsvAttachmentManager& attManager = msvStore->AttachmentManagerL();

	for ( TInt i = 0; i < attManager.AttachmentCount(); i++ )

	    {

		CMsvAttachment* attInfo = attManager.GetAttachmentInfoL(i);

		CleanupStack::PushL( attInfo );

        if (attInfo->MimeType() == KMimeTypeText())

            {

            // Mime type

            RFile attFile = attManager.GetAttachmentFileL(i);

            CleanupClosePushL( attFile );

            TInt charsetMIB = TextFileCharsetL(iFs, attFile);

            // Get the file size

            TInt fileSize = 0;

            User::LeaveIfError(attFile.Size(fileSize));

            // Read the file

            HBufC8* textSource = HBufC8::NewLC(fileSize);

            TPtr8 ptr8 = textSource->Des();

            attFile.Read(ptr8);

  			// Convert character set

            HBufC* text = HBufC::NewLC( fileSize );

            TPtr buf = text->Des();

            if ( KMmsIso10646Ucs2 != charsetMIB )

                {

                if ( KMmsUsAscii == charsetMIB )

                    buf.Copy(*textSource);

                else

                    ConvertToUcs2FromUtfL(iFs, buf, *textSource, charsetMIB);

                }

            else

                {

                TPtrC ptr(reinterpret_cast<const TUint16*>(textSource->Des().Ptr()), 

                                  textSource->Length() / sizeof(TText));

                // Ignore the first unicode charcter FFFE

                ptr.Set( ptr.Mid( 1 ) );

                buf = ptr;

                }

            // Add the text of the file as a content item

            // MMS message body is in attachment

			TBuf<64> body_field;

			body_field = KBodyField;

			if (bodycount>0)

			{

				// Add additional body fields

				body_field.AppendNum(bodycount);

			}

			else

			{

				// Add excerpt for the first body field

				HBufC* excerpt = CreateExcerptLC(iMmsMtm->Sender(), recipientArray, subject, *text, aFolderId);

				index_item->AddExcerptL(*excerpt);

				CleanupStack::PopAndDestroy(excerpt);

				excerptFieldAdded  = ETrue;

			}

            // TODO: add only few kilobytes of the body?

            index_item->AddFieldL(body_field, *text);

            ++bodycount;

            CleanupStack::PopAndDestroy( 3, &attFile ); // text, textSource, attFile

            }		

        else 

            {

            // add attachment name when binary file.

            if ( !excerptFieldAdded )

                {

                // attachment name might not be set

                HBufC* excerpt = CreateExcerptLC(iMmsMtm->Sender(), recipientArray, subject, attInfo->AttachmentName(), aFolderId);

                index_item->AddExcerptL(*excerpt);

                CleanupStack::PopAndDestroy(excerpt);

                excerptFieldAdded  = ETrue;

                }

            }

	    CleanupStack::PopAndDestroy( attInfo );		

	    }