/*
* Copyright (c) 2006 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:  Utils for message handling
*
*/



// INCLUDE FILES
#include    "IMMessageUtilsPC.h"
#include	"ChatDebugPrint.h"

#include    "imutils.h"

#include    "MCAMessagesWriteInterface.h"
#include    "MCAMessagesReadInterface.h"

#include    "MCAMessageCreator.h"
#include    "MCAMessageContainerInfo.h"

#include    "impsbuilddefinitions.h"

#include	"CCAConversationPC.h"
#include	"CCAEngine.h"
#include 	"MCAProcessManager.h"
#include 	"CCAProcessManagerFactory.h"
#include	"MCAMessage.h"
#include	"MCAConversationMessage.h"
#include	"CCAConversationMessage.h"

#include	"MCARecordedChatsPC.h"
#include	"CCARecordedChatsPC.h"
#include	"MCAMessageContainer.h"
#include	"CCAGroupPC.h"

#include	"MCAMessageFlowHandlerPC.h"
#include	"CCAMessageFlowHandlerPC.h"


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

// -----------------------------------------------------------------------------
// IMMessageUtilsPC: SendFileL
// -----------------------------------------------------------------------------
//
EXPORT_C void IMMessageUtilsPC::SendFileL(
    MCAConversationPC& aMessageRWInterfacePC,
    const MDesCArray* aSelectedNames,
    const TBool aFileProtected,
    const TDesC& aFileName,
    const TDesC8& aContentType,
    const TDesC8& aContentData,
    const TDesC& aSender /*= KNullDesC*/,
    const TDesC& aSapId /*= KNullDesC*/,
    const TDesC& aUserId /*= KNullDesC*/,
    const MDesCArray* aRecipients /*NULL*/ )
    {

    CCAEngine* engine = CCAProcessManagerFactory::InstanceL()->
                        GetProcessManager()->GetEngine();

    MCAMessageCreator& creator =
        engine->MessageUtils().MessageCreator();

    CCAConversationPC& msgRWInterface =
        static_cast <CCAConversationPC&>( aMessageRWInterfacePC );
    const MCAMessageContainerInfo& msgContainerInfo =
        msgRWInterface.ReadInterfaceL().TargetId();



    if ( !aFileProtected )
        {

        CHAT_DP( D_CHAT_LIT( "Sending file %S.." ), &aFileName );

        MCAMessageCreator::SMessageData data =
            {
            KMessageDataVersion,
            0,
            aSapId,
            aUserId,
            aSender,
            msgContainerInfo.Target(), // Recipient
            aRecipients,
            aSelectedNames,
            aFileName,
            aContentType,
            aContentData,
            MCAMessage::EMessageSent
            };

        MCAMessage* message = creator.CreateMessageL( data );
#ifdef RD_SEND_NOT_SUPPORTED_CONTENT
        if ( err != KErrNone )
            {
            message->SetProcessState( MCAMessage::EContentCorrupted );
            }
#endif //RD_SEND_NOT_SUPPORTED_CONTENT
        // Lock write interface buffer memory handling for sending
        // file, memory check is done when message is appended to
        // read container after possible image processing.
        msgRWInterface.WriteInterfaceL().LockBufferMemoryHandling( ETrue );
        msgRWInterface.WriteInterfaceL().AppendL( message );
        // Open interface
        msgRWInterface.WriteInterfaceL().LockBufferMemoryHandling( EFalse );
        }
#ifdef RD_SEND_NOT_SUPPORTED_CONTENT
    else
        {

        CHAT_DP( D_CHAT_LIT( "Sending file %S.." ), &aFileName );

        MCAMessageCreator::SMessageData data =
            {
            KMessageDataVersion,
            0,
            aSapId,
            aUserId,
            aSender,
            msgContainerInfo.Target(), // Recipient
            aRecipients,
            aSelectedNames,
            aFileName,
            aContentType,
            aContentData,
            MCAMessage::EMessageSent
            };
        MCAMessage* message = creator.CreateMessageL( data );
        message->SetProcessState( MCAMessage::EContentNotSupportedDrm );
        // Lock write interface buffer memory handling for sending
        // file, memory check is done when message is appended to
        // read container after possible image processing.
        msgRWInterface.WriteInterface().LockBufferMemoryHandling( ETrue );
        msgRWInterface.WriteInterface().AppendL( message );
        // Open interface
        msgRWInterface.WriteInterface().LockBufferMemoryHandling( EFalse );
        }
#endif //RD_SEND_NOT_SUPPORTED_CONTENT        
    }




