/*

* Copyright (c) 2002-2005 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 FILES

#include <w32std.h>

#include <SenServiceConnection.h> // error codes and framework ids

#include <SenBaseFragment.h>

#include <MSenServiceDescription.h>

#include "msencoreservicemanager.h"

#include "msentransport.h"

#include "sendebug.h"

#include "senlogger.h"

#include "senidwsfplugin.h"

#include "idwsfdiscoveryserviceclient.h"

#include "idwsfservicesession.h"

#include "idwsfcoreserviceconsumer.h"

#include "midwsfsessionvalidator.h"

#include <SenTransportProperties.h>

#include <SenSoapConstants.h>

// Create instance of concrete ECOM interface implementation

CSenIdWsfPlugin* CSenIdWsfPlugin::NewL(TAny* aManager)

    {

    MSenCoreServiceManager* manager =

                        reinterpret_cast<MSenCoreServiceManager*>(aManager);

    CSenIdWsfPlugin* self = new (ELeave) CSenIdWsfPlugin(*manager);

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Implementation of CSIF

// Constructor

CSenIdWsfPlugin::CSenIdWsfPlugin(MSenCoreServiceManager& aManager)

:   iManager(aManager)

    {

    }

CSenIdWsfPlugin::~CSenIdWsfPlugin()

    {

    //CSenIdWsfPlugin::Log()->Write(_L8("CSenIdWsfPlugin::~CSenIdWsfPlugin()"));

    }

// Second phase construction.

void CSenIdWsfPlugin::ConstructL()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenIdWsfPlugin::ConstructL - Version 2 [2006-05-09]");

    // Results to add a DUPLICATE xmlns in parse!

    BaseConstructL(KIdWsfFrameworkXMLNS, KIdWsfFrameworkLocalname);

    }

// New methods

/*

RFileLogger* CSenIdWsfPlugin::Log() const

    {

    return iManager.Log();

    }*/

//////////////////////////////////////////////////////////////////////////

// Implementation of CSIF

/**

* Return a system wide unique string to identify this framework

*

* @return TDesC8 that uniquely identifies this framework.

*/

const TDesC8& CSenIdWsfPlugin::Id()

    {

    return KDefaultIdWsfFrameworkID();

    }

TInt CSenIdWsfPlugin::CompareSDScore(const TSDScore& aSDScoreLeft,

                                                const TSDScore& aSDScoreRight)

    {

     //"greater" means better matchScore, i.e. further down in a list!

    return (aSDScoreLeft.iScore - aSDScoreRight.iScore);

    }

/**

* Try to find one or more services that match the given ServiceDescription.

* Register ServiceDescriptions for these to the owner of the framework,

* i.e. to the ServiceManager. Return the number of ServiceDescriptions that

* were added.

*

* @param    aPattern - A ServiceDescriptin that should be treated as a pattern

* @param    aRemoteConsumer - the consumer sending the request

* @param    aErrorMsg - in case that return value is negative, this may contain

*           error as descriptor (SOAP Fault etc)

*

*   return (TInt) aCount of matching ServiceDescriptions that were added

*/

