/*

* t_vimpstenginepresencesubservice.cpp ::Copyright (c) 2009 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:t_vimpstenginepresencesubservice.cpp

*

*/

#include "t_vimpstenginepresencesubservice.h"

#include <spentry.h>

#include <spsettings.h>

#include <spproperty.h>

#include <avabilitytext.h>

//#include "vimpstcustomcleanupapi.h"

#include <cntdb.h>

#include "s_ximpclient.h"

#include "s_ximpcontext.h"

#include "s_presencefeatures.h"

#include "s_presentitygroups.h"

#include "s_ximprequestcompleteevent.h"

#include "s_ximppresensitypresenceevent.h"

#include "s_ximppresencegrantrequestlistevent.h"

#include "s_ximppresensitygroupcontentevent.h"

#include "s_ximpcontextstateevent.h"

#include "s_ximpidentity.h"

#include "s_presenceinfo.h"

#include "s_presencebuddyinfo2.h"

#include "s_presenceblockinfo.h"

//#include "s_presencebuddyinfolist.h"

#include "s_ximppresensitypresenceevent.h"

#include "s_presencesubserviceeventobserver.h"

#include "cvimpstenginepresencesubservice.h"

#include "cvimpstenginecchhandler.h"

#include "cvimpstengineservicetablefetcher.h"

#include "cvimpstenginesessioncntxtobserver.h"

#include "cvimpstblockedlistmanager.h"

//extern MyCchService* myService;

extern TBool createService;

extern TBool tryPresenceSubServiceAvailable;

extern TBool tryAllSubserviceAvailable;

extern TInt32 gMXIMPRequestCompleteEventStubInterfaceId;

extern TInt32 gMXIMPContextStateEventStubInterfaceId;

extern TInt32 gMXIMPPresentityPresenceEventStubInterfaceId;

extern TInt32 gMXIMPPresenceGrantRequestListEventStubInterfaceId;

extern TInt32 gMXIMPPresenceBlockInfoStubInterfaceId;

extern TInt32 gMXIMPPresentityGroupEventStubInterfaceId;

extern TBool gRequestCompleteEventResultCodeKerrNotSupported;

extern TXIMPRequestId gMXIMPRequestCompleteEventStubRequestId;

extern TBool gCreateXIMPIdentity;

extern TInt gNewRequestsCountValue;

extern TInt gCurrentRequestsCountValue;

extern TBool gPersonPresenceInfoAvailable;

extern TBool tryConnParamWithSuccess;

extern TBool tryParamTomatchOwnId;

//extern MPresenceInfoStub* gMPresenceInfoStub;

// cache error 

extern TInt gAllBuddiesPresenceInServiceError;

const TInt KTestServiceId = 5;

//_LIT( KTestDb, "contacts.cdb" );

//_LIT( KTestContactList, "TEST_CONTACT_LIST" );

//_LIT( KTestUserId, "TEST_USER_ID" );

//_LIT( KTestNickName, "TEST_NICKNAME" );

_LIT( KTestContactId, "TEST_CONTACT_ID" );

_LIT( KTestStatusText, "TEST_STATUS" );

//_LIT( KTestPresenceUri, "test@test.com" );

//availability status text

_LIT(KBlockedState,"BlockedState");

//_LIT(KInvisibleState,"InvisibleState");

//_LIT(KAwayState,"AwayState");

//_LIT(KOnPhoneState,"OnPhoneState");

//_LIT(KDndState,"DoNotDisturb");

//_LIT(KPendingRequestState,"PendingRequestState");

//extern RPointerArray<MPresenceBuddyInfo> gPresenceArry;

