/*

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

 *

 */

#include "unieditormmsplugin_p.h"

// INCLUDE FILES

#include <e32base.h>

#include <f32file.h>

#include <msvids.h> 

#include <mtclreg.h>

#include <commdb.h> 

#include <mmsconst.h>

#include <mmsclient.h>

#include <mmsheaders.h>

#include <mmssettings.h>

#include <mmsmsventry.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh> 

#include <txtetext.h>

#include <txtrich.h>

#include <txtfmlyr.h>

#include <MuiuOperationWait.h>

#include <QDir>

#include <hbglobal.h>

#include <eikrted.h>

#include <MsgMediaInfo.h>

#include <MsgMediaResolver.h>

#include "UniSendingSettings.h"

#include "unidatamodelloader.h"

#include "unidatamodelplugininterface.h"

#include "s60qconversions.h"

#include "debugtraces.h"

#include "UniEditorGenUtils.h"

// Possible values for mms validity period in seconds

const TInt32 KUniMmsValidityPeriod1h = 3600;

const TInt32 KUniMmsValidityPeriod6h = 21600;

const TInt32 KUniMmsValidityPeriod24h = 86400;

const TInt32 KUniMmsValidityPeriod3Days = 259200;

const TInt32 KUniMmsValidityPeriodWeek = 604800;

const TInt32 KUniMmsValidityPeriodMax = 0;

const TInt  KMaxDetailsLength = 64; // Copy max this many chars to TMsvEntry::iDetails

_LIT( KAddressSeparator, ";" );

#define KSenduiMtmMmsUidValue 0x100058E1

const TUid KSenduiMtmMmsUid = {KSenduiMtmMmsUidValue};

#define LOC_FWD hbTrId("txt_messaging_formlabel_fwd")

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

// Two-phased constructor.

// @see Header

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

//

CUniEditorMmsPluginPrivate* CUniEditorMmsPluginPrivate::NewL()

{

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

    return self;

}

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

// Destructor

// @see Header

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

//

CUniEditorMmsPluginPrivate::~CUniEditorMmsPluginPrivate()

{

    //In case there is no settings at all leave occurs and resource not freed

    delete iMmsHeader;

    delete iEditor;

    delete iDom;

    delete iUniDataModel;

    ifsSession.Close();

    delete iMmsMtm;

    delete iMtmRegistry;

    delete iDataModelPluginLoader;

    delete iSession;

}

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

// C++ default constructor

// @see Header

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

//

CUniEditorMmsPluginPrivate::CUniEditorMmsPluginPrivate( )

{

    iSession = CMsvSession::OpenSyncL(*this);

}

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

// convertFromL

// @see Header

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

//

ConvergedMessage* CUniEditorMmsPluginPrivate::convertFromL( TMsvId aId,

    UniEditorPluginInterface::EditorOperation aOperation )

{

    QDEBUG_WRITE("Enter convertFromL");

    MmsMtmL()->SwitchCurrentEntryL( aId );

    MmsMtmL()->LoadMessageL();

    TMsvEntry entry =MmsMtmL()->Entry().Entry();

    ConvergedMessage* msg = new ConvergedMessage;

    CleanupStack::PushL(msg);

    if( entry.Parent() == KMsvDraftEntryIdValue )

    {

       convertFromDraftsL(*msg);

    }

    else if( aOperation == UniEditorPluginInterface::Forward)

    {

        convertFromForwardHandlerL(*msg);          

    }

    CleanupStack::Pop(msg);

    QDEBUG_WRITE("Exit convertFromL");

    return msg;

}

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

// convertFromDraftsL

// @see Header

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

//

void CUniEditorMmsPluginPrivate::convertFromDraftsL(

    ConvergedMessage& aMessage )

{

    QDEBUG_WRITE("Enter convertFromDraftsL");

    TMsvEntry entry =MmsMtmL()->Entry().Entry();

    //Message id 

    ConvergedMessageId id(entry.Id());

    aMessage.setMessageId(id);

    // Set Message type

    aMessage.setMessageType(ConvergedMessage::Mms);

    //Populate recipients

    populateRecipientsL(aMessage);

    //populate convergedmessage with the subject

    aMessage.setSubject(S60QConversions::s60DescToQString(

        MmsMtmL()->SubjectL()));

    // Priority

    TMsvPriority priority = entry.Priority();

    if( EMsvHighPriority == priority )

    {

        aMessage.setPriority(ConvergedMessage::High);

    }

    else if( EMsvLowPriority == priority )

    {

        aMessage.setPriority(ConvergedMessage::Low);

    }

    else if( EMsvMediumPriority == priority )

    {

        aMessage.setPriority(ConvergedMessage::Normal);

    }

    // Set direction and location

    aMessage.setDirection(ConvergedMessage::Outgoing);

    aMessage.setLocation (ConvergedMessage::Draft);

    //Populate body and attachments

    populateMessageBodyL(aMessage);

    QDEBUG_WRITE("Exit convertFromDraftsL");

}

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

// convertFromForwardHandlerL

// @see Header

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

//

