/*
* 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:   Class CCatalogsClientAccessPointData declation
*
*/


#include "catalogsclientaccesspointdata.h"
#include "catalogsaccesspoint.h"
#include "catalogsaccesspointmap.h"
#include "catalogsdebug.h"
#include "ncdnodeidentifier.h"
#include "ncdnodeidentifiereditor.h"

CCatalogsClientAccessPointData* CCatalogsClientAccessPointData::NewL() 
    {
    CCatalogsClientAccessPointData* self = NewLC();
    CleanupStack::Pop();
    return self;
    }
    
CCatalogsClientAccessPointData* CCatalogsClientAccessPointData::NewLC()
    {
    CCatalogsClientAccessPointData* self = 
        new (ELeave) CCatalogsClientAccessPointData();
    CleanupStack::PushL(self);
    return self;
    }
    
CCatalogsClientAccessPointData::~CCatalogsClientAccessPointData() 
    {
    iAccessPoints.ResetAndDestroy();
    iAccessPointMaps.ResetAndDestroy();
    }
    
void CCatalogsClientAccessPointData::AddAccessPointL(CCatalogsAccessPoint* aAccessPoint) 
    {
    iAccessPoints.AppendL(aAccessPoint);
    }
    
void CCatalogsClientAccessPointData::MapAccessPointL(
    const TDesC& aNameSpace,
    const MCatalogsAccessPointManager::TAction& aAction,
    const TDesC& aApId) 
    {
    // check if some access point is mapped already
    TInt mapCount = iAccessPointMaps.Count();
    for (TInt i = 0; i < mapCount; i++) 
        {
        CCatalogsAccessPointMap* map = iAccessPointMaps[i];
        if (map->NameSpace() == aNameSpace && map->Action() == aAction) 
            {
            // access point map found, delete it
            iAccessPointMaps.Remove(i);
            break;
            }
        }
     
    // create new map
    CCatalogsAccessPointMap* map = CCatalogsAccessPointMap::NewLC(
        aNameSpace, aAction, aApId);
    iAccessPointMaps.AppendL(map);
    CleanupStack::Pop(map);
    iAccessPointMaps.Compress();
    }

void CCatalogsClientAccessPointData::MapAccessPointL(
    const TDesC& aNameSpace,
    const TDesC& aCatalogId,
    const MCatalogsAccessPointManager::TAction& aAction,
    const TDesC& aApId) 
    {
    // check if some access point is mapped already
    TInt mapCount = iAccessPointMaps.Count();
    for (TInt i = 0; i < mapCount; i++) 
        {
        CCatalogsAccessPointMap* map = iAccessPointMaps[i];
        if (map->NameSpace() == aNameSpace && map->HasCatalogId() &&
            map->CatalogId() == aCatalogId && map->Action() == aAction) 
            {
            // access point map found, delete it
            iAccessPointMaps.Remove(i);
            break;
            }
        }
     
    // create new map
    CCatalogsAccessPointMap* map = CCatalogsAccessPointMap::NewLC(
        aNameSpace, aCatalogId, aAction, aApId);
    iAccessPointMaps.AppendL(map);
    CleanupStack::Pop(map);
    iAccessPointMaps.Compress();
    }
    
CCatalogsAccessPoint* CCatalogsClientAccessPointData::AccessPoint(
    const TDesC& aNameSpace,
    const MCatalogsAccessPointManager::TAction& aAction) const
    {
    const TDesC* apId = NULL;        
    
    // find the access point id
    // find the map
    TInt mapCount = iAccessPointMaps.Count();
    for (TInt i = 0; i < mapCount; i++) 
        {
        CCatalogsAccessPointMap* map = iAccessPointMaps[i];
        if (map->NameSpace() == aNameSpace && map->Action() == aAction && !map->HasCatalogId()) 
            {
            // id found
            apId = &map->AccessPointId();
            break;
            }
        }

    if (!apId) 
        {        
        return NULL;
        }
    
    return AccessPointById(*apId);
    }