// -----------------------------------------------------------------------------
// CCAMessageUtilsPC: SendMessageL
// -----------------------------------------------------------------------------
//

EXPORT_C TBool IMMessageUtilsPC::SendMessageL(
    const MCAConversationMessage& aMessage,
    const TDesC& aRecipient,
    MCAConversationPC& aMessageRWInterfacePC,
    const MDesCArray* aSelectedNames,
    const TDesC& aSender /*= KNullDesC*/,
    const TDesC& aSapId /*= KNullDesC*/,
    const TDesC& aUserId /*= KNullDesC*/,
    const TDesC& aFileName /*= KNullDesC*/,
    const MDesCArray* aRecipients /*NULL*/ )
    {

    CCAEngine* engine =
        CCAProcessManagerFactory::InstanceL()->
        GetProcessManager()->GetEngine();


    MCAMessageCreator& creator =
        engine->MessageUtils().MessageCreator();
    CCAConversationPC& msgRWInterface =
        static_cast <CCAConversationPC&>(
            aMessageRWInterfacePC );


    MCAMessageCreator::SMessageData data =
        {
        KMessageDataVersion,
        0,
        aSapId,
        aUserId,
        aSender,
        aRecipient,
        aRecipients,
        aSelectedNames,
        aFileName,
        aMessage.MimeType(),
        aMessage.ContentData(),
        MCAMessage::EMessageSent
        };

    // Create and write
    MCAMessage* newMessage = creator.CreateMessageL( data );
    newMessage->SetProcessState( MCAMessage::EContentReady );
    msgRWInterface.WriteInterfaceL().AppendL( newMessage );

    // message handled succesfully
    return ETrue;

    }


// ---------------------------------------------------------
// IMMessageUtilsPC::CloneMessageL()
// (other items were commented in a header).
// ---------------------------------------------------------
//
EXPORT_C MCAConversationMessage* IMMessageUtilsPC::CloneMessageL(
    const MCAConversationMessage& aFwdSource )
    {

    MCAConversationMessage& FwdMessageTmp =
        const_cast <MCAConversationMessage&>( aFwdSource );


    CCAConversationMessage* FwdMessage =
        dynamic_cast <CCAConversationMessage*>( &FwdMessageTmp );

    if ( !FwdMessage )
        {
        return NULL;
        }

    MCAProcessManager* processManager =
        CCAProcessManagerFactory::InstanceL()->GetProcessManager();
    CCAEngine&	engine ( *processManager->GetEngine() );

    MCAMessage* Msg =
        engine.MessageUtils().MessageCreator().CloneMessageL(
            &FwdMessage->GetMessage() );

    //transfer the ownership of Msg to the CCAConversationMessage
    CCAConversationMessage* NewFwdMsg = CCAConversationMessage::NewL( *Msg, Msg );

    return NewFwdMsg;

    }



