/*

* Copyright (c) 2005-2007 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: UniClientMtm implementation

*

*/

// INCLUDE FILES 

#include <txtrich.h>

#include <msvids.h>

#include <badesca.h>

#include <msvstore.h>

#include <mtmuids.h> 

#include <mtclbase.h>

#include <mtmdef.h>

#include <msvftext.h>       // CMsvFindText 

#include <cmsvmimeheaders.h>

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#include <msgtextutils.h>

#include <mmsgenutils.h>

#include <mmsattachmentwaiter.h>

#include <mmsattachmenthandler.h>

#include "UniMsvEntry.h"

#include "UniMtmPanic.h"

#include "UniHeaders.h"

#include "UniClientMtm.h"

#include "UniEditorUids.hrh"

#include "UniEditorLogging.h"

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

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

// Factory function

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

// 

EXPORT_C CUniClientMtm* CUniClientMtm::NewL(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aSession )

    {

    CUniClientMtm* self=new ( ELeave ) CUniClientMtm(

        aRegisteredMtmDll, aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

// 

CUniClientMtm::CUniClientMtm(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aSession )

    : CBaseMtm( aRegisteredMtmDll, aSession ),

    iUniHeaders ( NULL )

    {

    }

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

// Destructor

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

//     

CUniClientMtm::~CUniClientMtm()

    {

    delete iAttaWaiter;

    delete iUniHeaders;

    delete iTextUtils;

    }

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

// CUniClientMtm::CreateNewEntryL

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

//

TMsvId CUniClientMtm::CreateNewEntryL( TMsvId aDestination )

    {

    UNILOGGER_WRITE_TIMESTAMP( "CUniClientMtm::CreateNewEntryL start" );

    // Create new message entry

    TMsvEntry entry;

    entry.iType = KUidMsvMessageEntry;

    entry.iServiceId = KMsvLocalServiceIndexEntryId;

    entry.iMtm = TUid::Uid( KUidUniMtm );

    entry.iDate.UniversalTime();

    // The following ones will be set in completion.

    entry.SetInPreparation( ETrue );    

    entry.SetVisible( EFalse );         

    entry.iSize = 0;

    // Check that sufficient disk space available

    // for index entry

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(

            &Session().FileSession(), 

            sizeof( TMsvEntry ),

            Session().CurrentDriveL() ) )

        {

        // we use standard error code here

        User::Leave( KErrDiskFull );

        }

    SwitchCurrentEntryL( aDestination );

    iMsvEntry->CreateL( entry );

    SwitchCurrentEntryL( entry.Id() );

    UNILOGGER_WRITE_TIMESTAMP( "CUniClientMtm::CreateNewEntryL end" );

    return entry.Id();

    }

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

// METHODS FROM BASE CLASS

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

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

// CUniClientMtm::SaveMessageL

// Stores the multimedia message

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

//

void CUniClientMtm::SaveMessageL()

    {

    // First we should assert that iMsvEntry is not NULL, and panic, if it is

    __ASSERT_DEBUG( iMsvEntry!=NULL, Panic( EUniNotAMessage ));

    // SaveMessageL should only be supported for message entries.

    __ASSERT_DEBUG( iMsvEntry->Entry().iType.iUid == KUidMsvMessageEntryValue,

        Panic( EUniNotAMessage ) );

    CMsvStore* store = iMsvEntry->EditStoreL();

    CleanupStack::PushL( store );

    TMsvEntry indexEntry = iMsvEntry->Entry();

    SaveMessageL( *store, indexEntry ); 

    // Commit the stream store

    store->CommitL();

    CleanupStack::PopAndDestroy( store );

    // commit the index changes.

    iMsvEntry->ChangeL( indexEntry );

    }

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

// CUniClientMtm::SaveMessageL

// Stores the multimedia message

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

//

void CUniClientMtm::SaveMessageL( CMsvStore& aEditStore, TMsvEntry& aEntry ) 

    {

    // Store headers of a message

    // Because of attachments are handled using the new

    // attacment manager, the caller must store and commit the attachments

    // either one by one or after all have been added.

    // After saving all attachments the edit store used for that purpose

    // must be freed.

    // The store must be freed because all attachment info and uni headers

    // are saved in the actual message entry, there are no separate 

    // attachment entries anymore.

    // Check that sufficient disk space available

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL( 

        &Session().FileSession(), 

        iUniHeaders->Size(),

        iMessageDrive ) )

        {

        User::Leave( KErrDiskFull );

        }

    // Note: Body text not supported.

    iUniHeaders->StoreL( aEditStore );

    // needed to convert unimessages to sms messages

    StoreBodyL( aEditStore ); 

    // attachment size

    TInt32 totalSizeOfAllAttachments = AttachmentsSizeL( aEditStore );

    aEntry.iSize = iUniHeaders->Size() + totalSizeOfAllAttachments;

    // If there are multiple recipients then set the flag

    if (( iUniHeaders->ToRecipients().Count() + //lint !e115 !e1013 !e48 !e10 !e1055 !e746 !e628

        iUniHeaders->CcRecipients().Count() +  //lint !e115 !e1013 !e48 !e10 !e1055 !e746 !e628

        iUniHeaders->BccRecipients().Count() ) >= 2 ) //lint !e115 !e1013 !e48 !e10 !e1055 !e746 !e628

        {

        aEntry.SetMultipleRecipients( ETrue );

        }

    else

        {

        // clear multiple recipients in case recipients have

        // been deleted after the message was saved the last time

        aEntry.SetMultipleRecipients( EFalse );

        }

    // Set iDetails (recipient)

    TPtrC to;

    if ( iUniHeaders->ToRecipients().Count() ) //lint !e115 !e1013 !e48 !e10

        {

        to.Set( TMmsGenUtils::Alias( iUniHeaders->ToRecipients()[0] ) ); //lint !e115 !e1013 !e48 !e10 !e64

        if ( to.Length() <= 0 )

            {

            // If no alias part then set the real address in details

            to.Set( iUniHeaders->ToRecipients()[0] ); //lint !e115 !e1013 !e48 !e10 !e1025 !e1703 !e64 !e118

            }

        }

    aEntry.iDetails.Set( to );

    if ( totalSizeOfAllAttachments > 0 )

        {

        aEntry.SetAttachment( ETrue );

        }

    switch ( iUniHeaders->MessageTypeLocking() )

        {

        case EUniMessageTypeLocked:

            TUniMsvEntry::SetMessageTypeLocked( aEntry, ETrue );

            break;

        case EUniMessageTypeNotLocked:

            TUniMsvEntry::SetMessageTypeLocked( aEntry, EFalse );

            break;

        case EUniMessageTypeLockingNotSet:

        default:

            // Don't touch TMsvEntry.

            break;

        }

    }

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

