/*

* 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:  Storage service view implementation

*

*/

// INCLUDE FILES

#include "cvimpststorageserviceview.h"

#include "cvimpststoragecontactlist.h"

#include "cvimpststoragecontact.h"

#include "mvimpststoragevpbkcontactstore.h"

#include "cvimpststoragevpbkserverstore.h"

#include "cvimpststoragevpbklocalstore.h"

#include "cvimpststoragecontactsorter.h"

#include "cvimpststorageactivehandler.h"

#include "mvimpststoragecontactsobserver.h"

#include "vimpststorageutils.h"

#include <MVPbkStoreContact.h>

#include <VPbkContactStoreUris.h>

#include <TVPbkContactStoreUriPtr.h>

#include "vimpstdebugtrace.h"

#include "tvimpstconsts.h"

#include "mvimpststoragecontact.h"

// ============================ MEMBER FUNCTIONS ===============================

// panic handler

GLDEF_C void Panic( TVIMPSTStoragePanics aPanic )

    {

    User::Panic( KPanicCategory, aPanic );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::CVIMPSTStorageServiceView

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CVIMPSTStorageServiceView::CVIMPSTStorageServiceView(TUint32 aServiceId) :

    iServiceId(aServiceId),

    iOwnContact( NULL ),

    iUnNamedText( NULL )

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::CVIMPSTStorageServiceView()") );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::ConstructL

// Symbian 2nd phase constructor can leave.

// The constructor also does synchronizing with Phone Book by removing the

// deleted elements from the persistent storage

// -----------------------------------------------------------------------------

//

void CVIMPSTStorageServiceView::ConstructL(const TDesC& aStoreName, const TDesC& aServiceName)

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() begin") );

    iActiveHandler =  CVIMPSTStorageActiveHandler::NewL(this);

    // create sorter for contacts

    iContactSorter = CVIMPSTStorageContactSorter::NewL();

    //set the sorting algorithem to order by presence.

    iContactSorter->SetSortAlgorithm( MVIMPSTStorageContact::ECompareByPresence);

    TRACE( T_LIT("SubServiceType() Type : %S"), &aStoreName );

    //find whether its a local store or xsp store

	if ( VPbkContactStoreUris::DefaultCntDbUri().CompareC( aStoreName, 1, NULL )

	                        != 0 )

		{

		TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() service store created") ); 

		//Create XSP Store 

    	iVPbkContactStore = 

    			CVIMPSTStorageVPbkServerStore::NewL(aStoreName,aServiceName ,*this );

		}

	else

		{

		TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() local store created ") ); 

		//Create Local Contacts.cdb store 

		iVPbkContactStore = CVIMPSTStorageVPbkLocalStore::NewL(VPbkContactStoreUris::DefaultCntDbUri(), 

															   aServiceName,

															   *this );	

		}

    TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() end") );;

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CVIMPSTStorageServiceView* CVIMPSTStorageServiceView::NewL(TUint32 aServiceId,

										const TDesC& aStoreName,

										const TDesC& aServiceName)

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::NewL() begin") );

    CVIMPSTStorageServiceView* self = new( ELeave ) CVIMPSTStorageServiceView(aServiceId);

    CleanupStack::PushL( self );

    self->ConstructL(aStoreName, aServiceName);

    CleanupStack::Pop( self );

    TRACE( T_LIT("CVIMPSTStorageServiceView::NewL() end") );

    return self;

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView

// Two-phased constructor.

// -----------------------------------------------------------------------------

// Destructor

CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView()

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView() begin") );

    if( iActiveHandler )

	    {

	    iActiveHandler->Cancel();

	    delete iActiveHandler;	

	    }

    iContactListArray.ResetAndDestroy();

	delete iOwnContact;

 	delete iContactSorter;

	delete iVPbkContactStore;

    iContactObservers.Reset();

    iContactObservers.Close();

    if(iUnNamedText)

        {

        delete iUnNamedText;   

        iUnNamedText = NULL;

        }        

    TRACE( T_LIT("CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView() end") );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::AddObserverL

// From MVIMPSTStorageServiceView

// -----------------------------------------------------------------------------

//

void CVIMPSTStorageServiceView::AddObserverL( MVIMPSTStorageContactsObserver*

        aObserver )

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::AddObserverL() begin") );

    User::LeaveIfError( aObserver ? KErrNone : KErrArgument );

    TInt index = iContactObservers.Find( aObserver );

    if( index == KErrNotFound )

	    {

	    TRACE( T_LIT("CVIMPSTStorageServiceView::AddObserverL() aObserver added ") );

	    User::LeaveIfError( iContactObservers.Append( aObserver ) );	

	    }

	TRACE( T_LIT("CVIMPSTStorageServiceView::AddObserverL() end") );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::RemoveObserverL

// From MVIMPSTStorageServiceView

// -----------------------------------------------------------------------------

void CVIMPSTStorageServiceView::RemoveObserver( MVIMPSTStorageContactsObserver*

        aObserver )

	{

	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveObserver() begin") );

	__ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ));

	const TInt index( iContactObservers.Find( aObserver ) );

	if ( index >=0)

		{

		TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveObserver() aObserver found") );

		iContactObservers.Remove( index );

		iContactObservers.Compress();

		}

	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveObserver() begin") );

	}

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::SetUnnamedTextL

