/*

* 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 <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();

    }

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

TBool CCreatorMessages::AskDataFromUserL(TInt aCommand, TInt& aNumberOfEntries)

    {

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

    if ( aCommand == ECmdDeleteMessages )

        {

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

        }

    else if ( aCommand ==  ECmdDeleteCreatorMessages )

        {

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

        }

    if (iEngine->GetEngineWrapper()->EntriesQueryDialog(aNumberOfEntries, _L("How many entries to create?")))

        {

        // message type query

        if (iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message type"), R_MESSAGE_TYPE_QUERY, (TInt&) iMessageType))

            {

			if (iEngine->GetEngineWrapper()->ListQueryDialog(_L("Folder type"), R_FOLDER_TYPE_QUERY, (TInt&) iFolderType))

                {

                /*

                if (iFolderType == EMailbox)

                    {

                    // array to hold mailbox names

                    CDesCArray* names = new (ELeave) CDesCArrayFlat(16);

                    CleanupStack::PushL(names);                    

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

                    CleanupStack::PushL(session);

                    // generate list of mailboxes

                    CMsvEntrySelection* entrySelection = MsvUiServiceUtilities::GetListOfAccountsWithMTML(*session, KUidMsgTypeSMTP, ETrue);

                    CleanupStack::PushL(entrySelection);

                    TBool doReturn(EFalse);

                    if (entrySelection->Count() == 0)

                        {

                        CAknInformationNote* note = new(ELeave) CAknInformationNote;

                        note->ExecuteLD(_L("No mailboxes found"));

                        doReturn = ETrue;

                        }

                    else

                        {

                        // get mailbox names

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

                            {

                            CMsvEntry* centry = session->GetEntryL(entrySelection->At(i));

                            CleanupStack::PushL(centry);

                            TMsvEntry tentry = centry->Entry();

                            names->AppendL(tentry.iDetails);

                            CleanupStack::PopAndDestroy(); //centry

                            }

                        // show query

                        TInt index(0);

                        CAknListQueryDialog* dlg = new(ELeave) CAknListQueryDialog(&index);

                        dlg->PrepareLC(R_MAILBOX_SELECTION_QUERY);

                        dlg->SetItemTextArray(names);

                        dlg->SetOwnershipType(ELbmDoesNotOwnItemArray);

                        if(dlg->RunLD())

                            {

                            iUserSelectedMailbox = entrySelection->At(index);

                            doReturn = EFalse;

                            }

                        else

                            {

                            doReturn = ETrue;

                            }    

                        }

                    CleanupStack::PopAndDestroy(3); // names, session, entrySelection

                    if (doReturn)

                        return EFalse;                    

                    }

                */

                // query create as unread

                if (iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message status"), R_UNREAD_QUERY, (TInt&)iCreateAsUnread))

                    {                

                    // query number of characters in msg body

                    switch (iMessageType)

                        {

                        case ESMS:

                        case EMMS:

                        case EEmail:

                            {

                            iDefinedMessageLength = 100;

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

                                {

                                ;

                                }

                            else

                                return EFalse;

                            break;

                            }

                        case EAMS:

                        	{

                        	iDefinedMessageLength = 0;

                        	break;

                        	}

                        default: break;

                        }

                    // query attachments

                    iAttachments->Reset();

                    switch (iMessageType)

                        {

                        case EMMS:

                        case EEmail:

                            {

                            if (iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_MULTI_SELECTION_QUERY, iAttachments))

                                {

                                // "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 

                                    }

                                }

                            else

                                return EFalse;

                            break;

                            }

                        case EAMS:

                        	{

                            iAttachments->AppendL( TInt(0) );

                            if (iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_AMS_ATTACHMENT_SINGLE_SELECTION_QUERY, iAttachments->At(0)))

                                {

                                ;

                                }

                            else

                                return EFalse;                        

                            break;

                        	}

                        case EIrMessage:

                        case EBTMessage:

                            {

                            iAttachments->AppendL( TInt(0) );

                            if (iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_SINGLE_SELECTION_QUERY, iAttachments->At(0)))

                                {

                                ;

                                }

                            else

                                return EFalse;                        

                            break;

                            }

                        default: break;

                        }

                    return ETrue;  // all queries accepted

                    }

                else

                    return EFalse;

                }

            else

                return EFalse;

            }

        else

            return EFalse;

        }

    // else

        return EFalse;

    }

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

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

    if (parameters.iFolderType == EInbox)

        {

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

        delete smsHeader;

        smsHeader = NULL;

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

        if( parameters.iSenderAddress )

            {

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

            }

        else

            {

            smsHeader->SetFromAddressL(KEmpty);