/*

* Copyright (c) 2004 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:  Provides methods for Attendee View's engine class.

*

*/

// INCLUDE FILES

#include "CAttendeeEng.h"

#include "AttendeeParser.h"

#include "AttendeeEngUtils.h"

#include "AttendeeViewConsts.h"

#include "CAttendeeItemList.h"

#include "MAttendeeEngObserver.h"

#include <cpbkidlefinder.h> 

#include <CPbkContactEngine.h>

#include <cpbkcontactitem.h> 

#include <calentry.h>

#include <caluser.h>

#include <CPbkContactChangeNotifier.h>

//CONSTANTS

const TInt KInitialMatchEmail( -1 );

const TInt KOrganizer( 1 );

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

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

// CAttendeeEng::NewL

// Two-phased constructor.

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

//

CAttendeeEng* CAttendeeEng::NewL( CCalEntry& aCalEntry )

    {

    CAttendeeEng* self = new(ELeave)CAttendeeEng( aCalEntry );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self); // self

    return self;

    }

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

// CAttendeeEng::ConstructL

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

//

void CAttendeeEng::ConstructL()

    {

    iAttendees = CAttendeeItemList::NewL();

    iDeletedAttendees = CAttendeeItemList::NewL();

    iContactEngine = CPbkContactEngine::NewL();

    iFind = new(ELeave)CPbkFieldIdArray;    

    iFind->AppendL( EPbkFieldIdEmailAddress );

    iNotifier = CPbkContactChangeNotifier::NewL( *iContactEngine, this );        

    }

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

// CAttendeeEng::CAttendeeEng

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

// might leave.

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

//

CAttendeeEng::CAttendeeEng( CCalEntry& aCalEntry ) : iCalEntry( &aCalEntry )

    {

    }

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

// CAttendeeEng::~CAttendeeEng

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

//

CAttendeeEng::~CAttendeeEng()

    {

    delete iNotifier;

    delete iIdleFinder;                    

    delete iFind;

    delete iContactEngine;    

    delete iDeletedAttendees;

    delete iAttendees;    

    }

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

// CAttendeeEng::ParseAgnEntryL

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

//

void CAttendeeEng::ParseAgnEntryL()

	{    

    AttendeeParser::ParseAgnEntryL( *iCalEntry, *iAttendees );

    SortAttendeesL();

    MatchEmailsL();

	}

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

// CAttendeeEng::AddItemsL

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

//

void CAttendeeEng::AddItemL( TDesC& aEmailAddress )

    {        

    const TInt index( 

        AttendeeEngUtils::FindLastRequiredItemL( *iAttendees ) );    

    //Create CCalAttendee

    CCalAttendee* attendee = CCalAttendee::NewL( aEmailAddress );

    CleanupStack::PushL( attendee );

    attendee->SetRoleL( CCalAttendee::EReqParticipant );

    //Create CAttendeeItem

    CAttendeeItem* item = CAttendeeItem::NewL( attendee ); 

    CleanupStack::Pop( attendee );

    item->SetOwnership( ETrue );

    CleanupStack::PushL( item );

    iAttendees->InsertL( item, index );

    CleanupStack::Pop( item );

    }

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

// CAttendeeEng::AddItemL

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

//

void CAttendeeEng::AddItemL( CPbkContactItem& aPbkItem, 

                             const TPbkContactItemField* aAddress )

    {      

    const TInt index( 

        AttendeeEngUtils::FindLastRequiredItemL( *iAttendees ) );

    CCalAttendee* attendee = CCalAttendee::NewL( aAddress->Text() );  

    CleanupStack::PushL( attendee );

    attendee->SetRoleL( CCalAttendee::EReqParticipant );

    CAttendeeItem* item = CAttendeeItem::NewL( attendee );     

    CleanupStack::Pop( attendee );

    item->SetContactId( aPbkItem.Id() );

    item->SetOwnership( ETrue );

    CleanupStack::PushL( item );

    item->SetContactTitle( aPbkItem.GetContactTitleOrNullL() );       

    //check if item is already deleted    

    AttendeeEngUtils::CheckIfDeleted( *item, *iDeletedAttendees );

    iAttendees->InsertL( item, index );

    CleanupStack::Pop( item );

    }

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