T_VimpstEnginePresenceSubService* T_VimpstEnginePresenceSubService::NewLC()

    {

    T_VimpstEnginePresenceSubService* self = new( ELeave ) T_VimpstEnginePresenceSubService;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

T_VimpstEnginePresenceSubService::~T_VimpstEnginePresenceSubService()

    {

    }

void T_VimpstEnginePresenceSubService::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

//  FROM OBSERVER INTERFACES

void T_VimpstEnginePresenceSubService::HandleServceConnectionEventL()

    {

    }

void T_VimpstEnginePresenceSubService::SetupL()

    {

 	createService = ETrue;

    tryPresenceSubServiceAvailable = ETrue;

    iTestServiceId = CreateSpEntryL( KTestServiceId );

    iCchHandler = CVIMPSTEngineCchHandler::NewL( iTestServiceId, *iCchUiEventObserver);

    iServiceTableFetcher = CVIMPSTEngineServiceTableFetcher::NewL();

    iSessionCntxtObserver = CVIMPSTEngineSessionCntxtObserver::NewL( iTestServiceId );

    delete iSessionCntxtObserver->iFeatures;

    iSessionCntxtObserver->iFeatures = NULL;

    delete iSessionCntxtObserver->iPresenceCtx;

    iSessionCntxtObserver->iPresenceCtx = NULL;

    delete iSessionCntxtObserver->iClient;

    iSessionCntxtObserver->iClient = NULL;

    iSessionCntxtObserver->iClient = MXIMPClientStub::NewClientL();

    iSessionCntxtObserver->iPresenceCtx = 

        iSessionCntxtObserver->iClient->NewPresenceContextLC();    

    CleanupStack::Pop();// because of LC method

    iSessionCntxtObserver->iFeatures =  MyMPresenceFeatureStub::NewStubL( iSessionCntxtObserver->iPresenceCtx);

    iPresenceSubService = CVIMPSTEnginePresenceSubService::NewL( 

												        iTestServiceId,

												        *iCchHandler,

												        *iServiceTableFetcher,

												        *iSessionCntxtObserver,

												        *this );

    }

void T_VimpstEnginePresenceSubService::Teardown()

    {

    tryPresenceSubServiceAvailable = EFalse;

   // tryAllSubserviceAvailable = EFalse;

    createService = EFalse;

   // gCreateXIMPIdentity = EFalse;

   // gPersonPresenceInfoAvailable = EFalse;

    if ( iSessionCntxtObserver )

        {

        delete iSessionCntxtObserver->iFeatures;

	    iSessionCntxtObserver->iFeatures = NULL;

	    delete iSessionCntxtObserver->iPresenceCtx;

	    iSessionCntxtObserver->iPresenceCtx = NULL;

	    delete iSessionCntxtObserver->iClient;

	    iSessionCntxtObserver->iClient = NULL;

	    delete iSessionCntxtObserver;

        iSessionCntxtObserver = NULL;

        }

    if ( iPresenceSubService )

        {

        delete iPresenceSubService;

        iPresenceSubService = NULL;

        } 

    if ( iCchHandler )

        {

        delete iCchHandler;

        iCchHandler = NULL;

        }

    if ( iServiceTableFetcher )

        {

        delete iServiceTableFetcher;

        iServiceTableFetcher = NULL;

        }

   /* if ( gMPresenceInfoStub )

        {

        delete gMPresenceInfoStub;

        gMPresenceInfoStub = NULL;

        }*/

    }

TInt T_VimpstEnginePresenceSubService::CreateSpEntryL( TInt aServiceId )

    {

    CSPSettings* settings = CSPSettings::NewLC();

    CSPEntry* entry = CSPEntry::NewLC();

    entry->SetServiceId( aServiceId );

    CSPEntry* testEntry = CSPEntry::NewLC();

    TInt result = settings->FindEntryL( entry->GetServiceId(), *testEntry );

    if( result == KErrNone )

        {

        settings->UpdateEntryL( *entry );

        }

    else

        {

        settings->AddEntryL( *entry );

        }

    TInt createdServiceId = entry->GetServiceId();

    CleanupStack::PopAndDestroy( testEntry );

    CleanupStack::PopAndDestroy( entry );

    CleanupStack::PopAndDestroy( settings );

    return createdServiceId;

    }   

void T_VimpstEnginePresenceSubService::T_NewLL()

    {

    CVIMPSTEnginePresenceSubService* presenceSubService = NULL;

    presenceSubService = CVIMPSTEnginePresenceSubService::NewL(

        iTestServiceId,

        *iCchHandler,

        *iServiceTableFetcher,

        *iSessionCntxtObserver,

        *this);

    EUNIT_ASSERT( presenceSubService != NULL );

    delete presenceSubService;

    presenceSubService = NULL;

    }

void T_VimpstEnginePresenceSubService::T_SubServiceStateL()

    {

    RArray<TVIMPSTEnums::TVIMPSTRegistrationState> states;

    CleanupClosePushL( states );

    states.AppendL( TVIMPSTEnums::ESVCENotRegistered );

    states.AppendL( TVIMPSTEnums::ESVCERegistered );

    states.AppendL( TVIMPSTEnums::ESVCENetworkConnecting );

    states.AppendL( TVIMPSTEnums::ESVCEWaitingForNetwork );

    states.AppendL( TVIMPSTEnums::ESVCENetworkDisConnecting );

    states.AppendL( TVIMPSTEnums::ESVCEUpdatingContacts );

    for ( TInt i( 0 ) ; i < states.Count() ; i++ )

        {

        iPresenceSubService->iServiceState = states[ i ];

        EUNIT_ASSERT( states[ i ] == iPresenceSubService->SubServiceState() );

        }

    CleanupStack::PopAndDestroy( &states );

    }

void T_VimpstEnginePresenceSubService::T_TypeL()

    {    

    EUNIT_ASSERT( TVIMPSTEnums::EPresence == iPresenceSubService->Type() );

    }

void T_VimpstEnginePresenceSubService::T_Enabled()

    {

    // failed

    iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCERegistered;

    TBool enabled = iPresenceSubService->Enabled();

    EUNIT_ASSERT( enabled == ETrue );

    iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCENotRegistered;

    enabled = iPresenceSubService->Enabled();

    EUNIT_ASSERT( enabled == EFalse );

    }

void T_VimpstEnginePresenceSubService::T_RetrieveSubscribedListLL()

    {

    TInt error( KErrNone );

    gCreateXIMPIdentity = EFalse;

    TRAP( error, iPresenceSubService->RetrieveSubscribedListL( ) );

    EUNIT_ASSERT( KErrNoMemory == error );

    gCreateXIMPIdentity = ETrue;

    TRAP( error, iPresenceSubService->RetrieveSubscribedListL( ) );

    EUNIT_ASSERT( KErrNone == error );

    }

void T_VimpstEnginePresenceSubService::T_SubscribePresenceOfSingleContactL()

    {

    gCreateXIMPIdentity = ETrue;

    TRAPD( err, iPresenceSubService->SubscribePresenceOfSingleContactL( KNullDesC ) );

    EUNIT_ASSERT( err == KErrArgument );

   	gCreateXIMPIdentity = ETrue;

    TRAP( err, iPresenceSubService->SubscribePresenceOfSingleContactL(KTestContactId ) );

    EUNIT_ASSERT( KErrNone == err );

    }

void T_VimpstEnginePresenceSubService::T_UnSubscribePresenceOfSingleContactLL()

    {

    gCreateXIMPIdentity = ETrue;

    TRAPD( err, iPresenceSubService->UnSubscribePresenceOfSingleContactL( KTestContactId ) );

    EUNIT_ASSERT( KErrNone == err );

    }

void T_VimpstEnginePresenceSubService::T_DoHandlePresentityGroupContentEventLL()

	{

	TInt error( KErrNone );

	MXIMPContext* context = NULL;

	MPresentityGroupContentEventStub presentityGroupContentEvent;

	TRAP( error, iPresenceSubService->DoHandlePresentityGroupContentEventL( 

	 								*context, presentityGroupContentEvent ) );

	EUNIT_ASSERT( KErrNone == error );

	iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCEUpdatingContacts;

	TRAP( error, iPresenceSubService->DoHandlePresentityGroupContentEventL( 

	 								*context, presentityGroupContentEvent ) );

	EUNIT_ASSERT( KErrNone == error );

	}

void T_VimpstEnginePresenceSubService::T_DoHandlePresenceBlockListEventL()

    {

    TInt error( KErrNone );

    MXIMPContext* context = NULL;

    MPresenceBlockInfoStub presenceblockinfo;

    TRAP( error, iPresenceSubService->DoHandlePresenceBlockListEventL( 

                                    *context, presenceblockinfo ) );

    EUNIT_ASSERT( KErrNone == error );

    iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCEUpdatingContacts;

    TRAP( error, iPresenceSubService->DoHandlePresenceBlockListEventL( 

                                    *context, presenceblockinfo ) );

    EUNIT_ASSERT( KErrNone == error );

    }

void T_VimpstEnginePresenceSubService::T_DoHandlePresenceGrantRequestListEventLL()

    {

    TInt error( KErrNone );

    MXIMPContext* context = NULL;

    MPresenceGrantRequestListEventStub presenceGrantRequestListEventStub;

    ::gNewRequestsCountValue = 1;

    ::gCurrentRequestsCountValue = 1;

    TRAP( error, iPresenceSubService->DoHandlePresenceGrantRequestListEventL( 

        *context, presenceGrantRequestListEventStub ) );

    ::gNewRequestsCountValue = KErrNone;

    ::gCurrentRequestsCountValue = KErrNone;

    EUNIT_ASSERT( KErrNone == error );

    }

void T_VimpstEnginePresenceSubService::T_ResolveServiceStateLL()

    {

    TInt error( KErrNotFound );

    RArray<TCCHSubserviceState> subServiceStates;   

    CleanupClosePushL( subServiceStates );

    subServiceStates.AppendL( ECCHUninitialized );

    subServiceStates.AppendL( ECCHDisabled );

    subServiceStates.AppendL( ECCHConnecting );

    subServiceStates.AppendL( ECCHEnabled );

    subServiceStates.AppendL( ECCHDisconnecting );

    // Test with service error: KErrNone and all subservice states.

    TInt serviceError( KErrNone );

    for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )

        {

        TRAP( error, iPresenceSubService->ResolveServiceStateL( 

            	subServiceStates[ i ], serviceError ) );

        EUNIT_ASSERT( KErrNone == error );

        }

    // Test with service error: KErrNotFound and all subservice states.

    serviceError = KErrNotFound;

    TRAP( error, iPresenceSubService->ResolveServiceStateL( 

            	ECCHDisconnecting, serviceError ) );

    EUNIT_ASSERT( KErrNone == error );

    CleanupStack::PopAndDestroy( &subServiceStates );

    }

