/*

* 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: 

*

*/

#include "engine.h"

#include "enginewrapper.h"

#include "creator_message.h" 

#include "creator_traces.h"

#include "creator_contactsetcache.h"

#include <apgcli.h>

#include <MuiuServiceUtilities.h>

#include <utf.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // for CleanupResetAndDestroyPushL

//static const TInt KMessagesFieldLength = 1024;

//_LIT(KCreatorMessagesPrefixName, "CR_");

//_LIT(KCreatorMessagesPrefixFolderName, "CR_FLDR_");

const TUid KUidBIOBusinessCardMsg =  {0x10005531}; 

_LIT(KEmpty, "");

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

CMessagesParameters::CMessagesParameters()

    {

    LOGSTRING("Creator: CMessagesParameters::CMessagesParameters");

    iSenderAddress = HBufC::New(128);

    iRecipientAddress = HBufC::New(128);

    iMessageSubject = HBufC::New(128);

    iMessageBodyText = HBufC::New(10240);

    TRAP_IGNORE(iAttachments = new(ELeave) CArrayFixFlat<TInt>(64));

    iCreateAsUnread = ETrue;

    }

CMessagesParameters::~CMessagesParameters()

    {

    LOGSTRING("Creator: CMessagesParameters::~CMessagesParameters");

    delete iMessageBodyText;

    delete iMessageSubject;

    delete iRecipientAddress;

    delete iSenderAddress;

    delete iAttachments;

    iAttachmentPaths.ResetAndDestroy();

    iAttachmentPaths.Close(); 

    iRecipientAddressArray.ResetAndDestroy();

    iRecipientAddressArray.Close();

    iRecipientLinkIds.Close();

    iSenderLinkIds.Close();

    }

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

CCreatorMessages* CCreatorMessages::NewL(CCreatorEngine* aEngine)

    {

    CCreatorMessages* self = CCreatorMessages::NewLC(aEngine);

    CleanupStack::Pop(self);

    return self;

    }

CCreatorMessages* CCreatorMessages::NewLC(CCreatorEngine* aEngine)

    {

    CCreatorMessages* self = new (ELeave) CCreatorMessages;

    CleanupStack::PushL(self);

    self->ConstructL(aEngine);

    return self;

    }

CCreatorMessages::CCreatorMessages()

    {

    }

void CCreatorMessages::ConstructL(CCreatorEngine* aEngine)

    {

    LOGSTRING("Creator: CCreatorMessages::ConstructL");

    iEngine = aEngine;

    TRAP_IGNORE(iAttachments = new(ELeave) CArrayFixFlat<TInt>(64));

    iWaiter = CAsyncWaiter::NewL();

    }

CCreatorMessages::~CCreatorMessages()

    {

    LOGSTRING("Creator: CCreatorMessages::~CCreatorMessages");

    if ( iEngine && iEntryIds.Count() )

        {

        TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidMessages ) );

        }

    iEntryIds.Reset();

    iEntryIds.Close();

    delete iParameters;

    delete iWaiter;

    delete iTmpPhoneNumber;

    delete iTmpEmail;

    delete iAttachments;

    iRecipientArray.ResetAndDestroy();

    iRecipientArray.Close();

    iSenderArray.ResetAndDestroy();

    iSenderArray.Close();

    }

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

