/*

* Copyright (c) 2002-2007 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:  Phonebook 2 contact editor field array.

*

*/

#include "CPbk2ContactEditorFieldArray.h"

// Phonebook 2

#include "CPbk2ReadingFieldEditorVisitor.h"

#include "CPbk2IconInfoContainer.h"

#include "Pbk2ContactEditorFieldFactory.h"

#include "MPbk2ContactEditorField.h"

#include "MPbk2ContactEditorUiBuilder.h"

#include <Pbk2CommonUi.rsg>

#include <CPbk2PresentationContact.h>

#include <CPbk2PresentationContactFieldCollection.h>

#include <CPbk2PresentationContactField.h>

#include <MPbk2FieldProperty.h>

#include <Pbk2UIControls.rsg>

#include <MPbk2AppUi.h>

#include <CPbk2ServiceManager.h>

#include "TPbk2ContactEditorParams.h"

#include <MPbk2ApplicationServices.h>

#include "CPbk2IconInfo.h"

#include <aknlayoutscalable_avkon.cdl.h>

#include "CPbk2UIFieldArray.h"

#include "CPbk2UIField.h"

#include "Pbk2UIFieldProperty.hrh"

#include "Pbk2AddressTools.h"

#include <MPbk2ApplicationServices2.h>

// Virtual Phonebook

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <CVPbkFieldTypeSelector.h>

#include <VPbkEng.rsg>

#include <MVPbkFieldType.h>

#include <VPbkFieldType.hrh>

#include <TVPbkFieldVersitProperty.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

// System includes

#include <barsread.h>

#include <coemain.h>

#include <AknUtils.h>

#include <StringLoader.h>

/// Unnamed namespace for local definitions

namespace  {

_LIT( KPbk2UIControlsResFile, "Pbk2UIControls.rsc" );

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicInvariant_CountMismatch = 1,

    EPanicInvariant_FieldNotFound,

    EPanicInvariant_NotEditableFieldFound,

    EPanic_AddNewFieldL_OOB,

    EPanic_GetUiFieldIndex_OOB

    };

void Panic(TInt aReason)

    {

    _LIT(KPanicText, "CPbk2ContactEditorFieldArray");

    User::Panic(KPanicText, aReason);

    }

#endif // _DEBUG

/**

 * Finds property of given type from given contact.

 *

 * @param aFieldType    Field type to search for.

 * @param aContact      The contact in question.

 * @return  Field property if any. 

 */

const MPbk2FieldProperty* FindProperty

        ( const MVPbkFieldType& aType,

          const CPbk2PresentationContact& aContact )

    {

    CArrayPtr<const MPbk2FieldProperty>* props=

        aContact.AvailableFieldsToAddL();

    CleanupStack::PushL( props );

    TInt count( props->Count() );

    const MPbk2FieldProperty* property = NULL;

    for ( TInt i = 0; i < count && !property; ++i )

        {

        if ( props->At( i )->FieldType().IsSame( aType ) )

            {            

            property = props->At( i );

            }

        }    

    CleanupStack::PopAndDestroy( props );

    return property;

    }

/**

 * Returns maximum number of fields of given type in given contact.

 *

 * @param aType     Field type in question.

 * @param aContact  Contact in question.

 * @return  Maximum number of fields.

 */

TInt MaxNumberOfFieldL

        ( const MVPbkFieldType& aType,

          const CPbk2PresentationContact& aContact )

    {

    // Get the store limits

    TInt res = aContact.MaxNumberOfFieldL(aType);

    // If store has no limits or the number is bigger than one

    // -> check the UI limits

    const TInt oneFieldInContact = 1;

    if (res > oneFieldInContact || res == KVPbkStoreContactUnlimitedNumber)

        {

        const MPbk2FieldProperty* prop = FindProperty( aType, aContact );

        if (prop && prop->Multiplicity() == EPbk2FieldMultiplicityOne)

            {

            res = oneFieldInContact;

            }

        }

    return res;

    }

/**

 * Returns current amount of fields of given type in given contact.

 *

 * @param aType     Field type in question.

 * @param aContact  Contact in question.

 * @return  Amount of fields.

 */