void T_VimpstEnginePresenceSubService::T_CchEventOccuredLL()

    {

    TInt error( KErrNotFound );

    RArray<TCCHSubserviceState> subServiceStates;   

    CleanupClosePushL( subServiceStates );

    subServiceStates.AppendL( ECCHUninitialized );

    subServiceStates.AppendL( ECCHDisabled );

    subServiceStates.AppendL( ECCHConnecting );

    subServiceStates.AppendL( ECCHEnabled );

    subServiceStates.AppendL( ECCHDisconnecting );

   // Test with service error: KErrNone and all subservice states.

    TInt serviceError( KErrNone );

    for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )

        {

        TRAP( error, iPresenceSubService->CchEventOccuredL( 

            iTestServiceId, subServiceStates[ i ], serviceError ) );

        EUNIT_ASSERT( KErrNone == error );

        }

    // Test with service error: KErrNotFound and all subservice states.

    serviceError = KErrNotFound;

    for ( TInt j( 0 ) ; j < subServiceStates.Count() ; j++ )

        {

        TRAP( error, iPresenceSubService->CchEventOccuredL( 

            iTestServiceId, subServiceStates[ j ], serviceError ) );

        EUNIT_ASSERT( KErrNone == error );

        }

    CleanupStack::PopAndDestroy( &subServiceStates );

    EUNIT_ASSERT( KErrNone == error );

    }