// From MVIMPSTStorageServiceView

// -----------------------------------------------------------------------------

void CVIMPSTStorageServiceView::SetUnnamedTextL(HBufC* aUnnamedText )

	{

	// takes ownership

	iUnNamedText = aUnnamedText;	

	}

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::CreateContactListL

// -----------------------------------------------------------------------------

//

MVIMPSTStorageContactList* CVIMPSTStorageServiceView::CreateContactListL( 

										   const TDesC& aContactListId, 

                                           const TDesC& aDisplayName )

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() begin") );

    CVIMPSTStorageContactList* contactList = 

    						CVIMPSTStorageContactList::NewLC(*iContactSorter,

                                                         	  aContactListId, 

                                                         	  aDisplayName );

    TIdentityRelation< CVIMPSTStorageContactList > findBy( 

                                CVIMPSTStorageServiceView::ContactListFindByContactListId);

    TInt indexOfList( iContactListArray.Find( contactList, findBy ) );

    if( indexOfList == KErrNotFound )

        {

        TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() list not exist in list") );

        TLinearOrder< CVIMPSTStorageContactList > order( 

                             CVIMPSTStorageServiceView::ContactListOrderByDisplayName );

        iContactListArray.InsertInOrderAllowRepeats( contactList, order );

        CleanupStack::Pop( contactList ); 

        TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() new list created") );       

        }

    else

        {

        TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() list  already exist in list") );

        CleanupStack::PopAndDestroy( contactList );

        contactList = iContactListArray[ indexOfList ];

        }

    TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() end") );

    return contactList; 

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::RemoveContactList

// -----------------------------------------------------------------------------

//

void CVIMPSTStorageServiceView::RemoveContactList( const TDesC& aContactListId )

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactList() begin") );

    TInt pos( FindContactListById( aContactListId ) );

    if( pos >= 0 )

        {

        TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactList() aContactListId found") );

        delete iContactListArray[ pos ];

        iContactListArray.Remove( pos );  

        iContactListArray.Compress();      

        }

    TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactList() end") );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::ListCount

// Count of contactlists

// -----------------------------------------------------------------------------

//

TInt CVIMPSTStorageServiceView::ListCount() const

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::ListCount()") );

    return iContactListArray.Count();

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::ListAt

// Reference to contact list

// -----------------------------------------------------------------------------

//