CCatalogsAccessPoint* CCatalogsClientAccessPointData::AccessPointL(
    const TDesC& aNameSpace,
    const TDesC& aCatalogId,
    const MCatalogsAccessPointManager::TAction& aAction) const
    {
    const TDesC* apId = NULL;        
    
    // Create metadata identifier and search the access point using it.
    // Fake clientUid can be used, we are only interested in namespace and id
    // at this point.
    CNcdNodeIdentifier* nodeId =
        CNcdNodeIdentifier::NewLC( aNameSpace, aCatalogId, TUid::Uid( 1 ) );         
    CNcdNodeIdentifier* metaDataId = 
        NcdNodeIdentifierEditor::CreateMetaDataIdentifierL( *nodeId );
    CleanupStack::PopAndDestroy( nodeId );
    
    // find the access point id
    // find the map
    TInt mapCount = iAccessPointMaps.Count();
    for (TInt i = 0; i < mapCount; i++) 
        {
        CCatalogsAccessPointMap* map = iAccessPointMaps[i];
        if (map->NameSpace() == metaDataId->NodeNameSpace() && map->HasCatalogId() &&
            map->CatalogId() == metaDataId->NodeId() && map->Action() == aAction) 
            {
            // id found
            apId = &map->AccessPointId();
            break;
            }
        }

    delete metaDataId;
    metaDataId = NULL;
    
    if (!apId) 
        {        
        return NULL;
        }
    
    return AccessPointById(*apId);
    }
    
TInt CCatalogsClientAccessPointData::AccessPointCount() const 
    {
    return iAccessPoints.Count();
    }
    
CCatalogsAccessPoint& CCatalogsClientAccessPointData::AccessPoint(const TInt& aIndex)
    {
    return *iAccessPoints[aIndex];
    }

    
void CCatalogsClientAccessPointData::ExternalizeL(RWriteStream& aStream) 
    {
    DLTRACEIN((""));
    
    TInt apCount = iAccessPoints.Count();
    
    // write access points
    aStream.WriteInt32L(apCount);
    for (TInt i = 0; i < apCount; i++) 
        {
        iAccessPoints[i]->ExternalizeL(aStream);
        }
        
    TInt mapCount = iAccessPointMaps.Count();
    aStream.WriteInt32L(mapCount);
    
    // write access point maps
    for (TInt i = 0; i < mapCount; i++) 
        {
        iAccessPointMaps[i]->ExternalizeL(aStream);
        }
    DLTRACEOUT((""));
    }
    
void CCatalogsClientAccessPointData::InternalizeL(RReadStream& aStream) 
    {    
    DLTRACEIN((""));
    TInt apCount = aStream.ReadInt32L();
    for (TInt i = 0; i < apCount; i++) 
        {
        CCatalogsAccessPoint* ap = CCatalogsAccessPoint::NewLC(aStream);
        iAccessPoints.AppendL(ap);
        CleanupStack::Pop(); // ap
        }
        
    TInt mapCount = aStream.ReadInt32L();
    for (TInt i = 0; i < mapCount; i++) 
        {
        CCatalogsAccessPointMap* apMap = CCatalogsAccessPointMap::NewLC(aStream);
        iAccessPointMaps.AppendL(apMap);
        CleanupStack::Pop(); // apMap
        }
    }
     
    
CCatalogsClientAccessPointData::CCatalogsClientAccessPointData()
    {
    }
    
CCatalogsAccessPoint* CCatalogsClientAccessPointData::AccessPointById(
    const TDesC& apId) const 
    {
    TInt apCount = iAccessPoints.Count();
    for (TInt i = 0; i < apCount; i++) 
        {
        if (iAccessPoints[i]->NcdAccessPointId() == apId) 
            {
            return iAccessPoints[i];
            }
        }
    
    return NULL;
    }