// -----------------------------------------------------------------------------
// CCAMessageFlowHandlerPC::CreateInstanceL
//
// -----------------------------------------------------------------------------
//
EXPORT_C MCAMessageFlowHandlerPC* IMMessageUtilsPC::CreateInstanceL(
    MCAMessageContainer& aMessageContainer,
    MCAConversationPC& aConversationPC,
    TBool aRecordedChatHandler )
    {

    CCAConversationPC& conversationPC =
        *static_cast<CCAConversationPC*>( &aConversationPC );

    MCAProcessManager* processManager =
        CCAProcessManagerFactory::InstanceL()->GetProcessManager();
    CCAEngine&	engine ( *processManager->GetEngine() );

    CCAMessageFlowHandlerPC* FlowHandler =
        CCAMessageFlowHandlerPC::NewL(
            aMessageContainer,
            conversationPC.ReadInterfaceL(),
            *engine.GetInternalSettingsInterface(),
            aRecordedChatHandler );

    return 	FlowHandler;
    }

// -----------------------------------------------------------------------------
// CCAMessageFlowHandlerPC::CreateInstanceL
//
// -----------------------------------------------------------------------------
//
EXPORT_C MCAMessageFlowHandlerPC* IMMessageUtilsPC::CreateInstanceL(
    MCAMessageContainer& aMessageContainer,
    MCAGroupPC& aGroupPC,
    TBool aRecordedChatHandler )
    {

    CCAGroupPC& groupPC =
        *static_cast<CCAGroupPC*>( &aGroupPC );

    MCAProcessManager* processManager =
        CCAProcessManagerFactory::InstanceL()->GetProcessManager();
    CCAEngine&	engine ( *processManager->GetEngine() );

    CCAMessageFlowHandlerPC* FlowHandler =
        CCAMessageFlowHandlerPC::NewL(
            aMessageContainer,
            groupPC.ReadInterfaceL(),
            *engine.GetInternalSettingsInterface(),
            aRecordedChatHandler );

    return 	FlowHandler;
    }



// -----------------------------------------------------------------------------
// CCAMessageFlowHandlerPC::CreateInstanceL
//
// -----------------------------------------------------------------------------
//
EXPORT_C MCAMessageFlowHandlerPC* IMMessageUtilsPC::CreateInstanceL(
    MCAMessageContainer& aMessageContainer,
    MCARecordedChatsPC& aRecChatsPC,
    TBool aRecordedChatHandler )
    {

    CCARecordedChatsPC& recordedChatsPC =
        *static_cast<CCARecordedChatsPC*>( &aRecChatsPC );

    MCAProcessManager* processManager =
        CCAProcessManagerFactory::InstanceL()->GetProcessManager();
    CCAEngine&	engine ( *processManager->GetEngine() );

    CCAMessageFlowHandlerPC* FlowHandler = CCAMessageFlowHandlerPC::NewL(
                                               aMessageContainer,
                                               recordedChatsPC.ReadInterfaceL(),
                                               *engine.GetInternalSettingsInterface(),
                                               aRecordedChatHandler );

    return FlowHandler;
    }

