/*

* Copyright (c) 2007-2008 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:  common email part object

*

*/

#include <nmcommonheaders.h>

#include "emailtrace.h"

#include <apgcli.h>

#include <apmrec.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroy

//<cmail>

#include "CFSMailMessagePart.h"

#include "CFSMailPlugin.h"

//</cmail>

#include "CFSMailRequestObserver.h"

//<qmail>

#include "nmmessagepart.h"

#include "nmconverter.h"

//</qmail>

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

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

// CFSMailMessagePart::NewLC

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewLC(

    TFSMailMsgId aMessageId, TFSMailMsgId aMessagePartId )

{

    FUNC_LOG;

    CFSMailMessagePart* self = new (ELeave) CFSMailMessagePart();

    CleanupStack::PushL(self);

    self->ConstructL( aMessageId, aMessagePartId );

    return self;

} 

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

// CFSMailMessagePart::NewL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewL(

    TFSMailMsgId aMessageId, TFSMailMsgId aMessagePartId )

{

    FUNC_LOG;

    CFSMailMessagePart* self =

        CFSMailMessagePart::NewLC( aMessageId, aMessagePartId );

    CleanupStack::Pop(self);

    return self;

}

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

// CFSMailMessagePart::NewLC

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewLC(const NmId &aNmMessageId,

    const NmMessagePart& aNmMessage )

{

    FUNC_LOG;

  CFSMailMessagePart* self = new (ELeave) CFSMailMessagePart();

  CleanupStack::PushL(self);

  self->ConstructL( aNmMessageId,aNmMessage );

  return self;

} 

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

// CFSMailMessagePart::ConstructL

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

void CFSMailMessagePart::ConstructL( TFSMailMsgId aMessageId,

                                     TFSMailMsgId aMessagePartId )

{

    FUNC_LOG;

    // Base class initialization

    CFSMailMessageBase::ConstructL(aMessageId);

	iNmPrivateMessagePart = new NmMessagePartPrivate();

	iNmPrivateMessagePart->mOwnId.setId32(aMessagePartId.Id());

	iNmPrivateMessagePart->mOwnId.setPluginId32((quint32)aMessagePartId.PluginId().iUid);

	iMessagePartsStatus = EFSDefault;

	// set request handler pointer

	iRequestHandler = static_cast<CFSMailRequestHandler*>(Dll::Tls());

	iContentTypeParams  = new (ELeave)CDesCArrayFlat( KArrayGranularity );

	iContentDispositionParams = new (ELeave)CDesCArrayFlat( KArrayGranularity );

}

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

// CFSMailMessagePart::ConstructL

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

void CFSMailMessagePart::ConstructL( const NmId &aNmMessageId,const NmMessagePart& aNmMessage )

{

    FUNC_LOG;

    // Base class initialization

    CFSMailMessageBase::ConstructL(TFSMailMsgId(aNmMessageId));

    iNmPrivateMessagePart = aNmMessage.d;

    iMessagePartsStatus = EFSDefault;

    // set request handler pointer

    iRequestHandler = static_cast<CFSMailRequestHandler*>(Dll::Tls());

    iContentTypeParams  = new (ELeave)CDesCArrayFlat( KArrayGranularity );

    iContentDispositionParams = new (ELeave)CDesCArrayFlat( KArrayGranularity );

}

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

// CFSMailMessagePart::ConstructL

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

void CFSMailMessagePart::ConstructL(

    const NmMessagePart& aNmMessage,

    const NmMessageEnvelope& aNmMessageEnvelope)

{

    FUNC_LOG;

    // Base class initialization

    CFSMailMessageBase::ConstructL(aNmMessageEnvelope);

    iNmPrivateMessagePart = aNmMessage.d;

    iMessagePartsStatus = EFSDefault;

    // set request handler pointer

    iRequestHandler = static_cast<CFSMailRequestHandler*>(Dll::Tls());

    iContentTypeParams  = new (ELeave)CDesCArrayFlat( KArrayGranularity );

    iContentDispositionParams = new (ELeave)CDesCArrayFlat( KArrayGranularity );

}

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

// CFSMailMessagePart::~CFSMailMessagePart

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

EXPORT_C CFSMailMessagePart::~CFSMailMessagePart()

{

    FUNC_LOG;

	if(iAttachmentName)

	{

		delete iAttachmentName;

	}

 	iAttachmentName = NULL;

	if(iContentClass)

	{

		delete iContentClass;

	}

 	iContentClass = NULL;

	if(iMeetingRequest)

	{

		delete iMeetingRequest;

	}

	iMeetingRequest = NULL;

	if(iContentDispositionParams)

		{

	    iContentDispositionParams->Reset();

	    delete iContentDispositionParams;

		}

	if(iContentTypeParams)

		{

	    iContentTypeParams->Reset();

	    delete iContentTypeParams;		

		}

	iMessageParts.ResetAndDestroy();

}

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

