/*

* Copyright (c) 2007 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: 

*       

*

*/

#include <spsettings.h>

#include <MVPbkFieldType.h>

#include "cmscontactfield.h"

#include <MVPbkContactLink.h>

#include <MVPbkContactStore.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactManager.h>

#include <VPbkContactStoreUris.h>

#include <CVPbkContactFieldIterator.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactOperationBase.h>

#include <CVPbkTopContactManager.h>

#include <featmgr.h>

#include <crcseprofileregistry.h>

#include "bpas.h"

#include "bpasinfo.h"

#include "cmsserver.h"

#include "bpasiconinfo.h"

#include "cmsnotifyevent.h"

#include "cmsserverutils.h"

#include "bpasserviceinfo.h"

#include "cmsservercontact.h"

#include "cmsphonebookproxy.h"

#include "cmsserverasynccontact.h"

#include "cmsserverxspcontacthandler.h"

#include "mpresencetrafficlights.h"

#include "cmsserverdefines.h"

#include "cmsdebug.h"

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

// CCmsServerContact::CCmsServerContact

// 

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

// 

CCmsServerContact::CCmsServerContact( CCmsServerSession& aSession,

                                      CCmsServer& aCmsServer ) :

                                      iContactDeleted( EFalse ),

                                      iPresenceNotifySubscribed( EFalse ),                                       

                                      iSession( aSession ),

                                      iCmsServer( aCmsServer )

    {

    }

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

// CCmsServerContact::NewL

// 

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

// 

