/*

* 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:  Test Protocol implementation for XIMP Framework

 *

*/

#include <badesca.h>

#include <ecom/implementationproxy.h>

#include <ximpstatus.h>

#include <ximpserviceinfo.h>

#include <ximpcontextclientinfo.h>

#include <ximpprotocolconnectionhost.h>

#include <protocolpresencepublishingdatahost.h>

#include <protocolpresencefeatures.h>

#include <ximprestrictedobjectcollection.h>

#include <ximpidentity.h>

#include <presentitygroupinfo.h>

#include <presentitygroupmemberinfo.h>

#include <ximpobjectfactory.h>

#include <ximpprotocolrequestcompleteevent.h>

#include <presencefeatures.h>

#include <presenceobjectfactory.h>

#include <protocolpresencedatahost.h>

#include "pr_prfwtestprotocol.h"

#include "prfwgeneralwaiter.h"

#include "prfwtestmessaging.h"

#include "prfwtestmessenger.h"

#include "prfwtestfilelogichelper.h"

#include "prfwtestfiletool.h"

#include "ximprequestidbuilder.h"

#include "prfwtestprotocols.h"

const TInt KWaitTime = 1;

T_XIMPTestConnection::ClientWrapper* T_XIMPTestConnection::ClientWrapper::NewLC( const TDesC& aClientId )

    {

    ClientWrapper* self = new ( ELeave ) ClientWrapper;

    CleanupStack::PushL( self );

    self->ConstructL( aClientId );

    return self;

    }

void T_XIMPTestConnection::ClientWrapper::ConstructL( const TDesC& aClientId )

    {

    iId.CreateL( aClientId );

    }

void T_XIMPTestConnection::ClientWrapper::InitializeL( MXIMPProtocolConnectionHost& aConnectionHost )

    {

    if( !iMessenger )

        {

        TLex lex( iId );

        TInt index = 0;

        User::LeaveIfError( lex.Val( index ) );

        // TEST CODE

        __ASSERT_ALWAYS( index != -1, User::Panic(_L("Protocol"), 666));

        iMessenger = CXIMPTestMessenger::NewForAdaptationSideL( index );

        iPluginIndex = index;

        }

    if( !iFileLogicHelper )

        {

        iFileLogicHelper = CXIMPTestFileLogicHelper::NewL( aConnectionHost, *iMessenger );

        }

    if( !iFileTool )

        {

        // TODO FIX FILETOOL CREATION

        iFileTool = CXIMPTestFileTool::NewL( K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID, iId );

        iFileTool->RegisterObserverL( iFileLogicHelper );

        }

    }

T_XIMPTestConnection::ClientWrapper::~ClientWrapper()

    {

    if( iFileTool && iFileLogicHelper )

        {

        iFileTool->UnregisterObserver( iFileLogicHelper );

        }

    delete iFileTool;

    delete iFileLogicHelper;

    delete iMessenger;

    iId.Close();

    }

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

// OrderOfClients()

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

//

TInt T_XIMPTestConnection::OrderOfClients( const T_XIMPTestConnection::ClientWrapper& aFirst,

                                           const T_XIMPTestConnection::ClientWrapper& aSecond )

    {

    return aFirst.iId.Compare( aSecond.iId );

    }

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

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

// OrderOfConnections()

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

//

TInt T_XIMPTestConnection::OrderOfConnections( const T_XIMPTestConnection& aFirst,

                                               const T_XIMPTestConnection& aSecond )

    {

    TInt retVal = aFirst.iServerAddress->Compare( *aSecond.iServerAddress );

    if( retVal != 0 )

        {

        return retVal;

        }

    retVal = aFirst.iUserName->Compare( *aSecond.iUserName );

    if( retVal != 0 )

        {

        return retVal;

        }

    return aFirst.iPassword->Compare( *aSecond.iPassword );

    }

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

// T_XIMPTestConnection::T_XIMPTestConnection()

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

//

T_XIMPTestConnection::T_XIMPTestConnection()

    {

    }

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

// T_XIMPTestConnection::ConstructL()

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

//

void T_XIMPTestConnection::ConstructL( const MXIMPServiceInfo& aServiceInfo,

                                       const MXIMPContextClientInfo& aClientCtxInfo )

    {

    iWaitter = CXIMPTestGeneralWaiter::NewL( this );

    iAuxTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    iServerAddress = aServiceInfo.ServiceAddress().AllocL();

    iUserName = aServiceInfo.UserId().AllocL();

    iPassword = aServiceInfo.Password().AllocL();

    iClientId = aClientCtxInfo.ClientId().Identity().AllocL();

    }

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

// T_XIMPTestConnection::NewLC()

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

//

T_XIMPTestConnection* T_XIMPTestConnection::NewLC( const MXIMPServiceInfo& aServiceInfo,

                                                   const MXIMPContextClientInfo& aClientCtxInfo )

    {

    T_XIMPTestConnection* self = new( ELeave ) T_XIMPTestConnection(  );

    CleanupStack::PushL( self );

    self->ConstructL( aServiceInfo, aClientCtxInfo );

    return self;

    }

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

