/*
* 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);
            }
        }
    }
}