CCmsServerContact* CCmsServerContact::NewL( CCmsServerSession& aSession,

                                            CCmsServer& aCmsServer )

    {

    CCmsServerContact* self = new( ELeave ) CCmsServerContact( aSession, aCmsServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCmsServerContact::ConstructL

// 

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

// 

void CCmsServerContact::ConstructL()

    {

    PRINT( _L( "Start CCmsServerContact::ConstructL()" ) );

    iContactManager = iCmsServer.PhonebookProxyHandle().ContactManager();

    iAsyncContact = CCmsServerAsyncContact::NewL( *this, iCmsServer );

    iBrandedPresence = CBPAS::NewL();

    iBrandedPresence->SetObserver( this );

    PRINT( _L( "End CCmsServerContact::ConstructL()" ) );

    }

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

// CCmsServerContact::CCmsServerContact

// 

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

// 

CCmsServerContact::~CCmsServerContact()

    {

    PRINT( _L( "Start CCmsServerContact::~CCmsServerContact()" ) );

    iCmsServer.PhonebookProxyHandle().RemoveObserver( this );

    if ( iPresenceNotifySubscribed && iContactLink ) 

        {

        if ( iVoipHandler )

            {

            iVoipHandler->UnsubscribeBrandingForContact( iContactLink, this );            

            }

        if ( iChatHandler )

            {

            iChatHandler->UnsubscribeBrandingForContact( iContactLink, this );            

            }        

        }

    delete iStoreUri;

    delete iChatHandler;

    delete iVoipHandler;

    delete iXSPContactHandler;

    delete iContactLink;

    delete iContact;

    delete iCachedField8;

    delete iAsyncContact;

    delete iCachedField16;

    delete iBrandedPresence;

    delete iPackedContactLinkArray;

    delete iOperation;

    iPresenceEvents.ResetAndDestroy();

    iPhonebookEvents.ResetAndDestroy();

    iPresenceEvents.Close();

    iPhonebookEvents.Close();

    iXSPFindOperationsArray.ResetAndDestroy();

    iXSPFindOperationsArray.Close();

    delete iIdArray;

    PRINT( _L( "End CCmsServerContact::~CCmsServerContact()" ) );

    }

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

// CCmsServerContact::FetchEnabledFields

// 

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

// 

void CCmsServerContact::FetchEnabledFields( const RMessage2& aMessage )

    {

    PRINT( _L( "Start CCmsServerContact::FetchEnabledFields()" ) );

    iMessage = aMessage;

    if( iCachedField16 )

        {

        PRINT( _L("CCmsServerContact::FetchEnabledFields():Handle cached data send" ) );

        CachedDataSend16( KFirstParam );

        }

    else

        {

        PRINT( _L("CCmsServerContact::FetchEnabledFields():Initiate new fetch" ) );

        iAsyncContact->FetchEnabledFields(); 

        }

    PRINT( _L( "End CCmsServerContact::FetchEnabledFields()" ) );

    }

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

// CCmsServerContact::FetchContactData

// 

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

//

void CCmsServerContact::FetchContactData( const RMessage2& aMessage )

    {

    PRINT( _L(" Start CCmsServerContact::FetchContactData()" ) );

    iMessage = aMessage;

    if( !CachedData() )

        {

        PRINT( _L( "CCmsServerContact::FetchContactData():Initiate new fetch" ) );

        CCmsContactFieldItem::TCmsContactField fieldType = 

            ( CCmsContactFieldItem::TCmsContactField )aMessage.Int0();

        iAsyncContact->FetchContactData( fieldType ); 

        }

    PRINT( _L(" End CCmsServerContact::FetchContactData()" ) );    

    }

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

// CCmsServerContact::AsyncContact

// 

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

//

CCmsServerAsyncContact& CCmsServerContact::AsyncContact()

    {

    return *iAsyncContact;

    }

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

// CCmsServerContact::OfferContactEventL

// 

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

//

void CCmsServerContact::OfferContactEventL( TCmsPhonebookEvent aEventType,

                                             const MVPbkContactLink* aContactLink )

    {

    PRINT( _L(" Start CCmsServerContact::OfferContactEventL()" ) );

    TBuf<5> buffer( _L( "" ) );

    if ( !iContact )

    	{

		buffer.AppendNum( aEventType );

        CCmsNotifyEvent* event = CCmsNotifyEvent::NewL( buffer, *this );

        CleanupStack::PushL( event );

        User::LeaveIfError( iPhonebookEvents.Append( event ) );

        CleanupStack::Pop();  //event

        return;

    	}

    MVPbkContactLink* self = Contact().CreateLinkLC();

    if( aContactLink && aContactLink->IsSame( *self ) )

        {

        buffer.AppendNum( aEventType );

        if( ECmsContactDeleted == aEventType )

            {

            PRINT( _L( "CCmsServerContact::OfferContactEventL():  Contact deleted, invalidate this subsession" ) );

            delete iContact;

            iContact = NULL;

            iContactDeleted = ETrue;

            }

        else

            {

            HBufC8* link = self->PackLC();

            TInt error( iCmsServer.PhonebookProxyHandle().FetchContactL( *link, this ) );

            CleanupStack::PopAndDestroy();  //link

            PRINT1( _L( "CCmsServerContact::OfferContactEventL(): Contact handle reloaded - Error: %d" ), error );

            //Suppress UREL warning

            error = KErrNone;

            }

        if( !iPbkNotifyMessage.IsNull() )

            {

            TInt error( iPbkNotifyMessage.Write( KSecondParam, buffer ) );

            PRINT1( _L( "CCmsServerContact::OfferContactEventL():iPbkmsg.Complete() in OfferContactEventL this=%d" ), (TInt)this );

            iPbkNotifyMessage.Complete( error );           

            }

        else  //Add to queue

            {

            PRINT( _L( "CCmsServerContact::OfferContactEventL():Message == NULL => Add to queue" ) );

            CCmsNotifyEvent* event = CCmsNotifyEvent::NewL( buffer, *this );

            CleanupStack::PushL( event );

            User::LeaveIfError( iPhonebookEvents.Append( event ) );

            CleanupStack::Pop();  //event

            }

        }

    CleanupStack::PopAndDestroy();  //self

    PRINT( _L(" End CCmsServerContact::OfferContactEventL()" ) );

    }

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

// CCmsServerContact::IsDeleted

// 

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

// 

TBool CCmsServerContact::IsDeleted() const

    {

    return iContactDeleted;

    }

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

// CCmsServerContact::OrderNotifyL

// 

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

// 

void CCmsServerContact::OrderNotifyL( const RMessage2& aMessage, TBool aAskMore )

    {

    PRINT( _L(" Start CCmsServerContact::OrderNotifyL()" ) );

    TBool foundType( EFalse); 

    if ( CCmsContactFieldItem::ECmsPresenceAllNotification & aMessage.Int0() )    

        {

        foundType = ETrue;

        StartPresenceNotificationL( aMessage, aAskMore );

        }

    if ( CCmsContactFieldItem::ECmsPhonebookNotification & aMessage.Int0() )

        {

        foundType = ETrue;    

        PRINT1( _L( "CCmsServerContact::OrderNotifyL():iPbkMsg initiated in CCmsServerContact::OrderNotifyL() this=%d" ), (TInt)this );

        if( !aAskMore )

            {

            iCmsServer.PhonebookProxyHandle().AddObserverL( this );

            PRINT( _L( "CCmsServerContact::OrderNotifyL():Phonebook observer added" ) );

            }

        else

            {

            if( iPhonebookEvents.Count() > 0 )

                {

                PRINT( _L( "CCmsServerContact::OrderNotifyL():  Complete queued message" ) );

                CCmsNotifyEvent* event( iPhonebookEvents[0] );

                event->Complete( KSecondParam, aMessage );

                iPhonebookEvents.Remove( 0 );

                delete event;

                event = NULL;

                }

            }

        iPbkNotifyMessage = aMessage;

        }

    if ( !foundType )

        {

        User::Leave( KErrNotSupported );

        }

    PRINT( _L(" End CCmsServerContact::OrderNotifyL()" ) );    

    }

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

// CCmsServerContact::StartPresenceNotificationL

// 

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

//

void CCmsServerContact::StartPresenceNotificationL( const RMessage2& aMessage, TBool aAskMore )

    {

    PRINT( _L(" Start CCmsServerContact::StartPresenceNotificationL()" ) );

    if ( !aAskMore )

        {

        PRINT( _L( "CCmsServerContact::StartPresenceNotificationL(): First notification request => send presence info to client" ) );

        if ( iPresenceNotifySubscribed )

            {

            User::Leave( KErrInUse );

            }

        iPresenceNotifyMessage = aMessage;        

        if ( !iContactLink )

            {

            iContactLink = iContact->CreateLinkLC();

            CleanupStack::Pop(); // iContactLink

            } 

        if (  CCmsContactFieldItem::ECmsPresenceVoIPNotification & aMessage.Int0() )

            {

            StartPresenceVoipNotificationL();            

            }

        if (  CCmsContactFieldItem::ECmsPresenceChatNotification & aMessage.Int0() )

            {

            StartPresenceChatNotificationL();             

            }                         

        iPresenceNotifySubscribed = ETrue;                

        }

    else

        {

        PRINT( _L( "CCmsServerContact::StartPresenceNotificationL():Ask more == ETrue => Save the kernel message & check message queue" ) );

        iPresenceNotifyMessage = aMessage;

        if( iPresenceEvents.Count() > 0 )

            {

            PRINT( _L( "CCmsServerContact::StartPresenceNotificationL():Complete queued message" ) );

            CCmsNotifyEvent* event( iPresenceEvents[0] );

            event->Complete( KSecondParam, iPresenceNotifyMessage );

            iPresenceEvents.Remove( 0 );

            delete event;

            event = NULL;

            }

        }

    PRINT( _L(" End CCmsServerContact::StartPresenceNotificationL()" ) );    

    }

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

// CCmsServerContact::StartPresenceVoipNotificationL

// 

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

//

void CCmsServerContact::StartPresenceVoipNotificationL( )

    {  

PRINT( _L(" Start CCmsServerContact::StartPresenceVoipNotificationL" ) );

    const TInt count = sizeof( KPresenceFieldGroup ) / sizeof( KPresenceFieldGroup[0] );    

    CDesCArrayFlat* fieldArray = new ( ELeave ) CDesCArrayFlat( count );

    CleanupStack::PushL( fieldArray );

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

        {

        AddVoipFieldL( *fieldArray, KPresenceFieldGroup[i] );

        }

    if ( !iVoipHandler )

        {

        iVoipHandler = MPresenceTrafficLights::NewL();

        }    

    iVoipHandler->SubscribeBrandingForContactL( iContactLink, fieldArray, this, CCmsContactFieldItem::ECmsPresenceVoIPNotification );

    CleanupStack::PopAndDestroy( fieldArray );

    return;

    }

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

// CCmsServerContact::AddVoipFieldL

// 

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

//

void CCmsServerContact::AddVoipFieldL( CDesCArrayFlat& aArray, TInt aResourceId )

    {

    const MVPbkFieldType* type = iContactManager->FieldTypes().Find( aResourceId );

    CVPbkBaseContactFieldTypeIterator* itr = CVPbkBaseContactFieldTypeIterator::NewLC( 

            *type, iContact->Fields() );

    while( itr->HasNext() )

        {

        const MVPbkBaseContactField* field = itr->Next();

        if ( aResourceId == R_VPBK_FIELD_TYPE_IMPP )

            {

            const MVPbkContactFieldUriData& uri = MVPbkContactFieldUriData::Cast( field->FieldData() );

            if ( iAsyncContact->IsVoipCapableL( uri.Scheme() ) )

                {

                aArray.AppendL( uri.Uri() );

                }            

            }

        else

            {

            const MVPbkContactFieldTextData& text = MVPbkContactFieldTextData::Cast( field->FieldData() );

            aArray.AppendL( text.Text() );               

            }

        }

    CleanupStack::PopAndDestroy( itr );  //itr

    }

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

// CCmsServerContact::StartPresenceChatNotificationL

// 

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

//

void CCmsServerContact::StartPresenceChatNotificationL( )

    {

    PRINT( _L(" Start CCmsServerContact::StartPresenceChatNotificationL" ) );

    const TInt KMyServiceEstimate = 5;      

    CDesCArrayFlat* fieldArray = new ( ELeave ) CDesCArrayFlat( KMyServiceEstimate );

    CleanupStack::PushL( fieldArray );

    const MVPbkFieldType* type = iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_IMPP );

    CVPbkBaseContactFieldTypeIterator* itr = CVPbkBaseContactFieldTypeIterator::NewLC( 

            *type, iContact->Fields() );

    while( itr->HasNext() )

        {

        const MVPbkBaseContactField* field = itr->Next();

        const MVPbkContactFieldUriData& uri = MVPbkContactFieldUriData::Cast( field->FieldData() );

        if ( CmsServerUtils::IsFeatureSupportedL( ESubPropertyIMLaunchUid, uri.Scheme() ) )//iAsyncContact->IsImCapableL( uri.Scheme() ) )

            {

            fieldArray->AppendL( uri.Uri() );

            }

        }

    CleanupStack::PopAndDestroy( itr );  //itr

    if ( !iChatHandler )

        {

        iChatHandler = MPresenceTrafficLights::NewL();

        }    

    iChatHandler->SubscribeBrandingForContactL( iContactLink, fieldArray, this, CCmsContactFieldItem::ECmsPresenceChatNotification );

    CleanupStack::PopAndDestroy( fieldArray );

    PRINT( _L(" End CCmsServerContact::StartPresenceChatNotificationL" ) );

    return;

    }

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

// CCmsServerContact::CompleteNotify

// 

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

//

void CCmsServerContact::CompleteNotify( const RMessage2& aMessage, TInt aStatus )

    {

    PRINT( _L(" Start CCmsServerContact::CompleteNotify()" ) );

    PRINT1( _L( "CCmsServerContact::CompleteNotify(): Status:   %d" ), aStatus );

    if ( CCmsContactFieldItem::ECmsPresenceAllNotification & aMessage.Int0() )

        {

        // stop subscriptions

        if ( iPresenceNotifySubscribed && iContactLink ) 

            {

            if ( iVoipHandler )

                {

                iVoipHandler->UnsubscribeBrandingForContact( iContactLink, this );

                delete iVoipHandler;

                iVoipHandler = NULL;

                }

            if ( iChatHandler )

                {

                iChatHandler->UnsubscribeBrandingForContact( iContactLink, this ); 

                delete iChatHandler;

                iChatHandler = NULL;                

                }

            iPresenceNotifySubscribed = EFalse;            

            }

        EmptyPresenceQueue();

        if( !iPresenceNotifyMessage.IsNull())

            {

            iPresenceNotifyMessage.Complete( aStatus );

            }

        }

    if( CCmsContactFieldItem::ECmsPhonebookNotification & aMessage.Int0() )

        {

        EmptyPhonebookQueue();

        iCmsServer.PhonebookProxyHandle().RemoveObserver( this );

        if( !iPbkNotifyMessage.IsNull() )

            {

            PRINT1( _L( "CCmsServerContact::CompleteNotify():  iPbkMsg.Complete() in CompleteNotify this=%d"),(TInt)this );

            iPbkNotifyMessage.Complete( aStatus );

            }

        }

    }

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

// CCmsServerContact::EmptyPresenceQueue

// 

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

// 

void CCmsServerContact::EmptyPresenceQueue()

    {

    const TInt count = iPresenceEvents.Count();

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