// T_XIMPTestConnection::NewL()

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

//

T_XIMPTestConnection* T_XIMPTestConnection::NewL( const MXIMPServiceInfo& aServiceInfo,

                                                  const MXIMPContextClientInfo& aClientCtxInfo )

    {

    T_XIMPTestConnection* self = T_XIMPTestConnection::NewLC( aServiceInfo, aClientCtxInfo );

    CleanupStack::Pop( self );

    return self;

    }

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

// T_XIMPTestConnection::~T_XIMPTestConnection()

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

//

T_XIMPTestConnection::~T_XIMPTestConnection()

    {

    SetBoolean( EXIMPPlgTestDeath );

    if ( iAuxTimer )

        {

        iAuxTimer->Deque();

        }

    delete iAuxTimer;

    delete iWaitter;

    iClients.ResetAndDestroy();

    delete iServerAddress;

    delete iUserName;

    delete iPassword;

    delete iClientId;

    delete iClientToBeDeleted;

    }

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

// T_XIMPTestConnection::PrimeHost()

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

//

void T_XIMPTestConnection::PrimeHost( MXIMPProtocolConnectionHost& aHost )

    {

    iConnectionHost = &aHost;

    }

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

// T_XIMPTestConnection::PresenceFeatures()

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

//

MProtocolPresenceFeatures& T_XIMPTestConnection::ProtocolPresenceFeatures()

    {

    return *this;

    }

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

// T_XIMPTestConnection::PresenceFeatures()

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

//	MProtocolImFeatures* ProtocolImFeatures();

//MProtocolImFeatures* T_XIMPTestConnection::ProtocolImFeatures()

//    {

//    return NULL;

//    }

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

// T_XIMPTestConnection::GetProtocolInterface()

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

TAny* T_XIMPTestConnection::GetProtocolInterface(TInt aInterfaceId)

	{

	return NULL ;

	}

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

// T_XIMPTestConnection::PresenceWatching()

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

//

MProtocolPresenceWatching& T_XIMPTestConnection::PresenceWatching()

    {

    return *this;

    }

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

// T_XIMPTestConnection::PresencePublishing()

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

//

MProtocolPresencePublishing& T_XIMPTestConnection::PresencePublishing()

    {

    return *this;

    }

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

// T_XIMPTestConnection::PresentityGroups()

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

//

MProtocolPresentityGroups& T_XIMPTestConnection::PresentityGroups()

    {

    return *this;

    }

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

// T_XIMPTestConnection::PresenceAuthorization()

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

//

MProtocolPresenceAuthorization& T_XIMPTestConnection::PresenceAuthorization()

    {

    return *this;

    }

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

// T_XIMPTestConnection::HandleProtocolConnectionHostEvent()

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

//

void T_XIMPTestConnection::HandleProtocolConnectionHostEvent(

    const MXIMPProtocolConnectionHost& aHost,

    const MXIMPBase& aEvent )

    {

    if( &aHost != iConnectionHost )

        {

        User::Panic(_L("Protocol"), -42 );

        }

    if( aEvent.GetInterfaceId() == MXIMPProtocolRequestCompleteEvent::KInterfaceId )

        {

        const MXIMPProtocolRequestCompleteEvent* eventIf =

        TXIMPGetInterface< const MXIMPProtocolRequestCompleteEvent >::From( aEvent,

                                                                            MXIMPBase::EPanicIfUnknown );

        RDebug::Print( _L("   T_XIMPTestConnection: received ProtocolRequestCompleteEvent with result [%d]"), 

                       eventIf->ResultCode() );

        }

    }

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

// T_XIMPTestConnection::OpenSessionL()

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

//

void T_XIMPTestConnection::OpenSessionL( const MXIMPContextClientInfo& aClientCtxInfo,

                                       TXIMPRequestId aReqId )

    {

    iConnectionHost->RegisterObserverL( *this );

    ClientWrapper* client = ClientWrapper::NewLC( aClientCtxInfo.ClientId().Identity() );

    TLinearOrder< T_XIMPTestConnection::ClientWrapper > order( T_XIMPTestConnection::OrderOfClients );

    TInt indexOfClient = iClients.FindInOrder( client, order );

    if( indexOfClient != KErrNotFound )

        {

        User::LeaveIfError( indexOfClient );

        CleanupStack::PopAndDestroy(); //id

        client = iClients[ indexOfClient ];

        }

    else

        {

        client->InitializeL( *iConnectionHost );

        iCurrentMessenger = client->iMessenger;

        }

    PluginAPIMethodCommonL( aReqId );

    if( indexOfClient == KErrNotFound )

        {

        iClients.InsertInOrderL( client, order );

        CleanupStack::Pop(); //id

        }

    SetBooleanToCurrent( EXIMPPlgTestOpenSessionCalled );

    iWaitter->WaitForL( KWaitTime );

    }

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

// T_XIMPTestConnection::OpenSessionL()

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

//

