/*

* Copyright (c) 2002-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:  This module contains the implementation of CPEContactMatch class

*

*/

// INCLUDE FILES

#include "cpecontacthandling.h"

#include "cpecontactmatch.h"

#include <cphonecntfactory.h>

#include <cphcntmatcher.h>

#include <cphcntspeeddialmonitor.h>

#include <cphcntthumbnailloader.h>

#include <mpeclientinformation.h>

#include <mpedatastore.h>

#include <mphcntmatch.h>

#include <mphcntthumbnailloaderobserver.h>

#include <pepanic.pan>

#include <pevirtualengine.h>

#include <talogger.h>

#include <telmatchingextension.h>

#include <spsettings.h>

#include <spdefinitions.h>

#include <spproperty.h>

#include <spentry.h>

#include "cpecontactextensionwrapper.h"

// CONSTANTS

// Space - used as a separator between concatenated first and last name

_LIT( KPESpace," ");

// Contact group array granularity

const TInt KPEContactGroupArrayGranularity = 5;

// Minimum value of meanigful digits

const TInt KMinValueOfMeaningfulDigits = 4;

// Maximum value of meanigful digits

const TInt KMaxValueOfMeaningfulDigits = 20;

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

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

// CPEContactMatch::NewL

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

//

CPEContactMatch* CPEContactMatch::NewL(

        CPEContactHandling& aOwner,

        MPEDataStore& aDataStore

        )

    {

    CPEContactMatch* self = 

        new ( ELeave ) CPEContactMatch( aOwner, aDataStore );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CPEContactMatch::~CPEContactMatch()

    {

    delete iSpeedDialCommand;

    if ( iContactThumbnailLoader && iThumbnailId )

        {

        iContactThumbnailLoader->Cancel( iThumbnailId );

        }

    delete iThumbnailImage;

    delete iContactThumbnailLoader;

    delete iContactMatcher;

    delete iContactFactory;

    iPlugins.ResetAndDestroy();

    REComSession::FinalClose();

    iLibrary.Close();

    }

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

// CPEContactMatch::CreateSingleItemFetchL

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

//

CPhCntSingleItemFetch* CPEContactMatch::CreateSingleItemFetchL()

    {

    return iContactFactory->CreateSingleItemFetchL();

    }

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

// CPEContactMatch::CreateContactIdL

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

//

CPhCntContactId* CPEContactMatch::CreateContactIdL( const TDesC8& aContactId )

    {  

    return iContactFactory->CreateContactIdL( aContactId );

    }

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

// CPEContactMatch::CreateContactIdL

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

//

CPhCntContactId* CPEContactMatch::CreateContactIdL(

    TContactItemId aContactId )

    {  

    return iContactFactory->CreateContactIdL( aContactId );

    }

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

// CPEContactMatch::CPEContactMatch

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

//

CPEContactMatch::CPEContactMatch(

        CPEContactHandling& aOwner,

        MPEDataStore& aDataStore )

        : iOwner( aOwner ), iDataStore( aDataStore )

    {

    }

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

// CPEContactMatch::ConstructL

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

//

void CPEContactMatch::ConstructL()

    {

    //Mandatory services for providing contact match functionality

    TEFLOGSTRING( KTAOBJECT, "CNT CPEContactMatch::ConstructL > RLibrary::Load" );

    iContactFactory = CreateCntFactoryL();

    TEFLOGSTRING( KTAOBJECT, "CNT CPEContactMatch::ConstructL > CPhCntFactory::CreateContactMatcherL" );

    iContactMatcher = iContactFactory->CreateContactMatcherL();

    //Secondary services that may be enabled on demand

    ConstructThumbnailLoaderL();

    ConstructSpeedDialCommandL();

    }

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

// CPEContactMatch::ConstructThumbnailLoaderL

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

//

void CPEContactMatch::ConstructThumbnailLoaderL()

    {

    if ( !iContactThumbnailLoader )

        {

        TEFLOGSTRING( KTAOBJECT, "CNT CPEContactMatch::ConstructL > CPhCntFactory::CreateThumbnailLoaderL" );

        iContactThumbnailLoader = iContactFactory->CreateThumbnailLoaderL( *this );

        }

    else

        {

        TEFLOGSTRING( KTAERROR,

            "CNT CPECONTACTMATCH::CONSTRUCTTHUMBNAILLOADERL ! ALREADY EXISTS" );

        }

    }

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

// CPEContactMatch::ConstructSpeedDialCommandL

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

//

void CPEContactMatch::ConstructSpeedDialCommandL()

    {

    if ( !iSpeedDialCommand )

        {

        TEFLOGSTRING( KTAOBJECT, "CNT CPEContactMatch::ConstructL > CPhCntFactory::CreateSpeedDialMonitorL" );

        iSpeedDialCommand = iContactFactory->CreateSpeedDialMonitorL();

        }

    else

        {

        TEFLOGSTRING( KTAERROR,

            "CNT CPECONTACTMATCH::CONSTRUCTSPEEDDIALCOMMANDL ! ALREADY EXISTS" );

        }

    }

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

// CPEContactMatch::MatchWithContactIdL

// Synchronous method for finding contact data specified 

// with aContactId.

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

//

void CPEContactMatch::MatchWithContactIdL(

        const TInt aCallId

        )

    {

    TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithContactIdL" );

    MPhCntMatch* match( NULL );

    CPhCntContactId* contactId( NULL );

    contactId = CreateContactIdL( iDataStore.CallClientInformation( aCallId ).ContactLink() );

    CleanupStack::PushL( contactId );

    if ( iDataStore.CallType( aCallId ) == EPECallTypeVoIP )

        {

        if ( contactId && contactId->IsValid() )

            {

            TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithContactIdL > CPhCntMatcher::MatchVoipNumber" );

            // Get contact based on contact id.

            iContactMatcher->MatchVoipNumber( match, 

                                              iDataStore.RemotePhoneNumber( aCallId ),

                                              *contactId );

            }

        else

            {

            User::Leave( KErrArgument );

            }

        }

    else

        {

        if ( contactId && contactId->IsValid() )

            {

            TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithContactIdL > CPhCntMatcher::MatchNumber" );

            iContactMatcher->MatchNumber( match, 

                                          iDataStore.RemotePhoneNumber( aCallId ),

                                          *contactId );

            }

        else

            {

            User::Leave( KErrArgument );

            }

        }

    if ( match )

        {

        TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithContactIdL, Contact match found" );

        CopyContactFieldsDataL( *match, aCallId );

        if ( match->HasThumbnailImage() )

            {

            TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithContactIdL, Thumbnail image found" );

            // Start loading thumbnail for this contact

            // Error code may be ignored since this is not a critical function

            iDataStore.SetHasCallerThumbnail( ETrue, aCallId );

            LoadThumbnail( iDataStore.ContactId( aCallId ), aCallId );

            }

        match->Release();

        match = NULL;

        }

    CleanupStack::PopAndDestroy( contactId ); //contactId 

    }

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

// CPEContactMatch::MatchWithNumberL

// Synchronous method for finding contact data specified with phone number.

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

//

void CPEContactMatch::MatchWithNumberL(

        const TInt aCallId

        )

    {

    MPhCntMatch* match( NULL );

    RBuf remoteParty;

    remoteParty.CleanupClosePushL();

    if ( iDataStore.CallType( aCallId ) == EPECallTypeVoIP )

        {

        TEFLOGSTRING2( KTAINT, "CNT CPEContactMatch::MatchWithNumberL > CPhCntMatcher::MatchVoipNumber, call id: %d", aCallId );

        MatchWithVoipAdressL( aCallId, match, remoteParty );

        }

    else

        {

        TPEPhoneNumber remoteNumber = iDataStore.RemotePhoneNumber( aCallId );

        TEFLOGSTRING3( KTAINT, "CNT CPEContactMatch::MatchWithNumberL > CPhCntMatcher::MatchNumber, number: %S, call id: %d",

            &remoteNumber, aCallId );

        iContactMatcher->MatchNumber( match, remoteNumber );

        }

    if ( match )

        {

        TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithNumberL, Contact match found" );

        CopyContactFieldsDataL( *match, aCallId );

        if ( match->HasThumbnailImage() )

            {

            TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithNumberL, Thumbnail image found" );

            // Start loading thumbnail for this contact

            // Error code may be ignored since this is not a critical function

            iDataStore.SetHasCallerThumbnail( ETrue, aCallId );

            LoadThumbnail( iDataStore.ContactId( aCallId ), aCallId );

            }

        match->Release();

        match = NULL;

        }

    else if ( 0 < remoteParty.Length() )

        {

        TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::MatchWithNumberL, Set plugins remote name" );

        // Match not found, set plugins remote party name.

        // Make sure that length of the remote name is not too long.

        iDataStore.SetRemoteName( remoteParty.Left( 

                                    Min( KCntMaxTextFieldLength, remoteParty.Length() ) ), 

                                  aCallId );

        }

    CleanupStack::PopAndDestroy( &remoteParty );

    }

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

// CPEContactMatch::LoadThumbnail

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

//

TInt CPEContactMatch::LoadThumbnail(

        const CPhCntContactId& aContactId,

        const TInt aCallId )

    {

    // use call id for identifying which thumbnail is loaded

    // Increment it because zero is invalid value for the id

    TInt thumbnailId = aCallId + 1;

    iThumbnailId =

        reinterpret_cast< CPhCntThumbnailLoader::TThumbnailId > ( thumbnailId );

    TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::LoadThumbnail > CPhCntThumbnailLoader::Load" );

    return iContactThumbnailLoader->Load( iThumbnailId, aContactId );

    }

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

// CPEContactMatch::MpctloThumbnailLoaded

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

//

void CPEContactMatch::MpctloThumbnailLoaded(

        CPhCntThumbnailLoader::TThumbnailId aId,

        TInt aResult, 

        CFbsBitmap* aBitmap )

    {

    // Operation complete

    // Reset id to indicate that no thumbnail loading is in progress

    iThumbnailId = KPhCntThumbnailNullId;

    if ( aResult == KErrNone )

        {

        iThumbnailImage = aBitmap;

        // Decrement call id, see LoadThumbnail() for reason

        TInt thumbnailId = ( reinterpret_cast< TInt >( aId ) ) - 1;

        iOwner.SendMessage( MEngineMonitor::EPEMessageThumbnailLoadingCompleted, thumbnailId );

        }

    else

        {

        TEFLOGSTRING( KTAERROR,

            "CNT CPECONTACTMATCH::MPCTLOTHUMBNAILLOADED ! ERROR LOADING THUMBNAIL" );

        iOwner.SendErrorMessage( aResult );

        }

    }

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

// CPEContactMatch::ContactThumbnail

// Returns contact thumbnail image, NULL if not found

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

//

CFbsBitmap* CPEContactMatch::ContactThumbnail()

    {

    if ( !iThumbnailImage )

        {

        return NULL;

        }

    CFbsBitmap* returnedThumbnailImage( iThumbnailImage );

    iThumbnailImage = NULL; // Ownership is passed to caller

    return returnedThumbnailImage;

    }

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

// CPEContactMatch::CopyContactFieldsDataL

// Copies contact information to remote info struct

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

//

void CPEContactMatch::CopyContactFieldsDataL(

        const MPhCntMatch& aMatch,

        const TInt aCallId

        )

    {

    TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::CopyContactFieldsDataL: start" );

    // Set ringing tone's filename

    iDataStore.SetPersonalRingingTone( aMatch.PersonalRingingTone(), aCallId );

    // Set name

    // The following logic determines if one of the languages that require

    // swapping of first/last name order is selected and performs the operation.

    HBufC* lastname( NULL );

    HBufC* firstname( NULL );

    if ( aMatch.LastName().Length() > 0 )

        {

        TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::CopyContactFieldsDataL, alloc last name" );

        lastname = aMatch.LastName().Alloc();

        }

    if ( aMatch.FirstName().Length() > 0 )

        {

        TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::CopyContactFieldsDataL, alloc first name" );

        firstname = aMatch.FirstName().Alloc();

        }

    if ( ( lastname ) && ( firstname ) )

        {

        //Swap name order, if required by the current language setting

        const TLanguage language = User::Language();

        for ( TInt index = 0; index < KPENumberOfSwappedLanguages; index++ )

            {

            if ( KPESwappedLanguages[index] == language )

                {

                HBufC* tempfirstname( firstname );

                firstname = lastname;

                lastname = tempfirstname;

                break;

                }

            }

        }

    TPEContactName finalName;

    // Parse name by concatenating lastname and firstname

    if ( firstname )

        {

        finalName = *firstname;

        if ( finalName.Length() < KCntMaxTextFieldLength && lastname )

            {

            TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::CopyContactFieldsDataL, append with space" );

            finalName.Append( KPESpace );

            }

        delete firstname;

        firstname = NULL;

        }

    if ( lastname )

        {

        if ( finalName.Length() < KCntMaxTextFieldLength )

            {

            // Check how long last name can be added to the iName string. 

            TInt lastNameMaxLength = KCntMaxTextFieldLength - finalName.Length();

            if ( lastname->Length() > lastNameMaxLength )

                {

                TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::CopyContactFieldsDataL, append with part of last name" );

                // Cut extra chars from the string.

                finalName.Append( lastname->Left( lastNameMaxLength ) );          

                }

            else 

                {

                TEFLOGSTRING( KTAINT, "CNT CPEContactMatch::CopyContactFieldsDataL, append with last name" );

                finalName.Append( *lastname );

                }

            }

        delete lastname;

        lastname = NULL;

        }

    // Replace paragraph separator with space character

    const TText ps(0x2029);

    while ( finalName.Locate( ps ) != KErrNotFound )

        {

        finalName[ finalName.Locate( ps )] = ' ';

        }

    iDataStore.SetRemoteName( finalName, aCallId );

    iDataStore.SetRemoteTextToSpeechText( aMatch.TextToSpeechTextL(), aCallId );

    if ( aMatch.Number().Length() > 0 )

        {

        iDataStore.SetRemotePhoneNumber( aMatch.Number(), aCallId );    

        }   

    TInt phcntfinderNumberType = aMatch.NumberType();

    switch ( phcntfinderNumberType )

        {

        case MPhCntMatch::EMobileNumber:

            iDataStore.SetRemotePhoneNumberType( EPEMobileNumber, aCallId );

            break;

        case MPhCntMatch::EStandardNumber:

            iDataStore.SetRemotePhoneNumberType( EPETelephoneNumber, aCallId );

            break;

        case MPhCntMatch::EFaxNumber:

            iDataStore.SetRemotePhoneNumberType( EPEFaxNumber, aCallId );

            break;

        case MPhCntMatch::EPagerNumber:

            iDataStore.SetRemotePhoneNumberType( EPEPager, aCallId );

            break;

        case MPhCntMatch::EVoipNumber:

            iDataStore.SetRemotePhoneNumberType( EPEVoipNumber, aCallId );

            break;

        case MPhCntMatch::EVideoNumber:

            iDataStore.SetRemotePhoneNumberType( EPEVideoNumber, aCallId );

            break;        

        case MPhCntMatch::EAssistantNumber:

            iDataStore.SetRemotePhoneNumberType( EPEAssistantNumber, aCallId );

            break;        

        case MPhCntMatch::ECarNumber:

            iDataStore.SetRemotePhoneNumberType( EPECarNumber, aCallId );

            break;        

        case MPhCntMatch::EHomeNumber:

            iDataStore.SetRemotePhoneNumberType( EPEHomeNumber, aCallId );

            break;        

        case MPhCntMatch::EWorkNumber:

            iDataStore.SetRemotePhoneNumberType( EPEWorkNumber, aCallId );

            break;        

        case MPhCntMatch::ENone: // fall through

        default:

            iDataStore.SetRemotePhoneNumberType( EPEUnknownNumber, aCallId );

            break;

        }

    // Replace paragraph separator with space character

    TPEContactName companyName;

    companyName = aMatch.CompanyName();

    while ( companyName.Locate( ps ) != KErrNotFound )

        {

        companyName[ companyName.Locate( ps )] = ' ';

        }

    // Set Company name

    iDataStore.SetRemoteCompanyName( companyName, aCallId );

    // Set Call text

    iDataStore.SetCallerText( aMatch.CallText(), aCallId );

    // Set Call image