/*

* Copyright (c) 2008 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:  Implementation of the class CFscSendPluginImpl.

*

*/

#include "emailtrace.h"

#include <ecom/implementationproxy.h>

#include <bautils.h>

#include <CMessageData.h>

#include <sendui.h>

#include <sysutil.h>

#include <SenduiMtmUids.h>

#include <TSendingCapabilities.h>

#include <AknQueryDialog.h>

#include <AknsConstants.h>

#include <RPbkViewResourceFile.h> 

//<cmail>

#include "mfsccontactset.h"

#include "mfscactionutils.h"

#include <FscActionUtils.rsg>

#include <fscsendplugin.rsg>

#include <fscsendplugin.mbg>

#include "cfsccontactaction.h"

#include <StringLoader.h>

#include <featmgr.h>

#include "fsccontactactionserviceuids.hrh"

#include "mfsccontactactionpluginobserver.h"

//</cmail>

#include <MVPbkStoreContact.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactGroup.h>

#include <MVPbkContactLinkArray.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactIdConverter.h>

#include "fscactionpluginactionuids.h"

#include "cfscsendpluginimpl.h"

#include "cfscattachmentfile.h"

#include "fscactionplugincrkeys.h"

// CONSTANTS DECLARATIONS

// <cmail> flag not needed  here

const TInt KMaxContactIdStringLength = 10;

const TInt KMsgSpaceEstimationBytes = 10240;

const TInt KMaxLenghtOfAddressData = 255;

const TUid KCRUidUniEditor = {0x102072E5};

const TUint32 KUniEditorMaxRecipientCount = 0x00000002;

const TUint32 KUniEditorSoftLimitRecipientCount = 0x00000003;

const TInt KDefaultSmsRecipients = 20;

const TInt KDefaultMmsRecipients = 100;

const TInt KDefaultEmailRecipients = KMaxTInt;

const TInt KActionCount = 4;

const TInt KInvalidReasonId = 0;

//const TInt KContactListGranularity = 2;

_LIT( KSendPluginIconPath, "\\resource\\apps\\fscsendplugin.mif" );

_LIT( KResourceFilePath, "\\resource\\apps\\fscsendplugin.rsc");

// typedef declarations

typedef TBuf<KMaxLenghtOfAddressData> TAddressData;

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(

        KFscSendPluginImplImpUid,

        CFscSendPluginImpl::NewL )

    };

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

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

// CFscSendPluginImpl::NewL

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

//

