/*
* 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:  Store object for single buddy in a service
*
*/


#include "presencecachebuddystore.h"
#include "presencecacheservicestore.h"
#include "presencecachesession.h"
#include "presencetypehelpers.h"
#include "ximpidentityimp.h"
#include "presencebuddyinfoimp.h"

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

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceCacheBuddyStore* CPresenceCacheBuddyStore::NewL(
                                    CPresenceCacheServiceStore* aServiceStore,
                                    MXIMPIdentity* aIdentity)
    {
    CPresenceCacheBuddyStore* self = NewLC(aServiceStore,aIdentity);
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::~CPresenceCacheBuddyStore()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore::~CPresenceCacheBuddyStore()
    {
    if (iPresenceBuddyInfo)
        delete iPresenceBuddyInfo;
    if(iIdentity)
        delete iIdentity;
    iSubscribedSessions.Close();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::CPresenceCacheBuddyStore()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore::CPresenceCacheBuddyStore(
          CPresenceCacheServiceStore* aServiceStore):iPresenceBuddyInfo(NULL),
                                                    iServiceStore(aServiceStore)
    {
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::ConstructL(MXIMPIdentity* aIdentity)
    {
    if(aIdentity)
        iIdentity = TXIMPGetImpClassOrPanic< CXIMPIdentityImp >::From( *aIdentity );
    else
        iIdentity = CXIMPIdentityImp::NewL();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::SetPresenceBuddyInfo()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::SetPresenceBuddyInfo(MPresenceBuddyInfo* aPresBuddyInfo)
    {
    if(aPresBuddyInfo)
        {
        if (iPresenceBuddyInfo)
            delete iPresenceBuddyInfo;
        iPresenceBuddyInfo = aPresBuddyInfo;
        }
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::RemovePresenceBuddyInfo()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::RemovePresenceBuddyInfo()
    {
    if (iPresenceBuddyInfo)
        delete iPresenceBuddyInfo;
    iPresenceBuddyInfo = NULL;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::GetSubscribedSessions()
// ---------------------------------------------------------------------------
//
RPointerArray<CPresenceCacheSession>& CPresenceCacheBuddyStore::GetSubscribedSessions()
    {
    return iSubscribedSessions;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::AddSubscribedSession()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::AddSubscribedSession(CPresenceCacheSession* aSession)
    {
    if(iSubscribedSessions.Find(aSession)<0)
        iSubscribedSessions.Append(aSession);
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::RemoveSubscribedSession()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::RemoveSubscribedSession(CPresenceCacheSession* aSession)
    {
    TInt index = iSubscribedSessions.Find(aSession);
    if(index>-1)
        iSubscribedSessions.Remove(index);
    
    // delete this object if it doesnt have any presence or subscribers
    if(!(iPresenceBuddyInfo || HasSubscribers()))
        {
        if(iServiceStore)
            {
            iServiceStore->RemoveBlind(this);
            }
        }
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::SetBuddyId()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::SetBuddyId(MXIMPIdentity* aIdentity)
    {
    if(aIdentity)
        {
        delete iIdentity;
            iIdentity = TXIMPGetImpClassOrPanic< CXIMPIdentityImp >::From( *aIdentity );
        }
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::ServiceName()
// ---------------------------------------------------------------------------
//
TPtrC CPresenceCacheBuddyStore::ServiceName() const
    {
    _LIT(KColon, ":");
    TInt pos = iIdentity->Identity().Find(KColon);
    TPtrC serviceName;
    if(pos>0) // if colon found and there is something before colon, i.e. xsp id
        {
        serviceName.Set(iIdentity->Identity().Left(pos));
        }
    else
        serviceName.Set(TPtrC());
    return serviceName;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::PresenceBuddyInfo()
// ---------------------------------------------------------------------------
//
MPresenceBuddyInfo* CPresenceCacheBuddyStore::PresenceBuddyInfo() const
    {
    return iPresenceBuddyInfo;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::BuddyId()
// ---------------------------------------------------------------------------
//
const MXIMPIdentity* CPresenceCacheBuddyStore::BuddyId() const
    {
    return iIdentity;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::EqualsIdentity()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::EqualsIdentity(
                    const CPresenceCacheBuddyStore* aOtherInstance ) const
    {
    TBool ret(EFalse);
    if(aOtherInstance)
        {
        const CXIMPIdentityImp* tmp = 
            TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From( *(aOtherInstance->BuddyId()));
        ret = iIdentity->EqualsContent( *tmp);
        }
    return ret;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::EqualsIdentity()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::EqualsIdentity(
                    const MPresenceBuddyInfo* aOtherInstance ) const
    {
    TBool ret(EFalse);
    if(aOtherInstance)
        {
        const CXIMPIdentityImp* tmp = 
            TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From( *(aOtherInstance->BuddyId()));
        ret = iIdentity->EqualsContent( *tmp);
        }
    return ret;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::EqualsIdentity()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::EqualsIdentity(
                    const MXIMPIdentity& aOtherIdentity ) const
    {
    const CXIMPIdentityImp* tmp = 
            TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From(aOtherIdentity);
    return iIdentity->EqualsContent( *tmp);
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::HasPresence()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::HasPresence() const
    {
    if(iPresenceBuddyInfo)
        return ETrue;
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::HasSubscribers()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::HasSubscribers() const
    {
    if(iSubscribedSessions.Count())
        return ETrue;
    return EFalse;
    }