/*
* 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 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 )
            {
            const RArray<TPhCntNumber>& allNumbers = 
                contact->AllNumbers();
            const TInt count( allNumbers.Count() );
            for( TInt i = 0; i < count; i++ )
                {
                // Take first voip number and set it as contacts number.
                TPhCntNumber number = allNumbers[i];
                if( number.Type() == MPhCntMatch::EVoipNumber ||
                    number.Type() == MPhCntMatch::EMobileNumber ||
                    number.Type() == MPhCntMatch::EStandardNumber ||
                    number.Type() == CPhCntContact::EPagerNumber ||
                    number.Type() == CPhCntContact::EVideoNumber ||
                    number.Type() == CPhCntContact::EAssistantNumber ||
                    number.Type() == CPhCntContact::EFaxNumber ||
                    number.Type() == CPhCntContact::ECarNumber ) 
                    {
                    contact->SetMatchedVoipNumber( TPhCntSipURI( number.Number() ) );
                    break;
                    }
                }
            TPhCntSipURI sipUri( contact->Number() );
            TRAP( err, iFoundContacts->AddL( contact, sipUri.SipURI() ) );
            if( err )
                {
                delete contact;
                }
            else
                {
                aMatch = contact;
                }
         
            }
        }
    else
        {
        aMatch = existingContact;
        }
    }
    return err;
    }


// ---------------------------------------------------------------------------
// 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;
    }

TInt CPhCntMatcherVoIPImpl::CreateMatcher()
    {
    TInt err = CPhCntMatcherImpl::CreateMatcher();
    if (!err && !iVoipMatchStrategy )
        {
        TRAP( err, iVoipMatchStrategy = 
            CPhCntVoipContactMatchStrategy::NewL( iContactManager, 
            *iMatchContact ) );
        }
    return err;
    }

    
// End of File