void CUniEditorMmsPluginPrivate::convertFromForwardHandlerL(

    ConvergedMessage &aMessage)

{

    QDEBUG_WRITE("Enter convertFromForwardHandlerL");

    TMsvEntry entry =MmsMtmL()->Entry().Entry();

    //populate convergedmessage with the subject prepended with FW:

    QString subject = LOC_FWD + S60QConversions::s60DescToQString(

        MmsMtmL()->SubjectL());     

    aMessage.setSubject(subject);

    // Priority

    TMsvPriority priority = entry.Priority();

    if( EMsvHighPriority == priority )

    {

        aMessage.setPriority(ConvergedMessage::High);

    }

    else if( EMsvLowPriority == priority )

    {

        aMessage.setPriority(ConvergedMessage::Low);

    }

    else if( EMsvMediumPriority == priority )

    {

        aMessage.setPriority(ConvergedMessage::Normal);

    }

    //Populate body and attachments

    //The region info inside slides is not maintained

    populateMessageBodyL(aMessage);

    QDEBUG_WRITE("Exit convertFromForwardHandlerL");

}

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

// populateMessageBodyL

// @see Header

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

//

void CUniEditorMmsPluginPrivate::populateMessageBodyL(

    ConvergedMessage &aMessage)

{

    QDEBUG_WRITE("Enter populateMessageBodyL");

    if(!iDataModelPluginLoader)

    {

        iDataModelPluginLoader = new UniDataModelLoader;  

        iMmsDataPlugin = iDataModelPluginLoader->getDataModelPlugin(ConvergedMessage::Mms);

    }

    iMmsDataPlugin->restore(*MmsMtmL());

    int slideCount = iMmsDataPlugin->slideCount();

    int attachmentCount = iMmsDataPlugin->attachmentCount();

    ConvergedMessageAttachmentList attachmentList;

    if (slideCount > 0)

    {

        UniMessageInfoList slideContentList = 

            iMmsDataPlugin->slideContent(0);

        for (int i = 0; i < slideContentList.size(); ++i)

        {

            if( slideContentList.at(i)->mimetype().contains("text") )

            {

                QString textContent;

                QFile file(slideContentList.at(i)->path());

                file.open(QIODevice::ReadOnly);

                textContent = file.readAll();

                aMessage.setBodyText(textContent);

                file.close();

            }

            else

            {

            ConvergedMessageAttachment* attachment =

                new ConvergedMessageAttachment(

                    slideContentList.at(i)->path(),

                    ConvergedMessageAttachment::EInline);

            attachmentList << attachment;

            }

        }

        foreach(UniMessageInfo* slide,slideContentList)

        {

            delete slide;

        }

    }

    if(attachmentCount > 0)

    {

        UniMessageInfoList modelAttachmentList = 

            iMmsDataPlugin->attachmentList();

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

        {

            ConvergedMessageAttachment* attachment =

                new ConvergedMessageAttachment(

                    modelAttachmentList.at(i)->path(),

                    ConvergedMessageAttachment::EAttachment);

            attachmentList << attachment;

        }

        foreach(UniMessageInfo* attachment,modelAttachmentList)

        {

            delete attachment;

        }

    }

    if(attachmentList.count() > 0)

    {

        aMessage.addAttachments(attachmentList);

    }       

    //Delete the pluginloader instance

    delete iDataModelPluginLoader;

    iDataModelPluginLoader = NULL;

    iMmsDataPlugin = NULL;

    QDEBUG_WRITE("Exit populateMessageBodyL");

}

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

// convertToL

// @see Header

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

//

TMsvId CUniEditorMmsPluginPrivate::convertToL(ConvergedMessage *aMessage)

{

    QDEBUG_WRITE("Enter ConvertToL");

    // create message in drafts.

    CMsvEntry* cEntry = MmsMtmL()->Session().GetEntryL(KMsvDraftEntryId);

    CleanupStack::PushL(cEntry);

    MmsMtmL()->SwitchCurrentEntryL(cEntry->EntryId());

    TMsvEntry entry;

    entry.iMtm = MmsMtmL()->Type();

    entry.iType = KUidMsvMessageEntry;

    entry.iServiceId = MmsMtmL()->DefaultServiceL();

    entry.iDate.UniversalTime();

    cEntry->CreateL(entry);

    TMsvId entryId = entry.Id();

    //Since entry is created if any of the below functions leave 

    //the created entry has to be deleted

    TInt error = KErrNone;

    TRAP(error,DoConvertToL(aMessage,entry));

    CleanupStack::PopAndDestroy(cEntry);

    if (error != KErrNone)

    {

        this->deleteDraftsEntryL(entryId);

        entryId = -1; //Set Invalid entry id

    }

    QDEBUG_WRITE_FORMAT("Exit ConvertToL the entryId= ",entryId);

    return entryId;

}

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

// DoConvertToL

// @see Header

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

//

void CUniEditorMmsPluginPrivate::DoConvertToL(ConvergedMessage *aMessage,

    TMsvEntry& entry)