TInt CSenIdWsfPlugin::AddServiceDescriptionL( MSenServiceDescription& aPattern,

                                              MSenRemoteServiceConsumer& aRemoteConsumer,

                                              HBufC8*& /* aErrorMsg */ )

    {

    CSLOG(aRemoteConsumer.ConnectionId() , KMinLogLevel,(_L("Entered CSenIdWsfPlugin::AddServiceDescriptionL")));

    if( aPattern.Contract().Length() == 0 

        || ( aPattern.FrameworkId() != KDefaultIdWsfFrameworkID &&

             aPattern.FrameworkId() != KNullDesC8 ) )

        {

        return 0;

        }

#ifdef _SENDEBUG

    HBufC8* pAsXml = aPattern.AsXmlL();

    if(pAsXml)

        {

        CleanupStack::PushL(pAsXml);

        CSLOG_ALL(aRemoteConsumer.ConnectionId()  , KMaxLogLevel,(*pAsXml));

        CleanupStack::PopAndDestroy(); // pAsXml

        }

#endif

    RArray<TSDScore> searchResults;

    RPointerArray<CSenWSDescription> serviceDescriptions;

    RPointerArray<CSenWSDescription> tempArray;

    CleanupClosePushL(searchResults);

    CleanupClosePushL(serviceDescriptions);

    CleanupClosePushL(tempArray);

    TLinearOrder<TSDScore> order(&CSenIdWsfPlugin::CompareSDScore);

    TInt retVal =

        Manager().ServiceDescriptionsL(serviceDescriptions,

                                    KIdWsfFrameworkDiscoveryServiceContract);

    if(retVal != KErrNone)

        {

        CleanupStack::PopAndDestroy(3); // close the RPointerArrays

        return 0; // zero SD's were added

        }

    CIdWsfDiscoveryServiceClient* pDSClient = NULL;

    CSenIdentityProvider* pIdentityProvider = IdentityProviderL(&aPattern);

    //////////////////////////////////////////////////////////////////////////

    if(!pIdentityProvider)

        {

        CleanupStack::PopAndDestroy(3); // close the RPointerArrays

        return 0;//no possibility to add any SD as long as NO IdP is available!

        }

    //////////////////////////////////////////////////////////////////////////

    TInt attempts = 0;

    RPointerArray<CSenWSDescription> invalidDSClients;

    CleanupClosePushL(invalidDSClients);

    MSenServiceDescription *pDSDescription = NULL;

    TInt i = 0;

    while((i < serviceDescriptions.Count()) && (searchResults.Count() < 1))

        {

        pDSDescription = (MSenServiceDescription*) serviceDescriptions[i];

        if(pDSDescription->DescriptionClassType() ==

                    MSenServiceDescription::EIdWsfDiscoveryServiceClient)

            {

            pDSClient = (CIdWsfDiscoveryServiceClient*) pDSDescription;

            if(pDSClient->IsReadyL())

                {

                if( (!pIdentityProvider &&

                            (pDSClient->TrustAnchor() == KNullDesC8())) ||

                     (pIdentityProvider &&

                            (pDSClient->TrustAnchor() ==

                                    pIdentityProvider->ProviderID()) ))

                    {

                    pDSClient->FindServiceL(tempArray, 

                                            aPattern, 

                                            aRemoteConsumer);

                    attempts++;

                    for(TInt j = 0; j < tempArray.Count(); j++)

                        {

                        TSDScore temp;

                        temp.iSD = tempArray[j];

                        temp.iScore = tempArray[j]->ScoreMatchL(aPattern);

                        searchResults.Append(temp);

                        //searchResults.Append(tempArray[j]);

                        }

                    tempArray.Reset();

                    searchResults.Sort(order);

                    }

                else

                    {

                    invalidDSClients.Append(

                                (CSenWSDescription*)pDSDescription);

                    }

                }

            else

                {

                invalidDSClients.Append(

                                (CSenWSDescription*)pDSDescription);

                }

            }

        else

            {

            invalidDSClients.Append(

                                (CSenWSDescription*)pDSDescription);

            }

        i++;

        }

    if(searchResults.Count() < 1)

        {

        if(attempts < 1)    // no DS trusted by the IDP

                            //that was in the database (senidentities.xml)

            {

            // get a DS with the IdP as trust anchor

            pDSClient = DSClientL(pIdentityProvider, aRemoteConsumer);

            if(pDSClient && pDSClient->IsReadyL())

                {

                pDSClient->FindServiceL(tempArray, 

                                        aPattern,

                                        aRemoteConsumer);

                for(TInt j = 0; j < tempArray.Count(); j++)

                    {

                    TSDScore temp;

                    temp.iSD = tempArray[j];

                    temp.iScore = tempArray[j]->ScoreMatchL(aPattern);

                    searchResults.Append(temp);

                    //searchResults.Append(tempArray[j]);

                    }

                tempArray.Reset();

                searchResults.Sort(order);

                }

            }

        }

    if(searchResults.Count() < 1)

        {

        // try to validate invalid DS descriptions (clients)

        i = 0;

        while((i < invalidDSClients.Count()) && (searchResults.Count() < 1))

            {

            pDSDescription = (MSenServiceDescription*) invalidDSClients[i];

            if(pDSDescription->DescriptionClassType() ==

                        MSenServiceDescription::EIdWsfDiscoveryServiceClient)

                {

                pDSClient = (CIdWsfDiscoveryServiceClient*) pDSDescription;

                if(ValidateDSL(pDSClient,pIdentityProvider, aRemoteConsumer))

                    {

                    retVal = pDSClient->FindServiceL(tempArray, 

                                                     aPattern,

                                                     aRemoteConsumer);

                    CSLOG_FORMAT((aRemoteConsumer.ConnectionId()  , KNormalLogLevel, _L8("DS client FindServiceL() returned: (%d)"),

                        retVal));

                    retVal = 0;

                    for(TInt j = 0; j < tempArray.Count(); j++)

                        {

                        TSDScore temp;

                        temp.iSD = tempArray[j];

                        temp.iScore = tempArray[j]->ScoreMatchL(aPattern);

                        searchResults.Append(temp);

                        //searchResults.Append(tempArray[j]);

                        }

                    searchResults.Sort(order);

                    }

                }

            i++;

            }

        }

    for(i=0; i<searchResults.Count(); i++)

        {

        Manager().AddServiceDescriptionL(searchResults[i].iSD);

        }

    TInt countOfAddedSDs = searchResults.Count();

    // close: invalidDSClients, tempArray, serviceDescriptions, searchResults

    CleanupStack::PopAndDestroy(4);

    return countOfAddedSDs;

    }