// CAttendeeEng::DeleteItem

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

//

void CAttendeeEng::DeleteItemL( const TInt aIndex )

	{    

    if ( aIndex != 0 )

        {

        //delete from attendee view                        

        CAttendeeItem* item = iAttendees->Delete( aIndex );        

        if ( item )

            {

            CleanupStack::PushL( item );

            iDeletedAttendees->AppendL( item );

            CleanupStack::Pop( item );

            }

        NotifyL();

        }    

    else

        {

        NotifyError( KErrDelete );            

        }

	}

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

// CAttendeeEng::DeleteItems

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

//

void CAttendeeEng::DeleteItemsL( const CArrayFix<TInt>& aIndexes )

	{    

    const TInt count( aIndexes.Count() );

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

        {

        DeleteItemL( aIndexes.At( i ) );

        }

	}

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

// CAttendeeEng::ChangeAttendance

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

//

void CAttendeeEng::ChangeAttendanceL( const TInt aIndex, 

           const CAttendeeItem::TAttendance aAttendance )

    {    

    CAttendeeItem& item = At( aIndex );

    if ( !item.IsOrganizer() )

        {

        item.SetAttendanceL( aAttendance );                

        }    

    else

        {

        NotifyError( KErrSetAs );            

        }

    }

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

// CAttendeeEng::ChangeAttendances

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

//

void CAttendeeEng::ChangeAttendancesL( const CArrayFix<TInt>& aIndexes, 

                         const CAttendeeItem::TAttendance aAttendance )

    {

    const TInt count( aIndexes.Count() );

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

        {

        ChangeAttendanceL( aIndexes.At( i ), aAttendance );

        }    

    }

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

// CAttendeeEng::NumberOfItems

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

//

TInt CAttendeeEng::NumberOfItems() const

	{    

	return iAttendees->Count();

	}

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

// CAttendeeEng::At

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

//

CAttendeeItem& CAttendeeEng::At( const TInt aIndex ) const

	{

    return *iAttendees->At( aIndex );

	}

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

// CAttendeeEng::IsEdited

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

//

TBool CAttendeeEng::IsEditedL() const

    {

    TBool result( EFalse );

    if ( iDeletedAttendees->Count() != 0 || 

        ((iAttendees->Count() - KOrganizer) > iCalEntry->AttendeesL().Count()) )

        {        

        AttendeeParser::UpdateAgnEntryL( *iCalEntry,

                                         *iAttendees, 

                                         *iDeletedAttendees );        

        result = ETrue;

        }

    return result;

    }

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

// CAttendeeEng::SortAttendeesL

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

//

void CAttendeeEng::SortAttendeesL()

    {    

    iAttendees->SortL();

    NotifyL();

    }

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

// CAttendeeEng::SetObserver

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

//

void CAttendeeEng::SetObserver( MAttendeeEngObserver* aObserver )

	{

    iObserver = aObserver;	

	}

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

// CAttendeeEng::RemoveObserver

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

//

void CAttendeeEng::RemoveObserver()

	{

    iObserver = NULL;

	}

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

// CAttendeeEng::ContactEngine

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

//

CPbkContactEngine& CAttendeeEng::ContactEngine() const

    {    

    return *iContactEngine;

    }

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

// CAttendeeEng::PbkContactItemL

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

//

CPbkContactItem* CAttendeeEng::PbkContactItemL( const TInt aIndex ) const

    {    

    CAttendeeItem& attItem = At( aIndex );    

    CPbkContactItem* ret = NULL;

    if ( attItem.ContactId() != KNullContactId )

        {

        ret = iContactEngine->ReadContactLC( 

                                            attItem.ContactId() );

        CleanupStack::Pop( ret );

        }

    return ret;

    }

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

// CAttendeeEng::IdleFindCallback

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

//

