/*
* 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 <QObject>
#include <QDateTime>
#include <QVariantHash>

#include <xqconversions.h>

#include "tsservice.h"
#include "tsmodelobserver.h"
#include "tsserviceobserver.h"

// -----------------------------------------------------------------------------
LOCAL_C QVariantHash valueL(QObject *model, TInt offset)
{
    QList<QVariantHash> items;
    QMetaObject::invokeMethod(model, "taskList", Q_RETURN_ARG(QList<QVariantHash>, items));
    
    if (offset >= items.count()) {
        User::Leave(KErrCorrupt);
    }
    
    return items.at(offset);
}

// -----------------------------------------------------------------------------
CTsService* CTsService::NewLC(QObject* model)
{
    CTsService *self = new (ELeave)CTsService();
    CleanupStack::PushL(self);
    self->ConstructL(model);
    return self;
}

// -----------------------------------------------------------------------------
CTsService::CTsService()
{
    //No implementation required
}

// -----------------------------------------------------------------------------
void CTsService::ConstructL(QObject* model)
{
    mModel = model;    
    User::LeaveIfNull(mModel);
    // @todo: add checking for all necessary methods
    
    mServiceObserver = new TsServiceObserver(*this);
    User::LeaveIfNull(mServiceObserver);
    QObject::connect(mModel, 
                     SIGNAL(dataChanged()),
                     mServiceObserver,
                     SLOT(dataChanged()));
}

// -----------------------------------------------------------------------------
CTsService::~CTsService()
{
    delete mModel;
    delete mServiceObserver;
    delete mBuffer;
}

// -----------------------------------------------------------------------------
void CTsService::DataChanged()
{
    if (0 != mModelObserver) {
        mModelObserver->dataChanged(*this);
    }
}
// -----------------------------------------------------------------------------
TInt CTsService::count() const
{
    QList<QVariantHash> items;
    QMetaObject::invokeMethod(mModel, "taskList", Q_RETURN_ARG(QList<QVariantHash>, items));
    return items.count();
}

// -----------------------------------------------------------------------------
void CTsService::setObserver(MTsModelObserver *observer)
{
    mModelObserver = observer;
}

// -----------------------------------------------------------------------------
const TDesC& CTsService::displayNameL(TInt offset) const
{
    return stringValueL(offset, "TaskName");
}

// -----------------------------------------------------------------------------
TInt CTsService::iconHandleL(TInt offset) const
{
    return intValueL(offset, "TaskScreenshot");
}

// -----------------------------------------------------------------------------
TTime CTsService::timestampL(TInt offset) const
{
    return timeValueL(offset, "TaskTimestamp");
}

// -----------------------------------------------------------------------------
TTsModelItemKey CTsService::keyL(TInt offset) const
{
    return TTsModelItemKey(intValueL(offset, "TaskId"), reinterpret_cast<TInt>(this));
}

// -----------------------------------------------------------------------------
TBool CTsService::isActiveL(TInt offset) const
{
    return intValueL(offset, "TaskIsRunning");
}

// -----------------------------------------------------------------------------
TBool CTsService::isClosableL(TInt offset) const
{
    return intValueL(offset, "TaskCanBeClosed");
}

// -----------------------------------------------------------------------------
TBool CTsService::closeL(TTsModelItemKey key) const
{
    bool result(false);
    QMetaObject::invokeMethod(mModel, "closeTask", Q_RETURN_ARG(bool, result), Q_ARG(QVariant, key.key()));
    return result;
}

// -----------------------------------------------------------------------------
TBool CTsService::launchL(TTsModelItemKey key) const
{
    bool result(false);
    QMetaObject::invokeMethod(mModel, "openTask", Q_RETURN_ARG(bool, result), Q_ARG(QVariant, key.key()));
    return result;
}

// -----------------------------------------------------------------------------
TInt CTsService::intValueL(TInt offset, const char *key) const
{
    return valueL(mModel, offset).value(key).toInt();
}

// -----------------------------------------------------------------------------
TTime CTsService::timeValueL(TInt offset, const char *key) const
{
    // Conversion between TTime which counts from year 0, and QDateTime which uses unix epoch (1st Jan 1970)
    return TTime(_L("19700000:")) + TTimeIntervalSeconds(valueL(mModel, offset).value(key).toDateTime().toTime_t());
}

// -----------------------------------------------------------------------------
const TDesC& CTsService::stringValueL(TInt offset, const char *key) const
{
    delete mBuffer;
    const_cast<CTsService *>(this)->mBuffer = 0;
    
    const QVariantHash item(valueL(mModel, offset));
    QT_TRYCATCH_LEAVING(
    const_cast<CTsService *>(this)->mBuffer = 
    XQConversions::qStringToS60Desc(item.value(key).toString()));
    return *mBuffer;
}