/*

* Copyright (c) 2008 - 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:  handles interface to LIW and Content Publishing Service

*

*/

#include <cmailhandlerplugin.mbg>

#include <AknUtils.h>

#include <gulicon.h>

#include <bautils.h>

#include <StringLoader.h>

#include <emailwidget.rsg>

#include "emailtrace.h"

#include "CFSMailClient.h"

#include "cmailcpsif.h"

#include "cmailcpsifconsts.h"

#include "FreestyleEmailUiConstants.h"

#include "cmailwidgetcenrepkeysinternal.h"

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

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

// CMailCpsIf::NewL

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

//

CMailCpsIf* CMailCpsIf::NewL( CMailCpsHandler* aMailCpsHandler )

    {

    FUNC_LOG;

    CMailCpsIf* self = new(ELeave) CMailCpsIf( aMailCpsHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMailCpsIf::CMailCpsIf

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

//

CMailCpsIf::CMailCpsIf( CMailCpsHandler* aMailCpsHandler ) :

    iMailCpsHandler( aMailCpsHandler ),

    iMsgInterface ( NULL ),

    iIgnoreHsNotifications( EFalse )

    {

    FUNC_LOG;

    }

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

// CMailCpsIf::ConstructL

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

//

void CMailCpsIf::ConstructL()

    {

    FUNC_LOG;

    for (TInt i=0; i<KMaxMailboxCount; i++)

        {

        iAllowedToPublish[i] = EFalse;

        iInactive[i] = EFalse;

        }

    AllocateResourcesL();

    iMsgInterface = GetMessagingInterfaceL();

    RegisterForObserverL();

    PublisherRegisteryActionL();

    }

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

// CMailCpsIf::~CMailCpsIf

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

//

CMailCpsIf::~CMailCpsIf()

    {

    FUNC_LOG;

    TRAP_IGNORE(UnRegisterForObserverL());

    if ( iMsgInterface )

        {

        iMsgInterface->Close();

        iMsgInterface = NULL;

        }

    delete iServiceHandler;

    iInstIdList.ResetAndDestroy();  

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

    }

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

// CMailCpsIf::AllocateResourcesL

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

//

void CMailCpsIf::AllocateResourcesL()

    {

    FUNC_LOG;

    // create resourcefile 

    CCoeEnv* env = CCoeEnv::Static();

    TFileName resourceFile;

    TParse parse;

    parse.Set( KResourceFile, &KDC_ECOM_RESOURCE_DIR, NULL ); 

    resourceFile = parse.FullName();

    BaflUtils::NearestLanguageFile( env->FsSession(), resourceFile );

    iResourceFileOffset = env->AddResourceFileL( resourceFile );

    }

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

// CMailCpsIf::GetMessagingInterfaceL

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

//

MLiwInterface* CMailCpsIf::GetMessagingInterfaceL()

    {

    FUNC_LOG;

    if ( !iServiceHandler )

        {

        iServiceHandler = CLiwServiceHandler::NewL();

        }

    CLiwGenericParamList* inParam = CLiwGenericParamList::NewL();

    CleanupStack::PushL( inParam );

    CLiwGenericParamList* outParam = CLiwGenericParamList::NewL();

    CleanupStack::PushL( outParam );

    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, KCPInterface,

        KCPService  );

    crit->SetServiceClass( TUid::Uid(KLiwClassBase) );

    RCriteriaArray criteriaArray;

    criteriaArray.AppendL( crit );

    iServiceHandler->AttachL( criteriaArray );

    iServiceHandler->ExecuteServiceCmdL( *crit, *inParam, *outParam );

    delete crit;

    crit = NULL;

    criteriaArray.Reset();

    // find service interface

    TInt pos = 0;

    MLiwInterface* msgInterface = NULL;

    outParam->FindFirst( pos, KCPInterface );

    if ( pos != KErrNotFound )

        {

        msgInterface = (*outParam)[pos].Value().AsInterface(); // indexing should be safe

        }

    outParam->Reset();

    inParam->Reset();

    if( !msgInterface )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( outParam );

    CleanupStack::PopAndDestroy( inParam );

    return msgInterface;

    }

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

// CMailCpsIf::PublishSetupWizardL

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

//

void CMailCpsIf::PublishSetupWizardL(TInt instance)

    {

    FUNC_LOG;

    TFSMailMsgId mailBoxId;

    TFSMailMsgId folderId;

    HBufC* setupEmail = StringLoader::LoadLC(R_EMAILWIDGET_TEXT_SETUP_EMAIL);

    iSetupUid = PublishDescriptorL(

            KPubId, KContTypeSetupText,

            iInstIdList[instance]->Des(),

            *setupEmail, 

            KKeySetupText, KTriggerWizard8, NULL, mailBoxId, folderId);	

    PublishImageL(

            iInstIdList[instance]->Des(),

            KContTypeSetupIcon,

            KKeySetupIcon,

            EMbmCmailhandlerpluginQgn_prop_cmail_new_mailbox,

            EMbmCmailhandlerpluginQgn_prop_cmail_new_mailbox_mask,

            mailBoxId);

    CleanupStack::PopAndDestroy(setupEmail);    

    }

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

// CMailCpsIf::PublishActiveMailboxNameL

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

//

void CMailCpsIf::PublishActiveMailboxNameL(

    const TInt aInstance,

    const TInt aRowNumber, 

    const TDesC& aMailboxName,

    const TInt aMailBoxCount,

    TFSMailMsgId aMailBoxId,

    TFSMailMsgId aFolderId)

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeBodyText);        

    contentType.Append(row);

    TBuf<KMaxDescLen> textKey;

    textKey.Copy(KKeyBodyText);

    textKey.Append(row);

    iMailboxNameUid = PublishDescriptorL(

        KPubId, contentType, 

        iInstIdList[aInstance]->Des(),

        aMailboxName,

        textKey, KTriggerEmailUi8, aMailBoxCount,

        aMailBoxId, aFolderId);		

    }

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