void CAttendeeEng::IdleFindCallback()

    {

    if ( iIdleFinder->IsComplete() )

        {

        TRAPD( error, 

        if ( iIdleFinder->Error() != KErrNone )

            {             

            NotifyError( iIdleFinder->Error() );                

            }

        else

            {                                   

            UpdateAttendeesL( iIdleFinder->TakeContactIds() );                        

            NotifyL();

            }

        delete iIdleFinder;

        iIdleFinder = NULL;

        FindNextEmailL();        

        ); //End of TRAPD

        if ( error != KErrNone )

            {

            NotifyError( error );                

            }

        }    

    }

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

// CAttendeeEng::Attendees

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

//

MAttendeeItemList& CAttendeeEng::Attendees() const

    {    

    return *iAttendees;

    }

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

// CAttendeeEng::DeletedAttendees

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

//

MAttendeeItemList& CAttendeeEng::DeletedAttendees() const

    {    

    return *iDeletedAttendees;

    }

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

// CAttendeeEng::HandleDatabaseEventL

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

//

void CAttendeeEng::HandleDatabaseEventL( TContactDbObserverEvent aEvent )

    {

    switch( aEvent.iType )

        {

        case EContactDbObserverEventContactAdded: //Fall through

        case EContactDbObserverEventContactChanged:

        case EContactDbObserverEventUnknownChanges:

            {

            CPbkContactItem* contactItem = 

                iContactEngine->ReadContactLC( aEvent.iContactId );

            const TInt count( iAttendees->Count() );

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

                {

                CAttendeeItem& item = At( i );

                if ( item.ContactId() == KNullContactId )

                    {

                    if ( AttendeeEngUtils::Compare( *contactItem,

                                                    item ) )

                        {

                        item.SetContactId( contactItem->Id() );

                        item.SetContactTitle( 

                            contactItem->GetContactTitleOrNullL() );

                        }

                    }

                }

            CleanupStack::PopAndDestroy( contactItem );

            NotifyL();

            break;

            }

        case EContactDbObserverEventContactDeleted:        

            {            

            const TInt count( iAttendees->Count() );

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

                {

                CAttendeeItem& item = At( i );

                if ( item.ContactId() == aEvent.iContactId )

                    {                    

                    item.SetContactId( KNullContactId );

                    item.SetContactTitle( NULL );                           

                    }

                }            

            NotifyL();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CAttendeeEng::MatchEmailsL

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

//

void CAttendeeEng::MatchEmailsL()

    {

    iFindedIndex = KInitialMatchEmail;    

    FindNextEmailL();

    }

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

// CAttendeeEng::FindNextEmailL

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

//

void CAttendeeEng::FindNextEmailL()

    {    

    ++iFindedIndex;

    if ( iFindedIndex >= 0 &&

         iFindedIndex < iAttendees->Count() )

        {

        //email address must be without alias name.

        //e.g. name.name@domain.com

        iIdleFinder = iContactEngine->FindAsyncL(                 

                            At( iFindedIndex ).AgnAttendee()->Address(),

                            iFind, this );

        }          

    }

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

// CAttendeeEng::UpdateAttendeesL

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

//

void CAttendeeEng::UpdateAttendeesL( CContactIdArray* aFoundContacts )

    {  

    if ( aFoundContacts && aFoundContacts->Count() == 1 )

        {

        //Read contact

        CPbkContactItem* pbkItem = iContactEngine->ReadContactLC( 

                                    aFoundContacts->operator[]( 0 ) );

        //Update attendee

        CAttendeeItem& item = At( iFindedIndex );

        item.SetContactId( pbkItem->Id() );

        item.SetContactTitle( pbkItem->GetContactTitleOrNullL() );

        CleanupStack::PopAndDestroy(pbkItem); //pbkItem

        }

    delete aFoundContacts;

    }

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

// CAttendeeEng::NotifyL

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

//

void CAttendeeEng::NotifyL() const

    {

    if ( iObserver )

        {

        iObserver->NotifyL();

        }

    }

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

// CAttendeeEng::NotifyError

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

//

void CAttendeeEng::NotifyError( const TInt aErrorCode ) const

    {

    if ( iObserver )

        {

        iObserver->NotifyError( aErrorCode );

        }

    }

// End of File