// -----------------------------------------------------------------------------
// CCAMessageUtilsPC: SendFileL
// -----------------------------------------------------------------------------
//
EXPORT_C void IMMessageUtilsPC::SendFileL(
    MCAGroupPC& aMessageRWInterfacePC,
    const MDesCArray* aSelectedNames,
    const TBool aFileProtected,
    const TDesC& aFileName,
    const TDesC8& aContentType,
    const TDesC8& aContentData,
    const TDesC& aSender /*= KNullDesC*/,
    const TDesC& aSapId /*= KNullDesC*/,
    const TDesC& aUserId /*= KNullDesC*/,
    const MDesCArray* aRecipients /*NULL*/ )
    {

    CCAEngine* engine = CCAProcessManagerFactory::InstanceL()->
                        GetProcessManager()->GetEngine();

    MCAMessageCreator& creator =
        engine->MessageUtils().MessageCreator();

    CCAGroupPC& msgRWInterface =
        static_cast <CCAGroupPC&>( aMessageRWInterfacePC );
    const MCAMessageContainerInfo& msgContainerInfo =
        msgRWInterface.ReadInterfaceL().TargetId();



    if ( !aFileProtected )
        {

        CHAT_DP( D_CHAT_LIT( "Sending file %S.." ), &aFileName );

        MCAMessageCreator::SMessageData data =
            {
            KMessageDataVersion,
            0,
            aSapId,
            aUserId,
            aSender,
            msgContainerInfo.Target(), // Recipient
            aRecipients,
            aSelectedNames,
            aFileName,
            aContentType,
            aContentData,
            MCAMessage::EMessageSent
            };

        MCAMessage* message = creator.CreateMessageL( data );
#ifdef RD_SEND_NOT_SUPPORTED_CONTENT
        if ( err != KErrNone )
            {
            message->SetProcessState( MCAMessage::EContentCorrupted );
            }
#endif //RD_SEND_NOT_SUPPORTED_CONTENT
        // Lock write interface buffer memory handling for sending
        // file, memory check is done when message is appended to
        // read container after possible image processing.
        msgRWInterface.WriteInterfaceL().LockBufferMemoryHandling( ETrue );
        msgRWInterface.WriteInterfaceL().AppendL( message );
        // Open interface
        msgRWInterface.WriteInterfaceL().LockBufferMemoryHandling( EFalse );
        }
#ifdef RD_SEND_NOT_SUPPORTED_CONTENT
    else
        {

        CHAT_DP( D_CHAT_LIT( "Sending file %S.." ), &aFileName );

        MCAMessageCreator::SMessageData data =
            {
            KMessageDataVersion,
            0,
            aSapId,
            aUserId,
            aSender,
            msgContainerInfo.Target(), // Recipient
            aRecipients,
            aSelectedNames,
            aFileName,
            aContentType,
            aContentData,
            MCAMessage::EMessageSent
            };
        MCAMessage* message = creator.CreateMessageL( data );
        message->SetProcessState(
            MCAMessage::EContentNotSupportedDrm );
        // Lock write interface buffer memory handling for sending
        // file, memory check is done when message is appended to
        // read container after possible image processing.
        msgRWInterface.WriteInterface().LockBufferMemoryHandling(
            ETrue );
        msgRWInterface.WriteInterface().AppendL( message );
        // Open interface
        msgRWInterface.WriteInterface().LockBufferMemoryHandling(
            EFalse );
        }
#endif //RD_SEND_NOT_SUPPORTED_CONTENT        
    }




// -----------------------------------------------------------------------------
// CCAMessageUtilsPC: SendMessageL
// -----------------------------------------------------------------------------
//

EXPORT_C TBool IMMessageUtilsPC::SendMessageL(
    const MCAConversationMessage& aMessage,
    const TDesC& aRecipient,
    MCAGroupPC& aMessageRWInterfacePC,
    const MDesCArray* aSelectedNames,
    const TDesC& aSender /*= KNullDesC*/,
    const TDesC& aSapId /*= KNullDesC*/,
    const TDesC& aUserId /*= KNullDesC*/,
    const TDesC& aFileName /*= KNullDesC*/,
    const MDesCArray* aRecipients /*NULL*/ )
    {

    CCAEngine* engine = CCAProcessManagerFactory::InstanceL()->
                        GetProcessManager()->GetEngine();


    MCAMessageCreator& creator =
        engine->MessageUtils().MessageCreator();
    CCAGroupPC& msgRWInterface =
        static_cast <CCAGroupPC&>( aMessageRWInterfacePC );


    MCAMessageCreator::SMessageData data =
        {
        KMessageDataVersion,
        0,
        aSapId,
        aUserId,
        aSender,
        aRecipient,
        aRecipients,
        aSelectedNames,
        aFileName,
        aMessage.MimeType(),
        aMessage.ContentData(),
        MCAMessage::EMessageSent
        };

    // Create and write
    MCAMessage* newMessage = creator.CreateMessageL( data );
    newMessage->SetProcessState( MCAMessage::EContentReady );
    msgRWInterface.WriteInterfaceL().AppendL( newMessage );

    // message handled succesfully
    return ETrue;

    }


//  End of File