CFscSendPluginImpl* CFscSendPluginImpl::NewL( TAny* aParams )

    {

    FUNC_LOG;

    TFscContactActionPluginParams* params = 

            reinterpret_cast< TFscContactActionPluginParams* >( aParams );

    CFscSendPluginImpl* self = new( ELeave ) CFscSendPluginImpl( *params );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFscSendPluginImpl::~CFscSendPluginImpl

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

//

CFscSendPluginImpl::~CFscSendPluginImpl()

    {

    FUNC_LOG;

    delete iContactMsgAction;

    delete iContactAudioMsgAction;

// <cmail> flag not needed  here

    delete iContactPostcardAction;

    delete iContactEmailAction;

    delete iActionList;

    delete iAttachmentFile;

    CCoeEnv::Static()->DeleteResourceFile( iResourceHandle );

    }

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

// CFscSendPluginImpl::Uid

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

//

TUid CFscSendPluginImpl::Uid() const 

    {

    FUNC_LOG;

    TUid uid = { KFscSendPluginImplImpUid };

    return uid;

    }

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

// CFscSendPluginImpl::ActionList

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

//

const CArrayFix<TUid>* CFscSendPluginImpl::ActionList() const

    {

	FUNC_LOG;

    return iActionList;

    }

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

// CFscSendPluginImpl::GetActionL

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

//

const MFscContactAction& CFscSendPluginImpl::GetActionL(

    TUid aActionUid ) const

    {

	FUNC_LOG;

    const MFscContactAction* action = NULL;

    if ( aActionUid == KFscActionUidCreateMsg )

        {

        action = iContactMsgAction;

        }

    else if ( aActionUid == KFscActionUidCreateAudMsg )

        {

        action = iContactAudioMsgAction;

        }

// <cmail> flag not needed  here

    else if ( aActionUid == KFscActionUidPostcard &&

              iContactPostcardAction != NULL )

        {

        action = iContactPostcardAction;

        }

    else if ( aActionUid == KFscActionUidEmail )

        {

        action = iContactEmailAction;

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    return *action;

    }

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

// CFscSendPluginImpl::PriorityForContactSetL

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

//

void CFscSendPluginImpl::PriorityForContactSetL( 

    TUid aActionUid,

    MFscContactSet& aContactSet,

    TFscContactActionVisibility& aActionMenuVisibility,

    TFscContactActionVisibility& aOptionsMenuVisibility,

    MFscContactActionPluginObserver* aObserver )

    {

    FUNC_LOG;

    switch(iLastEvent)

        {

        case EActionEventIdle:

            {

            iActionUid = aActionUid;

            iContactSet = &aContactSet;

            iActionMenuVisibility = &aActionMenuVisibility;

            iOptionsMenuVisibility = &aOptionsMenuVisibility;

            iPluginObserver = aObserver;

            iIsExecute = EFalse;

            iActionPriority = KFscActionPriorityNotAvailable;

            iContactSet->SetToFirstContact();

            iContactSet->SetToFirstGroup();

            iLastEvent = EActionEventCanExecuteLaunched;

            CanExecuteL( aActionUid, aContactSet );

            break;

            }

        case EActionEventCanExecuteFinished:

            {

            if ( iCanDisplay == KErrNone )

                {

                aActionMenuVisibility.iVisibility = 

                    TFscContactActionVisibility::EFscActionVisible;

                aOptionsMenuVisibility.iVisibility = 

                    TFscContactActionVisibility::EFscActionVisible;

                if ( aActionUid == KFscActionUidCreateMsg )

                    {

                    iActionPriority = iParams.iUtils->ActionPriority( 

                        KFscCrUidCreateMsg,

                        KFscActionPrioritySendMsg );

                    }

                else if ( aActionUid == KFscActionUidCreateAudMsg )

                    {

                    iActionPriority = iParams.iUtils->ActionPriority( 

                        KFscCrUidCreateAudMsg,

                        KFscActionPrioritySendAudio );

                    }

                else if ( aActionUid == KFscActionUidPostcard )

                    {

//</cmail>

                    if ( FeatureManager::FeatureSupported( KFeatureIdMmsPostcard ) )

                        {  

                        iActionPriority = iParams.iUtils->ActionPriority( 

                            KFscCrUidPostcard, KFscActionPrioritySendPostcard );

                        }

                    }

//</cmail>

                else if ( aActionUid == KFscActionUidEmail )

                    {

                    iActionPriority = iParams.iUtils->ActionPriority( 

                        KFscCrUidEmail,

                        KFscActionPrioritySendEmail );

                    }

                    // no else. already checked in CanExecuteL()

                CheckPriority( aActionUid );

                }

            else

                {

                iLastEvent = EActionEventContactAvailableLaunched;

                ContactAvailableL( aContactSet );

                }

            break;

            }

        case EActionEventContactAvailableFinished:

            {

            // Message is Visible in Options menu even if phone number isn't available

            if ( aActionUid == KFscActionUidCreateMsg &&

                    iIsContactAvailable )

                {

                aOptionsMenuVisibility.iVisibility = 

                    TFscContactActionVisibility::EFscActionVisible;

                aActionMenuVisibility.iVisibility = 

                    TFscContactActionVisibility::EFscActionHidden;

                aActionMenuVisibility.iReasonId = KInvalidReasonId;

                iActionPriority = iParams.iUtils->ActionPriority( 

                        KFscCrUidCreateMsg,

                        KFscActionPrioritySendMsg );

                }

            else

                {

                iActionPriority = KFscActionPriorityNotAvailable;

                aActionMenuVisibility.iVisibility = 

                    TFscContactActionVisibility::EFscActionHidden;

                aActionMenuVisibility.iReasonId = KInvalidReasonId;

                aOptionsMenuVisibility.iVisibility = 

                    TFscContactActionVisibility::EFscActionHidden;

                aOptionsMenuVisibility.iReasonId = KInvalidReasonId;

                }

            CheckPriority( aActionUid );

            break;

            }

        case EActionEventCanceled:

            {

            iLastEvent = EActionEventIdle;

            break;

            }

        default:

            {

            ResetData();

            break; // <cmail>

            }

        }

    }

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

// CFscSendPluginImpl::ExecuteL 

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

//

void CFscSendPluginImpl::ExecuteL( 

     TUid aActionUid,

     MFscContactSet& aContactSet,

     MFscContactActionPluginObserver* aObserver )

    {

	FUNC_LOG;

    switch ( iLastEvent )

        {

        case EActionEventIdle:

            {

            iActionUid = aActionUid;

            iContactSet = &aContactSet;

            iPluginObserver = aObserver;                      

            iIsExecute = ETrue;

            iContactSet->SetToFirstContact();

            iContactSet->SetToFirstGroup();

            iGroupIteratorPosition = 1;

            iGroupMembersCount = 0;

            iGroupMemberIndex = 0;

            iMaxRecipients = MaxMsgRecipientsL();

            iAddressList = CMessageData::NewL();                

            if( aContactSet.HasNextContact() )

                {

                iLastEvent = EActionEventExecuteContactRetrieve;

                aContactSet.NextContactL( this );

                }

            else 

                {

                if ( aContactSet.HasNextGroup() )

                    {

                    iLastEvent = EActionEventExecuteGroupRetrieve;

                    aContactSet.NextGroupL( this );

                    }

                else

                    {

                    iLastEvent = EActionEventExecuteFinished;

                    ExecuteL( aActionUid, aContactSet, aObserver );

                    }

                }

            break;

            }

        case EActionEventExecuteProcessContact:

            {            

            MVPbkContactLinkArray* linkArray = 

                iRetrievedStoreContact->GroupsJoinedLC();

            TBool found = EFalse;

            if ( aContactSet.GroupCount() > 0 

                    && linkArray->Count() > 0 )

                {                                 

                while ( aContactSet.HasNextGroup() 

                        && !found )

                    {                    

                    if ( linkArray->Find( *aContactSet.NextGroupLinkL() ) 

                            != KErrNotFound )

                        {

                        found = ETrue; 

                        }                    

                    }

                aContactSet.SetToFirstGroup();  

                }

            CleanupStack::PopAndDestroy(); //linkArray

            if ( !found ) 

                {

                if ( aActionUid ==  KFscActionUidPostcard )

                    {

//</cmail>

                    if ( FeatureManager::FeatureSupported( KFeatureIdMmsPostcard ) )

                        {  

                        AddPostcardContactL( 

                            *iAddressList,

                            *iRetrievedStoreContact );

                        }

//</cmail>

                    }

                else

                    {

                    TInt result = AddContactL( 

                        aActionUid,

                        *iAddressList,

                        *iRetrievedStoreContact );

                    if ( result == KErrCancel )

                        {

                        // Cancel whole operation                                                

                        ResetData();

                        aObserver->ExecuteComplete();

                        break;

                        }

                    else if ( result != KErrNone )

                        {

                        ++iMissingCount;

                        }

                    }

                }

            if ( aContactSet.HasNextContact() )

                {

                iLastEvent = EActionEventExecuteContactRetrieve;

                aContactSet.NextContactL( this );

                }

            else if ( aContactSet.HasNextGroup() )

                {

                iLastEvent = EActionEventExecuteGroupRetrieve;

                aContactSet.NextGroupL( this );

                }

            else 

                {

                iLastEvent = EActionEventExecuteFinished;

                ExecuteL( aActionUid, aContactSet, aObserver );

                }    

            break;

            }

        case EActionEventExecuteProcessGroup:

            {

            iGroupMembersCount = aContactSet.GroupContactCountL( 

                    *iRetrievedStoreGroup );

            if ( iGroupMembersCount > 0 )

                {

                iLastEvent = EActionEventExecuteContactRetrieve;

                aContactSet.GetGroupContactL( *iRetrievedStoreGroup, iGroupMemberIndex++, this );

                }

            else

                {

                if ( aContactSet.HasNextGroup() )

                    {

                    iGroupIteratorPosition++;

                    iLastEvent = EActionEventExecuteGroupRetrieve;

                    aContactSet.NextGroupL( this );

                    }

                else

                    {

                    iLastEvent = EActionEventExecuteFinished;

                    ExecuteL( aActionUid, aContactSet, aObserver );

                    }

                }            

            break;

            }

        case EActionEventExecuteProcessGroupMember:

            {

            if ( !IsAnyGroupMemberL( *iRetrievedGroupMember ) )

                {

                TInt result = AddContactL( 

                    aActionUid,

                    *iAddressList,

                    *iRetrievedGroupMember );

                if ( result == KErrCancel )

                    {

                    // Cancel whole operation                                                

                    ResetData();

                    aObserver->ExecuteComplete();

                    break;

                    }

                else if ( result != KErrNone )

                    {

                    ++iMissingCount;

                    }

                }

            delete iRetrievedGroupMember;

            iRetrievedGroupMember = NULL;

            if ( iGroupMemberIndex < iGroupMembersCount )

                {

                iLastEvent = EActionEventExecuteContactRetrieve;

                aContactSet.GetGroupContactL( *iRetrievedStoreGroup, iGroupMemberIndex++, this );

                }

            else if ( aContactSet.HasNextGroup() )

                {

                iGroupMemberIndex = 0;

                iGroupMembersCount = 0;

                iGroupIteratorPosition++;

                iLastEvent = EActionEventExecuteGroupRetrieve;

                aContactSet.NextGroupL( this );

                }

            else

                {

                iLastEvent = EActionEventExecuteFinished;

                ExecuteL( aActionUid, aContactSet, aObserver );

                }

            break;

            }

        case EActionEventExecuteFinished:

            {

            if ( aContactSet.ContactCount() == 1 

                     && aContactSet.GroupCount() == 0 

                     && iMissingCount == 1 )

                 {

                 //if only one contact available and without

                 //proper contact information