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

#include <QtTest/QtTest>
#include <QPainter>
#include <XQConversions>

#include <afstorageglobals.h>
#include <afentry.h>

#include "afstorageclient.h"
#include "afstorageproxy.h"
#include "afserializer.h"

namespace {
    const int KApplicationId = 42;
    
    const char KActivityId[] = "TestActivity";
    const char KImagePath[] = "SomeFakePath";
}

void TestAfStorageProxy::init()
{
    mProxy = new AfStorageProxy();
}

void TestAfStorageProxy::cleanup()
{
    delete mProxy;
    mProxy = NULL;
}

void TestAfStorageProxy::testSaveActivityDataSerialization()
{    
    // check that data and metadata are properly serialized
    QVariant data("Data");
    QVariantHash metaData;
    QString someKey("SomeKey");
    QVariant someValue("SomeValue");
    metaData.insert(someKey, someValue);
    
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    mProxy->saveActivity(KApplicationId, KActivityId, data, metaData, QPixmap());
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);
    
    CAfEntry *entry = CAfStorageClient::lastCallEntry;
    QVERIFY(entry);
    
    QVariantHash deserializedMetaData;
    deserializedMetaData << entry->Data(CAfEntry::Public);
    QVERIFY(deserializedMetaData.contains(someKey));
    QCOMPARE(deserializedMetaData.value(someKey), someValue);    

    QVariantHash deserializedData;
    deserializedData << entry->Data(CAfEntry::Private);
    QVERIFY(deserializedData.contains(ActivityDataKeyword));
    QCOMPARE(deserializedData.value(ActivityDataKeyword), data);    
}

void TestAfStorageProxy::testSaveActivityFlags()
{   
    // test that activities are visible and non-persistent by default
    {
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);
        
        CAfEntry *entry = CAfStorageClient::lastCallEntry;
        QVERIFY(entry);
        
        QVERIFY(!(entry->Flags() & CAfEntry::Persistent));
        QVERIFY(!(entry->Flags() & CAfEntry::Invisible));
        CAfStorageClient::clearLastCallInfo();
    }
 
    // test persistency flag is properly set
    {
        QVariantHash metaData;
        metaData.insert(ActivityPersistence, true);
    
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), metaData, QPixmap());
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);
        
        CAfEntry *entry = CAfStorageClient::lastCallEntry;
        QVERIFY(entry);
        
        QVERIFY(entry->Flags() & CAfEntry::Persistent);
        CAfStorageClient::clearLastCallInfo();
    } 
 
    // test visibility flag is properly set
    {
        QVariantHash metaData;
        metaData.insert(ActivityVisibility, false);
    
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), metaData, QPixmap());
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);
        
        CAfEntry *entry = CAfStorageClient::lastCallEntry;
        QVERIFY(entry);
        
        QVERIFY(entry->Flags() & CAfEntry::Invisible);
        CAfStorageClient::clearLastCallInfo();
    } 
}

void TestAfStorageProxy::testSaveActivityScreenshotHandle()
{   
    // in case of null pixmap -1 handle will be sent to server
    {
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);
        
        QCOMPARE(CAfStorageClient::lastCallImageHandle, -1);
        CAfStorageClient::clearLastCallInfo();
    }
 
    // proper handle is sent for non-null pixmap
    {
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());
        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);
        
        QVERIFY(CAfStorageClient::lastCallImageHandle != -1);
        CAfStorageClient::clearLastCallInfo();
    }
}

void TestAfStorageProxy::testDeprecatedAddAndUpdateMethods()
{
    // we don't test those methods thoroughly, because a) it's basically the
    // same code as saveActivity b) those methods are deprecated and will be
    // removed soon.
    
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    
    mProxy->addActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());    
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::AddActivityMethod);
    mProxy->addActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());
    
    mProxy->updateActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::UpdateActivityMethod);
    mProxy->updateActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());
}

void TestAfStorageProxy::testRemoveActivity()
{
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    mProxy->removeActivity(KApplicationId, KActivityId);    
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::RemoveActivityMethod);
    
    CAfEntry *entry = CAfStorageClient::lastCallEntry;
    QVERIFY(entry);
    QCOMPARE(entry->ApplicationId(), KApplicationId);
    QScopedPointer<HBufC> activityIdAsDesc(XQConversions::qStringToS60Desc(QString(KActivityId)));
    QVERIFY(entry->ActivityId().Compare(*activityIdAsDesc.data()) == 0);
}

void TestAfStorageProxy::testRemoveApplicationActivities()
{
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    mProxy->removeApplicationActivities(KApplicationId);    
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::RemoveApplicationActivitiesMethod);
    
    CAfEntry *entry = CAfStorageClient::lastCallEntry;
    QVERIFY(entry);
    QCOMPARE(entry->ApplicationId(), KApplicationId);
}