// CMailCpsIf::PublishIndicatorIconL

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

//

void CMailCpsIf::PublishIndicatorIconL( const TInt aInstance, 

                                        const TInt aRowNumber,

                                        const TInt aIcon )

    {

    FUNC_LOG;

    TFSMailMsgId mailBoxId;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeIndicatorIcon);        

    contentType.Append(row);

    TBuf8<KMaxDescLen> row8;

    row8.Num(aRowNumber);

    TBuf8<KMaxDescLen> key;

    key.Copy(KKeyIndicatorIcon);     

    key.Append(row8);

    PublishImageL(

              iInstIdList[aInstance]->Des(),

              contentType,

              key,

              aIcon,

              aIcon + 1,

              mailBoxId);

    }

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

// CMailCpsIf::PublishMailboxIconL

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

//

void CMailCpsIf::PublishMailboxIconL( const TInt aInstance,

                                      const TInt aRowNumber, 

                                      const TInt aIcon,

                                      TFSMailMsgId aMailBoxId )

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeMailboxIcons);        

    contentType.Append(row);

    TBuf8<KMaxDescLen> row8;

    row8.Num(aRowNumber);

    TBuf8<KMaxDescLen> key;

    key.Copy(KKeyMailboxIcons);     

    key.Append(row8);

    PublishImageL(

              iInstIdList[aInstance]->Des(),

              contentType,

              key,

              aIcon,

              aIcon + 1,

              aMailBoxId);    

    }

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

// CMailCpsIf::PublishMailDetailL

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

//

void CMailCpsIf::PublishMailDetailL( const TInt aInstance,        

                                     const TInt aRowNumber, 

                                     const TDesC& aText,

                                     TWidgetMailDetails aDetail)

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    if (aDetail == ETime)

        {    

        contentType.Copy(KContTypeTime);

        }

    else

        {

        contentType.Copy(KContTypeBodyText);

        }

    contentType.Append(row);

    TBuf<KMaxDescLen> textKey;

    if (aDetail == ETime)

        {

        textKey.Copy(KKeyTime);

        }

    else

        {

        textKey.Copy(KKeyBodyText);

        }

    textKey.Append(row);

    TFSMailMsgId mailBoxId;

    TFSMailMsgId folderId;

    iMailboxNameUid = PublishDescriptorL(

        KPubId, contentType, 

        iInstIdList[aInstance]->Des(),

        aText,

        textKey, KNullDes8, NULL,

        mailBoxId, folderId);  

    }

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

// CMailCpsIf::ResetMessageL

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

//

void CMailCpsIf::ResetMessageL( TInt /*aRowNumber*/ )

    {

    FUNC_LOG;

    RemoveL( iMsgUid );

    iMsgUid = 0;

    }

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

// CMailCpsIf::ExtractItemId

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

//

TUint CMailCpsIf::ExtractItemId( 

    const CLiwGenericParamList& aInParamList )

    {

    FUNC_LOG;

    TUint result ( 0 );

    TInt pos( 0 );

    aInParamList.FindFirst( pos, KItemId );

    if ( pos != KErrNotFound )

        {

        // item id present - extract and return

        aInParamList[pos].Value().Get( result ); // indexing should be safe

        }

    return result;

    }

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

// CMailCpsIf::PublishDescriptorL

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

//