// CFSMailMessagePart::CFSMailMessagePart

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

CFSMailMessagePart::CFSMailMessagePart()

{

    FUNC_LOG;    

    iContentClass = HBufC::New(1);

    iContentClass->Des().Copy(KNullDesC());

	iAttachmentName = HBufC::New(1);

	iAttachmentName->Des().Copy(KNullDesC());

	iReadMessageParts = ETrue;

}

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

// CFSMailMessagePart::GetContentType

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

EXPORT_C const TDesC& CFSMailMessagePart::GetContentType() const

{

    FUNC_LOG;

    iContentTypePtr.Set(reinterpret_cast<const TUint16*> (iNmPrivateMessagePart->mContentType.utf16()),

    		iNmPrivateMessagePart->mContentType.length());

    return iContentTypePtr;

}

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

// CFSMailMessagePart::SetContentType

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

EXPORT_C void CFSMailMessagePart::SetContentType( const TDesC& aContentType )

{

    FUNC_LOG;

    QString qtContentType = QString::fromUtf16(aContentType.Ptr(), aContentType.Length());

    iNmPrivateMessagePart->mContentType = qtContentType;

}

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

// CFSMailMessagePart::GetPartId

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

EXPORT_C TFSMailMsgId CFSMailMessagePart::GetPartId() const

{

    FUNC_LOG;

    return TFSMailMsgId(iNmPrivateMessagePart->mOwnId);

}

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

// CFSMailMessagePart::ChildPartsL

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

EXPORT_C void CFSMailMessagePart::ChildPartsL( RPointerArray<CFSMailMessagePart>& aParts,

    TFSMailMessagePartDataSource aDataSource)

{

    FUNC_LOG;

    if (aDataSource == EDataSourceMessageStore)

        {

        if (CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

            {

            plugin->ChildPartsL(GetMailBoxId(), GetFolderId(),

                    GetMessageId(), GetPartId(), aParts);

            }

        }

    else

        {

        int count = iNmPrivateMessagePart->mChildParts.count();

        for (int i = 0; i < count; i++)

            {

            CFSMailMessagePart* part = CFSMailMessagePart::NewLC(

                    NmConverter::mailMsgIdToNmId(GetMessageId()),

                    *iNmPrivateMessagePart->mChildParts[i]);

            aParts.AppendL(part);

            CleanupStack::Pop(part);

            }

        }

 }

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

// CFSMailMessagePart::ChildPartL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::ChildPartL( TFSMailMsgId aPartId )

{

    FUNC_LOG;

    CFSMailMessagePart* part = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

        {

        part = plugin->MessagePartL(GetMailBoxId(),

                  GetFolderId(),

                  GetMessageId(),

                  aPartId);

        }

    return part;

}

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

// CFSMailMessagePart::IsMessageL

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

EXPORT_C TBool CFSMailMessagePart::IsMessageL() const

{

    FUNC_LOG;

    TBuf<KMaxDataTypeLength> ptr;

    if ( !iNmPrivateMessagePart->mContentType.isNull() ) {

		ptr.Copy(GetContentType());

    	TInt length = ptr.Locate(';');

    	if(length >= 0) {

			ptr.SetLength(length);

		}

    	if( !ptr.Compare(KFSMailContentTypeMessage) ) {

			return ETrue;

    	}

    }

    return EFalse;

}

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

// CFSMailMessagePart::NewChildPartL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewChildPartL( const TFSMailMsgId aInsertBefore,

                                const TDesC& aContentType )

{

    FUNC_LOG;

    CFSMailMessagePart* part = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

        {

        part = plugin->NewChildPartL(   GetMailBoxId(), GetFolderId(), GetMessageId(),

                    GetPartId(), aInsertBefore, aContentType );

        }

    return part;

}

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

// CFSMailMessagePart::RemoveChildPartL

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

EXPORT_C void CFSMailMessagePart::RemoveChildPartL( TFSMailMsgId aPartId )

{

    FUNC_LOG;

    // get plugin pointer

    TFSMailMsgId id = GetPartId();

    if(id.IsNullId())

        {

        id = GetMessageId();

        }

    CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(id);

    if(plugin)

        {

        plugin->RemoveChildPartL( GetMailBoxId(), GetFolderId(), GetMessageId(), GetPartId(), aPartId );

        }

}

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

// CFSMailMessagePart::GetContentClass

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

EXPORT_C const TDesC& CFSMailMessagePart::GetContentClass()

{

    FUNC_LOG;

    return *iContentClass;

}

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

// CFSMailMessagePart::SetContentClass

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

EXPORT_C void CFSMailMessagePart::SetContentClass( const TDesC& aContentClass )

