/*

* Copyright (c) 2006 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:  Process Component for Contact Editing

*

*/

// ============================ HEADER FILES ===============================

// INCLUDE FILES

#include "CCAContactEditPC.h"

#include "CCAStorageManagerFactory.h"

#include "MCAPresence.h"

#include "CAPresenceManager.h"

#include "MCAMainViewArrayPC.h"

#include "MCAContactLists.h"

#include "MCAPresence.h"

#include "MCAPresenceError.h"

#include "MCAPresenceErrors.h"

#include "MCAContactList.h"

#include "CCAMainViewArrayPC.h"

#include "CAUtils.h"

#include "ChatDebugAssert.h"

#include "ChatDebugPrint.h"

#include "MCAStoredContact.h"

#include "MCAStoredContacts.h"

#include "MCAProcessManager.h"

#include "MCASettingsPC.h"

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

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

// CCAContactEditPC::NewL

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

//

CCAContactEditPC* CCAContactEditPC::NewL( MCASettingsPC& aCCASettingsPC )

    {

    CCAContactEditPC* self = CCAContactEditPC::NewLC( aCCASettingsPC );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCAContactEditPC::NewLC

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

//

CCAContactEditPC* CCAContactEditPC::NewLC( MCASettingsPC& aCCASettingsPC )

    {

    CCAContactEditPC* self = new( ELeave ) CCAContactEditPC( aCCASettingsPC );

    CleanupStack::PushL( self );

    return self;

    }

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

// Destructor

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

//

CCAContactEditPC::~CCAContactEditPC()

    {

    }

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

// CCAContactEditPC::CCAContactEditPC

//

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

//

CCAContactEditPC::CCAContactEditPC( MCASettingsPC& aCCASettingsPC )

        :  iContact( NULL ),

        iCCASettingsPC( aCCASettingsPC )

    {

    }

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

// CCAContactEditPC::GetContactDetailsL

//

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

//

void CCAContactEditPC::GetContactDetailsL(

    const TBool aAliasEnabled,

    const TBool aNicknameEnabled,

    TBool&  aOwnData,

    HBufC*& aOrigId,

    HBufC*& aAlias,

    HBufC*& aNickname,

    HBufC*& aUserId,

    HBufC*& aIdentification

)

    {

    if ( iContact )

        {

        // found an existing contact, store the user id

        aOwnData = iOwnData;

        aUserId = iContact->UserId().AllocL();

        aOrigId = iContact->UserId().AllocL();

        aIdentification = iContact->Identification().AllocL();

        if ( aAliasEnabled )

            {

            aAlias = iContact->Alias().AllocL();

            if ( ! aAlias->Length() )

                {

                delete aAlias;

                aAlias = NULL;

                if ( aOwnData )

                    {

                    // this is our own status

                    // so get the alias from engine

                    aAlias = iCCASettingsPC.GetSapSettingValuePCL(

                                 TEnumsPC::EOwnAlias, NULL );

                    iContact->SetAliasL( aAlias ? ( *aAlias ) : KNullDesC() );

                    }

                }

            }

        if ( aNicknameEnabled )

            {

            aNickname = iContact->Nickname().AllocL();

            }

        }

    }

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

// CCAContactEditPC::IsWVIDAvailableAndValidL

//

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

//

TBool CCAContactEditPC::IsWVIDAvailableAndValidL( TBool aCreateNew,

                                                  const TDesC&  aListId,

                                                  const TDesC& aWVID, TBool& aContactInList,

                                                  TDesC*& aUserID )

    {

    TBool retValue = EFalse;

    TBool validContact = ETrue; //This is ETrue, if we are creating a new contact

    // check if there's already a contact with same wvid

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    MCAStoredContact* contactInList = contacts->FindContact( aListId, aWVID );

    if ( !aCreateNew )

        {

        //if contact editor in EditMode

        // validContact is EFalse if iContact not a valid contact

        validContact = contacts->IsContactValid( iContact );

        }

    if ( contactInList && validContact )

        {

        retValue = ETrue;

        if ( iContact != contactInList )

            //this is a new contact

            {

            aContactInList = ETrue;

            aUserID = const_cast <TDesC *>( &contactInList->UserId() );

            }

        }

    return retValue;

    }

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

// CCAContactEditPC::FindAnyContactByNickL

//

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

//

TBool CCAContactEditPC::FindAnyContactByNickL( const TDesC& aNickName )

    {

    TBool retValue = EFalse;

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    MCAStoredContact* contact = contacts->FindAnyContactByNick( aNickName );

    if ( ( contact ) && ( contact != iContact ) )

        {

        retValue = ETrue;

        }

    return retValue;

    }

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

// CCAContactEditPC::AddContactL

//

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

//

TInt CCAContactEditPC::AddContactL(

    const TDesC& aListId,

    const TDesC& aWVID, const TDesC& aNickName,

    const TDesC& aAlias )

    {

    // fetch the contacts in list

    MCAStoredContact *addedContact = NULL;

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    TRAPD( err, addedContact = listInterface->AddServerContactL(

                                   aListId, aWVID, aNickName ) );

    if ( addedContact )

        {

        if ( &aAlias ) //time being fix for crash

            {

            addedContact->SetAliasL( aAlias );

            }

        iContact = addedContact;

        }

    return err;

    }

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

// CCAContactEditPC::UpdateContactL

//

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

//

TInt CCAContactEditPC::UpdateContactL( const TDesC& aListId,

                                       const TDesC& aWVID,

                                       const TDesC& aNickName )

    {

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    TRAPD( err, listInterface->UpdateContactNicknameL( aListId, aWVID,

                                                       aNickName ) );

    return err;

    }

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

// CCAContactEditPC::RemoveContactL

//

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

//

TInt CCAContactEditPC::RemoveContactL(

    const TDesC& aListId,

    const TDesC& aWVID )

    {

    // fetch the contacts in list

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    TRAPD( err, listInterface->DeleteServerContactL( aListId, aWVID ) );

    return err;

    }

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

// CCAContactEditPC::SetAnyContactL

//

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

//

void CCAContactEditPC::SetAnyContactL( const TDesC& aWVID )

    {

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    MCAStoredContact* contact = contacts->FindAnyContact( aWVID );

    iContact = contact;

    }

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

// CCAContactEditPC::SetContactL

//

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

//

void CCAContactEditPC::SetContactL( const TDesC& aListId,

                                    const TDesC& aWVID )

    {

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    MCAStoredContact* contact = contacts->FindContact( aListId, aWVID );

    iContact = contact;

    }

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

// CCAContactEditPC::GetCurrentContactNickname

//

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

//

const TDesC& CCAContactEditPC::GetCurrentContactNickname() const

    {

    __CHAT_ASSERT_DEBUG( iContact );

    return iContact->Nickname();

    }

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

// CCAContactEditPC::GetCurrentContactUserId

//

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

//

const TDesC& CCAContactEditPC::GetCurrentContactUserId() const

    {

    __CHAT_ASSERT_DEBUG( iContact );

    return iContact->UserId();

    }

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

// CCAContactEditPC::InitialiseL

//

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

//

void CCAContactEditPC::InitialiseL(

    MCAMainViewArrayPC& aMainViewArrayPC,

    const TInt index, TBool& aOwnStatus )

    {

    //reset the member variables

    iOwnData = EFalse;

    iContact = NULL;

    CCAMainViewArrayPC& ccaMainViewArrayPC =

        static_cast<CCAMainViewArrayPC&>( aMainViewArrayPC );

    MCAStoredContacts* contactlist =

        CCAStorageManagerFactory::ContactListInterfaceL();

    if ( index != -1 )

        {

        iContact = ccaMainViewArrayPC.GetContactForContactEditor( index ) ;

        // check for own status

        if ( iContact == &contactlist->OwnStatus() )

            {

            iOwnData = ETrue;

            aOwnStatus = ETrue;

            }

        }

    }

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

// CCAContactEditPC::IsContact

//

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

//

TBool CCAContactEditPC::IsContact() const

    {

    if ( iContact )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CCAContactEditPC::GetAliasFromPresenceL

//

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

//

HBufC* CCAContactEditPC::GetAliasFromPresenceL( const TDesC& aWVID )

    {

    // add mode - contact does not exist

    // get the alias from the network,

    MCAPresence* presence = CAPresenceManager::InstanceL();

    if ( aWVID.Length() )

        {

        return presence->AliasL( aWVID );

        }

    else

        {

        // write manually, WVID does not exist, thus can't get alias

        // so use an empty alias

        return KNullDesC().AllocL();

        }

    }

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

// CCAContactEditPC::DeleteCurrentContactL

//

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

//

TInt CCAContactEditPC::DeleteCurrentContactL( const TDesC& aListId,

                                              const TDesC& aOrigId )

    {

    // can't delete self

    if ( iOwnData )

        {

        return KErrAccessDenied;

        }

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    // delete contact

    TRAPD( error,

           listInterface->DeleteServerContactL( aListId, aOrigId ) );

    if ( error == KErrNone )

        {

        iContact = NULL;

        }

    return error;

    }

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

// CCAContactEditPC::LastContactEditOperationResultL

//

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

//

const RPointerArray<MCAPresenceError>& CCAContactEditPC::LastContactEditOperationResultL( void )

    {

    // show the detailed error codes

    MCAPresence* presence = CAPresenceManager::InstanceL();

    MCAContactLists* listInterface = presence->ContactLists();

    const MCAPresenceErrors& lastResult =

        listInterface->LastOperationResult();

    return lastResult.DetailedErrors();

    }

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

// CCAContactEditPC::GetListIdLC

//

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

//

HBufC* CCAContactEditPC::GetListIdL( const TDesC& aId, TInt /*aNoListsResource*/,

                                     TInt &aItemCount, CDesCArrayFlat*& aListIdArray,

                                     RArray< TInt > 	&aIndexArray,

                                     const TBool aMoveOperation /*= EFalse*/ )

    {

    //make sure that we push iIndexArray to the cleanupstack

    CleanupClosePushL( aIndexArray );

    MCAStoredContacts* contacts = CCAStorageManagerFactory::ContactListInterfaceL();

    // Get list id from listquery.

    TInt listCount = contacts->ListCount();

    // Granularity has to be > 0

    aListIdArray = new ( ELeave ) CDesCArrayFlat( Max( listCount, 1 ) );

    CleanupStack::PushL( aListIdArray ) ;

    if ( !aMoveOperation )

        {

        //In case of Add, all contact lists in which contact is not available is shown.

        for ( TInt index( 0 ); index < listCount; ++index )

            {

            MCAContactList& contactList = contacts->ListAt( index ) ;

            if ( !contacts->FindContact( contactList.ListId(), aId ) )

                {

                aListIdArray->AppendL( contactList.DisplayName() );

                aIndexArray.AppendL( index );

                }

            }

        }

    else

        {

        /* In case of Move, all contact lists, except the current list, are shown in the list

        in same order as in IM contact list.

        */

        for ( TInt index( 0 ); index < listCount; ++index )

            {

            MCAContactList& contactList = contacts->ListAt( index ) ;

            TPtrC listid = contactList.ListId();

            //check whether its the current contact list

            if ( !CAUtils::NeutralCompare(

                     aId,

                     listid, EFalse ) )

                {

                //we have found the current list - Now add all other lists other

                //then the current one.

                for ( TInt jIndex( index + 1 ); jIndex < listCount; ++jIndex )

                    {

                    MCAContactList& contactLst = contacts->ListAt( jIndex ) ;