TInt CurrentAmountOfFieldTypeInContact

        ( const MVPbkFieldType& aType,

          const CPbk2PresentationContact& aContact  )

    {

    const TInt maxMatchPriority = aContact.ContactStore().

        StoreProperties().SupportedFields().MaxMatchPriority();

    const TInt count = aContact.PresentationFields().FieldCount();

    TInt res = 0;

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

        {

        const MVPbkStoreContactField& field =

            aContact.PresentationFields().FieldAt(i);

        const MVPbkFieldType* type = NULL;

        for ( TInt j = 0; j < maxMatchPriority && !type; ++j )

            {

            type = field.MatchFieldType(j);

            }            

        if ( (aType.IsSame( *type ) ) )

            {

            ++res;

            }

        }

    return res;

    }

/**

 * Checks is field addition possible.

 *

 * @param aType     Field type to add.

 * @param aContact  Contact in question.

 * @return  ETrue if field addition is possible.

 */

TBool IsFieldAdditionPossibleL

        ( const MVPbkFieldType& aType,

          const CPbk2PresentationContact& aContact )

    {

    TInt max = MaxNumberOfFieldL(aType, aContact);

    if (max == KVPbkStoreContactUnlimitedNumber)

        {

        return ETrue;

        }

    else

        {

        TInt cur = CurrentAmountOfFieldTypeInContact( aType, aContact );

        return cur < max;

        }

    }    

} /// namespace

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

// CPbk2ContactEditorFieldArray::CPbk2ContactEditorFieldArray

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

//

inline CPbk2ContactEditorFieldArray::CPbk2ContactEditorFieldArray

        ( CPbk2PresentationContact& aContact,

          MPbk2ContactEditorUiBuilder& aUiBuilder,

          CPbk2ContactEditorFieldFactory& aFieldFactory,

          MPbk2ApplicationServices* aAppServices ) :

            iContact( aContact ),

            iUiBuilder( aUiBuilder ),

            iFieldFactory(aFieldFactory),

            iAppServices( aAppServices )

    {

    }

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

// CPbk2ContactEditorFieldArray::~CPbk2ContactEditorFieldArray

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

//

CPbk2ContactEditorFieldArray::~CPbk2ContactEditorFieldArray()

    {

    iFieldArray.ResetAndDestroy();

    delete iIconInfoContainer;

    delete iReadingFieldBinder;

    }

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

// CPbk2ContactEditorFieldArray::NewL

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

//