TInt CSenIdWsfPlugin::AddServiceDescriptionL( const TDesC8& aServiceTypeContract,

                                              MSenRemoteServiceConsumer& aRemoteConsumer,

                                              HBufC8*& aErrorMsg )

    {

    /*

    * Ask the DiscoveryService client to search for services of

    * the given type;

    * Add these services to the framework manager.

    */

    CSLOG(aRemoteConsumer.ConnectionId()   , KMinLogLevel,(_L("IdWsf-plugin: Searching for session with contract:")));

    CSLOG(aRemoteConsumer.ConnectionId()   , KMinLogLevel,(aServiceTypeContract));

    MSenServiceDescription *pPattern = CIdWsfServiceInstance::NewLC(aServiceTypeContract);

    TInt count = AddServiceDescriptionL(*pPattern, aRemoteConsumer, aErrorMsg);

    CleanupStack::PopAndDestroy( pPattern  );

    return count;

    }

/**

* Attempt to register the ServiceDescription to the ServiceManager that

* owns the framework.

* This is a callback used by the ServiceManager to give frameworks a chance

* to replace a generic ServiceDescription into something that is more specific,

* and more useful, to the ServiceInvocationFramework.

*

* @param aServiceDescription A ServiceDescription

*

*   return TInt aError - indicates the error or KErrNone if successfull

*/

TInt CSenIdWsfPlugin::RegisterServiceDescriptionL(MSenServiceDescription& aServiceDescription)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenIdWsfPlugin::RegisterServiceDescriptionL");

    // Sanity checks

#ifdef _SENDEBUG

    HBufC8* pAsXml = aServiceDescription.AsXmlL();

    if(pAsXml)

        {

        CleanupStack::PushL(pAsXml);

        TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(*pAsXml));

        CleanupStack::PopAndDestroy(); // ptr

        }

#endif // _SENDEBUG

    TInt retval = KErrNone;

    CIdWsfServiceSession *pSession = NULL;

    TPtrC8 contract = aServiceDescription.Contract();

    if(contract == KIdWsfFrameworkAuthenticationServiceContract)

        {

        retval = RegisterASClientL(&aServiceDescription);

        }

    else if(contract.Length()>0 &&

            (contract == KIdWsfFrameworkDiscoveryServiceContract))

        {

        retval = RegisterDSClientL(&aServiceDescription);

        }

    else

        {

        if(aServiceDescription.DescriptionClassType() ==

                    MSenServiceDescription::EIdWSFServiceSession)

            {

            pSession = (CIdWsfServiceSession*) &aServiceDescription;

            retval = Manager().AddServiceDescriptionL(pSession);

            }

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,(_L8("Creating session from description...")));

#ifdef _SENDEBUG

            TPtrC8 con = aServiceDescription.Contract();

            TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMinLogLevel  ,_L8(" Using Contract: '%S'"), &con));

