/*

* 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 "uiservicetabtracer.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 )

    {

	TRACER_AUTO;

    }

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

// 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)

    {

	TRACER_AUTO;

    iActiveHandler =  CVIMPSTStorageActiveHandler::NewL(this);

    // create sorter for contacts

    iContactSorter = CVIMPSTStorageContactSorter::NewL();

    //set the sorting algorithem to order by presence.

    iContactSorter->SetSortAlgorithm( MVIMPSTStorageContact::ECompareByPresence);

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

    //find whether its a local store or xsp store

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

	                        != 0 )

		{

	TRACE( " service store created" );

		//Create XSP Store 

    	iVPbkContactStore = 

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

		}

	else

		{

	TRACE( "local store created " ); 

		//Create Local Contacts.cdb store 

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

															   aServiceName,

															   *this );	

		}

    }

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

// CVIMPSTStorageServiceView::NewL

// Two-phased constructor.

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

//

CVIMPSTStorageServiceView* CVIMPSTStorageServiceView::NewL(TUint32 aServiceId,

										const TDesC& aStoreName,

										const TDesC& aServiceName)

    {

	TRACER_AUTO;

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

    CleanupStack::PushL( self );

    self->ConstructL(aStoreName, aServiceName);

    CleanupStack::Pop( self );

    return self;

    }

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

// CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView

// Two-phased constructor.

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

// Destructor

CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView()

    {

	TRACER_AUTO;

    if( iActiveHandler )

	    {

	    iActiveHandler->Cancel();

	    delete iActiveHandler;	

	    }

    iContactListArray.ResetAndDestroy();

	delete iOwnContact;

 	delete iContactSorter;

	delete iVPbkContactStore;

    iContactObservers.Reset();

    iContactObservers.Close();

    if(iUnNamedText)

        {

        delete iUnNamedText;   

        iUnNamedText = NULL;

        }        

    }

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

// CVIMPSTStorageServiceView::AddObserverL

// From MVIMPSTStorageServiceView

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

//

void CVIMPSTStorageServiceView::AddObserverL( MVIMPSTStorageContactsObserver*

        aObserver )

    {

	TRACER_AUTO;

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

    TInt index = iContactObservers.Find( aObserver );

    if( index == KErrNotFound )

	    {

		TRACE( "aObserver added ");

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

	    }

    }

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

// CVIMPSTStorageServiceView::RemoveObserverL

// From MVIMPSTStorageServiceView

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

void CVIMPSTStorageServiceView::RemoveObserver( MVIMPSTStorageContactsObserver*

        aObserver )

	{

	TRACER_AUTO;

	__ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ));

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

	if ( index >=0)

		{

		TRACE( "aObserver found" );

		iContactObservers.Remove( index );

		iContactObservers.Compress();

		}

	}

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

// CVIMPSTStorageServiceView::SetUnnamedTextL

// From MVIMPSTStorageServiceView

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

void CVIMPSTStorageServiceView::SetUnnamedTextL(HBufC* aUnnamedText )

	{

	// takes ownership

	iUnNamedText = aUnnamedText;	

	}

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

// CVIMPSTStorageServiceView::CreateContactListL

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

//

MVIMPSTStorageContactList* CVIMPSTStorageServiceView::CreateContactListL( 

										   const TDesC& aContactListId, 

                                           const TDesC& aDisplayName )

    {

	TRACER_AUTO;

    CVIMPSTStorageContactList* contactList = 

    						CVIMPSTStorageContactList::NewLC(*iContactSorter,

                                                         	  aContactListId, 

                                                         	  aDisplayName );

    TIdentityRelation< CVIMPSTStorageContactList > findBy( 

                                CVIMPSTStorageServiceView::ContactListFindByContactListId);

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

    if( indexOfList == KErrNotFound )

        {

		TRACE( "list not exist in list");

        TLinearOrder< CVIMPSTStorageContactList > order( 

                             CVIMPSTStorageServiceView::ContactListOrderByDisplayName );

        iContactListArray.InsertInOrderAllowRepeats( contactList, order );

        CleanupStack::Pop( contactList ); 

        TRACE( " new list created");

        }

    else

        {

		TRACE( " list  already exist in list" );

        CleanupStack::PopAndDestroy( contactList );

        contactList = iContactListArray[ indexOfList ];

        }

    return contactList; 

    }

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

// CVIMPSTStorageServiceView::RemoveContactList

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

//

void CVIMPSTStorageServiceView::RemoveContactList( const TDesC& aContactListId )

    {

	TRACER_AUTO;

    TInt pos( FindContactListById( aContactListId ) );

    if( pos >= 0 )

        {

		TRACE( "aContactListId found" );

        delete iContactListArray[ pos ];

        iContactListArray.Remove( pos );  

        iContactListArray.Compress();      

        }

    }

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

// CVIMPSTStorageServiceView::ListCount

// Count of contactlists

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

//

TInt CVIMPSTStorageServiceView::ListCount() const

    {

	TRACER_AUTO;

    return iContactListArray.Count();

    }

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

// CVIMPSTStorageServiceView::ListAt

// Reference to contact list

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

//

MVIMPSTStorageContactList& CVIMPSTStorageServiceView::ListAt( TInt aIndex ) const

    {  

	TRACER_AUTO;

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

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

    return *iContactListArray[ aIndex ];

    }

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

// CVIMPSTStorageServiceView::ContactCount

// Count of contacts

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

//

TInt CVIMPSTStorageServiceView::ContactCount( TBool aSkipOfflineContacts ) const

    {

	TRACER_AUTO;

    TInt contactCount( 0 );

    TInt count( iContactListArray.Count() );

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

        {

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

                                                         EFalse );

        }

		TRACE(" contactCount = %d" ,contactCount );

    return contactCount;

    }

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

// CVIMPSTStorageServiceView::UpdatepresenceL

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

//

MVIMPSTStorageContact* CVIMPSTStorageServiceView::UpdatePresenceL( 

					                             const TDesC& aContactId, 

					                             TVIMPSTEnums::TOnlineStatus aStatus,

					                             const TDesC& aStatusText,

					                             const TDesC8& aAvatarData,

					                             TBool aIsClearingAvatar /*= EFalse*/)

	{

	TRACER_AUTO;

	MVIMPSTStorageContact* contact = NULL;

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

	    {

		TRACE("own Item presence");

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

	        {

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

	            {

				TRACE( "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( " own presene NotifyAllObserversL");

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

		    }

	    contact = iOwnContact;

		}

	else

		{

		TRACE( "contact item ");

		contact = FindContactByUserId( aContactId );

		if(contact)

			{

			TRACE( "contact exist " );

			TInt index = KErrNotFound;

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

			TRACE( "contact oldOnlineStatus = %d", oldOnlineStatus );

			TRACE( "contact new presence = %d", aStatus );

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

			if(  oldOnlineStatus != aStatus )

			    {

				TRACE( "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( "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("aStatusText = %S ", &aStatusText );

			TRACE( "NotifyAllObserversL called" );

			TRACE( "NotifyAllObserversL finish" );	

			}

	 	}	

    return contact;

    }

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

// CVIMPSTStorageServiceView::UpdateAvatarL

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

//

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

							                  const TDesC8& aAvatarData ) 

 {

 TRACER_AUTO;

 MVIMPSTStorageContact* contact = NULL;

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

		{

		TRACE( "own avatar" );

		iOwnContact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);	

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

	    contact = iOwnContact;

		}

	else

		{

		TRACE( "buddy avatar" );

	    contact = FindContactByUserId( aContactId );

		if(contact)

			{

			TRACE( "contact exit");

			contact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);	

			TInt index = IndexOfContact(contact);

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

		    TRACE( " NotifyAllObserversL called" );		

			}

	   	}

   return contact;

   }

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

// CVIMPSTStorageServiceView::FindContactListInternal

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

//

CVIMPSTStorageContactList* CVIMPSTStorageServiceView::FindContactListInternal( 

                                                const TDesC& aListId )

    {

	TRACER_AUTO;

	TInt contactListIndex( FindContactListById( aListId ) );

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

    }

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

// CVIMPSTStorageServiceView::FindContactList

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

//

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

    {

	TRACER_AUTO;     

    return FindContactListInternal( aListId );

    }

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

// CVIMPSTStorageServiceView::FindContactListById

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

//

TInt CVIMPSTStorageServiceView::FindContactListById(const TDesC& aListId )

	{

	TRACER_AUTO;

	TInt index = KErrNotFound;

	TInt count( iContactListArray.Count() );

	TRACE( " count = %d", count );

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

		{

		if( KErrNone == VIMPSTStorageUtils::NeutralCompare( 

							 aListId, 

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

			{

			TRACE( " contact list found" );

			index = i;

			break;

			}

		}

	return index;

	}

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

// CVIMPSTStorageServiceView::FindContactListById

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

//

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

	{

	TRACER_AUTO;

	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( " contact found = %d ", i );           

            break;

            }

        }

    return contact;

  	}

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

// CVIMPSTStorageServiceView::GetServiceId

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

//

TUint32 CVIMPSTStorageServiceView::GetServiceId()

    {

	TRACER_AUTO;

    return iServiceId;

    }

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

// CVIMPSTStorageServiceView::LocalStore

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

//

TBool CVIMPSTStorageServiceView::IsLocalStore() const

	{

	TRACER_AUTO;

	return iVPbkContactStore->LocalStore();	

	}  

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

// CVIMPSTStorageServiceView::OwnContactL

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

//

MVIMPSTStorageContact& CVIMPSTStorageServiceView::OwnContactL()

	{

	TRACER_AUTO;

	if( !iOwnContact )

		{

		iOwnContact = CVIMPSTStorageContact::NewL(KNullDesC,

		        								  KNullDesC )	;	

		}

	return *iOwnContact;	

	}