/*
* 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 <s32mem.h>
#include <hash.h>
#include <fbs.h>
#include <bautils.h>

#include "afstoragesynctask.h"
#include "activitycmd.h"
#include "afentry.h"
const TInt KMaxPathLength = 256;

_LIT(KUnsupportedStorageSyncTask, "Unsupported sync storage task");

// -----------------------------------------------------------------------------
/**
 * Handle synchronous data storage requests
 * @param dataStorage - data storage
 * @param msg - request message
 */
void AfStorageSyncTask::ExecuteL(MAfTaskStorage& observers,
                                 CAfStorage& dataStorage, 
                                 const RMessage2& msg)
{
    switch (msg.Function()) {
    case AddActivity: 
        AddActivityL(dataStorage, msg);
        break;
    case UpdateActivity:
        UpdateActivityL(dataStorage, msg);
        break;
    case RemoveActivity:
        DeleteActivityL(dataStorage, msg);
        break;
    case RemoveApplicationActivities:
        DeleteApplicationActivitiesL(dataStorage, msg);
        break;
    default:
        //this code shouldn't be called. fatal error: means wrong session implementation 
        User::Panic(KUnsupportedStorageSyncTask, KErrGeneral);
    };
    msg.Complete(KErrNone);
    NotifyChangeL(observers, msg);
}

// -----------------------------------------------------------------------------
/**
 * Handle adding new activity.
 * @param dataStorage - data storage
 * @param msg - request message
 */
void AfStorageSyncTask::AddActivityL(CAfStorage& dataStorage, 
                                     const RMessage2& msg)
{
    //Read message and bitmap handle
    TPckgBuf<TInt> bitmapHdl(0);
    CAfEntry *entry = CAfEntry::NewLC();
    ReadEntryL(*entry, msg);
    msg.ReadL(1, bitmapHdl);
    
    RBuf thumbnailPath;
    CleanupClosePushL(thumbnailPath);
    ThumbnailPathL(thumbnailPath, 
                   dataStorage.Fs(), 
                   entry->ApplicationId(), 
                   entry->ActivityId());
    CreateThumbnailL(thumbnailPath, bitmapHdl());
    entry->SetImageSrcL(thumbnailPath);
    dataStorage.AddActivityL(*entry);
    CleanupStack::PopAndDestroy(&thumbnailPath);
    
    CleanupStack::PopAndDestroy(entry);
}

// -----------------------------------------------------------------------------
/**
 * Handle updating existing activiy
 * @param dataStorage - data storage
 * @param msg - request message
 */
void AfStorageSyncTask::UpdateActivityL(CAfStorage& dataStorage, 
                                        const RMessage2& msg)
{
    TPckgBuf<TInt> bitmapHdl(0);
    CAfEntry *entry = CAfEntry::NewLC();
    ReadEntryL(*entry, msg);
    msg.ReadL(1, bitmapHdl);
        
    RBuf thumbnailPath;
    CleanupClosePushL(thumbnailPath);
    ThumbnailPathL(thumbnailPath, 
                   dataStorage.Fs(), 
                   entry->ApplicationId(), 
                   entry->ActivityId());
    CreateThumbnailL(thumbnailPath, bitmapHdl());
    entry->SetImageSrcL(thumbnailPath);
    dataStorage.UpdateActivityL(*entry);
    CleanupStack::PopAndDestroy(&thumbnailPath);
    CleanupStack::PopAndDestroy(entry);
}

// -----------------------------------------------------------------------------
/**
 * Handle removing activity.
 * @param dataStorage - data storage
 * @param msg - request message
 */
void AfStorageSyncTask::DeleteActivityL(CAfStorage& dataStorage, 
                                        const RMessage2& msg)
{
    CAfEntry *entry = CAfEntry::NewLC();
    ReadEntryL(*entry, msg);
    dataStorage.DeleteActivityL(*entry);
    CleanupStack::PopAndDestroy(entry);
}

// -----------------------------------------------------------------------------
/**
 * Handle removing all application activities.
 * @param dataStorage - data storage
 * @param msg - request message
 */
