/*

* Copyright (c) 2009 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:

*

*/

#include <tstaskmonitorglobals.h>

#include "tsstorage.h"

#include "tsmodelitemkeymsg.h"

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

/**

 * Two phase construction. Create and initialize storage instance.

 * @param dataProviders - list of data providers

 * @return storage instane

 */

CTsStorage* CTsStorage::NewL(const TArray<MTsModel*> &dataProviders)

{

    CTsStorage* self = new(ELeave) CTsStorage();

    CleanupStack::PushL(self);

    self->ConstructL(dataProviders);

    CleanupStack::Pop(self);

    return self;

}

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

/**

 * Destructor. Function cancel subscribtion for data change notyfications

 */

CTsStorage::~CTsStorage()

{

    for (TInt iter(0); iter < mDataProviders.Count(); ++iter) {

        mDataProviders[iter]->setObserver(0);

    }

    mData.Close();

}

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

/**

 * First phase construction.

 */

CTsStorage::CTsStorage()

{

    //No implementation required

}

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

/**

 * Second phase construction. Function make subscribtion for data changes notifications

 * @param dataProviders - list of data providers

 */

void CTsStorage::ConstructL(const TArray<MTsModel*> &dataProviders)

{

    for (TInt iter(0); iter < dataProviders.Count(); ++iter) {

        mDataProviders.AppendL(dataProviders[iter]);

        dataProviders[iter]->setObserver(this);

    }

}

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

/**

 * Interface implementation

 * @see MTsDataObserver::DataChanged()

 */

void CTsStorage::DataChanged()

{

    resetModel();

}

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

TBool CTsStorage::isSupported(TInt function) const

{

    return (OpenTaskMessage == function || CloseTaskMessage == function);

}

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

void CTsStorage::handleDataL(TInt function, RReadStream& dataStream)

{

    if(!isSupported(function)) {

        User::Leave(KErrCorrupt);

    }

    CTsModelItemKeyMsg* msg = CTsModelItemKeyMsg::NewLC(dataStream);

    OpenTaskMessage == function ? launchL(msg->key()) : closeL(msg->key());

    CleanupStack::PopAndDestroy(msg);

}

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

/**

 * Interface implementation

 * @see MTsModelObserver::dataChanged(MTsModel &)

 */

void CTsStorage::dataChanged(MTsModel &/*model*/)

{

    resetModel();

}

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

/**

 * Interface implementation

 * @see MTsModelObserver::dataChanged(const TTsModelItem &)

 */

void CTsStorage::dataChanged(const TTsModelItem &/*item*/)

{

    resetModel();

}

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

/**

 * Interface implementation

 * @see MTsModel::count()

 */

TInt CTsStorage::count() const

{

    return mData.Count();

}

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

/**

 * Interface implementation

 * @see MTsModel::setObserver(MTsModelObserver *)

 */

void CTsStorage::setObserver(MTsModelObserver *observer) 

{

    mDataObserver = observer;

}

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

/**

 * Interface implementation

 * @see MTsModel::displayNameL(TInt)

 */

const TDesC& CTsStorage::displayNameL(TInt offset) const 

{

    return mData[offset].displayNameL();

}

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

/**

 * Interface implementation

 * @see MTsModel::iconHandleL(TInt)

 */

TInt CTsStorage::iconHandleL(TInt offset) const 

{

    return mData[offset].iconHandleL();

}

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

/**

 * Interface implementation

 * @see MTsModel::timestampL(TInt)

 */

TTime CTsStorage::timestampL(TInt offset) const 

{

    return mData[offset].timestampL();

}

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

/**

 * Interface implementation

 * @see MTsModel::keyL(TInt)

 */

TTsModelItemKey CTsStorage::keyL(TInt offset) const 

{

    return mData[offset].keyL();

}

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

/**

 * Interface implementation

 * @see MTsModel::isActiveL(TInt)

 */

TBool CTsStorage::isActiveL(TInt offset) const 

{

    return mData[offset].isActiveL();

}

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

/**

 * Interface implementation

 * @see MTsModel::isClosableL(TInt)

 */

TBool CTsStorage::isClosableL(TInt offset) const 

{

    return mData[offset].isClosableL();

}

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

/**

 * Interface implementation

 * @see MTsModel::closeL(TTsModelItemKey)

 */

TBool CTsStorage::closeL(TTsModelItemKey key) const 

{

    return findL(key).closeL();

}

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

/**

 * Interface implementation

 * @see MTsModel::launchL(TTsModelItemKey)

 */

TBool CTsStorage::launchL(TTsModelItemKey key) const 

{

    return findL(key).launchL(); 

}

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

TTsModelItem CTsStorage::findL(TTsModelItemKey key) const

{

    for(TInt offset(0); offset < mData.Count(); ++offset) {

        if(mData[offset].keyL() == key){

            return mData[offset];

        }

    }

    User::Leave(KErrNotFound);

    return itemL(0);//just avoid compilation warnings

}

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

/**

 * Retrieve shallow copy of data from known data providers and sort entries

 */

TInt CTsStorage::resetModel()

{

    TRAPD(errNo, resetModelL());

    return errNo;

}

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

/**

 * Retrieve shallow copy of data from known data providers and sort entries

 */

void CTsStorage::resetModelL() 

{

    mData.Reset();

    for (TInt iter(0); iter < mDataProviders.Count(); ++iter) {

        pullDataL(*(mDataProviders[iter]));

    }

    reorderDataL();

    if (0 != mDataObserver) {

        mDataObserver->dataChanged(*this);

    }

}

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

/**

 * Retrieve shallow copy of data from source model

 * @param src - source model 

 */

void CTsStorage::pullDataL(const MTsModel& src)

{

    for (TInt iter(0); iter < src.count(); ++iter) {

        mData.AppendL(src.itemL(iter));

    }

}

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

/**

 * Sort internal data model 

 */

void CTsStorage::reorderDataL()

{

    for (TInt prev(0); prev < mData.Count(); ++prev) {

        for(TInt next(prev + 1); next < mData.Count(); ++next) {

            const TTsModelItem prevItem(mData[prev]), nextItem(mData[next]);

            if(prevItem.timestampL() < nextItem.timestampL()) {

                mData.Remove(prev);

                mData.InsertL(nextItem, prev);

                mData.Remove(next);

                mData.InsertL(prevItem, next);

            }

        }

    }

}