void T_VimpstEnginePresenceSubService::T_DoHandleCchErrorLL()

    {

    RArray<TInt> serviceErrors;

    CleanupClosePushL( serviceErrors );

    serviceErrors.AppendL( KErrGeneral ); // Tests default case

    serviceErrors.AppendL( KCCHErrorBandwidthInsufficient );

    serviceErrors.AppendL( KCCHErrorInvalidIap );

    serviceErrors.AppendL( KCCHErrorAuthenticationFailed );

    serviceErrors.AppendL( KCCHErrorNetworkLost );

    serviceErrors.AppendL( KCCHErrorLoginFailed );

    serviceErrors.AppendL( KCCHErrorServiceNotResponding );

    serviceErrors.AppendL( KCCHErrorInvalidSettings );

    serviceErrors.AppendL( KCCHErrorAccessPointNotDefined );

    for ( TInt i( 0 ) ; i < serviceErrors.Count() ; i++ )

        {

        TRAPD( err, iPresenceSubService->DoHandleCchErrorL( 

            serviceErrors[ i ] ) );

        EUNIT_ASSERT( KErrNone == err );

        }

    CleanupStack::PopAndDestroy( &serviceErrors );

    }

void T_VimpstEnginePresenceSubService::T_PublishOwnPresenceLL()

    {

    RArray<TVIMPSTEnums::TOnlineStatus> onlineStatusArray;

    CleanupClosePushL( onlineStatusArray );

    onlineStatusArray.AppendL( TVIMPSTEnums::EUnknown );

 //   onlineStatusArray.AppendL( TVIMPSTEnums::EOffline );

 //   onlineStatusArray.AppendL( TVIMPSTEnums::EOnline );

 //   onlineStatusArray.AppendL( TVIMPSTEnums::EInvisible );

 //   onlineStatusArray.AppendL( TVIMPSTEnums::EAway );

 //   onlineStatusArray.AppendL( TVIMPSTEnums::EBusy );

    for ( TInt i( 0 ); i < onlineStatusArray.Count() ; i++ )

        {

        TRAPD( err, iPresenceSubService->PublishOwnPresenceL( 

            onlineStatusArray[ i ], KTestStatusText ) );

        EUNIT_ASSERT( KErrNone == err );

        }

    CleanupStack::PopAndDestroy( &onlineStatusArray );

    }

