/*
* Copyright (c) 2004 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 <SenXmlUtils.h>
#include <SenCredential.h>
#include <SenFacet.h>
#include <SenServiceConnection.h>
#include <SenXmlElement.h>

#include "idwsfserviceinstance.h"

namespace
    {
    const TInt KFLATBUF_SIZE = 128;
    }

CIdWsfServiceInstance* CIdWsfServiceInstance::NewL()
    {
    CIdWsfServiceInstance* pNew = CIdWsfServiceInstance::NewLC();
    CleanupStack::Pop(); // pNew
    return pNew;
    }

CIdWsfServiceInstance* CIdWsfServiceInstance::NewLC()
    {
    CIdWsfServiceInstance* pNew = new (ELeave) CIdWsfServiceInstance;
    CleanupStack::PushL(pNew);
    pNew->ConstructL(KNullDesC8(), KNullDesC8());
    return pNew;
    }

CIdWsfServiceInstance* CIdWsfServiceInstance::NewL(const TDesC8& aUri)
    {
    CIdWsfServiceInstance* pNew = CIdWsfServiceInstance::NewLC(aUri);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

CIdWsfServiceInstance* CIdWsfServiceInstance::NewLC(const TDesC8& aUri)
    {
    CIdWsfServiceInstance* pNew = new (ELeave) CIdWsfServiceInstance;
    CleanupStack::PushL(pNew);
    pNew->ConstructL(aUri, KNullDesC8());
    return pNew;
    }

CIdWsfServiceInstance* CIdWsfServiceInstance::NewL(
                                            CIdWsfServiceInstance& aTemplate)
    {
    CIdWsfServiceInstance* pNew = CIdWsfServiceInstance::NewLC(aTemplate);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

CIdWsfServiceInstance* CIdWsfServiceInstance::NewLC(
                                            CIdWsfServiceInstance& aTemplate)
    {
    CIdWsfServiceInstance* pNew = new (ELeave) CIdWsfServiceInstance;
    CleanupStack::PushL(pNew);
    pNew->ConstructL(aTemplate.ServiceType(), aTemplate.ProviderId());
    return pNew;
    }

CIdWsfServiceInstance::CIdWsfServiceInstance() :
    CSenWSDescription( EIdWsfServiceInstance ),
    ipProviderId( NULL ),
    ipEndpoint( NULL ),
    ipServiceType( NULL ),
    ipResourceId( NULL ),
    ipMechanisms( NULL ),
    ipCredentialRefs( NULL )
    {
    }
    
void CIdWsfServiceInstance::ConstructL(const TDesC8& aUri,
                                       const TDesC8& aProviderId)
    {
    CSenDomFragment::BaseConstructL(NewElementName());

    HBufC8* pNew = NULL;
    if (aUri != KNullDesC8)
        {
        pNew = aUri.AllocL();
        }
    ipServiceType = pNew;
    SetProviderIdL(aProviderId);
    }

CIdWsfServiceInstance::~CIdWsfServiceInstance()
    {
    delete ipProviderId;
    delete ipResourceId;
    delete ipEndpoint;

    delete ipServiceType;
    delete ipMechanisms;
    delete ipCredentialRefs;

    iCredentialList.ResetAndDestroy();
    iFacets.ResetAndDestroy();
    }

TBool CIdWsfServiceInstance::Matches(
                            MSenServiceDescription& aOtherServiceDescription)
    {
    TPtrC8 patternEndpoint = aOtherServiceDescription.Endpoint();
    TPtrC8 thisEndpoint = Endpoint();

    if(patternEndpoint.Length()>0)
        {
        if(!(thisEndpoint.Length()>0 && patternEndpoint == thisEndpoint))
            {
            return EFalse;
            }
        }

    TPtrC8 patternContract = aOtherServiceDescription.Contract();
    TPtrC8 thisContract = Contract();

    if(patternContract.Length()>0)
        {
        if(!(thisContract.Length()>0 && patternContract == thisContract))
            {
            return EFalse;
            }
        }
    return ETrue;
    }

TBool CIdWsfServiceInstance::Matches(
                                CIdWsfServiceInstance& aOtherServiceInstance)
    {
    if (!Matches((MSenServiceDescription&)aOtherServiceInstance)) return EFalse;

    TPtrC8 patternProvider = aOtherServiceInstance.ProviderId();
    TPtrC8 thisProvider = ProviderId();

    if(patternProvider.Length()>0)
        {
        if(!(thisProvider.Length()>0 && patternProvider == thisProvider))
            return EFalse;
        }
    return ETrue;
    }


TPtrC8 CIdWsfServiceInstance::Contract()
    {
    if (ipServiceType)
        return *ipServiceType;
    else
        return KNullDesC8();
    }

TPtrC8 CIdWsfServiceInstance::FrameworkId()
    {
    return KDefaultIdWsfFrameworkID();
    }

TPtrC8 CIdWsfServiceInstance::FrameworkVersion()
    {
    return KIdWsfFrameworkVersion();
    }

void CIdWsfServiceInstance::SetContractL(const TDesC8& aContract)
    {
    HBufC8* pNew = NULL;
    if(aContract.Length()>0)
        pNew = aContract.AllocL();

    delete ipServiceType;
    ipServiceType = pNew;
    }

void  CIdWsfServiceInstance::WriteAsXMLToL(RWriteStream& /* aWriteStream */)
    {
    // Nothing to do, because for ID-WSF we never save ServiceInstances,
    // only sessions.
    return;
    }