TUint CMailCpsIf::PublishDescriptorL(

    const TDesC& aPublisherId, 

    const TDesC& aContentType,

    const TDesC& aContentId, 

    const TDesC& aTextToAdd,

    const TDesC& aKey,

    const TDesC8& aTrigger,

    const TInt /*aMailBoxCount*/,

    TFSMailMsgId /*aMailBoxId*/,

    TFSMailMsgId /*aFolderId*/ )

    {

    FUNC_LOG;

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    TUint id(0);

    TBuf8<KMaxDescLen> key;

    key.Copy(aKey);

    if ( iMsgInterface )

        {

        TLiwGenericParam cptype( KType, TLiwVariant( KCpData ));

        inparam->AppendL( cptype );

        CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* map = CLiwDefaultMap::NewLC();

        map->InsertL( key,  TLiwVariant( aTextToAdd ) );

        cpdatamap->InsertL( KPublisherId, TLiwVariant( aPublisherId ));

        cpdatamap->InsertL( KContentType, TLiwVariant( aContentType ));

        cpdatamap->InsertL( KContentId, TLiwVariant( aContentId ));

        cpdatamap->InsertL( KDataMap, TLiwVariant( map ) );

        if( aTrigger.Length() > 0 )

            {

            CLiwDefaultMap* mapAction = CLiwDefaultMap::NewLC();

            CLiwDefaultMap* mapInterface  = CLiwDefaultMap::NewLC();

            CLiwDefaultMap* mapPlugin = CLiwDefaultMap::NewLC();

            mapInterface ->InsertL( KDataForActionHandler, TLiwVariant( mapPlugin )  );

            mapAction->InsertL( aTrigger, TLiwVariant(  mapInterface  ) ); 

            cpdatamap->InsertL( KActionMap, TLiwVariant(mapAction) );

            }

        TLiwGenericParam item( KItem, TLiwVariant( cpdatamap ));

        inparam->AppendL( item );

        // Execute command

        iMsgInterface->ExecuteCmdL( KAdd , *inparam, *outparam );

        id = ExtractItemId(*outparam );

        if( aTrigger.Length() > 0 )

            {

            CleanupStack::PopAndDestroy( 3 ); // action

            }

        CleanupStack::PopAndDestroy( map );

        CleanupStack::PopAndDestroy( cpdatamap );

        item.Reset();

        cptype.Reset();

        }

    outparam->Reset();

    inparam->Reset();

    return id;

    }

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

// CMailCpsIf::PublishImageL

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

//

void CMailCpsIf::PublishImageL(

        const TDesC& aContentId,

        const TDesC& aContentType,

        const TDesC8& aKey,

        TInt aBitmapId,

        TInt aBitmapMaskId,

        TFSMailMsgId aMailBoxId )

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> iconIds(KNullDesC);

    if ( aBitmapId == EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account )   

        {

        // This is mailbox icon. Try finding branded mailbox icon.

        TInt error(KErrNone);

        TBuf<KMaxDescLen> brandedIconIds(KNullDesC);

        MFSMailBrandManager& brandManager = iMailCpsHandler->MailClient().GetBrandManagerL();

        TRAPD( err, error = brandManager.GetGraphicIdsL( EFSMailboxIcon,  aMailBoxId, brandedIconIds ) );        

        if ( err == KErrNone && error == KErrNone )

            {            

            iconIds.Copy(KMifPrefix);

            iconIds.Append(brandedIconIds);

            }

        }

    if (!iconIds.Length())

        {

        TBuf<KMaxDescLen> id;

        iconIds.Copy(KMifPrefix);

        iconIds.Append(KMifPath);

        iconIds.Append(KSpace);

        id.Num(aBitmapId);

        iconIds.Append(id);     

        iconIds.Append(KSpace);

        id.Num(aBitmapMaskId);

        iconIds.Append(id);        

        }

    // The actual image publishing part starts here   

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    TLiwGenericParam type( KType, TLiwVariant(KCpData));

    inparam->AppendL( type );

    CLiwDefaultMap* pdatamap = CLiwDefaultMap::NewLC();

    CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

    pdatamap->InsertL( KPublisherId, TLiwVariant( KPubId ));

    pdatamap->InsertL( KContentType, TLiwVariant( aContentType ));

    pdatamap->InsertL( KContentId, TLiwVariant( aContentId ));

    datamap->InsertL(aKey, TLiwVariant(iconIds));

    pdatamap->InsertL( KDataMap, TLiwVariant(datamap) );

    TLiwGenericParam item( KItem, TLiwVariant( pdatamap ));       

    inparam->AppendL( item );

    // Publish icon ( or remove it from widget when no id provided )

    if ( aBitmapId == KNullIcon )

        {

        iMsgInterface->ExecuteCmdL( KDelete, *inparam, *outparam);    

        }

    else

        {

        iMsgInterface->ExecuteCmdL( KAdd, *inparam, *outparam);

        }

    CleanupStack::PopAndDestroy( datamap );

    CleanupStack::PopAndDestroy( pdatamap );    

    item.Reset();

    type.Reset();

    outparam->Reset();

    inparam->Reset();

    }