void CCreatorMessages::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData)

    {

    LOGSTRING("Creator: CCreatorMessages::QueryDialogClosedL");  

    if( aPositiveAction == EFalse )

        {

        iEngine->ShutDownEnginesL();

        return;

        }

    const TDesC* showText = &KSavingText;

    TBool finished(EFalse);

    TBool retval(ETrue);

    switch(aUserData)

        {

        case ECreatorMessagesDelete:

            showText = &KDeletingText;

            iEntriesToBeCreated = 1;

            finished = ETrue;

            break;

        case ECreatorMessagesStart:

            // message type query

            retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message type"), R_MESSAGE_TYPE_QUERY, (TInt*) &iMessageType, this, ECreatorMessagesMessageType);

            break;

        case ECreatorMessagesMessageType:

            retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Folder type"), R_FOLDER_TYPE_QUERY, (TInt*) &iFolderType, this, ECreatorMessagesFolderType);

            break;

        case ECreatorMessagesFolderType:

            // query create as unread

            retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message status"), R_UNREAD_QUERY, (TInt*)&iCreateAsUnread, this, ECreatorMessagesMessageStatus);

            break;

        case ECreatorMessagesMessageStatus:

            if( iMessageType == ESMS || iMessageType == EMMS || iMessageType == EEmail )

                {

                iDefinedMessageLength = 100;

                retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iDefinedMessageLength, _L("Amount of characters in message body?"), ETrue, 

                    this, ECreatorMessagesCharsInBody

                    );

                break;

                }

            else

                {

                iDefinedMessageLength = 0;

                // goto query attachments ... :-) DO NOT break;

                }

        case ECreatorMessagesCharsInBody:

            // query attachments

            iAttachments->Reset();

            if( iMessageType == EMMS || iMessageType == EEmail)

                {

                retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_MULTI_SELECTION_QUERY, 

                    iAttachments, this, ECreatorMessagesAttachment

                    );

                }

            else if( iMessageType == EAMS )

                {

                iAttachments->AppendL( TInt(0) );

                retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_AMS_ATTACHMENT_SINGLE_SELECTION_QUERY, 

                    &iAttachments->At(0), this, ECreatorMessagesAttachment

                    );

                }

            else if( iMessageType == EIrMessage || iMessageType == EBTMessage )

                {

                iAttachments->AppendL( TInt(0) );

                retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_SINGLE_SELECTION_QUERY,

                    &iAttachments->At(0), this, ECreatorMessagesAttachment

                    );

                }

            else

                {

                finished = ETrue;

                }

            break;

        case ECreatorMessagesAttachment:

            finished = ETrue;

            if(iMessageType== EMMS || iMessageType == EEmail)

                {

                // "none" is selected

                if (iAttachments->At(0) == 0)

                    {

                    iAttachments->Reset();

                    }

                else  // otherwise fix indexes

                    {

                    for (TInt i=0; i<iAttachments->Count(); i++)

                        iAttachments->At(i)--;  // decrease value by one 

                    }

                }

            break;

        default:

            //some error

            retval = EFalse;

            break;

        }

    if( retval == EFalse )

        {

        iEngine->ShutDownEnginesL();

        }

    else if( finished )

        {

        // add this command to command array

        iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated);

        // started exucuting commands

        iEngine->ExecuteFirstCommandL( *showText );

        }

    }

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

TBool CCreatorMessages::AskDataFromUserL(TInt aCommand)

    {

    LOGSTRING("Creator: CCreatorMessages::AskDataFromUserL");

    CCreatorModuleBase::AskDataFromUserL(aCommand);

    if ( aCommand == ECmdDeleteMessages )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all messages?"), this, ECreatorMessagesDelete );

        }

    else if ( aCommand ==  ECmdDeleteCreatorMessages )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all messages created with Creator?"), this, ECreatorMessagesDelete  );

        }

    return iEngine->GetEngineWrapper()->EntriesQueryDialog( &iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorMessagesStart );

    }

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

