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

#include <fbs.h>

#include <QSize>
#include <QPixmap>
#include <QDateTime>

#include <XQConversions>

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

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

AfStorageProxyPrivate::AfStorageProxyPrivate(AfStorageProxy *q) : mClient(0), q_ptr(q)
{    
    QT_TRAP_THROWING(
        mClient = CAfStorageClient::NewL(*this);
        User::LeaveIfError(mAppArcSession.Connect());
    );
}

AfStorageProxyPrivate::~AfStorageProxyPrivate()
{
    delete mClient;
    mAppArcSession.Close();
}

bool AfStorageProxyPrivate::saveActivity(int applicationId, const QString &activityId, const QString &customActivityName, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
{
    int screenshotHandle(-1);
    CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
    if (bitmap) {
        screenshotHandle = bitmap->Handle();
    }
    
    CAfEntry *entry = createSaveEntry(applicationId, activityId, customActivityName, activityData, metadata);
    int result = mClient->saveActivity(*entry, screenshotHandle);    
    delete entry;
    delete bitmap;
    
    return KErrNone == result;
}

bool AfStorageProxyPrivate::removeActivity(int applicationId, const QString &activityId)
{
    CAfEntry *entry = createFilterEntry(applicationId, activityId);
    int result = mClient->removeActivity(*entry);
    delete entry;
    return KErrNone == result;
}
   
bool AfStorageProxyPrivate::removeApplicationActivities(int applicationId)
{
    CAfEntry *entry = createFilterEntry(applicationId);
    int result = mClient->removeApplicationActivities(*entry);
    delete entry;
    return KErrNone == result;
}

bool AfStorageProxyPrivate::activities(QList<QVariantHash> &list, int limit)
{
    RPointerArray<CAfEntry> results;
    
    int result = mClient->activities(results, limit);
    list.clear();
    for (int i=0; i < results.Count(); ++i) {
        list.append(extractMetadata(results[i], false));
    }
   
    results.ResetAndDestroy();
    return KErrNone == result;
}

bool AfStorageProxyPrivate::applicationActivities(QStringList &list, int applicationId)
{
    RPointerArray<CAfEntry> results;
    
    CAfEntry *entry = createFilterEntry(applicationId);
    int result = mClient->applicationActivities(results, *entry);
    delete entry;
    
    list.clear();
    for (int i=0; i < results.Count(); ++i) {
        list.append(XQConversions::s60DescToQString(results[i]->ActivityId()));
    }
   
    results.ResetAndDestroy();
    return KErrNone == result;
}

bool AfStorageProxyPrivate::activityData(QVariant &data, int applicationId, const QString &activityId)
{
    CAfEntry *entry = getEntry(applicationId, activityId);
    
    if (!entry) {
        return false;
    }
    
    QVariantHash deserializedData;
    deserializedData << entry->Data(CAfEntry::Private);
    data = deserializedData[ActivityDataKeyword];
    delete entry;
    return true;
}

bool AfStorageProxyPrivate::activityMetaData(QVariantHash &metadata, int applicationId, const QString &activityId)
{
    CAfEntry *entry = getEntry(applicationId, activityId);
    
    if (entry) {
        metadata = extractMetadata(entry, true);
        delete entry;
        return true;
    }    
    
    return false;
}

bool AfStorageProxyPrivate::waitActivity()
{
    return KErrNone == mClient->waitActivity();
}
    
bool AfStorageProxyPrivate::launchActivity(int applicationId, const QString &activityUri)
{
    CAfEntry *entry = createFilterEntry(applicationId, activityUri);
    int result = mClient->launchActivity(*entry);
    delete entry;
    return KErrNone == result;
}

bool AfStorageProxyPrivate::getThumbnail(const QString &imagePath, void *userData)
{
    HBufC *source = XQConversions::qStringToS60Desc(imagePath);
    int result = mClient->getThumbnail(*source, userData);
    delete source;
    return KErrNone == result;
}

bool AfStorageProxyPrivate::notifyDataChange()
{
    return KErrNone == mClient->notifyDataChange();
}


void AfStorageProxyPrivate::waitActivityRequestCompleted(int result, const TDesC8 &data)
{
    if (KErrCancel != result) {
        waitActivity();
    }
    if (KErrNone == result) {
        emit q_ptr->activityRequested(XQConversions::s60Desc8ToQString(data));
    }
}

void AfStorageProxyPrivate::getThumbnailRequestCompleted(int result, int bitmapHandle, void *userData)
{
    if (KErrNone == result) {
        CFbsBitmap* bitmap = new CFbsBitmap();
        if (KErrNone == bitmap->Duplicate(bitmapHandle)) {
            emit q_ptr->thumbnailRequested(QPixmap::fromSymbianCFbsBitmap(bitmap), userData);
        }
        delete bitmap;
    }
}

void AfStorageProxyPrivate::dataChangeNotificationCompleted(int result)
{
    if (KErrCancel != result) {
        notifyDataChange();
    }
    if (KErrNone == result) {
        emit q_ptr->dataChanged();
    }
}
 
CAfEntry *AfStorageProxyPrivate::createFilterEntry(int applicationId, const QString &activityId)
{   
    CAfEntry *entry(0); 
    QT_TRAP_THROWING(entry = CAfEntry::NewL(0, applicationId, TPtrC(static_cast<const TUint16*>(activityId.utf16())), KNullDesC(), KNullDesC(), KNullDesC8(), KNullDesC8(), TTime()));
    return entry;
}

CAfEntry *AfStorageProxyPrivate::createSaveEntry(int applicationId, const QString &activityId, const QString &customActivityName, const QVariant &activityData, const QVariantHash &metadata)
{   
    CAfEntry *entry(0); 
    
    QT_TRAP_THROWING(
        int flags(0);
        QVariantHash privData;
        privData.insert(ActivityDataKeyword, activityData);
        RBuf8 privateBuff;
        RBuf8 publicBuff;
        CleanupClosePushL(privateBuff);
        CleanupClosePushL(publicBuff);
        privateBuff << privData;
        publicBuff << metadata;
        
        if (metadata.contains(ActivityPersistence) && metadata[ActivityPersistence].toBool()) {
            flags |= CAfEntry::Persistent;
        }
        
        if (metadata.contains(ActivityVisibility) && !metadata[ActivityVisibility].toBool()) {
            flags |= CAfEntry::Invisible;
        }
        
        HBufC *actBuff = XQConversions::qStringToS60Desc(activityId);
        CleanupStack::PushL(actBuff);
        
        HBufC *customNameBuff = XQConversions::qStringToS60Desc(customActivityName);
        CleanupStack::PushL(customNameBuff);
        
        entry = CAfEntry::NewL(flags, 
                               applicationId, 
                               *actBuff, 
                               *customNameBuff,
                               KNullDesC, 
                               privateBuff, 
                               publicBuff,
                               convertQDateTimeToTTime(metadata[ActivityTimestamp].toDateTime()));
        CleanupStack::PopAndDestroy(customNameBuff);
        CleanupStack::PopAndDestroy(actBuff);
        CleanupStack::PopAndDestroy(&publicBuff);
        CleanupStack::PopAndDestroy(&privateBuff);
    );
    return entry;
}

CAfEntry *AfStorageProxyPrivate::getEntry(int applicationId, const QString &activityId)
{
    CAfEntry *entry = createFilterEntry(applicationId, activityId);
    CAfEntry *resultEntry(0);
    int result = mClient->activityData(resultEntry, *entry);
    delete entry;
    
    if (KErrNone != result) {
        delete resultEntry;
        resultEntry = 0;
    }
    
    return resultEntry;
}

QVariantHash AfStorageProxyPrivate::extractMetadata(CAfEntry *entry, bool includePublicData)
{
    QVariantHash metadata;
    if (includePublicData) {
        metadata << entry->Data(CAfEntry::Public);
    }
    metadata.insert(ActivityApplicationKeyword, entry->ApplicationId());
    metadata.insert(ActivityActivityKeyword, XQConversions::s60DescToQString(entry->ActivityId()));
    metadata.insert(ActivityApplicationName, activityDisplayText(entry));
    metadata.insert(ActivityScreenshotKeyword, XQConversions::s60DescToQString(entry->ImageSrc()));
    metadata.insert(ActivityPersistence, (entry->Flags() & CAfEntry::Persistent) ? true : false);
    metadata.insert(ActivityVisibility, (entry->Flags() & CAfEntry::Invisible) ? false : true); 
    metadata.insert(ActivityTimestamp, convertTTimeToQDateTime(entry->Timestamp())); 
    return metadata;
}

QString AfStorageProxyPrivate::activityDisplayText(CAfEntry *entry)
{
    if (entry->CustomActivityName().Compare(KNullDesC()) == 0) {
        TApaAppInfo info;
        mAppArcSession.GetAppInfo(info, TUid::Uid(entry->ApplicationId()));
        return QString::fromUtf16(info.iShortCaption.Ptr(), info.iShortCaption.Length());        
    } else {
        return XQConversions::s60DescToQString(entry->CustomActivityName());
    }
}

// -----------------------------------------------------------------------------
TTime AfStorageProxyPrivate::convertQDateTimeToTTime(const QDateTime &timestamp) const
{
    return TTime( _L( "19700000:" ) ) + TTimeIntervalSeconds( timestamp.toTime_t() ) +
                         TTimeIntervalMicroSeconds( timestamp.time().msec() * 1000 );
}

// -----------------------------------------------------------------------------
QDateTime AfStorageProxyPrivate::convertTTimeToQDateTime(const TTime &s60Time) const
{
    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;    
}