void T_VimpstEnginePresenceSubService::T_ConvertPresenceStatus()

    {

    EUNIT_ASSERT( NPresenceInfo::ENotAvailable == 

        iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EOffline ) );

    EUNIT_ASSERT( NPresenceInfo::EAvailable == 

            iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EOnline ) );

    EUNIT_ASSERT( NPresenceInfo::EHidden == 

            iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EInvisible ) );

    EUNIT_ASSERT( NPresenceInfo::EAway == 

            iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EAway ) );

    EUNIT_ASSERT( NPresenceInfo::EBusy == 

            iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EBusy ) );

    EUNIT_ASSERT( NPresenceInfo::ENotAvailable == 

                iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EUnknown ) );

    }

/*

void T_VimpstEnginePresenceSubService::T_FetchPresenceFormCacheL()

    {

    TInt error = iPresenceSubService->FetchPresenceFormCache();

    EUNIT_ASSERT( KErrNone == error );

    gAllBuddiesPresenceInServiceError = KErrBadHandle;

    error = iPresenceSubService->FetchPresenceFormCache();

    EUNIT_ASSERT( KErrBadHandle == error );

    delete iPresenceSubService->iServiceName;

    iPresenceSubService->iServiceName = NULL;

    error = iPresenceSubService->FetchPresenceFormCache();

    EUNIT_ASSERT( KErrArgument == error );

    }

*/

void T_VimpstEnginePresenceSubService::T_HandlePresenceReadLL()

    {

    TInt error( KErrNone );

    TInt testError( KErrGeneral );

    tryConnParamWithSuccess = ETrue;

    RPointerArray< MPresenceBuddyInfo2> buddyInfoList;

    TRAP( error, iPresenceSubService->HandlePresenceReadL( 

        testError, buddyInfoList ) );

    EUNIT_ASSERT( KErrNone == error );

    CleanupClosePushL( buddyInfoList );

    MPresenceBuddyInfo2Stub* buddyInfo1 = MPresenceBuddyInfo2Stub::NewStubL();

    CleanupDeletePushL( buddyInfo1 );

    MPresenceBuddyInfo2Stub* buddyInfo2 = MPresenceBuddyInfo2Stub::NewStubL();

    CleanupDeletePushL( buddyInfo2 );

    MPresenceBuddyInfo2Stub* buddyInfo3 = MPresenceBuddyInfo2Stub::NewStubL();

    CleanupDeletePushL( buddyInfo3 );

    buddyInfoList.AppendL( buddyInfo1 );

    buddyInfoList.AppendL( buddyInfo2 );

    buddyInfoList.AppendL( buddyInfo3 );

    testError = KErrNone;

    TRAP( error, iPresenceSubService->HandlePresenceReadL( 

        testError, buddyInfoList ) );

    EUNIT_ASSERT( KErrNone == error );

    CleanupStack::Pop(3); //buddyInfo1,2,3 just pop since ownership is tranferred

    tryConnParamWithSuccess = EFalse;

    tryParamTomatchOwnId = ETrue;

    testError = KErrNone;