TInt CCreatorMessages::CreateRandomMessageEntryL(TInt aCommand)

    {

    LOGSTRING2("Creator: CCreatorMessages::CreateRandomMessageEntryL - Command: %d", aCommand);

    TInt err = KErrNone;

    iDefinedMessageLength = iEngine->RandomNumber(100, 300);

    switch (aCommand)

        {

	    case ECmdCreateRandomEntrySMSInbox:     { iMessageType=ESMS; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntrySMSDrafts:    { iMessageType=ESMS; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntrySMSOutbox:    { iMessageType=ESMS; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntrySMSSent:      { iMessageType=ESMS; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

        case ECmdCreateRandomEntryMMSInbox:     { iMessageType=EMMS; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryMMSDrafts:    { iMessageType=EMMS; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryMMSOutbox:    { iMessageType=EMMS; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}    

	    case ECmdCreateRandomEntryMMSSent:      { iMessageType=EMMS; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

        case ECmdCreateRandomEntryEmailInbox:   { iMessageType=EEmail; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryEmailDrafts:  { iMessageType=EEmail; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryEmailOutbox:  { iMessageType=EEmail; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryEmailSent:    { iMessageType=EEmail; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

        case ECmdCreateRandomEntryBIOInbox:     { iMessageType=ESmartMessage; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryBIODrafts:    { iMessageType=ESmartMessage; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryBIOOutbox:    { iMessageType=ESmartMessage; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryBIOSent:      { iMessageType=ESmartMessage; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

        case ECmdCreateRandomEntryIRInbox:      { iMessageType=EIrMessage; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryIRDrafts:     { iMessageType=EIrMessage; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryIROutbox:     { iMessageType=EIrMessage; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryIRSent:       { iMessageType=EIrMessage; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

        case ECmdCreateRandomEntryBTInbox:      { iMessageType=EBTMessage; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryBTDrafts:     { iMessageType=EBTMessage; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryBTOutbox:     { iMessageType=EBTMessage; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryBTSent:       { iMessageType=EBTMessage; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryAMSInbox:     { iMessageType=EAMS; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryAMSDrafts:     { iMessageType=EAMS; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryAMSOutbox:     { iMessageType=EAMS; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

	    case ECmdCreateRandomEntryAMSSent:     { iMessageType=EAMS; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

	    default: { User::Panic(_L("MessageCommand"), 901);  break;}

        }

    return err;

    }

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

TInt CCreatorMessages::CreateMessageEntryL(CMessagesParameters *aParameters, TBool /*aTakeUserGivenParameters*/)

    {

    LOGSTRING("Creator: CCreatorMessages::CreateMessageEntryL");

    delete iParameters;

    iParameters = 0;   

    CMessagesParameters* parameters = aParameters;

    // random data needed if no predefined data available

    if (!parameters)

        {

        iParameters = new(ELeave) CMessagesParameters;

        parameters = iParameters;

        // check if values from ui needed

        //if (aTakeUserGivenParameters)

        //    {            

            parameters->iMessageType = iMessageType;

            parameters->iFolderType = iFolderType;

            parameters->iDefinedMessageLength = iDefinedMessageLength;

            parameters->iCreateAsUnread = iCreateAsUnread;

            for (TInt i=0; i<iAttachments->Count(); i++)

                parameters->iAttachments->AppendL(iAttachments->At(i)); 

        //    }

        //else

        //    {

            // message length

        //    parameters->iDefinedMessageLength = iEngine->RandomNumber(100, 300);

        //    }    

        if (parameters->iMessageType == EEmail)

            {

            parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

            parameters->iSenderAddress->Des().Append( _L("@") );

            parameters->iSenderAddress->Des().Append( iEngine->RandomString(CCreatorEngine::ECompany) );

            parameters->iSenderAddress->Des().Append( _L(".com") );

            parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

            parameters->iRecipientAddress->Des().Append( _L("@") );

            parameters->iRecipientAddress->Des().Append( iEngine->RandomString(CCreatorEngine::ECompany) );

            parameters->iRecipientAddress->Des().Append( _L(".net") );

            }

        else if (parameters->iMessageType == EIrMessage || parameters->iMessageType == EBTMessage)

            {

            parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

            parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

            }

        else

            {

            parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EPhoneNumber) );

            parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EPhoneNumber) );

            }

        // subject

        parameters->iMessageSubject->Des() = iEngine->RandomString(CCreatorEngine::EMessageSubject);

        // message body

        parameters->iMessageBodyText->Des().Copy(_L(""));

        TPtrC randText = iEngine->RandomString(CCreatorEngine::EMessageText);

        for (TInt i=0; i<parameters->iDefinedMessageLength / randText.Length() +1; i++)

            {

            parameters->iMessageBodyText->Des().Append( randText );

            parameters->iMessageBodyText->Des().Append( _L(" ") );

            }

        parameters->iMessageBodyText->Des() = parameters->iMessageBodyText->Des().Left(parameters->iDefinedMessageLength);

        // BIO message type (from bitsids.h)  // TO-DO: add support for all BIO message types...

        parameters->iBIOMessageType = KUidBIOBusinessCardMsg;

        }

    TInt err = KErrNone;

    switch (parameters->iMessageType)

        {

        case ESMS:          { err = CreateSMSEntryL(*parameters);  break; }

        case EMMS:          { err = CreateMMSEntryL(*parameters);  break; }

        case EAMS:          { err = CreateAMSEntryL(*parameters);  break; }

        case EEmail:        { err = CreateEmailEntryL(*parameters);  break; }

        case ESmartMessage: { err = CreateSmartMessageEntryL(*parameters);  break; }

        case EIrMessage:    { err = CreateObexEntryL( TUid::Uid(KUidMsgTypeIrTInt32), *parameters );  break; }    

        case EBTMessage:    { err = CreateObexEntryL( TUid::Uid(KUidMsgTypeBtTInt32), *parameters );  break; }

        default:            { User::Panic(_L("MsgType"), 851);  break;}

        }

    iSenderArray.ResetAndDestroy();

    iRecipientArray.ResetAndDestroy();

    return err;

    }

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

TInt CCreatorMessages::CreateSMSEntryL(const CMessagesParameters& parameters)

    {

    LOGSTRING("Creator: CCreatorMessages::CreateSMSEntryL");

    TInt err = KErrNone;

    // init

    CMsvSession* session = CMsvSession::OpenSyncL(*this);

    CleanupStack::PushL(session);

    CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);

    CleanupStack::PushL(registry);

    // get the client mtm and return if it isn't supported in the system        

    CSmsClientMtm* clientMtm = NULL;

    TRAP(err, clientMtm = static_cast<CSmsClientMtm*>(registry->NewMtmL(KUidMsgTypeSMS)));

    if (err || !clientMtm)

        {

        iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Message type module not found"));

        CleanupStack::PopAndDestroy(2);

        User::Leave(KErrNotFound);

        }  

    CleanupStack::PushL(clientMtm);   

    // create a new object to access an existing entry

    CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

    CleanupStack::PushL(msvEntry);

    // get default service

    TMsvId defaultServiceId = 0;

    TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());

    if (err)

        {

        iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Define a SMS centre first"));

        CleanupStack::PopAndDestroy(2);

        User::Leave(KErrNotFound);

        } 

    // set folder type

    switch (parameters.iFolderType)

        {

        case EInbox:    { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);   break; }

        case EDrafts:   { msvEntry->SetEntryL(KMsvDraftEntryId);              break; }

        case EOutbox:   { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);  break; }

        case ESent:     { msvEntry->SetEntryL(KMsvSentEntryId);               break; }

        default:        { User::Panic(_L("Folder Type"), 871);                break; } 

        }

    // mtm takes ownership of entry context	

    CleanupStack::Pop(msvEntry);

    clientMtm->SetCurrentEntryL(msvEntry);    

    // create a new message

    clientMtm->CreateMessageL(defaultServiceId);

    // set the from field to sms header

    // !!! This will cause CRASH

    /*if (parameters.iFolderType == EInbox)

        {

        CSmsHeader* smsHeader = &clientMtm->SmsHeader();

        delete smsHeader; // <-- This will cause CRASH

        smsHeader = NULL;

        smsHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, clientMtm->Body());        

        if( parameters.iSenderAddress )

            {

            smsHeader->SetFromAddressL( parameters.iSenderAddress->Des() );

            }

        else

            {

            smsHeader->SetFromAddressL(KEmpty);

            }

        }       */

    // set body

    clientMtm->Body().Reset();

    clientMtm->Body().InsertL(0, parameters.iMessageBodyText->Des());        

    // get the entry of the message

    TMsvEntry messageEntry = clientMtm->Entry().Entry();

    // set the details field

    if (parameters.iFolderType == EInbox)

        {

        SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

        }

    else

        {

        SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

        // Add all recipients to clientMtm

        // iRecipientArray is up-to-date so don't call AddRecipientsL here 

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

            {

            clientMtm->AddAddresseeL( iRecipientArray[i]->Des() );

            }

        }

    // set the sending state for outbox message

    // to avoid SMSMtmUI:15 panic in messages application

    if (parameters.iFolderType == EOutbox )

        {

        messageEntry.SetSendingState( KMsvSendStateWaiting );

        }

    // set the description field same as the first part of the message body

    messageEntry.iDescription.Set( parameters.iMessageBodyText->Des().Left(KSmsDescriptionLength) );

    // save the changes done above

    clientMtm->Entry().ChangeL(messageEntry);

    // save the message     

    clientMtm->SaveMessageL();

	// final fine tuning

    messageEntry.SetAttachment(EFalse);

    messageEntry.iDate.HomeTime();

    messageEntry.SetVisible(ETrue);

    messageEntry.SetInPreparation(EFalse);

    if (parameters.iCreateAsUnread)

        {

        messageEntry.SetUnread(ETrue);

        messageEntry.SetNew(ETrue);

        }

    else

        {