#endif

            pSession = CIdWsfServiceSession::NewLC(*this);

            retval = pSession->InitializeFromL(aServiceDescription);

            if (retval == KErrNone)

                {

                retval = Manager().AddServiceDescriptionL(pSession);

                CleanupStack::Pop(pSession);

                }

            else

                {

                CleanupStack::PopAndDestroy(pSession);

                }

            }

        }

    return retval;

    }

TInt CSenIdWsfPlugin::UnregisterServiceDescriptionL(

                                MSenServiceDescription& aServiceDescription)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,(_L8("UnRegisterServiceDescriptionL(.)")));

#ifdef _SENDEBUG

    HBufC8* pAsXml = aServiceDescription.AsXmlL();

    if(pAsXml)

        {

        CleanupStack::PushL(pAsXml);

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(*pAsXml));

        CleanupStack::PopAndDestroy(); // ptr

        }

#endif // _SENDEBUG

    TInt retval = KErrNone;

    CIdWsfServiceSession *pSession = NULL;

    TPtrC8 contract = aServiceDescription.Contract();

    if(contract == KIdWsfFrameworkAuthenticationServiceContract)

        {

        retval = UnRegisterASClientL(&aServiceDescription);

        }

    else if(contract.Length()>0 &&

        (contract == KIdWsfFrameworkDiscoveryServiceContract))

        {

        retval = UnRegisterDSClientL(&aServiceDescription);

        }

    else

        {

        if(aServiceDescription.DescriptionClassType() ==

                MSenServiceDescription::EIdWSFServiceSession)

            {

            pSession = (CIdWsfServiceSession*) &aServiceDescription;

            retval = Manager().RemoveServiceDescriptionL(*pSession);

            }

        else

            {

#ifdef _SENDEBUG

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"Creating session from description...");

            TPtrC8 con = aServiceDescription.Contract();

            TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMinLogLevel  ,_L8("-contract: '%S'"), &con));

#endif // _SENDEBUG

            pSession = CIdWsfServiceSession::NewLC(*this);

            retval = pSession->InitializeFromL(aServiceDescription);

            if (retval == KErrNone)

                {

                retval = Manager().RemoveServiceDescriptionL(*pSession);

                }

            CleanupStack::PopAndDestroy(pSession);

            }

        }

    return retval;

    }

TInt CSenIdWsfPlugin::UnRegisterASClientL(

                                MSenServiceDescription *aServiceDescription)

    {

#ifdef _SENDEBUG

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenIdWsfPlugin::UnRegisterASClientL");

     TPtrC8 endpoint = aServiceDescription->Endpoint();

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,(endpoint));

#endif

    TInt retval = KErrNone;

    CIdWsfServiceSession *pSession = NULL;

    CIdWsfAuthenticationServiceClient *pASClient = NULL;

    if(aServiceDescription->DescriptionClassType() ==

                MSenServiceDescription::EIdWsfAuthenticationServiceClient)

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,(_L8("This ServiceDescription is already an AS Client")));

        pASClient = (CIdWsfAuthenticationServiceClient*)aServiceDescription;

        retval = Manager().RemoveServiceDescriptionL(*pASClient);

        }

    else

        {

        pSession = CIdWsfServiceSession::NewLC(*this);

        retval = pSession->InitializeFromL(*aServiceDescription);

        if(retval != KErrNone)

            {

            CleanupStack::PopAndDestroy(pSession); 

            return retval;

            }

#ifdef _SENDEBUG

        TPtrC8 sessionEndpoint = pSession->Endpoint();

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"Creating ASClient and new Session using Endpoint:");

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,(sessionEndpoint));

#endif

        pASClient = CIdWsfAuthenticationServiceClient::NewLC(*this);//, *Log());

        pASClient->SetServiceSessionL(pSession);    // pSession will be owned by ASClient

        CleanupStack::Pop(2); // pASClient, pSession

        CleanupStack::PushL(pASClient);

        retval = Manager().RemoveServiceDescriptionL(*pASClient);

        if(retval != KErrNone)

            {

            delete pASClient;

            }

        CleanupStack::Pop(); // pASClient

        }

    return retval;

    }

TInt CSenIdWsfPlugin::RegisterASClientL(

                                MSenServiceDescription *aServiceDescription)

    {