{

    TMsvId entryId = entry.Id();

     // switch to created entry

     MmsMtmL()->SwitchCurrentEntryL(entryId);

     //Add recipients

     addRecipientsL(aMessage);

     //There is no size check inside plugin as it assumes 

     //we get proper data from editor

     HBufC* sub = S60QConversions::qStringToS60Desc(aMessage->subject());

     if( sub )

     {

         CleanupStack::PushL(sub);

         MmsMtmL()->SetSubjectL( *sub );

         CleanupStack::PopAndDestroy(sub);

     }

     //Add attachments

     // fetch attachment list and populate the smil model

     ConvergedMessageAttachmentList attachmentlist = aMessage->attachments();

     int attachmentcount = attachmentlist.count();

     if ((attachmentcount> 0) || !(aMessage->bodyText().isEmpty()))

     {

        QDEBUG_WRITE("Before calling iUniDataModel->restore");

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

        delete iUniDataModel;

        iUniDataModel = NULL;

        iUniDataModel = CUniDataModel::NewL(ifsSession, *MmsMtmL());

        iUniDataModel->RestoreL(*this, ETrue);

        QDEBUG_WRITE("Before calling iUniDataModel->addSlide");

        bool slideContentAdded = false;

        //Adding first slide

        iUniDataModel->SmilModel().AddSlideL(0);

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

        {

            if (attachmentlist[i]->attachmentType()

                    == ConvergedMessageAttachment::EInline)

            {

                slideContentAdded = true;

                addObjectL(0, attachmentlist[i]->filePath());

            }

            else if (attachmentlist[i]->attachmentType()

                    == ConvergedMessageAttachment::EAttachment)

            {

                addAttachmentL(attachmentlist[i]->filePath());

            }

        }

        if (! (aMessage->bodyText().isEmpty()))

        {

            slideContentAdded = true;

            addTextObjectL(0, aMessage->bodyText());

        }

        if (slideContentAdded)

        {

            iUniDataModel->ObjectList().SaveAll(*this, CMsvAttachment::EMsvFile);

            // Open store even if we didn't need it here.

            // -> We don't need to check later whether the store 

            //is open or not.    

            CMsvStore* editStore = MmsMtmL()->Entry().EditStoreL();

            //Ensure that the store is deleted if anything 

            //leaves before deletion otherwise the entry store will be locked

            //and entry cant be deleted

            CleanupStack::PushL(editStore);

            delete iDom;

            iDom = NULL;

            iDom = iUniDataModel->SmilModel().ComposeL();

            iUniDataModel->SmilList().CreateSmilAttachmentL(*this,

                                                            *editStore,

                                                            iDom);

             //Commit the store before setting the root

             editStore->CommitL();

             //delete the store before setMessageRoot is called

             CleanupStack::PopAndDestroy(editStore);

            //Set message root after composing SMIL but before 

            //calling SaveMessageL and after the store has been deleted

            MmsMtmL()->SetMessageRootL(iUniDataModel->SmilList().GetSmilAttachmentByIndex(0));

        }

        else

        {

            //Remove the slide   

            iUniDataModel->SmilModel().RemoveSlide(0);

             // Open store even if we didn't need it here.

             // -> We don't need to check later whether the store is open or not.    

             CMsvStore* editStore = MmsMtmL()->Entry().EditStoreL();

             //Ensure that the store is deleted if anything 

             //leaves before deletion otherwise the entry store will be locked

             //and entry cant be deleted

             CleanupStack::PushL(editStore);

             //Commit the store before setting the root

             editStore->CommitL();

             //delete the store before setMessageRoot is called

             CleanupStack::PopAndDestroy(editStore);

         }

     }

     //Set the priority before calling save

     ConvergedMessage::Priority priority = aMessage->priority();

     if (ConvergedMessage::High == priority)

     {

         MmsMtmL()->SetMessagePriority(EMmsPriorityHigh);

     }

     else if (ConvergedMessage::Low == priority)

     {

         MmsMtmL()->SetMessagePriority(EMmsPriorityLow);

     }

     else if (ConvergedMessage::Normal == priority)

     {

         MmsMtmL()->SetMessagePriority(EMmsPriorityNormal);

     }

     //Saving the changes

     MmsMtmL()->SaveMessageL();

     entry = MmsMtmL()->Entry().Entry();

     TBuf<KMaxDetailsLength> detailsBuf;

     MakeDetailsL( detailsBuf );

     entry.iDetails.Set( detailsBuf );

     MmsMtmL()->Entry().ChangeL(entry); // commit changes      

}

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

// sendL

// @see Header

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

//

void CUniEditorMmsPluginPrivate::sendL( TMsvId aId )

{

    QDEBUG_WRITE("Enter sendL");

    MmsMtmL()->SwitchCurrentEntryL( aId );

    MmsMtmL()->LoadMessageL();

    CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

    CMsvOperation* oper = MmsMtmL()->SendL( wait->iStatus );

    CleanupStack::PushL( oper );

    wait->Start();

    CleanupStack::PopAndDestroy( oper );

    CleanupStack::PopAndDestroy( wait );