/*

* 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:  Implements VoIP specific matching methods.

*

*/

#include <MVPbkContactLinkArray.h>

#include <TVPbkContactStoreUriPtr.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include "cphcntmatchervoipimpl.h"

#include "tphcntsipuri.h"

#include "cphcntfoundcontacts.h"

#include "cphcntmatchcontact.h"

#include "cphcntvoipcontactmatchstrategy.h"

#include "tphcntvoipmatchArray.h"

#include "mphcntmatch.h"

#include "CPhCntContact.h"

#include "cphcntvpbkcontactid.h"

#include "cphcntfetchcontact.h"

#include "CPhCntContactManager.h"

#include "cphcntstoreloaderimpl.h" //

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

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

// Static constructor

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

//

CPhCntMatcherVoIPImpl* CPhCntMatcherVoIPImpl::NewL(

    const MPhoneCntPbkOwner& aOwner )

    {

    CPhCntMatcherVoIPImpl* self = 

        new( ELeave ) CPhCntMatcherVoIPImpl( aOwner );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CPhCntMatcherVoIPImpl::~CPhCntMatcherVoIPImpl()

    {

    delete iVoipMatchStrategy;

    delete iContactStoreLoader;

    }

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

// From class CPhCntMatcher

// Matches voip contacts

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

//    

TInt CPhCntMatcherVoIPImpl::MatchVoipNumber(

    MPhCntMatch*& aMatch,

    const TDesC& aMatchString,

    TBool aAllowUserNameMatch,

    MDesCArray* aContactStoreUris,

    TInt aCharsForMatching )

    {    

    TPhCntSipURI sipUri( aMatchString, aCharsForMatching );

    TInt err = CreateMatcher();    

    if ( err == KErrNone )

        {

        CPhCntContact* existingContact = 

            iFoundContacts->FindContact( sipUri.SipURI() );

        if( !existingContact )

            {

            // Check for service specific contact stores and

            // open stores if not open

            if ( aContactStoreUris )

                {

                TInt storeCount = aContactStoreUris->MdcaCount();

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

                    {

                    TPtrC storeUri = aContactStoreUris->MdcaPoint( i );

                    err = iContactStoreLoader->LoadContactStoreWithUri( storeUri );              

                    }  

                }

            const MVPbkContactLinkArray* linkArray = NULL;

            // Find possible contacts.

            if( aAllowUserNameMatch && !aCharsForMatching )

                {

                err = iMatchContact->MatchContact(

                    linkArray, sipUri.UserNamePart(), *iVoipMatchStrategy );

                }

            else if ( aCharsForMatching )

                {

                err = iMatchContact->MatchContact(

                    linkArray, sipUri.FixedUserNamePart(), *iVoipMatchStrategy );            

                }

            else

                {

                err = iMatchContact->MatchContact( 

                    linkArray, sipUri.SipURI() , *iVoipMatchStrategy );    

                }

            MPhCntMatch* match = NULL;

            if( !err )

                {

                // Fetch all the matched contacts, because iVoipMatchStrategy

                // could give us a match that is matched to wrong contact field.

                const TInt matchedContacts( linkArray->Count() );

                // Find real matches.

                TPhCntVoipMatchArray voipMatches;

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

                    {

                    // Get contacts from phone book.

                    CPhCntContact* match = NULL;

                    err = FetchContact( match, linkArray->At( i ), sipUri.SipURI() );

                    if( !err )

                        {

                        TRAP_IGNORE( voipMatches.AppendL( match ) );

                        }

                    else

                        {

                        // Error in fetching contacts 

                        break;

                        }

                    }

                if( aAllowUserNameMatch || aCharsForMatching )   

                    {

                    match = voipMatches.FindFullOrUsernameMatch( sipUri, aCharsForMatching );

                    }

                else

                    {

                    // Take the first match, that is voip contact. Gives NULL if match not found.

                    match = voipMatches.FindFullMatch( sipUri );

                    }

                // Release extra matches

                voipMatches.ReleaseMatches();

                }

            // If no error and match still null pointer, then no contacts were found.

            if( !err && !match )        

                {

                err = KErrNotFound;

                }

            else

                {

                aMatch = match;

                }

            }

        else

            {

            aMatch = existingContact;

            }

        }

    return err;

    }

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

// From class CPhCntMatcher

// Matches voip contacts

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

TInt CPhCntMatcherVoIPImpl::MatchVoipNumber(

    MPhCntMatch*& aMatch,

    const TDesC& aMatchString,

    const CPhCntContactId& aContactId )

    {

    const CPhCntVPbkContactId& contactId = 

            static_cast<const CPhCntVPbkContactId&>( aContactId );

    const MVPbkContactLink& contactLink = contactId.ContactLink();

    TInt err = CreateMatcher();

    const TVPbkContactStoreUriPtr uri 

        = contactLink.ContactStore().StoreProperties().Uri(); 

    // Open contact store if not opened earlier

    iContactStoreLoader->LoadContactStoreWithUri( uri.UriDes() );

    if ( err == KErrNone )

        {

        CPhCntContact* existingContact = 

            iFoundContacts->FindContact( contactLink );

        if ( !existingContact )

            {

            CPhCntContact* contact = NULL;

            err = iFetchContact->FetchContact( contactLink,  contact );

            if ( !err )

                {

                SetMatchedVoIPNumberIfExists( *contact, aMatchString );

                TPhCntSipURI sipUri( contact->Number() );

                TRAP( err, iFoundContacts->AddL( contact, sipUri.SipURI() ) );

                if ( err )

                    {

                    delete contact;

                    }

                else

                    {

                    aMatch = contact;

                    }

                }

            }

        else

            {

            aMatch = existingContact;

            }

        }

    return err;

    }

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

// Sets matched VoIP number if it was found.

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

//    

void CPhCntMatcherVoIPImpl::SetMatchedVoIPNumberIfExists( 

    CPhCntContact& aContact,

    const TDesC& aMatchString )

    {

    const RArray<TPhCntNumber>& allNumbers = aContact.AllNumbers();

    const TInt numberCount( allNumbers.Count() );

    TPhCntSipURI sipUri( aMatchString );

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

        {

        TPhCntNumber number = allNumbers[i];

        if ( number.Type() == CPhCntContact::EVoipNumber ||

             number.Type() == CPhCntContact::EMobileNumber || 

             number.Type() == CPhCntContact::EStandardNumber ||

             number.Type() == CPhCntContact::EPagerNumber ||

             number.Type() == CPhCntContact::EVideoNumber ||

             number.Type() == CPhCntContact::EAssistantNumber ||

             number.Type() == CPhCntContact::EFaxNumber ||

             number.Type() == CPhCntContact::ECarNumber ) 

            {

            // If uris are the same then we have a full match.

            // (usernamepart requires case sensitive match, domain is not sensitive)

            TPhCntSipURI matchURI( number.Number() );

            if ( matchURI.SipURI().CompareF( sipUri.SipURI() ) == KErrNone &&

                 matchURI.UserNamePart().Compare( sipUri.UserNamePart() ) == KErrNone )

                {

                aContact.SetMatchedVoipNumber( matchURI );

                break;

                }

            }

        }

    }

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

// From class CPhCntMatcher

// Determines if contact has CS numbers.

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

//

TBool CPhCntMatcherVoIPImpl::HasCSNumbers( 

    const CPhCntContactId& aContactId )

    {

    TBool hasCSNumbers = EFalse;

    const CPhCntVPbkContactId& contactId = 

            static_cast<const CPhCntVPbkContactId&>( aContactId );

    if ( CreateMatcher() == KErrNone )

        {

        // Check if we have contact already.

        CPhCntContact* contact = 

            iFoundContacts->FindContact( contactId.ContactLink() );

        if ( contact ) 

            {

            hasCSNumbers = HasCSNumbers( contact );

            contact->Release();

            }

        else

            {

            // Fetch the contact from Virtual phonebook.

            const TInt err = 

                iFetchContact->FetchContact( contactId.ContactLink(), contact );

            hasCSNumbers = HasCSNumbers( contact );

            // We can delete the contact, because it is not added to 

            // iFoundContacts.

            delete contact;

            }

        }

    return hasCSNumbers;

    }

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

// Constructor

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

//

CPhCntMatcherVoIPImpl::CPhCntMatcherVoIPImpl(

    const MPhoneCntPbkOwner& aOwner ) : 

    CPhCntMatcherImpl( aOwner )

    {

    }

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

// Second phase constructor

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

//

void CPhCntMatcherVoIPImpl::ConstructL()

    {

    CPhCntMatcherImpl::ConstructL();

    iContactStoreLoader = CPhCntStoreLoaderImpl::NewL( iContactManager ); 

    }

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

// Determines if contat has other phone numbers than CS numbers.

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

//  

TBool CPhCntMatcherVoIPImpl::HasCSNumbers( 

    const CPhCntContact* const aContact )

    {

    TBool hasCSNumbers = EFalse;

    if ( aContact )

        {

        const RArray<TPhCntNumber>& allNumbers = aContact->AllNumbers();

        const TInt count( allNumbers.Count() );

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

            {

            const MPhCntMatch::TNumberType type = allNumbers[i].Type();

            if ( type != MPhCntMatch::ENone &&

                 type != MPhCntMatch::EFaxNumber &&

                 type != MPhCntMatch::EPagerNumber &&

                 type != MPhCntMatch::EVoipNumber 

                )

                {

                hasCSNumbers = ETrue;

                }

            }

        }

    return hasCSNumbers;

    }

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

// Creates the contact matcher.

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

//  

TInt CPhCntMatcherVoIPImpl::CreateMatcher()

    {

    TInt err = CPhCntMatcherImpl::CreateMatcher();

    if ( !err && !iVoipMatchStrategy )

        {

        TRAP( err, iVoipMatchStrategy = 

            CPhCntVoipContactMatchStrategy::NewL( iContactManager, 

            *iMatchContact ) );

        }

    return err;

    }

// End of File