/*

* Copyright (c) 2006 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:   Model Class used by widgets.

*

*/

//INCLUDES 

#include <alf/ialfmodelchangeobserver.h> 

#include <osn/alfptrvector.h>

#include <memory>

#include <alf/alfmodel.h>

#include "alf/alfmodeloperation.h"

#include <alf/alfvarianttype.h>

#include <alf/alfexceptions.h>

//#include "alf/alfperf.h"

#include <osn/osnnew.h>

using osncore::AlfPtrVector;

using std::auto_ptr;

// Forward declared inside the Alf namespace

namespace Alf

    {

class AlfModelImpl

    {

public :

	AlfModelImpl():mDataSource(0)

	    {

	    }

	~AlfModelImpl()

	    {

        delete mDataSource;

	    mObserverArray.clear();

		}

    /**

     * Array of Observers for the Model individual observers not owned

     */

    AlfPtrVector<IAlfModelChangeObserver> mObserverArray;

    /**

     * Data Source for the Model owned

     */ 

    IAlfVariantType* mDataSource;

    };

////////////////////// AlfModel //////////////////////

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

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

// Description : Constructor - 

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

//

OSN_EXPORT AlfModel::AlfModel()

    {

    }

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

// Description : Constructor - 

// Data Source for the model is passed

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

//

OSN_EXPORT AlfModel::AlfModel( IAlfVariantType* aDataSource )

    {

    mData.reset( new(EMM) AlfModelImpl() );

    mData->mDataSource  = aDataSource;  

    mData->mObserverArray.setAutoDelete(false);

    }

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

// Description : Class Destructor

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

//

OSN_EXPORT AlfModel::~AlfModel()

    {

    }

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

// Description : Adds model change observers

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

//

OSN_EXPORT void AlfModel::addModelChangeObserver(

    IAlfModelChangeObserver& aObserver)

    {

    if(mData->mObserverArray.findRef(&aObserver)<0)

    	{

	    mData->mObserverArray.resize(mData->mObserverArray.count()+1);

	    mData->mObserverArray.insert(mData->mObserverArray.count(),

	                                 &aObserver);

    	aObserver.modelChanged( *this );

    	}

    }

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

// Description : Removes model change observers

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

//

OSN_EXPORT void AlfModel::removeModelChangeObserver(

    IAlfModelChangeObserver& aObserver)

    {

    for ( int i = 0; i < mData->mObserverArray.count(); ++i )

    	{

    	if(mData->mObserverArray[i]==&aObserver)

    	 {

    	  mData->mObserverArray.remove( i );

		  return;

    	 }

    	}

    }

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

// Description : Sets the data for the model

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

//

OSN_EXPORT void AlfModel::setData(IAlfVariantType* aData)

    {

    if( mData->mDataSource != 0 )

        {

        delete mData->mDataSource;

        mData->mDataSource=0;

        }

    mData->mDataSource = aData;

    for ( int i = 0; i < mData->mObserverArray.count(); ++i )

        {

        mData->mObserverArray[i]->modelChanged( *this );

        }

    }

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

// Description : Returns the Data Source

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

//

OSN_EXPORT IAlfVariantType* AlfModel::data() const

    {

    return  mData->mDataSource;

    }

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

// Description : notifies, that the model is changed.

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

//    

OSN_EXPORT void AlfModel::notifyModelChanged()

    {

    //Notify all the observers

    for ( int i = 0; i < mData->mObserverArray.count(); ++i )

        {

        mData->mObserverArray[i]->modelChanged(*this);

        }    

    }

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

// Description : Clears the Data Source

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

//

OSN_EXPORT void AlfModel::clearModel()

    {

    //Delete the Model

    if( mData->mDataSource != 0 )

        {

        delete mData->mDataSource;

        mData->mDataSource=0;        

        }

    //Notify all the observers

    for ( int i = 0; i < mData->mObserverArray.count(); ++i )

        {

        mData->mObserverArray[i]->modelChanged(*this);

        }

    }

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

// From class IAlfInterfaceBase.

// Static getter for interfaces provided by the widget,

// the control, or the model.

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

//

OSN_EXPORT IAlfInterfaceBase* AlfModel::makeInterface( const IfId& aType)

    {

    UString param(aType.mImplementationId);

    if ( param == IAlfModel::type().mImplementationId )

        {

        return this;

        }

    return 0;

    }

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

//Add a  number of data fields in the model data. All model change

//observers are notified about the change.  Internal API not exported

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

void AlfModel::addData(AlfModelOperation* aAddOperation)

    {

    IAlfVariantType* newData = 0;

    IAlfVariantType* parentData = 0;

    try

        {

        //ALF_PERF_START( perfdata, "AlfModel-AddData-Adding")

        newData = aAddOperation->getNewData();     

        parentData  = aAddOperation->parentData(*data());

        int index = aAddOperation->index();

        if(parentData->type()== IAlfVariantType::EBranch &&

               newData->type() == IAlfVariantType::EMap )

            {

            // This is actually the same as updating the data,

            // since we can not have multiple branch or child data maps

            if ( index == 0 )

                {

                // Set data for the branch

                parentData->branch()->setData( newData->map() );

                }

            else if ( index == 1 )

                {

                // Set data for the branch children

                parentData->branch()->setChildData( newData->map() );

                }

            }

        else if(parentData->type()== IAlfVariantType::EMap)

            {

            parentData->map()->addItem( newData,

                                   aAddOperation->newDataName() );

            }

        else if(parentData->type()== IAlfVariantType::EContainer )

            {

            parentData->container()->addItem(index, newData);

            }

        //ALF_PERF_STOP( perfdata, "AlfModel-AddData-Adding")

        }

	catch(AlfDataException& e)	        

        {

        newData = 0;

        parentData = 0;

        ALF_THROW(AlfDataException,EInvalidModelOperation,"AlfModel")

        // Note the aAddOperation is not deleted. In case of exception the user

        // should delete this object 

        }

    }

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

//Remove a  number of data fields in the model data. All model change

//observers are notified about the change.

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

void AlfModel::removeData(AlfModelOperation* aRemoveOperation)

    {

    IAlfVariantType* parentData = 0;

    try

        {

        //ALF_PERF_START( perfdata, "AlfModel-RemoveData-Removing")

        parentData  = aRemoveOperation->parentData(*data());         

        int index = aRemoveOperation->index();

        if(parentData->type()== IAlfVariantType::EBranch )

            {

            if ( index == 0 )

                {

                // Remove the branch data

                parentData->branch()->setData( 0 );

                }

            else if ( index == 1 )

                {

                // Remove the branch children data

                parentData->branch()->setChildData( 0 );

                }

            }

        else if(parentData->type()== IAlfVariantType::EMap)

            {

            parentData->map()->removeItem(index);

            }

        else if(parentData->type()== IAlfVariantType::EContainer )

            {

            parentData->container()->removeItem(index);

            }    

        //ALF_PERF_STOP( perfdata, "AlfModel-RemoveData-Removing")

        }

    catch(AlfDataException& e)

        {

        parentData = 0;

        ALF_THROW(AlfDataException,EInvalidModelOperation,"AlfModel")

        // Note the aRemoveOperation is not deleted. In case of exception the

        // user should delete this object	

        }

    }

void AlfModel::updateData(AlfModelOperation* aUpdateOperation)

    {

    IAlfVariantType* newData = 0;

    IAlfVariantType* parentData = 0;

    try

        {

        //ALF_PERF_START( perfdata, "AlfModel-UpdateData-Updating")

        newData= aUpdateOperation->getNewData();

        parentData  = aUpdateOperation->parentData(*data());

        int index = aUpdateOperation->index();

        if(parentData->type()== IAlfVariantType::EBranch &&

                newData->type() == IAlfVariantType::EMap )

            {

            if ( index == 0 )

                {

                // Update the branch data

                parentData->branch()->setData( newData->map() );

                }

            else if ( index == 1 )

                {

                // Update the data for the branch children

                parentData->branch()->setChildData( newData->map() );

                }

            }

        else if(parentData->type()== IAlfVariantType::EMap)

            {

            parentData->map()->replaceItem(index, newData);

            }

        else if(parentData->type()== IAlfVariantType::EContainer )

            {

            parentData->container()->replaceItem(index,newData);

            }

        //ALF_PERF_STOP( perfdata, "AlfModel-UpdateData-Updating")

        }

    catch(AlfDataException& e)

        {

        parentData=0;

        newData=0;

        ALF_THROW(AlfDataException,EInvalidModelOperation,"AlfModel")

        //Note the aUpdateOperation is not deleted. In case of exception the user should delete this object

        }

    }

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

//Add a  number of data fields in the model data. All model change

//observers are notified about the change. 

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

OSN_EXPORT void AlfModel::addData(

    int aNumContainerIndices, int* aContainerIndices, IAlfVariantType* aData)

    {

    auto_ptr<AlfModelOperation> op( AlfModelOperation::create(

    AlfModelOperation::EOperationAdd,

    aNumContainerIndices,

    aContainerIndices,

    aData ) );

    executeOperation( op.get() );

    }

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

//Remove a  number of data fields in the model data. All model change

//observers are notified about the change.

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

OSN_EXPORT void AlfModel::removeData(

    int aNumContainerIndices, int* aContainerIndices)

    {

    auto_ptr<AlfModelOperation> op( AlfModelOperation::create(

    AlfModelOperation::EOperationRemove,

    aNumContainerIndices,

    aContainerIndices ) );

    executeOperation( op.get() );

    }

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

//Remove a  number of data fields in the model data. All model change

//observers are notified about the change.

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

OSN_EXPORT void AlfModel::updateData(

    int aNumContainerIndices, int* aContainerIndices, IAlfVariantType* aData)

    {

    auto_ptr<AlfModelOperation> op( AlfModelOperation::create(

    AlfModelOperation::EOperationUpdate,

    aNumContainerIndices,

    aContainerIndices,

    aData ) );

    executeOperation( op.get() );

    }

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

    /**

    *  Api for executing batch operations

    * 

    *  @param aOperationsArray  - An RPOinterArray containing the list of 

    *                             operations to be executed in batch.

    *  @since S60 ?S60_version 

    */  

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

OSN_EXPORT void AlfModel::executeOperations(

    AlfPtrVector<AlfModelOperation>&  aOperationsArray)

    {

    int index = 0;

    int count = aOperationsArray.count();  

    int obsvrCount = mData->mObserverArray.count();

    AlfModelOperation* tempOperation=0;

    for ( index = 0; index < obsvrCount; index++ )

        {

        mData->mObserverArray[index]->dataChanging( aOperationsArray );

        }

    for ( index = 0; index < count; index++ )

        {

        tempOperation = aOperationsArray[index];

        switch( tempOperation->operation() )

            {

            case AlfModelOperation::EOperationAdd:                 

                 this->addData( tempOperation );

                break;

            case AlfModelOperation::EOperationRemove:                   

                 this->removeData( tempOperation );

                break;

            case AlfModelOperation::EOperationUpdate:

                 this->updateData( tempOperation );

            default:

                break;

            }

        }

    for ( index = 0; index < obsvrCount; index++ )

        {

        mData->mObserverArray[index]->dataChanged();

        }

    }

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

    /**

    *  Api for executing one operation at a Time

    * 

    *  @param aOperation    - An Operation to be executed on the model.

    *  @since S60 ?S60_version 

    */  

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

OSN_EXPORT void AlfModel::executeOperation(AlfModelOperation* aOperation)

    {

    int index = 0;

    int obsvrCount = mData->mObserverArray.count();

    for ( index = 0; index < obsvrCount; index++ )

        {

        mData->mObserverArray[index]->dataChanging( *aOperation );

        }

    switch(aOperation->operation())

        {

        case AlfModelOperation::EOperationAdd:                 

             this->addData(aOperation);

            break;

        case AlfModelOperation::EOperationRemove:                   

             this->removeData(aOperation);

            break;

        case AlfModelOperation::EOperationUpdate:

             this->updateData(aOperation);

        default:

            break;

        }

    for ( index = 0; index < obsvrCount; index++ )

        {

        mData->mObserverArray[index]->dataChanged();

        }

    }

} // Alf