/*
* 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 <e32std.h>
#include <s32strm.h>

//#include "SenDebug.h"

#include <SenElement.h>
#include <SenXmlUtils.h>

#include "senpolicy.h"
#include "SenIdentityProviderIdArray8.h"

// ============================ LOCAL FUNCTIONS ===============================

namespace
    {
    _LIT8(KPolicyLocalName, "Policy");
    _LIT8(KTransportLocalName, "Transport");
    _LIT8(KIapIdLocalName, "IapId");
    _LIT8(KSnapIdLocalName, "SnapId");
    _LIT8(KIdentityProviderIDsLocalName, "IdentityProviderIDs");
    _LIT8(KIdentityProviderIDsStrictAttrName, "strict");
    _LIT8(KIdentityProviderIDsStrictAttrTrue, "true");
    _LIT8(KIdentityProviderIDLocalName, "IdentityProviderID");
    }


EXPORT_C CSenPolicy* CSenPolicy::NewL()
    {
    CSenPolicy* pNew = NewLC();
    CleanupStack::Pop();
    return(pNew) ;
    }

EXPORT_C CSenPolicy* CSenPolicy::NewLC()
    {
    CSenPolicy* pNew = new (ELeave) CSenPolicy;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(KPolicyLocalName());
    return pNew;
    }


EXPORT_C CSenPolicy* CSenPolicy::NewL(TUint32 aIapId)
    {
    CSenPolicy* pNew = NewLC(aIapId);
    CleanupStack::Pop();
    return(pNew) ;
    }


EXPORT_C CSenPolicy* CSenPolicy::NewLC(TUint32 aIapId)
    {
    CSenPolicy* pNew = new (ELeave) CSenPolicy;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(KPolicyLocalName(), aIapId);
    return pNew;
    }

EXPORT_C CSenPolicy* CSenPolicy::NewL(TUint32 aId, TBool aIsSnapId)
    {
    CSenPolicy* pNew = NewLC(aId, aIsSnapId);
    CleanupStack::Pop();
    return(pNew) ;
    }


EXPORT_C CSenPolicy* CSenPolicy::NewLC(TUint32 aId, TBool aIsSnapId)
    {
    CSenPolicy* pNew = new (ELeave) CSenPolicy;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(KPolicyLocalName(), aId, aIsSnapId);
    return pNew;
    }


CSenPolicy::CSenPolicy()
:   iIdpIdList(NULL)
    {
    }

CSenPolicy::~CSenPolicy()
    {
    delete iIdpIdList;
    }

EXPORT_C void CSenPolicy::BaseConstructL(const TDesC8& aPolicyLocalName)
    {
    CSenBaseFragment::BaseConstructL(aPolicyLocalName);
    }

EXPORT_C void CSenPolicy::BaseConstructL(const TDesC8& aPolicyLocalName,
                                         TUint32 aIapId)
    {
    CSenBaseFragment::BaseConstructL(aPolicyLocalName);
    SetIapIdL(aIapId);
    }

EXPORT_C void CSenPolicy::BaseConstructL(const TDesC8& aPolicyLocalName,
                                         TUint32 aId, TBool aIsSnapId)
    {
    CSenBaseFragment::BaseConstructL(aPolicyLocalName);
    if (aIsSnapId == EFalse)
        {
    SetIapIdL(aId);
        }
    else
        {
    SetSnapIdL(aId);
        }
    }

EXPORT_C TBool CSenPolicy::Accepts(MSenPolicy& aPolicyPattern)
    {
    TBool retVal(ETrue);
    TRAPD(err, retVal = AcceptsL(aPolicyPattern));
    if (err) return EFalse;
    return retVal;
    }

TBool CSenPolicy::AcceptsL(MSenPolicy& aPolicyPattern)
    {
    TUint32 thisIapID(0);
    TUint32 patternIapID(0);

    if(aPolicyPattern.IapId(patternIapID) == KErrNone
        && (IapId(thisIapID) != KErrNone
         || patternIapID!=thisIapID))
        {
        return EFalse; // policies do NOT match(!)
        }

    const CSenIdentityProviderIdArray8& patternIdps =
                                    aPolicyPattern.IdentityProviderIds8L();
    if(patternIdps.IsStrict())
        {
        const CSenIdentityProviderIdArray8& thisIdps = IdentityProviderIds8L();
        TInt thisCount(thisIdps.Count());
        TInt pos(-1);
        TBool matches(EFalse);
        for(TInt i=0; i<thisCount; i++)
            {
            if(patternIdps.Find(thisIdps[i], pos, ECmpNormal)==KErrNone)
                {
                matches = ETrue;
                break;
                }
            }
        return matches;
        }

    return ETrue;
    }


// Setter for IAP ID
EXPORT_C void CSenPolicy::SetIapIdL(TUint32 aIapId)
    {
    CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
    if(aIapId > 0)
        {
        if(!pTransportElement)
            {
            pTransportElement = &(AsElement().AddElementL(KTransportLocalName));
            }
        CSenElement* pSnapIdElement =
        pTransportElement->Element(KSnapIdLocalName);

        if(pSnapIdElement)
            {
            pSnapIdElement = pTransportElement->RemoveElement(KSnapIdLocalName);
            }        
        CSenElement* pIapIdElement =
                                pTransportElement->Element(KIapIdLocalName);
        if(!pIapIdElement)
            {
            pIapIdElement = &(pTransportElement->AddElementL(KIapIdLocalName));
            }
        TBuf8<128> buf;
        buf.AppendFormat(_L8("%u"), aIapId);
        pIapIdElement->SetContentL(buf);        
        }
    else 
        {
        if(pTransportElement)
            {
            CSenElement* pIapIdElement =
            pTransportElement->Element(KIapIdLocalName);

            if(pIapIdElement)
                {
                pIapIdElement = pTransportElement->RemoveElement(KIapIdLocalName);
                }
            }
        }


    }

// Getter for IAP ID
EXPORT_C TInt CSenPolicy::IapId(TUint32& aCurrentIapId)
    {
    CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
    if(pTransportElement)
        {
        CSenElement* pIapIdElement =
                                pTransportElement->Element(KIapIdLocalName);
        if(pIapIdElement && pIapIdElement->HasContent())
            {
            //SENDEBUG((_L("CSenPolicy::IapIdL: content found")));
            TPtrC8 content = pIapIdElement->Content();
            TLex8 lex(content);

            TInt err = lex.Val(aCurrentIapId, EDecimal);
            return err;
            }
        //SENDEBUG((_L("CSenPolicy::IapIdL: <IapId> element not found")));
        }
    //SENDEBUG((_L("CSenPolicy::IapIdL: <Transport> element not found")));
    return KErrNotFound;
    }

// Setter for SNAP ID
EXPORT_C void CSenPolicy::SetSnapIdL(TUint32 aSnapId)
    {
    if(aSnapId > 0)
        {
        CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
        if(!pTransportElement)
            {
            pTransportElement = &(AsElement().AddElementL(KTransportLocalName));
            }
        
        CSenElement* pIapIdElement =
        pTransportElement->Element(KIapIdLocalName);

        if(pIapIdElement)
            {
            pIapIdElement = pTransportElement->RemoveElement(KIapIdLocalName);
            }        
        
        CSenElement* pSnapIdElement =
                                pTransportElement->Element(KSnapIdLocalName);
        if(!pSnapIdElement)
            {
            pSnapIdElement = &(pTransportElement->AddElementL(KSnapIdLocalName));
            }
        TBuf8<128> buf;
        buf.AppendFormat(_L8("%u"), aSnapId);
        pSnapIdElement->SetContentL(buf);        
        }
    else
        {
        CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
        if(pTransportElement)
            {
            CSenElement* pSnapIdElement =
            pTransportElement->Element(KSnapIdLocalName);

            if(pSnapIdElement)
                {
                pSnapIdElement = pTransportElement->RemoveElement(KSnapIdLocalName);
                }
            }
        }

    }

// Getter for SNAP ID
EXPORT_C TInt CSenPolicy::SnapId(TUint32& aCurrentSnapId)
    {
    CSenElement* pTransportElement = AsElement().Element(KTransportLocalName);
    if(pTransportElement)
        {
        CSenElement* pSnapIdElement =
                                pTransportElement->Element(KSnapIdLocalName);
        if(pSnapIdElement && pSnapIdElement->HasContent())
            {
            //SENDEBUG((_L("CSenPolicy::SnapIdL: content found")));
            TPtrC8 content = pSnapIdElement->Content();
            TLex8 lex(content);

            TInt err = lex.Val(aCurrentSnapId, EDecimal);
            return err;
            }
        //SENDEBUG((_L("CSenPolicy::SnapIdL: <SnapId> element not found")));
        }
    //SENDEBUG((_L("CSenPolicy::SnapIdL: <Transport> element not found")));
    return KErrNotFound;
    }

// Setter: overrides current values with the given values from the array
EXPORT_C void CSenPolicy::SetIdentityProviderIdsL(
                                        CSenIdentityProviderIdArray8& aList)
    {
    CSenElement* pListElement =
                            AsElement().Element(KIdentityProviderIDsLocalName);

    if(pListElement)
        {
        CSenElement* pRemoved = AsElement().RemoveElement(*pListElement);
        delete pRemoved;
        }

    TInt count(aList.Count());
    if(count>0)
        {
        for(TInt i=0; i<count; i++)
            {
            TPtrC8 providerId = aList[i];
            if(providerId.Length()>0)
                {
                AddIdentityProviderIdL(providerId);
                }
            }
        }
    }

// Adder: adds a new IDP ID value at the end of the current list value(s)
// Checks for duplicate (does not insert new ID elements with equal content)
// @return KErrAlreadyExists, if a duplicate is tried to add
//         KErrArgument if a zero-length descriptor is tried
//         to add (aProviderId.Length() == 0)
//
//          NOTE: allocates a copy of given aProviderId!
//
EXPORT_C TInt CSenPolicy::AddIdentityProviderIdL(const TDesC8& aProviderId)
    {
    if(aProviderId.Length()>0)
        {
        // there is something relevant to add..

        // check next that <IdentityProviderIDs> element exists
        CSenElement* pListElement =
                            AsElement().Element(KIdentityProviderIDsLocalName);

        // check if this policy is "empty" (no content yet)
        if(!pListElement)
            {
            // add the <IdentityProviderIDs> element..
            pListElement =
                    &AsElement().AddElementL(KIdentityProviderIDsLocalName);
            }
        else
            {
            // check if ID being inserted already exists
            // (prevent inserting a duplicate)

            RPointerArray<CSenElement>& children = pListElement->ElementsL();
            TInt childCount(children.Count());

            // loop through child elements and check their content
            for(TInt i=0; i<childCount; i++)
                {
                TPtrC8 content = children[i]->Content();
                if(content == aProviderId)
                    {
                    // duplicate found(!)
                    return KErrAlreadyExists;   
                    }
                }

            }

        CSenElement& added =
                    pListElement->AddElementL(KIdentityProviderIDLocalName);

        added.SetContentL(aProviderId);
        // content set: ok
        return KErrNone;
        }
    else // tried to add zero length descriptor (aProviderId.Length() == 0)
        {
        // return argument error
        return KErrArgument;
        }
    }

// sets (rebuilds) the IAP ID and IDP ID list values from template
// @return  - a error, if at least one addition of new contents has
// failed OR KerrNone if every property was successfully reset
EXPORT_C TInt CSenPolicy::RebuildFrom(MSenPolicy& aTemplate)
    {
    TInt retVal(KErrNone);
    TRAPD(err, retVal = RebuildFromL(aTemplate));
    if (err != KErrNone)
        {
        retVal = err;
        }
    return retVal;
    }

TInt CSenPolicy::RebuildFromL(MSenPolicy& aTemplate)
    {
    TInt retVal(KErrNone);
    // check for possible provider policy definition

    TUint32 iapId(0);
    TInt err = aTemplate.IapId(iapId);
    if(err==KErrNone)
        {
        // update the latest IAP "recommendation"
        SetIapIdL(iapId);
        }
    const CSenIdentityProviderIdArray8& ids =
                                        aTemplate.IdentityProviderIds8L();
    TInt idsCount(ids.MdcaCount());
    for(TInt j=0; j<idsCount; j++)
        {
        TPtrC8 value = ids[j];
        if(value.Length()>0)
            {
            err = AddIdentityProviderIdL(value);
            if(err!=KErrNone)
                {
                retVal = err; // indicate that some IDP could not be added
                }
            }
        }
    return retVal;
    }

// Getter: return an empty array if no IDP:s have been spesified
// or a list of IDP arrays if such value(s) have been set.
//
// Ownership of the array remains within this class
EXPORT_C const CSenIdentityProviderIdArray8&
                                        CSenPolicy::IdentityProviderIds8L()
    {
    // construct temporary array and fill it with the xml content
    CSenIdentityProviderIdArray8* pArray =
                                        CSenIdentityProviderIdArray8::NewLC();

    // check next that <IdentityProviderIDs> element exists
    CSenElement* pListElement =
                            AsElement().Element(KIdentityProviderIDsLocalName);
    if(pListElement)
        {
        // Check if strict attribute has "true" value.
        const TDesC8* pStrictValue =
                pListElement->AttrValue(KIdentityProviderIDsStrictAttrName);
        if(pStrictValue && *pStrictValue == KIdentityProviderIDsStrictAttrTrue)
            {
            pArray->SetStrict(ETrue);
            }

        // next check that child elements exist
        RPointerArray<CSenElement>& elements  = pListElement->ElementsL();
        TInt count(elements.Count());
        for(TInt i=0; i<count; i++)
            {
            CSenElement* element = elements[i];
            if(element && element->HasContent())
                {
                pArray->AppendL(element->Content());
                }
            }
        }

    delete iIdpIdList;
    iIdpIdList = pArray;
    CleanupStack::Pop(); // pArray
    return *iIdpIdList;
    }

// End of file