MVIMPSTStorageContactList& CVIMPSTStorageServiceView::ListAt( TInt aIndex ) const

    {   

    TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() begin") );

    // User::LeaveIfError( aIndex < iContactListArray.Count() ? KErrNone : KErrArgument ); 

    __ASSERT_ALWAYS( (aIndex < iContactListArray.Count() && aIndex >=0 ), Panic( EContactsArrayOutOfSync ));  

    TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() end") );

    return *iContactListArray[ aIndex ];

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::ContactCount

// Count of contacts

// -----------------------------------------------------------------------------

//

TInt CVIMPSTStorageServiceView::ContactCount( TBool aSkipOfflineContacts ) const

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() begin") );

    TInt contactCount( 0 );

    TInt count( iContactListArray.Count() );

    for( TInt a( 0 ); a < count; ++a )

        {

        contactCount += iContactListArray[ a ]->ContactCount( aSkipOfflineContacts, 

                                                         EFalse );

        }

    TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() contactCount = %d") ,contactCount );

    TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() end") );

    return contactCount;

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::UpdatepresenceL

// -----------------------------------------------------------------------------

//

MVIMPSTStorageContact* CVIMPSTStorageServiceView::UpdatePresenceL( 

					                             const TDesC& aContactId, 

					                             TVIMPSTEnums::TOnlineStatus aStatus,

					                             const TDesC& aStatusText,

					                             const TDesC8& aAvatarData,

					                             TBool aIsClearingAvatar /*= EFalse*/)

	{

	TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() begin") );

	MVIMPSTStorageContact* contact = NULL;

	if( iOwnContact && ( aContactId.Compare( iOwnContact->UserId() ) == 0  ) )

	    {

	    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() own Item presence") );

	    if( aAvatarData.Compare(iOwnContact->AvatarContent() ) != 0 )

	        {

	        if((aIsClearingAvatar)||(aAvatarData.Length() > 0))

	            {

	            TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() own avatar change NotifyAllObserversL") );

	            iOwnContact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore );  

	            NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL,iOwnContact,0);

	            }

	        }

	    if( ( iOwnContact->OnlineStatus() !=  aStatus ) || ( aStatusText.Compare( iOwnContact->StatusText() ) != 0 ) )

	        {

		    // own presence has changes

		    // update to own presence

		    iOwnContact->SetOnlineStatus( aStatus );

		    iOwnContact->SetStatusTextL(aStatusText);

		    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() own presene NotifyAllObserversL") );

		    NotifyAllObserversL(TVIMPSTEnums::EStorageOwnPresenceChange,NULL, iOwnContact,0);

		    }

	    contact = iOwnContact;

		}

	else

		{

		TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact item ") );

		contact = FindContactByUserId( aContactId );

		if(contact)

			{

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact exist ") );

			TInt index = KErrNotFound;

			TVIMPSTEnums::TOnlineStatus oldOnlineStatus = contact->OnlineStatus();

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact oldOnlineStatus = %d"), oldOnlineStatus );

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact new presence = %d"), aStatus );

			//status text can be different for the sam status hence not inside the if condition.

			if(  oldOnlineStatus != aStatus )

			    {

			    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact presence change ") );

			    contact->SetOnlineStatus( aStatus );

			    TInt count = iContactListArray.Count();

			    for(TInt i = 0; i < count; i++)

			        {

			        index = iContactListArray[i]->FindIndexOfContact(contact);

			        if(KErrNotFound != index )

			            {

			            iContactListArray[i]->ResortContact(contact);

			            TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact ResortContact ") );

			            // get the index of the sorted contact, as after sorting the 

			            // index would have changed based on presence.

			            // break after the contact list is found and the contact is found

			            break;

			            }

			        }

			    contact->SetStatusTextL(aStatusText);

			    if(aAvatarData.Length()>0)

			    {

			     TInt oldIndex = IndexOfContact (contact);   

			     contact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);  

			     NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL, contact, oldIndex );

			    }

				// once this event occued ,apply the sorting

				NotifyAllObserversWithDelay(TVIMPSTEnums::EStorageMultiplePresenceChange,NULL, contact, -1);

			    }

			else if( aStatusText.Compare( contact->StatusText() ) != 0 )

			    {

			    TInt oldIndex = IndexOfContact (contact);	

			    contact->SetStatusTextL(aStatusText);

			    NotifyAllObserversL(TVIMPSTEnums::EStoragePresenceChange,NULL, contact, oldIndex );	

			    }

			else if( aAvatarData.Length() && aAvatarData.Compare( contact->AvatarContent() ) != 0  )

			    {

			    TInt oldIndex = IndexOfContact (contact);   

			    contact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);  

			    NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL, contact, oldIndex );

			    }

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() aStatusText = %S "), &aStatusText );

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() NotifyAllObserversL called") );

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() NotifyAllObserversL finish") );	

			}

	 	}

	TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() end") );

    return contact;

    }

 // -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::UpdateAvatarL

