/*
* Copyright (c) 2008 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:  The cache stores a single array of this type. 
*
*/


#include <s32strm.h>
#include <mpresencebuddyinfo2.h>

#include "presencecacheservicestore.h"
#include "presencecachebuddystore.h"
#include "presencetrace.h"
#include "presenceobjecthelpers.h"

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceCacheServiceStore* CPresenceCacheServiceStore::NewLC()
    {
    CPresenceCacheServiceStore* self = new( ELeave ) CPresenceCacheServiceStore;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceCacheServiceStore* CPresenceCacheServiceStore::NewL()
    {
    CPresenceCacheServiceStore* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::~CPresenceCacheServiceStore()
// ---------------------------------------------------------------------------
//
CPresenceCacheServiceStore::~CPresenceCacheServiceStore()
    {
    TInt count = iBuddyStoreCollection.Count();
    for (TInt i=0;i<count;i++)
        {
        delete iBuddyStoreCollection[i];
        }
    iBuddyStoreCollection.Close();
    delete iServiceName;
    iServiceName = NULL;        
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::CPresenceCacheServiceStore()
// ---------------------------------------------------------------------------
//
CPresenceCacheServiceStore::CPresenceCacheServiceStore(): iServiceName(NULL)
    {
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresenceCacheServiceStore::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::SetServiceNameL()
// ---------------------------------------------------------------------------
//
void CPresenceCacheServiceStore::SetServiceNameL(TDesC& aServiceName)
    {
    delete iServiceName;
    iServiceName = NULL;
    iServiceName = aServiceName.AllocL();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::GetObjectCollection()
// ---------------------------------------------------------------------------
//
RPointerArray<CPresenceCacheBuddyStore>& CPresenceCacheServiceStore::GetObjectCollection()
    {
    return iBuddyStoreCollection;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::ServiceName()
// ---------------------------------------------------------------------------
//
TPtrC CPresenceCacheServiceStore::ServiceName() const
    {
    return *iServiceName;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::Count()
// ---------------------------------------------------------------------------
//
TInt CPresenceCacheServiceStore::Count() const
    {
    return iBuddyStoreCollection.Count();
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::PresenceCount()
// ---------------------------------------------------------------------------
//
TInt CPresenceCacheServiceStore::PresenceCount() const
    {
    return iPresenceCount;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::AddBlind()
// ---------------------------------------------------------------------------
//
TInt CPresenceCacheServiceStore::AddBlind(CPresenceCacheBuddyStore* aBuddyStore)
    {
    TRACE( _L("CPresenceCacheServiceStore::AddBlind - begin") );
    // TRACE_1( _L("______identity: %S"), &aBuddyStore->BuddyId() );
    // TRACE_1( _L("______iService: %S"), &iServiceName->Des());
    if (!aBuddyStore)
        return KErrArgument;
    
    iBuddyStoreCollection.Append(aBuddyStore);
    
    // now update the presence count
    if (aBuddyStore->HasPresence())
        {
        iPresenceCount++;        
        }
        
    TRACE( _L("CPresenceCacheServiceStore::AddBlind - return"));
    return KErrNone;
    }
    
    
// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::AddOrReplacePresenceL()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore* CPresenceCacheServiceStore::AddOrReplacePresenceL
                                            (MPresenceBuddyInfo2* aBuddyPresInfo)
    {
    TRACE( _L("CPresenceCacheServiceStore::AddOrReplacePresence - begin") );
    // TRACE_1( _L("______identity: %S"), &(aBuddyPresInfo->BuddyId() ));
    // TRACE_1( _L("______iService: %d"), &(iServiceName->Des()));
    
    CPresenceCacheBuddyStore* newBuddyStore(NULL);
    if(!aBuddyPresInfo)
        return newBuddyStore;
    
    TBool oldPresExists(EFalse);
    
    TInt count = iBuddyStoreCollection.Count();
    for (TInt i=0;i<count;i++)
        {
        if( (iBuddyStoreCollection[i])->EqualsIdentity(aBuddyPresInfo) )
            {
            oldPresExists = (iBuddyStoreCollection[i])->HasPresence();
            iBuddyStoreCollection[i]->SetPresenceBuddyInfo(aBuddyPresInfo);
            newBuddyStore = iBuddyStoreCollection[i];
            TRACE( _L("_________Match found") );
            break;
            }
        }
    
    //if not edited, we need to add a new buddy store    
    if (!newBuddyStore)
        {        
        newBuddyStore = CPresenceCacheBuddyStore::NewLC(this, aBuddyPresInfo->BuddyId());
        newBuddyStore->SetPresenceBuddyInfo(aBuddyPresInfo);
        iBuddyStoreCollection.Append(newBuddyStore);
        CleanupStack::Pop(newBuddyStore); //newBuddyStore
        }
        
    // new presence is certainly added, check whether it was existed
    if (!oldPresExists)
        {
        iPresenceCount++;        
        }

    TRACE( _L("CPresenceCacheServiceStore::AddOrReplacePresence - return"));
    return newBuddyStore;
    }


// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::RemoveBlind()
// ---------------------------------------------------------------------------
//
void CPresenceCacheServiceStore::RemoveBlind(CPresenceCacheBuddyStore* aPresenceBuddyInfo)
    {
    TInt index = iBuddyStoreCollection.Find(aPresenceBuddyInfo);
    if (index>-1)
        {
        delete iBuddyStoreCollection[index];
        iBuddyStoreCollection.Remove(index);
        }
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::FindAndRemove()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore* CPresenceCacheServiceStore::FindAndRemove
                                    (const TDesC& aIdentity, TInt& aErr)
    {
    TRACE( _L("CPresenceCacheServiceStore::FindAndRemove - begin") );
    // TRACE_1( _L("______iService: %S"), &(iServiceName->Des()));
    // TRACE_1( _L("______identity: %S"), &(aIdentity ));
    TBool oldPresExists(EFalse);
    CPresenceCacheBuddyStore* buddyStore(NULL);
    aErr = KErrNotFound;

    TInt count = iBuddyStoreCollection.Count();
    for (TInt i=0;i<count;i++)
        {
        if ( (iBuddyStoreCollection[i])->EqualsIdentity(aIdentity) )
            {
            oldPresExists = (iBuddyStoreCollection[i])->HasPresence();
            
            //only delete presence if there are subscribers
            if ((iBuddyStoreCollection[i])->HasSubscribers())
                {
                (iBuddyStoreCollection[i])->SetPresenceBuddyInfo(NULL);
                buddyStore = iBuddyStoreCollection[i];
                }
            else //if there are no subscribers remove the whole package
                {
                delete iBuddyStoreCollection[i];
                iBuddyStoreCollection.Remove(i);                
                }
            break;
            }
        }
    
    // update presence info counts
    if(oldPresExists)
        {
        iPresenceCount--;
        aErr = KErrNone;      
        }

    TRACE_1( _L("CPresenceCacheServiceStore::FindAndRemove - buddyStore=%d"),buddyStore );
    return buddyStore;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::RemoveExpiredBuddyInfos
// ---------------------------------------------------------------------------
//

void CPresenceCacheServiceStore::RemoveExpiredBuddyInfos( 
        RPointerArray<CPresenceCacheBuddyStore>& aBuddyStores )
    {
    TInt count = iBuddyStoreCollection.Count();
    for( TInt i = 0 ; i < count ; ++i )
        {
        CPresenceCacheBuddyStore* buddyStore = iBuddyStoreCollection[i];
        MPresenceBuddyInfo2* buddyInfo = buddyStore->PresenceBuddyInfo();

        if( buddyInfo &&
                PresenceCacheBuddyUtils::IsBuddyInfoExpired( *buddyInfo ) )
            {
            // remove buddy info
            buddyStore->SetPresenceBuddyInfo( NULL );
            --iPresenceCount;
            if( buddyStore->HasSubscribers() )
                {
                aBuddyStores.Append( buddyStore ); // ignore error
                }
            else
                {
                delete buddyStore;
                iBuddyStoreCollection.Remove( i );
                --i;
                --count;
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::FindAndGet()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore* CPresenceCacheServiceStore::FindAndGet(
                                     const TDesC& aIdentity) const
    {
    TRACE( _L("CPresenceCacheServiceStore::FindAndGet - begin") );
    // TRACE_1( _L("______iService: %S"), &(iServiceName->Des()));
    TRACE_1( _L("______identity: %S"), &(aIdentity ));
    CPresenceCacheBuddyStore* buddyStore(NULL);
    
    TInt count = iBuddyStoreCollection.Count();
    for (TInt i=0;i<count;i++)
        {
        if ( (iBuddyStoreCollection[i])->EqualsIdentity(aIdentity))
            {
            buddyStore = iBuddyStoreCollection[i];
            break;
            }
        }
    TRACE_1( _L("CPresenceCacheServiceStore::FindAndGet - buddyStore=%d"),buddyStore );    
    return buddyStore;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheServiceStore::RemoveAllPresences()
// ---------------------------------------------------------------------------
//
void CPresenceCacheServiceStore::RemoveAllPresences()
    {
    TRACE( _L("CPresenceCacheServiceStore::RemoveAllPresences - begin") );
    // TRACE_1( _L("______iService: %S"), &(iServiceName->Des()));
    
    TInt count = iBuddyStoreCollection.Count();
    TRACE_1( _L("______store collection count: %d"), count);
    for (TInt i=0;i<count;i++)
        {
        (iBuddyStoreCollection[i])->RemovePresenceBuddyInfo();
        //if it doesnt have subscribers delete this whole object
        if(!(iBuddyStoreCollection[i]->HasSubscribers()))
            {
            delete iBuddyStoreCollection[i];
            iBuddyStoreCollection.Remove(i);
            count--;
            i--;
            }
        }
    iPresenceCount = 0;
    TRACE(_L("CPresenceCacheServiceStore::RemoveAllPresences - end"));    
    }

// eof