{

    FUNC_LOG;

    HBufC* contentClass = HBufC::New(aContentClass.Length());

    // store new mailbox name

    if(contentClass)

        {

        delete iContentClass;

        iContentClass = contentClass;

        iContentClass->Des().Copy(aContentClass);

        }

    iContentClass->ReAlloc(aContentClass.Length());

    if(iContentClass)

        {

        iContentClass->Des().Copy(aContentClass);   

        }

}

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

// CFSMailMessagePart::ContentSize

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

EXPORT_C TUint CFSMailMessagePart::ContentSize() const

{

    FUNC_LOG;

    return (TUint)iNmPrivateMessagePart->mSize;

	}

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

// CFSMailMessagePart::SetContentSize

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

EXPORT_C void CFSMailMessagePart::SetContentSize( TUint aContentSize )

	{

    FUNC_LOG;

    iNmPrivateMessagePart->mSize = quint32(aContentSize);

	}

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

// CFSMailMessagePart::ContentID

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

EXPORT_C const TDesC& CFSMailMessagePart::ContentID()

{

    FUNC_LOG;

    iContentIDPtr.Set(reinterpret_cast<const TUint16*> (iNmPrivateMessagePart->mContentId.utf16()),

    		iNmPrivateMessagePart->mContentId.length());

    return iContentIDPtr;	

	}

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

// CFSMailMessagePart::SetContentIDL

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

EXPORT_C void CFSMailMessagePart::SetContentIDL( const TDesC& aContentID )

{

    FUNC_LOG;

    QString qtContentID = QString::fromUtf16(aContentID.Ptr(), aContentID.Length());

    iNmPrivateMessagePart->mContentId = qtContentID;    

	}

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

// CFSMailMessagePart::CopyMessageAsChildPartL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::CopyMessageAsChildPartL(

                          TFSMailMsgId aInsertBefore,

                          CFSMailMessage* aMessage )

{

    FUNC_LOG;

    CFSMailMessagePart* part = NULL;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

        {

        part = plugin->CopyMessageAsChildPartL(GetMailBoxId(),GetFolderId(),GetMessageId(),GetPartId(),

                      aInsertBefore, *aMessage);

        }

  return part;

}

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

// CFSMailMessagePart::RemoveContentL

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

EXPORT_C void CFSMailMessagePart::RemoveContentL()

{

    FUNC_LOG;

    CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId());

    // <qmail>

    if(!plugin)

    // </qmail>

        {

        plugin = iRequestHandler->GetPluginByUid(GetMessageId());

        }

    // <qmail>

    if(plugin)

    // </qmail>

        {

        RPointerArray<CFSMailMessagePart> parts;

        RArray<TFSMailMsgId> partIds;

        plugin->ChildPartsL(GetMailBoxId(),GetFolderId(),GetMessageId(),GetPartId(),parts);

        for(TInt i=0;i<parts.Count();i++)

            {

            partIds.Append(parts[i]->GetMessageId());

            }

        partIds.Append(GetPartId());

        plugin->RemovePartContentL(GetMailBoxId(), GetFolderId(), GetMessageId(), partIds);

        parts.ResetAndDestroy();

        partIds.Reset();

    }

}

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

// CFSMailMessagePart::RemoveDownLoadedAttachmentsL

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

EXPORT_C void CFSMailMessagePart::RemoveDownLoadedAttachmentsL()

{

    FUNC_LOG;

    CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId());

    // <qmail>

    if(!plugin)

    // </qmail>

        {

        plugin = iRequestHandler->GetPluginByUid(GetMessageId());

        }

    // <qmail>

    if(plugin)

    // </qmail>

        {

        // get attachment list

        RPointerArray<CFSMailMessagePart> attachments;

        attachments.Reset();

        DoAttachmentListL(attachments);

        // copy attachment part ids

        RArray<TFSMailMsgId> ids;

        ids.Reset();

        for(TInt i=0;i<attachments.Count();i++)

            {

            ids.Append(attachments[i]->GetPartId());

            }

        // remove attachment fetched contents 

        if(ids.Count())

            {

            TRAP_IGNORE(plugin->RemovePartContentL(GetMailBoxId(), GetFolderId(), GetMessageId(), ids));

            }

        // clean tables

        attachments.ResetAndDestroy();

        ids.Reset();

        }

}

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

// CFSMailMessagePart::GetContentFileL

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

EXPORT_C RFile CFSMailMessagePart::GetContentFileL()

{

    FUNC_LOG;

    if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

        {

        TInt rcode = plugin->GetMessagePartFileL( GetMailBoxId(), GetFolderId(),

                                      GetMessageId(), GetPartId(),

                                      iFile );

        // if content is encrypted, use temp dir files

        if(rcode == KErrNotSupported)

            {

            // temp directory C:\Private\<uid>

            TFileName fileName;

            iFile = iRequestHandler->GetTempFileL(GetPartId(),fileName);

            plugin->CopyMessagePartFileL(GetMailBoxId(), GetFolderId(),

                                     GetMessageId(), GetPartId(),

                                     fileName);

            }

        }

    return iFile;