// -----------------------------------------------------------------------------

//

 MVIMPSTStorageContact* CVIMPSTStorageServiceView::UpdateAvatarL(const TDesC& aContactId,

							                  const TDesC8& aAvatarData ) 

 {

 TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() begin") );

 MVIMPSTStorageContact* contact = NULL;

 if( iOwnContact && ( aContactId.Compare( iOwnContact->UserId() ) == 0  ) )

		{

		TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() own avatar") );

		iOwnContact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);	

		NotifyAllObserversL(TVIMPSTEnums::EStorageOwnPresenceChange,NULL, iOwnContact,0);

	    contact = iOwnContact;

		}

	else

		{

		TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() buddy avatar") );

	    contact = FindContactByUserId( aContactId );

		if(contact)

			{

			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() contact exit") );

			contact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);	

			TInt index = IndexOfContact(contact);

		    NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL, contact,index);

		    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() NotifyAllObserversL called") );		

			}

	   	}

   TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() end") );

   return contact;

   }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::FindContactListInternal

// -----------------------------------------------------------------------------

//

CVIMPSTStorageContactList* CVIMPSTStorageServiceView::FindContactListInternal( 

                                                const TDesC& aListId )

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactListInternal begin") );    

	TInt contactListIndex( FindContactListById( aListId ) );

	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactListInternal end ") );

    return ( contactListIndex >= 0 ? iContactListArray[ contactListIndex ] : NULL );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::FindContactList

// -----------------------------------------------------------------------------

//

MVIMPSTStorageContactList* CVIMPSTStorageServiceView::FindContactList( const TDesC& aListId )

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList") ); 

    return FindContactListInternal( aListId );

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::FindContactListById

// -----------------------------------------------------------------------------

//

TInt CVIMPSTStorageServiceView::FindContactListById(const TDesC& aListId )

	{

	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList begin") );

	TInt index = KErrNotFound;

	TInt count( iContactListArray.Count() );

	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList count = %d"), count );

	for( TInt i= 0  ; i < count ; i++ )

		{

		if( KErrNone == VIMPSTStorageUtils::NeutralCompare( 

							 aListId, 

                             iContactListArray[ i ]->ListId(), EFalse )   )

			{

			TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList contact list found") );

			index = i;

			break;

			}

		}

	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList end") );

	return index;

	}

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::FindContactListById

// -----------------------------------------------------------------------------

//

MVIMPSTStorageContact* CVIMPSTStorageServiceView::FindContactByLink(const MVPbkContactLink& aContactLink )

	{

	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByLink begin") );

	MVIMPSTStorageContact* contact = NULL;

	TInt count( iContactListArray.Count() );

    for( TInt i= 0  ; i < count ; i++ )

        {

        CVIMPSTStorageContactList* contactList = iContactListArray[ i ];

        contact = contactList->FindContactByContactLink( aContactLink );

        if( contact )

            { 

            TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByLink contact found = %d "), i );           

            break;

            }

        }

    TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByLink end") );

    return contact;

  	}

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::GetServiceId

// -----------------------------------------------------------------------------

//

TUint32 CVIMPSTStorageServiceView::GetServiceId()

    {

    TRACE( T_LIT("CVIMPSTStorageServiceView::GetServiceId") );

    return iServiceId;

    }

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::LocalStore

// -----------------------------------------------------------------------------

//

TBool CVIMPSTStorageServiceView::IsLocalStore() const

	{

	TRACE( T_LIT("CVIMPSTStorageServiceView::IsLocalStore") );

	return iVPbkContactStore->LocalStore();	

	}  

// -----------------------------------------------------------------------------

// CVIMPSTStorageServiceView::OwnContactL

// -----------------------------------------------------------------------------

//

MVIMPSTStorageContact& CVIMPSTStorageServiceView::OwnContactL()

	{

	TRACE( T_LIT("CVIMPSTStorageServiceView::OwnContact begin") );

	if( !iOwnContact )

		{

		iOwnContact = CVIMPSTStorageContact::NewL(KNullDesC,

		        								  KNullDesC )	;