void T_XIMPTestConnection::OpenSessionL(

                const TInt& aSettingsId,

                TXIMPRequestId aReqId )

    {

    iConnectionHost->RegisterObserverL( *this );

    ClientWrapper* client = ClientWrapper::NewLC( _L("0") );

    TLinearOrder< T_XIMPTestConnection::ClientWrapper > order( T_XIMPTestConnection::OrderOfClients );

    TInt indexOfClient = iClients.FindInOrder( client, order );

    if( indexOfClient != KErrNotFound )

        {

        User::LeaveIfError( indexOfClient );

        CleanupStack::PopAndDestroy(); //id

        client = iClients[ indexOfClient ];

        }

    else

        {

        client->InitializeL( *iConnectionHost );

        iCurrentMessenger = client->iMessenger;

        }

    PluginAPIMethodCommonL( aReqId );

    if( indexOfClient == KErrNotFound )

        {

        iClients.InsertInOrderL( client, order );

        CleanupStack::Pop(); //id

        }

    SetBooleanToCurrent( EXIMPPlgTestOpenSessionCalled );

    iWaitter->WaitForL( KWaitTime );

    }

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

// T_XIMPTestConnection::CloseSession()

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

//

void T_XIMPTestConnection::CloseSession( const MXIMPContextClientInfo& aClientCtxInfo,

                                         TXIMPRequestId aReqId )

    {

    PluginAPIMethodCommonL( aReqId );

    iClientToBeDeleted = NULL;

    TInt count = iClients.Count();

    TBool found(EFalse);

    for( TInt a = 0; a < count && !iClientToBeDeleted; ++a )

        {

        if( aClientCtxInfo.ClientId().Identity().Compare( iClients[ a ]->iId ) == 0 )

            {

            iClientToBeDeleted = iClients[ a ];

            iClients.Remove( a );

            found = ETrue;

            }

        }

    SetBooleanToCurrent( EXIMPPlgTestCloseSessionCalled );

    if(found)

    iWaitter->WaitForL( KWaitTime );

    else

    	{

	    MXIMPStatus* status = iConnectionHost->ObjectFactory().NewStatusLC();

	    CleanupStack::Pop(); // status.

	    status->SetResultCode(KErrNone);

    	iConnectionHost->HandleRequestCompleted( aReqId, status);    		

    	}

    }

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

// T_XIMPTestConnection::GetSupportedFeaturesL()

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

//

void T_XIMPTestConnection::GetSupportedFeaturesL( CDesC8Array& aFeatures ) const

    {

    if ( ! iClients.Count() )

        {

        User::LeaveIfError( KErrNotReady );

        }

    // first empty the whole array

    aFeatures.Reset();

    // then add two features there: 1 supported by XIMP, 1 not

    aFeatures.AppendL( _L8("feat/pres/pub") );

    aFeatures.AppendL( _L8("feat/worlddomination") );

    }

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

// T_XIMPTestConnection::DoSubscribeOwnPresenceL

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

//

void T_XIMPTestConnection::DoSubscribeOwnPresenceL( const MPresenceInfoFilter& aPif,

        TXIMPRequestId aReqId )

    {

    PluginAPIMethodCommonL( aReqId );

    SetBooleanToCurrent( EXIMPPlgTestSubscribeOwnPresenceCalled );

    // TODO do something, like in PublishPresence

    iWaitter->WaitForL( KWaitTime );

    }

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

// T_XIMPTestConnection::DoUpdateOwnPresenceSubscriptionL

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

//

void T_XIMPTestConnection::DoUpdateOwnPresenceSubscriptionPifL( const MPresenceInfoFilter& aPif,

        TXIMPRequestId aReqId )

    {

    PluginAPIMethodCommonL( aReqId );

    SetBooleanToCurrent( EXIMPPlgTestUpdateOwnSubscriptionCalled );

    // TODO do something, like in PublishPresence

    iWaitter->WaitForL( KWaitTime );

    }

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

// From MPscPlugin class.

// T_XIMPTestConnection::DoSubscribePresenceWatcherListL()

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

//

void T_XIMPTestConnection::DoSubscribePresenceWatcherListL( TXIMPRequestId aReqId )

    {

    PluginAPIMethodCommonL( aReqId );

    SetBooleanToCurrent( EXIMPPlgTestSubscribePresenceWatcherListCalled );

    // TODO do something, like in PublishPresence

    iWaitter->WaitForL( KWaitTime );

    }

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

// From MPscPlugin class.

// T_XIMPTestConnection::DoUnsubscribePresenceWatcherListL()

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

//

void T_XIMPTestConnection::DoUnsubscribePresenceWatcherListL( TXIMPRequestId aReqId )

    {

    PluginAPIMethodCommonL( aReqId );

    SetBooleanToCurrent( EXIMPPlgTestUnsubscribePresenceWatcherListCalled );

    // TODO do something, like in PublishPresence

    iWaitter->WaitForL( KWaitTime );

    }

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

// T_XIMPTestConnection::DoSubscribePresentityGroupListL

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

//

void T_XIMPTestConnection::DoSubscribePresentityGroupListL( TXIMPRequestId aReqId )

    {

    PluginAPIMethodCommonL( aReqId );