/*

* 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 "tstaskmonitor_p.h"

#include "tstaskmonitor.h"

#include <eikenv.h>

#include <fbs.h>

#include <s32mem.h>

#include <XQConversions>

#include "tstaskmonitorclient.h"

#include "tstask.h"

#include "tstaskchangeinfo.h"

#include "tsutils.h"

#include "tstaskmonitorhistory.h"

using TaskSwitcher::CleanupResetAndDestroyPushL;

TsTaskMonitorPrivate::TsTaskMonitorPrivate(TsTaskMonitor *q) : q_ptr(q), mClient(0), mWsSession(CEikonEnv::Static()->WsSession())

{

    QT_TRAP_THROWING(mClient = CTsTaskMonitorClient::NewL());

    mClient->Subscribe(*this);

}

TsTaskMonitorPrivate::~TsTaskMonitorPrivate()

{

    mClient->CancelSubscribe();

    delete mClient;

}

QList<TsTaskChange> TsTaskMonitorPrivate::changeList(bool fullList)

{

    QList<TsTaskChange> retVal;

    return retVal;

}

{

    }

    }

}

QDateTime TsTaskMonitorPrivate::dateTimeFromS60(const TTime &s60Time)

{

    TTime posixEpoch(_L("19700000:"));

    TTimeIntervalSeconds secondsFrom;

    TTimeIntervalMicroSeconds microSecondsFrom;

    s60Time.SecondsFrom(posixEpoch, secondsFrom);

    microSecondsFrom = s60Time.MicroSecondsFrom(posixEpoch);

    QDateTime retVal = QDateTime::fromTime_t(secondsFrom.Int());

    retVal = retVal.addMSecs((microSecondsFrom.Int64() % TInt64(1000000) ) / TInt64(1000));

    return retVal;    

}

int TsTaskMonitorPrivate::findItemIndex(

                          const QList<TsTaskMonitorHistory> &historyList,

                          const TsTaskMonitorHistory &item )

{

    for (int iter(0); iter < historyList.count(); iter++) {

            return iter;

        }

    }

    return -1;

}

QList<int>  TsTaskMonitorPrivate::findInserts(

                                 const QList<TsTaskMonitorHistory> &newHistory)

{

    QList<int> retVal = QList<int>();

    for (int iter(0); iter < newHistory.count(); iter++) {

        if (findItemIndex(mTaskHistory, newHistory[iter]) == -1) {

            retVal.append(iter);

        }

    }

    return retVal;

}

QList<int> TsTaskMonitorPrivate::findDeletes(

                                 const QList<TsTaskMonitorHistory> &newHistory)

{

    QList<int> retVal = QList<int>();

    //iterate backwards to keep order during model operations

    for (int iter(mTaskHistory.count() -1); iter >= 0 ; iter--) {

        if (findItemIndex(newHistory, mTaskHistory[iter]) == -1) {

            retVal.append(iter);

        }

    }

    return retVal;    

}

QList<TsTaskChange> TsTaskMonitorPrivate::getDeletesChangeset(

                                                      const QList<int> &deleteList)

{

    QList<TsTaskChange> retVal;

    foreach (int index, deleteList) {

        TsTaskChangeInfo deleteChange(TsTaskChangeInfo::KInvalidOffset,

                                                                   index);

        retVal.append(TsTaskChange(deleteChange, QSharedPointer<TsTask>()));

    }

    return retVal;

}

QList<TsTaskChange> TsTaskMonitorPrivate::getInsertsChangeset(const QList<int> &insertList,

{

    QList<TsTaskChange> retVal;

    foreach (int index, insertList) {

        TsTaskChangeInfo insertChange(index,

                                 TsTaskChangeInfo::KInvalidOffset);

        retVal.append(TsTaskChange(

                            insertChange,

                            QSharedPointer<TsTask>(new TsTask(taskList[index], *this))));

    }

    return retVal;

}

QList<TsTaskMonitorHistory> TsTaskMonitorPrivate::substractInsertsFromNew(

                                      const QList<int> &insertList,

                                      const QList<TsTaskMonitorHistory> &newHistory )

{

    QList<TsTaskMonitorHistory> retVal(newHistory);

    for ( int iter(insertList.count() - 1); iter >= 0 ; iter--) {

        retVal.removeAt(insertList[iter]);

    }

    return retVal;

}

QList<TsTaskMonitorHistory> TsTaskMonitorPrivate::substractDeletesFromOld(

                                      const QList<int> &deleteList)

{

    QList<TsTaskMonitorHistory> retVal(mTaskHistory);  

    for (int iter(0); iter < deleteList.count() ; iter++) {

        retVal.removeAt(deleteList[iter]);

    }

    return retVal;

}

QList<TsTaskChange> TsTaskMonitorPrivate::findMovesAndUpdates( 

                                     const QList<TsTaskMonitorHistory> &newMinusInserts,

                                     QList<TsTaskMonitorHistory> &workingList)

{

    QList<TsTaskChange> retVal;

    for (int newPos(0); newPos < newMinusInserts.count(); newPos++) {

        //case 1 item has moved

        int previousPos = findItemIndex(workingList, newMinusInserts[newPos]);

        if (newPos != previousPos) {

            TsTaskChangeInfo moveChange(newPos, previousPos);

            retVal.append(

                TsTaskChange(moveChange, QSharedPointer<TsTask>()));

            workingList.move(previousPos, newPos);

        }

        // case 2 item has changed

        if (newMinusInserts[newPos].isUpdated(workingList[newPos])) {

            TsTaskChangeInfo updateChange(newPos, newPos);

            retVal.append( TsTaskChange(

                              updateChange,

        }

    }

    return retVal;

}

void TsTaskMonitorPrivate::HandleRunningAppChange()

{

    emit q_ptr->taskListChanged();

}

{

}

{

}