void AfStorageSyncTask::DeleteApplicationActivitiesL(CAfStorage& dataStorage, 
                                                     const RMessage2& msg)
{
    CAfEntry *entry = CAfEntry::NewLC();
    ReadEntryL(*entry, msg);
    dataStorage.DeleteActivitiesL(*entry);
    CleanupStack::PopAndDestroy(entry);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void AfStorageSyncTask::NotifyChangeL(MAfTaskStorage& observers,
                                      const RMessage2& msg)
{
    const RPointerArray<CAfTask> &table(observers.StorageData());
    for (TInt iter(table.Count() - 1); 0 <= iter; --iter) {
        table[iter]->BroadcastReceivedL(msg);
    }
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void AfStorageSyncTask::ReadEntryL(CAfEntry& entry, const RMessage2& msg)
{
    RBuf8 serializedEntry;
    CleanupClosePushL(serializedEntry);
    serializedEntry.CreateL(msg.GetDesLengthL(0));
    msg.ReadL(0, serializedEntry);
    RDesReadStream reader(serializedEntry);
    CleanupClosePushL(reader);
    
    reader >> entry;
    
    CleanupStack::PopAndDestroy(&reader);
    CleanupStack::PopAndDestroy(&serializedEntry);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void AfStorageSyncTask::CreateThumbnailL(const TDesC &path, TInt hdl)
{
    if (0 >= hdl) {
        User::Leave(KErrCorrupt);
    }
    CFbsBitmap *bitmap = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bitmap);
    User::LeaveIfError(bitmap->Duplicate(hdl));
    User::LeaveIfError(bitmap->Save(path));
    CleanupStack::PopAndDestroy(bitmap);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void AfStorageSyncTask::ThumbnailPathL(RBuf &dst, 
                                       RFs& fileSystem, 
                                       TInt uid, 
                                       const TDesC &activityName)
{
    _LIT(KUidFormat, "%+08x\\");
    _LIT(KExtFormat, ".mbm");
    //Generate activity hash
    RBuf8 buff8;
    CleanupClosePushL(buff8);
    buff8.CreateL(activityName.Length());
    buff8.Copy(activityName);
    HBufC8 *activityHash = Md5HexDigestL(buff8);
    CleanupStack::PopAndDestroy(&buff8);
    CleanupStack::PushL(activityHash);
    
    //Get private path
    RBuf privatePath;
    CleanupClosePushL(privatePath);
    privatePath.CreateL(KMaxPathLength);
    User::LeaveIfError(fileSystem.PrivatePath(privatePath));
    
    //Format activity path
    privatePath.AppendFormat( KUidFormat, uid);
    
    const TInt requiredSize(privatePath.Length() + 
                            activityHash->Length() + 
                            KExtFormat().Length());
    CAfEntry::ReallocL(dst, requiredSize);
    
    //Copy path
    dst.Copy(privatePath);
    privatePath.Copy(*activityHash);//reuse already allocated buffer to convert 8 -> 16
    dst.Append(privatePath);
    dst.Append(KExtFormat());
    
    CleanupStack::PopAndDestroy(&privatePath);
    CleanupStack::PopAndDestroy(activityHash);
    
    BaflUtils::EnsurePathExistsL(fileSystem, dst);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
HBufC8* AfStorageSyncTask::Md5HexDigestL(const TDes8 &string)
{
    _LIT8(KMd5HexFormat, "%+02x");
    CMD5* md5 = CMD5::NewL();
    CleanupStack::PushL(md5);
    
    TPtrC8 hashedSig(md5->Hash(string));
    
    HBufC8* buf = HBufC8::NewL(hashedSig.Length() * 2);
    TPtr8 bufPtr = buf->Des();
    
    for(TInt i(0); i< hashedSig.Length(); ++i) {
        bufPtr.AppendFormat(KMd5HexFormat,hashedSig[i]);
    }
    CleanupStack::PopAndDestroy(md5);
    return buf;
}