HBufC* CIdWsfServiceInstance::AsXmlUnicodeL()
    {
    // Nothing to do, because for ID-WSF we never save ServiceInstances,
    // only sessions.
    // note: could return NULL
    return KNullDesC().AllocL();
    }

HBufC8* CIdWsfServiceInstance::AsXmlL()
    {
    // Nothing to do, because for ID-WSF we never save ServiceInstances,
    // only sessions.
    // note: could return NULL
    return KNullDesC8().AllocL();
    }

TPtrC8 CIdWsfServiceInstance::ProviderId()
    {
    if(ipProviderId)
        return *ipProviderId;
    else
        return KNullDesC8();
    }

TPtrC8 CIdWsfServiceInstance::ResourceId()
    {
    if (ipResourceId)
        return *ipResourceId;
    else
        return KNullDesC8();
    }

TPtrC8 CIdWsfServiceInstance::Endpoint()
    {
    if (ipEndpoint)
        return *ipEndpoint;
    else
        return KNullDesC8();
    }

TPtrC8 CIdWsfServiceInstance::ServiceType()
    {
    if (ipServiceType)
        return *ipServiceType;
    else
        return KNullDesC8();
    }

TInt CIdWsfServiceInstance::SetProviderIdL( const TDesC8& aURI )
    {
    TInt retVal( KErrNone );
    HBufC8* pNew = NULL;
    if( aURI.Length() > 0 )
        {
        pNew = aURI.AllocL();
        }
//    else
//        {
//        retVal = KErrArgument;
//        }
    delete ipProviderId;
    ipProviderId = pNew;
    return retVal;
    }

void CIdWsfServiceInstance::SetResourceIdL( const TDesC8& aURI )
    {
    HBufC8* pNew = NULL;
    if(aURI.Length()>0)
        pNew = aURI.AllocL();
    delete ipResourceId;
    ipResourceId = pNew;
    }

void CIdWsfServiceInstance::SetEndPointL(const TDesC8& aURI)
    {
    HBufC8* pNew = NULL;
    if(aURI.Length()>0)
        pNew = aURI.AllocL();
    delete ipEndpoint;
    ipEndpoint = pNew;
    }

void CIdWsfServiceInstance::SetServiceTypeL(const TDesC8& aURI)
    {
    HBufC8* pNew = NULL;
    if(aURI.Length()>0)
        pNew = aURI.AllocL();
    delete ipServiceType;
    ipServiceType = pNew;
    }

CDesC8Array& CIdWsfServiceInstance::MechanismsL()
    {
    if(!ipMechanisms)
        {
        ipMechanisms = new (ELeave) CDesC8ArrayFlat(KFLATBUF_SIZE);
        }
    return *ipMechanisms;
    }

CDesC8Array& CIdWsfServiceInstance::CredentialRefsL()
    {
    if(!ipCredentialRefs)
        {
        ipCredentialRefs = new (ELeave) CDesC8ArrayFlat(KFLATBUF_SIZE);
        }
    return *ipCredentialRefs;
    }

TBool CIdWsfServiceInstance::SupportsMechanism(const TDesC8& aURI)
    {
    if (ipMechanisms)
        {
        TInt pos;
        return (ipMechanisms->Find(aURI, pos, ECmpNormal) == KErrNone);
        }
    return EFalse;
    }

CSenCredential* CIdWsfServiceInstance::Credential()
    {
    CSenCredential* pCredential = NULL;
    TInt count(iCredentialList.Count());
    for(TInt i=0; i<count && pCredential == NULL; i++)
        {
        pCredential = iCredentialList[i];
        }
    return pCredential;
    }


void CIdWsfServiceInstance::SetCredentialL(const TDesC8& aIdRef,
                                           const CSenCredential& aCredential)
    {
    TInt refCount(CredentialRefsL().Count());
    for (TInt i = 0; i < refCount; i++)
        {
        // Remove IDREFs and add actual credential
        if (CredentialRefsL()[i] == aIdRef)
            {
            CSenCredential* pCredential = CSenCredential::NewL(aCredential);
            iCredentialList.Append(pCredential);
            ipCredentialRefs->Delete(i);
            break;
            }
        }
    }