CPbk2ContactEditorFieldArray* CPbk2ContactEditorFieldArray::NewL

        ( CVPbkContactManager& aContactManager,

          CPbk2PresentationContact& aContact,

          MPbk2ContactEditorUiBuilder& aUiBuilder,

          CPbk2ContactEditorFieldFactory& aFieldFactory )

    {

    CPbk2ContactEditorFieldArray* self = 

        new ( ELeave ) CPbk2ContactEditorFieldArray

            ( aContact, aUiBuilder, aFieldFactory );

    CleanupStack::PushL( self );

    self->ConstructL( aContactManager );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2ContactEditorFieldArray::NewL

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

//

CPbk2ContactEditorFieldArray* CPbk2ContactEditorFieldArray::NewL

        ( CVPbkContactManager& aContactManager,

          CPbk2PresentationContact& aContact,

          MPbk2ContactEditorUiBuilder& aUiBuilder,

          CPbk2ContactEditorFieldFactory& aFieldFactory,

          MPbk2ApplicationServices* aAppServices )

    {

    CPbk2ContactEditorFieldArray* self = 

        new ( ELeave ) CPbk2ContactEditorFieldArray

            ( aContact, aUiBuilder, aFieldFactory,aAppServices );

    CleanupStack::PushL( self );

    self->ConstructL( aContactManager );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2ContactEditorFieldArray::ConstructL

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

//

inline void CPbk2ContactEditorFieldArray::ConstructL

        ( CVPbkContactManager& aContactManager )

    {

    iIconInfoContainer = CPbk2IconInfoContainer::NewL

        ( R_PBK2_ICON_INFO_ARRAY );

    //Calculate preferred size for xsp service icons 

    TRect mainPane;

    AknLayoutUtils::LayoutMetricsRect(

        AknLayoutUtils::EMainPane, mainPane );

    TAknLayoutRect listLayoutRect;

    listLayoutRect.LayoutRect(

        mainPane,

        AknLayoutScalable_Avkon::list_single_graphic_pane_g2(0).LayoutLine() );

    TSize size(listLayoutRect.Rect().Size());

    /*

     * Use iAppServices if provided. This is to enable editor use outside from pbk2 context

     */

    MPbk2ApplicationServices2* servicesExtension = NULL;

    if( iAppServices )

    	{

    	// Add xsp service icons

		servicesExtension = 

			reinterpret_cast<MPbk2ApplicationServices2*>

				( iAppServices->MPbk2ApplicationServicesExtension(

						KMPbk2ApplicationServicesExtension2Uid ) );

    	}

    else

    	{

    	// Add xsp service icons

		servicesExtension = 

			reinterpret_cast<MPbk2ApplicationServices2*>

				( Phonebook2::Pbk2AppUi()->ApplicationServices().

					MPbk2ApplicationServicesExtension(

						KMPbk2ApplicationServicesExtension2Uid ) );

    	}

    CPbk2ServiceManager& servMan = servicesExtension->ServiceManager();

    const CPbk2ServiceManager::RServicesArray& services = servMan.Services();

    TUid uid;

    uid.iUid = KPbk2ServManId;

    for ( TInt i = 0; i < services.Count(); i++ )

        {

        const CPbk2ServiceManager::TService& service = services[i];

        if ( service.iBitmapId && service.iBitmap )

            {

            AknIconUtils::SetSize(

                services[i].iBitmap,

                size );

            AknIconUtils::SetSize(

                services[i].iMask,

                size );

            TPbk2IconId id = TPbk2IconId( uid, services[i].iBitmapId );

            CPbk2IconInfo* info = CPbk2IconInfo::NewLC(

                id, services[i].iBitmap, services[i].iMask, size );

            iIconInfoContainer->AppendIconL(info);

            CleanupStack::Pop(info);

            }

        }

    iReadingFieldBinder = CPbk2ReadingFieldEditorVisitor::NewL

        ( aContactManager );

    }

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

// CPbk2ContactEditorFieldArray::CreateFieldsFromContactL

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

//

void CPbk2ContactEditorFieldArray::CreateFieldsFromContactL(TPbk2ContactEditorParams& aParams)

    {

    __TEST_INVARIANT;

    iParams = aParams;

    RArray<TPbk2FieldGroupId> addedGroups;

    CleanupClosePushL(addedGroups);

    CPbk2UIFieldArray* uiArray = CPbk2UIFieldArray::NewL(

   		KPbk2UIControlsResFile, CCoeEnv::Static()->FsSession(), iFieldFactory);

    CleanupStack::PushL(uiArray);

    TInt nextFreePos = 0;

    CreateUIFieldL(*uiArray, EPbk2FieldGroupIdNone, EPbk2FieldOrderTop, nextFreePos);

    const TInt count = iContact.PresentationFields().FieldCount();

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

        {

        CPbk2PresentationContactField& contactField = 

            iContact.PresentationFields().At(i);

        if ( contactField.IsEditable() )

            {

            if( IsFieldPartOfAddress(contactField) )

            	{

            	if( Pbk2AddressTools::MapViewTypeToAddress(iParams.iActiveView) == 

            		contactField.FieldProperty().GroupId() )

            		{

            		MPbk2ContactEditorField* field = 

            			iFieldFactory.CreateFieldLC( contactField, nextFreePos++, *iIconInfoContainer );

		            iFieldArray.AppendL( CPbk2ContactEditorArrayItem::NewL( field ) );

		            CleanupStack::Pop();

            		}

            	else if( iParams.iActiveView == TPbk2ContactEditorParams::EEditorView )

            		{

            		if( addedGroups.Find(contactField.FieldProperty().GroupId()) == KErrNotFound )

            			{	

		        		CreateUIFieldL(

		        				*uiArray, 

		        				contactField.FieldProperty().GroupId(),

		        				(TPbk2FieldOrder)Pbk2AddressTools::MapAddressToOrdering(contactField.FieldProperty().GroupId()), 

		        				nextFreePos );

		        		addedGroups.AppendL(contactField.FieldProperty().GroupId());

            			}

            		}

            	}

            else if( iParams.iActiveView == TPbk2ContactEditorParams::EEditorView )

            	{

            	MPbk2ContactEditorField* field = 

        			iFieldFactory.CreateFieldLC( contactField, nextFreePos, *iIconInfoContainer );

                if ( field )

                    {

                    nextFreePos++;

                    iFieldArray.AppendL( CPbk2ContactEditorArrayItem::NewL( field ) );

                    CleanupStack::Pop();

                    }

            	}

            }

        }

    CreateUIFieldL(*uiArray, EPbk2FieldGroupIdNone, EPbk2FieldOrderBottom, nextFreePos);

    AcceptL(*iReadingFieldBinder);

    CleanupStack::PopAndDestroy(uiArray);

    CleanupStack::PopAndDestroy(&addedGroups);

    __TEST_INVARIANT;

    }

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

// CPbk2ContactEditorFieldArray::CreateUIFieldL

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

//

void CPbk2ContactEditorFieldArray::CreateUIFieldL(

		CPbk2UIFieldArray& aFieldsArr, 

		TPbk2FieldGroupId aAddressGroup,

		TPbk2FieldOrder aOrder,

		TInt& aNextFreePos )

    {

    if( aOrder == EPbk2FieldOrderUndefinied )

    	{

    	return;

    	}

    for(TInt idx = 0; idx < aFieldsArr.Count(); idx++)

       	{

       	MPbk2UIField& field = aFieldsArr.At(idx);

       	if( field.Order() == aOrder )

   	   		{

   	   		if( iParams.iActiveView == TPbk2ContactEditorParams::EEditorView && 

   	   			field.CtrlType() == EPbk2FieldCtrlTypeExtAssignFromMapsEditor )

   	   			{

   	   			continue;

   	   			}

   	   		RBuf text;

   	   		TBool textAlloc = EFalse;

   	   		if( aAddressGroup == EPbk2FieldGroupIdPostalAddress ||

   	   			aAddressGroup == EPbk2FieldGroupIdHomeAddress ||

   	   			aAddressGroup == EPbk2FieldGroupIdCompanyAddress )

   	   			{

   	   			Pbk2AddressTools::GetAddressPreviewLC( iContact.StoreContact(), aAddressGroup, text );

   	   			textAlloc = ETrue;

   	   			}

   	   		MPbk2ContactEditorUIField* cefield = 

   	   			iFieldFactory.CreateFieldLC(field, aNextFreePos, iUiBuilder, text, *iIconInfoContainer);

   	   	    if( cefield )

   	   	    	{

   	   	    	aFieldsArr.RemoveAt(idx);

   	   	    	iFieldArray.AppendL(CPbk2ContactEditorArrayItem::NewL(cefield));

   		   		CleanupStack::Pop(cefield);

   		   		aNextFreePos++;

   	   	    	}

   	   	    if ( textAlloc )

   	   	    	{

   	   	    	CleanupStack::PopAndDestroy(); //text

   	   	    	}

   	   	    else

   	   	    	{

   	   	    	text.Close();

   	   	    	}

   	   	    break;

   	   		}

       	}

    }

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

// CPbk2ContactEditorFieldArray::UpdateControlsL

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

//

void CPbk2ContactEditorFieldArray::UpdateControlsL()

    {

    const TInt count = iFieldArray.Count();

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

        {

        if( iFieldArray[i]->ContactEditorUIField() && 

        	iFieldArray[i]->ContactEditorUIField()->UIField()->CtrlType() != 

        	EPbk2FieldCtrlTypeExtAssignFromMapsEditor )

        	{

        	RBuf text;

        	Pbk2AddressTools::GetAddressPreviewLC( iContact.StoreContact(),

				Pbk2AddressTools::MapCtrlTypeToAddress( 

					iFieldArray[i]->ContactEditorUIField()->UIField()->CtrlType()), text );

  	    	iFieldArray[i]->ContactEditorUIField()->SetControlTextL(text);

  	    	CleanupStack::PopAndDestroy(); //text

        	}

        }

    }

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

// CPbk2ContactEditorFieldArray::IsEditorFieldControlEmpty

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

//

TBool CPbk2ContactEditorFieldArray::IsEditorFieldControlEmpty( TInt aIndex ) const

    {

    TBool result = ETrue;

    const TInt count = iFieldArray.Count();

    if ( aIndex >= count )

        {

        return result;

        }

    if ( iFieldArray[aIndex]->ContactEditorField() )

        {

        HBufC* text = NULL;

        TRAP_IGNORE( text = iFieldArray[aIndex]->ContactEditorField()->ControlTextL() );

        TInt fld = iFieldArray[aIndex]->ContactEditorField()->FieldProperty().FieldType().FieldTypeResId();

        if ( fld != R_VPBK_FIELD_TYPE_RINGTONE && 

                fld != R_VPBK_FIELD_TYPE_THUMBNAILPIC &&

                fld != R_VPBK_FIELD_TYPE_CALLEROBJIMG ) 

            {

            if ( text && text->Length() > 0 )

                {

                // If Fields contain only spaces; then treat field as empty field 

                text->Des().TrimAll();

                if ( text->Length() > 0 )

                    {

                    result = EFalse;

                    }

                }

            }

        delete text;

        text = NULL;