// CUniClientMtm::LoadMessageL

// Loads the unified message

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

//

void CUniClientMtm::LoadMessageL()

    {

    // First we should assert that iMsvEntry is not NULL, and panic, if it is

   	__ASSERT_DEBUG( iMsvEntry, Panic( EUniNotAMessage ) );

    // LoadMessageL should only be supported for message entries.

    __ASSERT_DEBUG( iMsvEntry->Entry().iType.iUid == KUidMsvMessageEntryValue,

        Panic( EUniNotAMessage ) );

    // Old data must be reset first....

    // CMmsSettings resets itself before doing restore, so that's ok.

    TMsvEntry indexEntry = iMsvEntry->Entry(); //lint !e1924

    // load the correct data

    // get read-only message store

    CMsvStore* store = iMsvEntry->ReadStoreL();

    CleanupStack::PushL( store );

    // Restore headers of unified message

    // if headers do not exist does nothing. Default headers will be used.

    iUniHeaders->RestoreL( *store );

    if ( iUniHeaders->MessageTypeLocking() == EUniMessageTypeLockingNotSet &&

        TUniMsvEntry::IsMessageTypeLocked( indexEntry ) )

        {

        switch ( TUniMsvEntry::CurrentMessageType( indexEntry ) )

            {

            case EUniMessageCurrentTypeSms:

                {

                iUniHeaders->SetMessageTypeSetting( EUniMessageTypeSettingSms );

                iUniHeaders->SetMessageTypeLocking( EUniMessageTypeLocked );

                break;

                }

            case EUniMessageCurrentTypeMms:

                {

                iUniHeaders->SetMessageTypeSetting( EUniMessageTypeSettingMms );

                iUniHeaders->SetMessageTypeLocking( EUniMessageTypeLocked );

                break;

                }

            default:

                break;

            }

        }

    // Attachment info is not restored.

    // It makes no sense to cache the attachment info as new attachments

    // can be added with the help of the attachment magager without 

    // informing uni Client MTM of the additions.

    // Caller must use attachment manager to get attachment info.

    CleanupStack::PopAndDestroy( store );  

    store = NULL;

    // Build the iAddresseeList up

    BuildAddresseeListL();

    }

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

// CUniClientMtm::ReplyL

// Send a reply to current message

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

//