void CIdWsfServiceInstance::SetCredentialL(const CSenCredential& aCredential)
    {
    const TDesC8& idRef = ((CSenCredential&)aCredential).Id();
    SetCredentialL(idRef, aCredential);
    }

void CIdWsfServiceInstance::AddSecurityMechL(const TDesC8& aUri)
    {
    MechanismsL().AppendL(aUri);
    }

void CIdWsfServiceInstance::AddCredentialRefL(const TDesC8& aIdRef)
    {
    CredentialRefsL().AppendL(aIdRef);
    }

TInt CIdWsfServiceInstance::HasFacetL(const TDesC8& aURI, TBool& aHasFacet)
    {
    aHasFacet = EFalse;
    TInt count(iFacets.Count());

    for (TInt i=0;i<count && !aHasFacet;i++)
        {
        if (iFacets[i]->Name() == aURI)
            {
            aHasFacet = ETrue;
            }
        }

    return KErrNone;
    }

TInt CIdWsfServiceInstance::FacetValue(TDesC8& aURI, HBufC8*& aValueTo)
    {
    delete aValueTo;
    aValueTo = NULL;

    TInt retVal = KErrNotFound;
    TInt count(iFacets.Count());

    for (TInt i=0;i<count && retVal == KErrNotFound;i++)
        {
        if (iFacets[i]->Name() == aURI)
            {
            aValueTo = iFacets[i]->Value().Alloc();
            if (aValueTo == NULL) retVal = KErrNoMemory;
            else retVal = KErrNone;
            }
        }
    return retVal;
    }

TInt CIdWsfServiceInstance::AddFacetL(const CSenFacet& aFacet)
    {
    return SetFacetL(aFacet);
    }

TInt CIdWsfServiceInstance::SetFacetL(const CSenFacet& aFacet)
    {
    TBool hasFacet;
    HasFacetL(((CSenFacet&)aFacet).Name(),hasFacet);
    if (hasFacet)
        {
        RemoveFacet(((CSenFacet&)aFacet).Name());
        }
    CSenFacet* pNewFacet = CSenFacet::NewL(((CSenFacet&)aFacet));
    return iFacets.Append(pNewFacet);
    }

TInt CIdWsfServiceInstance::RemoveFacet(const TDesC8& aURI)
    {
    TInt count(iFacets.Count());

    for (TInt i=0;i<count;i++)
        {
        if (iFacets[i]->Name() == aURI)
            {
            delete iFacets[i];
            iFacets.Remove(i);
            return KErrNone;
            }
        }

    return KErrNotFound;
    }

TInt CIdWsfServiceInstance::FacetsL(RFacetArray& aFacetArray)
    {
    CSenFacet* pFacet = NULL;
    TInt count(iFacets.Count());
    for (TInt i=0; i<count; i++)
        {
        pFacet = CSenFacet::NewL(*iFacets[i]);
        aFacetArray.Append(pFacet);
        }
    return KErrNone;
    }

TInt CIdWsfServiceInstance::ScoreMatchL(MSenServiceDescription& aPattern)
    {
    TInt score(0);

    if ((aPattern.Endpoint().Length() > 0) &&
        (aPattern.Endpoint() == Endpoint()))
        {
        score++;
        }
    if ((aPattern.Contract().Length() > 0) &&
        (aPattern.Contract() == Contract()))
        {
        score++;
        }

    RFacetArray otherFacets;
    CleanupClosePushL(otherFacets);
    aPattern.FacetsL(otherFacets);

    HBufC8* pFacetValue = NULL;
    TPtrC8 facetName;

    TInt count(otherFacets.Count());
    for (TInt i=0; i<count; i++)
        {
        facetName.Set(otherFacets[i]->Name());
        FacetValue(facetName,pFacetValue);
        if (pFacetValue && *pFacetValue == otherFacets[i]->Value())
            {
            score++;
            }
        delete pFacetValue;
        pFacetValue = NULL;
        }

    otherFacets.ResetAndDestroy();
    CleanupStack::Pop(); // otherFacets

    return score;
    }

// equals to CSenWSDescription implementation at the moment
TBool CIdWsfServiceInstance::HasEqualPrimaryKeysL(MSenServiceDescription& aCandidate)
    {
    TBool retVal(EFalse);
    if(aCandidate.Endpoint()  == Endpoint() &&
       aCandidate.Contract() == Contract() &&
       aCandidate.FrameworkId() == FrameworkId())
        {
        retVal = ETrue;
        }
    return retVal;    
    }


TBool CIdWsfServiceInstance::HasSuperClass( TDescriptionClassType aType )
    {
    if( aType == MSenServiceDescription::EWSDescription ) // direct superclass!
        {
        // If asked type is the know *direct* father/mother, return true:
        return ETrue; 
        } 
    else
        {
        // Otherwise, ask from superclass (chain, recursively)
        return CSenWSDescription::HasSuperClass( aType ); 
        }
    }



// End of File