void TestAfStorageProxy::testWaitActivity()
{
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    
    CAfStorageClient::expectedReturnCode = KErrCancel;
    mProxy->waitActivity();
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::WaitActivityMethod);
    
    CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;
    CAfStorageClient::expectedReturnCode = KErrNone;
    mProxy->waitActivity();
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::WaitActivityMethod);
}

void TestAfStorageProxy::testLaunchActivity()
{
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    mProxy->launchActivity(KApplicationId, KActivityId);        
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::LaunchActivityMethod);
    
    CAfEntry *entry = CAfStorageClient::lastCallEntry;
    QVERIFY(entry);
    QCOMPARE(entry->ApplicationId(), KApplicationId);
    QScopedPointer<HBufC> activityIdAsDesc(XQConversions::qStringToS60Desc(QString(KActivityId)));
    QVERIFY(entry->ActivityId().Compare(*activityIdAsDesc.data()) == 0);
}

void TestAfStorageProxy::testGetThumbnail()
{
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    
    CAfStorageClient::expectedReturnCode = KErrNone;
    mProxy->getThumbnail(QSize(100, 50), QString(KImagePath), this);
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::GetThumbnailMethod);
    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iWidth, 100);
    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iHeight, 50);
    QScopedPointer<HBufC> pathAsDesc(XQConversions::qStringToS60Desc(QString(KImagePath)));
    QVERIFY(CAfStorageClient::lastCallThumbnailPath->Compare(*pathAsDesc.data()) == 0);
    QVERIFY(CAfStorageClient::lastCallUserData == this);
    
    CAfStorageClient::expectedReturnCode = KErrNone;
    mProxy->getThumbnail(QSize(0, 0), QString(KImagePath), this);
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::GetThumbnailMethod);
    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iWidth, 0);
    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iHeight,0);
    QVERIFY(CAfStorageClient::lastCallThumbnailPath->Compare(*pathAsDesc.data()) == 0);
    QVERIFY(CAfStorageClient::lastCallUserData == this);
    
    CAfStorageClient::expectedReturnCode = KErrAccessDenied;
    mProxy->getThumbnail(QSize(100, 50), QString(KImagePath), this);
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::GetThumbnailMethod);
    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iWidth, 100);
    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iHeight,50);
    QVERIFY(CAfStorageClient::lastCallThumbnailPath->Compare(*pathAsDesc.data()) == 0);
    QVERIFY(CAfStorageClient::lastCallUserData == this);
    
}
    
void TestAfStorageProxy::testNotifyDataChange()
{
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);
    
    CAfStorageClient::expectedReturnCode = KErrCancel;
    mProxy->notifyDataChange();
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NotifyDataChangeMethod);
    
    CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;
    CAfStorageClient::expectedReturnCode = KErrNone;
    mProxy->notifyDataChange();
    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NotifyDataChangeMethod);
}

// ---------------------------------------------------------------------------
void TestAfStorageProxy::testActivities()
{
    mProxy->removeApplicationActivities(KApplicationId);
    
    QList< QVariantHash > result;
    QVERIFY(mProxy->activities(result));
    QVERIFY(result.count() >= 0);
    
    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());
    QVERIFY(mProxy->activities(result));
    QVERIFY(result.count() > 0);
}

// ---------------------------------------------------------------------------
void TestAfStorageProxy::testApplicationActivities()
{
    mProxy->removeApplicationActivities(KApplicationId);
    
    QStringList result;
    QVERIFY(mProxy->applicationActivities(result, KApplicationId));
    QCOMPARE(result.count(), 0);
    
    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());
    QVERIFY(mProxy->applicationActivities(result, KApplicationId));
    QCOMPARE(result.count(), 1);
}

// ---------------------------------------------------------------------------
void TestAfStorageProxy::testActivityData()
{
    mProxy->removeApplicationActivities(KApplicationId);
    
    QVariant result;
    QVERIFY(!mProxy->activityData(result, KApplicationId, KActivityId));
    
    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(KApplicationId), QVariantHash(), generateNonNullScreenshot());
    QVERIFY(mProxy->activityData(result, KApplicationId, KActivityId));
    QCOMPARE(result, QVariant(KApplicationId));
}

void TestAfStorageProxy::testActivityMetaData()
{
    QVariantHash result;
    QVERIFY(!mProxy->activityMetaData(result, KApplicationId, KActivityId));
    
    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(KApplicationId), QVariantHash(), generateNonNullScreenshot());
    QVERIFY(mProxy->activityMetaData(result, KApplicationId, KActivityId));
}

// ---------------------------------------------------------------------------
//  helper methods
// ---------------------------------------------------------------------------
//
QPixmap TestAfStorageProxy::generateNonNullScreenshot()
{
    QPixmap screenshot(10, 10);    
    {
        QPainter painter(&screenshot);
        painter.setBrush(Qt::black);
        painter.drawRect(screenshot.rect());
        painter.setBrush(QColor::fromHsv(0, 255, 255));
        painter.drawEllipse(screenshot.rect());
    }
    return screenshot;
}

QTEST_MAIN(TestAfStorageProxy)