CMsvOperation* CUniClientMtm::ReplyL(

    TMsvId /*aDestination*/,

    TMsvPartList /*aPartList*/,

    TRequestStatus& /*aCompletionStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniClientMtm::ForwardL

// Forward current message

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

//

CMsvOperation* CUniClientMtm::ForwardL(

    TMsvId /*aDestination*/,

    TMsvPartList /*aPartList*/,

    TRequestStatus& /*aCompletionStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CUniClientMtm::ValidateMessage

// Validate selected parts of current message

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

//

TMsvPartList CUniClientMtm::ValidateMessage(

    TMsvPartList aPartList )

    {

    __ASSERT_DEBUG( iMsvEntry, Panic( EUniNotAMessage ));

    TMsvPartList retVal = 0;

    if ( iMsvEntry->Entry().iType.iUid != KUidMsvMessageEntryValue )

        {

        // not a message, no part is valid

        retVal = aPartList;

        }

    if ( aPartList & KMsvMessagePartRecipient )

        {

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

            {

            retVal |= KMsvMessagePartRecipient;

            }

        else

            {

            // check the recipient list for valid 'addresses'

            for (TInt ii=0; ii < iAddresseeList->Count(); ++ii)

                {

                TPtrC oneAddress = (*iAddresseeList)[ii];

                TPtrC pureAddress = TMmsGenUtils::PureAddress( oneAddress );

                if ( ( pureAddress.Length() == 0 ) || 

                    !TMmsGenUtils::IsValidAddress( pureAddress, ETrue ) )

                    {

                    retVal |= KMsvMessagePartRecipient;

                    break;

                    }

                }

            }

        }

    // all attachments are considered valid - even no attachments

    return retVal;

    }

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

// CUniClientMtm::Find

// Find text in selected message parts

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

//

TMsvPartList CUniClientMtm::Find(

    const TDesC& aTextToFind,

    TMsvPartList aPartList )

	{

	TMsvPartList foundList( KMsvMessagePartNone );

	TRAP_IGNORE( foundList = DoFindL( aTextToFind, aPartList) );

	return foundList;

	}

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

// CUniClientMtm::DoFindL

// Find text in selected message parts

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

//

TMsvPartList CUniClientMtm::DoFindL(

    const TDesC& aTextToFind,

    TMsvPartList aPartList )

    {

    // The final version will not have a rich text body, but we could

    // search for example the originator and description.

    __ASSERT_DEBUG( iMsvEntry, Panic( EUniNotAMessage ) );

    TMsvPartList foundList = KMsvMessagePartNone;

    TMsvEntry entry = iMsvEntry->Entry();

    CMsvFindText* findText = CMsvFindText::NewL();

    CleanupStack::PushL( findText );

    if ( aPartList & KMsvMessagePartRecipient )

        {

        // Find from To, Cc and Bcc fields

        if ( FindInRecipientL( aTextToFind, 

            aPartList, iUniHeaders->ToRecipients(), *findText))

            {

            foundList |= KMsvMessagePartRecipient;

            }

        else if ( FindInRecipientL( aTextToFind, 

            aPartList, iUniHeaders->CcRecipients(), *findText ))

            {

            foundList |= KMsvMessagePartRecipient;

            }

        else if ( FindInRecipientL( aTextToFind, 

            aPartList, iUniHeaders->BccRecipients(), *findText ))

            {

            foundList |= KMsvMessagePartRecipient;

            }

        }

    if ( aPartList & KMsvMessagePartDescription )

        {

        if ( findText->FindTextL( aTextToFind, entry.iDescription, 

            aPartList ) )

            {

            foundList |= KMsvMessagePartDescription;

            }

        }

    CleanupStack::PopAndDestroy( findText );

    return foundList;

    }

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

// CUniClientMtm::AddAddresseeL

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

//

void CUniClientMtm::AddAddresseeL( const TDesC& aRealAddress )

    {

    // Add to general list

    // When no type is specified, the address will have type "to"

    iAddresseeList->AppendL( EMsvRecipientTo, aRealAddress );

    // Add to "To" recipient list

    iUniHeaders->AddTypedAddresseeL( aRealAddress, EMsvRecipientTo ); //lint !e115 !e1013 !e48 !e10 !e1514 !e64

    }

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

// CUniClientMtm::AddAddresseeL

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

//

void CUniClientMtm::AddAddresseeL(

    const TDesC& aRealAddress,

    const TDesC& aAlias )

    {

    if ( aAlias.Length() > 0 )

        {

        HBufC* buf = TMmsGenUtils::GenerateAddressL( aRealAddress, aAlias );

        CleanupStack::PushL( buf );

        AddAddresseeL( buf->Des() );

        CleanupStack::PopAndDestroy( buf );  

        }

    else

        {        

        AddAddresseeL( aRealAddress );

        }

    }

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

// CUniClientMtm::AddAddresseeL

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

//

void CUniClientMtm::AddAddresseeL( TMsvRecipientType aType,

    const TDesC& aRealAddress )

    {

    // Add to general list

    // When no type is specified, the address will have type "to",

    // "cc" or "bcc"

    iAddresseeList->AppendL( aType, aRealAddress );

    // Add to recipient list

    iUniHeaders->AddTypedAddresseeL( aRealAddress, aType );

    }

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

// CUniClientMtm::AddAddresseeL

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

//

void CUniClientMtm::AddAddresseeL(

    TMsvRecipientType aType,

    const TDesC& aRealAddress,

    const TDesC& aAlias )

    {

    if ( aAlias.Length() > 0 )

        {

        HBufC* buf = TMmsGenUtils::GenerateAddressL( aRealAddress, aAlias );

        CleanupStack::PushL( buf );

        AddAddresseeL(aType, buf->Des());

        CleanupStack::PopAndDestroy( buf ); 

        }

    else

        {        

        AddAddresseeL( aType, aRealAddress );

        }

    }

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

// CUniClientMtm::RemoveAddressee

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

//

void CUniClientMtm::RemoveAddressee( TInt aIndex )

    {

	if ( aIndex < 0 )

		{