/*
* 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 "tstaskcontent.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;
     
    QT_TRAP_THROWING (

        HBufC8 *data = mClient->TasksContentLC();
        if (data->Size() == 0) {
            CleanupStack::PopAndDestroy(data);
            return retVal;
        }
        TPtr8 dataPointer(data->Des());
        RDesReadStream dataStream(dataPointer);
        CleanupClosePushL(dataStream);

        int count = dataStream.ReadInt32L();

        QT_TRYCATCH_LEAVING(
            QList< QSharedPointer<TsTaskContent> > taskList;
            QList<TsTaskMonitorHistory> newTaskHistory;
            for (int iter(0); iter < count; iter++) {
                QSharedPointer<TsTaskContent> content(new TsTaskContent);
                TsTaskMonitorHistory newHistoryItem = internalizeContentL(dataStream, content);
                newHistoryItem.setOffset(iter);
                newTaskHistory.append(newHistoryItem);
                taskList.append(content);
            }
            if (fullList) {
                mTaskHistory.clear();
            }
            QList<int> insertsList = findInserts(newTaskHistory);
            QList<int> deletesList = findDeletes(newTaskHistory);
            QList<TsTaskMonitorHistory> newMinusInserts;
            if (insertsList.count() > 0 ) {
                newMinusInserts = substractInsertsFromNew(insertsList, newTaskHistory);
            } else {
                newMinusInserts = newTaskHistory;
            }
            QList<TsTaskMonitorHistory> interimList;
            if (deletesList.count() > 0 ) {
                retVal.append(getDeletesChangeset(deletesList));
                interimList = substractDeletesFromOld(deletesList);
            } else {
                interimList = mTaskHistory;
            }
            retVal.append(findMovesAndUpdates(newMinusInserts, taskList, interimList));
            if (mTaskHistory.isEmpty()) {
                retVal.append(TsTaskChange(TsTaskChangeInfo(), QSharedPointer<TsTask>()));
            }
            retVal.append(getInsertsChangeset(insertsList, taskList));
            mTaskHistory = newTaskHistory;
        )//QT_TRYCATCH_LEAVING
        CleanupStack::PopAndDestroy(&dataStream);
        CleanupStack::PopAndDestroy(data);
    );//QT_TRAP_THROWING
       
    return retVal;
}

TsTaskMonitorHistory TsTaskMonitorPrivate::internalizeContentL(RDesReadStream &  dataStream,
                                    QSharedPointer<TsTaskContent> &content)
{
    // get name
    TInt nameLength(dataStream.ReadInt32L());
    if (0 < nameLength) {
        HBufC* name = HBufC::NewLC(dataStream, nameLength);
        content->mName = XQConversions::s60DescToQString(*name);
        CleanupStack::PopAndDestroy(name);
    }
    TPckgBuf<TTime> updateTime;
    dataStream.ReadL(updateTime);
    QDateTime historyTime =  dateTimeFromS60(updateTime());
    
    // get screenshot
    TInt screenshotHandle = dataStream.ReadInt32L();
    CFbsBitmap *screenshot = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(screenshot);
    if (KErrNone == screenshot->Duplicate(screenshotHandle)) {
        content->mScreenshot = QPixmap::fromSymbianCFbsBitmap(screenshot);
    }
    CleanupStack::PopAndDestroy(screenshot);
    // get key
    TInt keyLength(dataStream.ReadInt32L());
    if (0 < keyLength) {
        HBufC8* key = HBufC8::NewLC(keyLength);
        TPtr8 des(key->Des());
        dataStream.ReadL(des, keyLength);
        content->mKey = XQConversions::s60Desc8ToQByteArray(*key);
        CleanupStack::PopAndDestroy(key);
    }
    // get other values
    content->mActive = dataStream.ReadInt32L();
    content->mClosable = dataStream.ReadInt32L();  
    return TsTaskMonitorHistory(content->mKey, historyTime);
}

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++) {
        if(historyList[iter].isEqual(item)) {
            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,
                                        const QList< QSharedPointer<TsTaskContent> > &taskList)
{
    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,
                                     const QList< QSharedPointer<TsTaskContent> > &taskList,
                                     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);
            int taskListOffset = newMinusInserts[newPos].offset();
            retVal.append( TsTaskChange(
                              updateChange,
                              QSharedPointer<TsTask>(new TsTask(taskList[taskListOffset], *this)))); 
        }
    }
    return retVal;
}

void TsTaskMonitorPrivate::HandleRunningAppChange()
{
    emit q_ptr->taskListChanged();
}

void TsTaskMonitorPrivate::openTask(const QByteArray &key)
{
    TPtrC8 desC(reinterpret_cast<const TUint8*>(key.constData()), key.length());
    mClient->OpenTask(desC);
    
}

void TsTaskMonitorPrivate::closeTask(const QByteArray &key)
{
    TPtrC8 desC(reinterpret_cast<const TUint8*>(key.constData()), key.length());
    mClient->CloseTask(desC);
}