/*

 * Copyright (c) 2007 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:  CS Preview Plugin Handler, This class creates and updates sqlite based db

 *                with the message-preview data.

 *

 */

// USER INCLUDES

#include "ccspreviewpluginhandler.h"

#include "UniObject.h"

// SYSTEM INCLUDES

#include <mmsclient.h>

#include <mtclreg.h>

#include <msvids.h>

#include <e32const.h>

#include <SendUiConsts.h>

#include <utf.h>

//CONSTANTS

//DB-file

_LIT(KDbFileName, "c:[2002A542]conversations.db");

//Encoding

_LIT(KEncodingStmnt,"PRAGMA encoding=\"UTF-8\"");

//Size

_LIT(KCacheSizeStmnt,"PRAGMA default_cache_size = 1024");

// Create table query statement

_LIT(KSqlCreateStmt, "CREATE TABLE IF NOT EXISTS conversation_messages ( message_id  INTEGER PRIMARY KEY, msg_parsed  INTEGER DEFAULT 0, subject TEXT(100), body_text TEXT(160), preview_path TEXT, msg_property INTEGER, preview_icon BLOB DEFAULT NULL ) " );

//Insert without bitmap query

_LIT(KSqlInsertStmt, "INSERT OR REPLACE INTO conversation_messages (message_id, msg_parsed, subject, body_text, preview_path, msg_property ) VALUES( :message_id, :msg_parsed, :subject, :body_text, :preview_path,  :msg_property )");

//update with bitmap query

_LIT(KSqlUpdateBitmapStmt, "UPDATE conversation_messages SET preview_icon=:preview_icon WHERE message_id=:message_id " );

// query to see if msg_parsed is set

_LIT(KSelectMsgParsedStmt, " SELECT message_id, msg_parsed  FROM conversation_messages WHERE message_id=:message_id ");

// Remove record from conversation_messages table.

_LIT(KRemoveMsgStmnt,"DELETE FROM conversation_messages WHERE message_id=:message_id");

// NOTE:- DRAFTS ENTRIES ARE NOT HANDLED IN THE PLUGIN

// ============================== MEMBER FUNCTIONS ============================

// ----------------------------------------------------------------------------

// CCsPreviewPluginHandler::NewL

// Two Phase Construction

// ----------------------------------------------------------------------------

//

CCsPreviewPluginHandler* CCsPreviewPluginHandler::NewL(

    CCsPreviewPlugin *aMsgObserver)

{

    PRINT ( _L("Enter CCsMsgHandler::NewL") );

    CCsPreviewPluginHandler* self = new (ELeave) CCsPreviewPluginHandler();

    CleanupStack::PushL(self);

    self->ConstructL(aMsgObserver);

    CleanupStack::Pop(self);

    PRINT ( _L("End CCsPreviewPluginHandler::NewL") );

    return self;

}

// ----------------------------------------------------------------------------

// CCsPreviewPluginHandler::~CCsPreviewPluginHandler

// Destructor

// ----------------------------------------------------------------------------

//

CCsPreviewPluginHandler::~CCsPreviewPluginHandler()

{

    PRINT ( _L("Enter CCsPreviewPluginHandler::~CCsPreviewPluginHandler") );

    iSqlDb.Close();

    iThumbnailRequestArray.Close();

    ifsSession.Close();

    if (iMmsMtm)

    {

        delete iMmsMtm;

        iMmsMtm = NULL;

    }

    if (iMtmRegistry)

    {

        delete iMtmRegistry;

        iMtmRegistry = NULL;

    }

    if (iSession)

    {

        delete iSession;

        iSession = NULL;

    }

    if (iThumbnailManager)

    {

        delete iThumbnailManager;

        iThumbnailManager = NULL;

    }

    PRINT ( _L("End CCsPreviewPluginHandler::~CCsPreviewPluginHandler") );

}

// ----------------------------------------------------------------------------

// CCsMsgHandler::ConstructL

// Two Phase Construction

// ----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::ConstructL(CCsPreviewPlugin *aMsgObserver)

{

    PRINT ( _L("Enter CCsPreviewPluginHandler::ConstructL") );

    iMsgObserver = aMsgObserver;

    //file session connect

    User::LeaveIfError(ifsSession.Connect());

    //create msv session

    iSession = CMsvSession::OpenSyncL(*this);

    //create mtm registry

    iMtmRegistry = CClientMtmRegistry::NewL(*iSession);

    //create mms client mtm

    iMmsMtm = static_cast<CMmsClientMtm*> (iMtmRegistry-> NewMtmL(

        KSenduiMtmMmsUid));

    //create thumbnail manager

    iThumbnailManager = CThumbnailManager::NewL(*this);

    // open DB

    TInt error = iSqlDb.Open(KDbFileName);

    PRINT1 ( _L("End CCsPreviewPluginHandler::ConstructL open DB file error=%d"), error );

    // if not found, create DB

    if (error == KErrNotFound)

    {

        //create sqlite-DB

        TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

        RSqlSecurityPolicy securityPolicy;

        securityPolicy.Create(defaultPolicy);

        // TODO, setting UID security policy

        //TSecurityPolicy readPolicy(ECapabilityReadUserData);  

        //securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, readPolicy);

        iSqlDb.Create(KDbFileName, securityPolicy);

        //Create the table inside DB

        iSqlDb.Exec(KSqlCreateStmt);

        iSqlDb.Exec(KEncodingStmnt);

        iSqlDb.Exec(KCacheSizeStmnt);

    }

    else

    {

        User::LeaveIfError(error);

    }

    PRINT ( _L("End CCsPreviewPluginHandler::ConstructL") );

}

// ----------------------------------------------------------------------------

// CCsPreviewPluginHandler::CCsPreviewPluginHandler

// Two Phase Construction

// ----------------------------------------------------------------------------

//

CCsPreviewPluginHandler::CCsPreviewPluginHandler()

{

}

// ----------------------------------------------------------------------------

// CCsPreviewPluginHandler::HandleSessionEventL

// Implemented for MMsvSessionObserver

// ----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::HandleSessionEventL(TMsvSessionEvent aEvent,

    TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/)

{

    PRINT1 ( _L("Enter CCsPreviewPluginHandler::HandleSessionEventL aEvent=%d"),aEvent );

    CMsvEntrySelection* selection = NULL;

    TMsvId parent;

    //args

    if (aArg1 == NULL || aArg2 == NULL)

    {

        PRINT ( _L("Enter CCsPreviewPluginHandler::HandleSessionEventL arguments invalid"));

        return;

    }

    //start, processing the event

    selection = (CMsvEntrySelection*) aArg1;

    parent = *(TMsvId*) aArg2;

    //Drafts not handled

    if (KMsvDraftEntryIdValue == parent)

    {

        return;

    }

    switch (aEvent)

    {

        case EMsvEntriesChanged:

        case EMsvEntriesMoved:

        {

            HandleEventL(selection);

        }

        break;

        case EMsvEntriesDeleted:

        {

            for (TInt i = 0; i < selection->Count(); i++)

            {

                RSqlStatement sqlDeleteStmt;

                CleanupClosePushL(sqlDeleteStmt);

                sqlDeleteStmt.PrepareL(iSqlDb, KRemoveMsgStmnt);

                TInt messageIdIndex = sqlDeleteStmt.ParameterIndex(_L(

                    ":message_id"));

                User::LeaveIfError(sqlDeleteStmt.BindInt(messageIdIndex, selection->At(i)));

                User::LeaveIfError(sqlDeleteStmt.Exec());

                CleanupStack::PopAndDestroy(&sqlDeleteStmt);

            }

        }

        break;

    }

    PRINT ( _L("Exit CCsPreviewPluginHandler::HandleSessionEventL") );

}

// ---------------------------------------------------------------------

// CCsPreviewPluginHandler::HandleEvent

// Handle events

// ---------------------------------------------------------------------

//

void CCsPreviewPluginHandler::HandleEventL(CMsvEntrySelection* aSelection)

{

    PRINT ( _L("Enter CCsPreviewPluginHandler::HandleEvent") );

    TMsvEntry entry;

    TMsvId service;

    TInt error = KErrNone;

    for (TInt i = 0; i < aSelection->Count(); i++)

    {

        error = iSession->GetEntry(aSelection->At(i), service, entry);

        if ( (KErrNone == error) && !entry.InPreparation() && entry.Visible()

                && (KSenduiMtmMmsUidValue == entry.iMtm.iUid))

        {

            PRINT ( _L("Enter CCsPreviewPluginHandler::HandleEvent for loop started.") );

            TInt msgId = entry.Id();

            //check if the message is already parsed

            RSqlStatement sqlSelectStmt;

            CleanupClosePushL(sqlSelectStmt);

            sqlSelectStmt.PrepareL(iSqlDb,KSelectMsgParsedStmt);

            TInt messageIdIndex = sqlSelectStmt.ParameterIndex(

                _L(":message_id"));

            User::LeaveIfError(sqlSelectStmt.BindInt(messageIdIndex, msgId));

            if (sqlSelectStmt.Next() == KSqlAtRow)

            {

                TInt parsedColIndex = sqlSelectStmt.ColumnIndex(

                    _L("msg_parsed"));

                TInt msgParsed = sqlSelectStmt.ColumnInt(parsedColIndex);

                //if message alresdy parsed, move to next message.

                if (msgParsed)

                {

                    CleanupStack::PopAndDestroy(&sqlSelectStmt);

                    continue;

                }

            }

            CleanupStack::PopAndDestroy(&sqlSelectStmt);

            // update db with message preview data

            RSqlStatement sqlInsertStmt;

            CleanupClosePushL(sqlInsertStmt);

            sqlInsertStmt.PrepareL(iSqlDb, KSqlInsertStmt);

            // parse message

            iMmsMtm->SwitchCurrentEntryL(msgId);

            iMmsMtm->LoadMessageL();

            CUniDataModel* iUniDataModel = CUniDataModel::NewL(ifsSession,

                *iMmsMtm);

            CleanupStack::PushL(iUniDataModel);

            iUniDataModel->RestoreL(*this, ETrue);

            //msg property

            TInt msgProperty = 0;

            if (iUniDataModel->AttachmentList().Count() > 0)

            {

                msgProperty |= EPreviewAttachment;

            }

            TPtrC videoPath;

            TPtrC imagePath;

            // preview parsing

            TInt slideCount = iUniDataModel->SmilModel().SlideCount();

            TBool isBodyTextSet = EFalse;

            TBool isImageSet = EFalse;

            TBool isAudioSet = EFalse;

            TBool isVideoSet = EFalse;

            for (int i = 0; i < slideCount; i++)

            {

                int slideobjcount =

                        iUniDataModel->SmilModel().SlideObjectCount(i);

                for (int j = 0; j < slideobjcount; j++)

                {

                    CUniObject *obj =

                            iUniDataModel->SmilModel(). GetObjectByIndex(i, j);

                    TPtrC8 mimetype = obj->MimeType();

                    TMsvAttachmentId attachId = obj->AttachmentId();

                    //bodytext

                    if (!isBodyTextSet && (mimetype.Find(_L8("text"))

                            != KErrNotFound))

                    {

                        //bind bodytext into statement

                        BindBodyText(sqlInsertStmt, attachId);

                        isBodyTextSet = ETrue;

                    }

                    //image parsing

                    if (!isImageSet && (mimetype.Find(_L8("image"))

                            != KErrNotFound))

                    {

                        //get thumbnail for this image

                        GetThumbNailL(attachId, mimetype, msgId);

                        isImageSet = ETrue;

                        imagePath.Set(obj->MediaInfo()->FullFilePath());

                        msgProperty |= EPreviewImage;

                    }

                    //audio content

                    if (!isAudioSet && (mimetype.Find(_L8("audio"))

                            != KErrNotFound))

                    {

                        isAudioSet = ETrue;

                        msgProperty |= EPreviewAudio;

                    }

                    //video content

                    if (!isVideoSet && (mimetype.Find(_L8("video"))

                            != KErrNotFound))

                    {

                        videoPath.Set(obj->MediaInfo()->FullFilePath());

                        isVideoSet = ETrue;

                        msgProperty |= EPreviewVideo;

                    }

                }

            }

            //set preview path

            TInt previewPathIndex = sqlInsertStmt.ParameterIndex(_L(

                ":preview_path"));

            if (isVideoSet)

            {

                User::LeaveIfError(sqlInsertStmt.BindText(previewPathIndex,

                    videoPath));

            }

            else if (isImageSet)

            {

                User::LeaveIfError(sqlInsertStmt.BindText(previewPathIndex,

                    imagePath));

            }

            //msg_id

            TInt msgIdIndex = sqlInsertStmt.ParameterIndex(_L(":message_id"));

            User::LeaveIfError(sqlInsertStmt.BindInt(msgIdIndex, msgId));

            //subjext

            TInt subjectIndex = sqlInsertStmt.ParameterIndex(_L(":subject"));

            User::LeaveIfError(sqlInsertStmt.BindText(subjectIndex,

                iMmsMtm->SubjectL()));

            //msg_property

            TInt msgPropertyIndex = sqlInsertStmt.ParameterIndex(_L(

                ":msg_property"));

            User::LeaveIfError(sqlInsertStmt.BindInt(msgPropertyIndex,

                msgProperty));

            //msg-parsed

            TInt msgParsedIndex = sqlInsertStmt.ParameterIndex(

                _L(":msg_parsed"));

            User::LeaveIfError(sqlInsertStmt.BindInt(msgParsedIndex, 1)); // 1 as true

            //execute sql stament

            User::LeaveIfError(sqlInsertStmt.Exec());

            //cleanup

            CleanupStack::PopAndDestroy(2, &sqlInsertStmt);

        }

}//end for loop

PRINT ( _L("Exit CCsPreviewPluginHandler::HandleEvent") );

}

// -----------------------------------------------------------------------------

// CCsPreviewPluginHandler::RestoreReady()

// 

// -----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::RestoreReady(TInt /*aParseResult*/, TInt /*aError*/)

{

}

// -----------------------------------------------------------------------------

// CCsPreviewPluginHandler::ThumbnailReady()

// 

// -----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::ThumbnailReady(TInt aError,

    MThumbnailData& aThumbnail, TThumbnailRequestId aId)

{

    // This function must not leave.

    if (!aError)

    {

        PRINT ( _L("CCsPreviewPluginHandler::ThumbnailReady received.") );

        TInt err;

        TRAP(err, HandleThumbnailReadyL(aThumbnail, aId));

        PRINT1 ( _L("CCsPreviewPluginHandler::ThumbnailReady handling error= %d."), err );

    }

    else

    {

        // An error occurred while getting the thumbnail.

        PRINT1 ( _L("End CCsPreviewPluginHandler::ThumbnailReady error= %d."), aError );

    }

}

// -----------------------------------------------------------------------------

// CCsPreviewPluginHandler::ThumbnailPreviewReady()

// callback

// -----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::ThumbnailPreviewReady(

    MThumbnailData& /*aThumbnail*/, TThumbnailRequestId /*aId*/)

{

}

// -----------------------------------------------------------------------------

// CCsPreviewPluginHandler::HandleThumbnailReadyL()

// 

// -----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::HandleThumbnailReadyL(MThumbnailData& aThumbnail,

    TThumbnailRequestId aId)

{

    //match response to request

    ThumbnailRequestData tempObj;

    tempObj.iRequestId = aId;

    TInt index = iThumbnailRequestArray.Find(tempObj,

        CCsPreviewPluginHandler::CompareByRequestId);

    if (index < 0)

    {

        PRINT ( _L("End CCsPreviewPluginHandler::HandleThumbnailReady request match not found.") );

        return;

    }

    // get msg-id corresponding to the request-id

    TInt msgId = iThumbnailRequestArray[index].iMsgId;

    //remove the request from requestarray

    iThumbnailRequestArray.Remove(index);

    // get bitmap

    CFbsBitmap* bitmap = aThumbnail.Bitmap();

    // sql-statment to set preview-icon

    RSqlStatement sqlInsertStmt;

    CleanupClosePushL(sqlInsertStmt);

    sqlInsertStmt.PrepareL(iSqlDb, KSqlUpdateBitmapStmt);

    TInt msgIdIndex = sqlInsertStmt.ParameterIndex(_L(":message_id"));

    TInt previewIconIndex = sqlInsertStmt.ParameterIndex(_L(":preview_icon"));

    User::LeaveIfError(sqlInsertStmt.BindInt(msgIdIndex, msgId));

    RSqlParamWriteStream previewIconStream;

    CleanupClosePushL(previewIconStream);

    //bind data

    User::LeaveIfError(previewIconStream.BindBinary(sqlInsertStmt, previewIconIndex));

    bitmap->ExternalizeL(previewIconStream);

    previewIconStream.CommitL();

    //execute the statent

    User::LeaveIfError(sqlInsertStmt.Exec());

    CleanupStack::PopAndDestroy(2,&sqlInsertStmt);//sqlInsertStmt,previewIconStream

}

//-----------------------------------------------------------------------------

// CCsPreviewPluginHandler::CompareByRequestId

// Compare to conversation entry object based on Entry Ids

//----------------------------------------------------------------------------

TBool CCsPreviewPluginHandler::CompareByRequestId(

    const ThumbnailRequestData& aFirst, const ThumbnailRequestData& aSecond)

{

    if (aFirst.iRequestId == aSecond.iRequestId)

        return ETrue;

    return EFalse;

}

// -----------------------------------------------------------------------------

// CCsPreviewPluginHandler::BindBodyText()

// 

// -----------------------------------------------------------------------------

//

void CCsPreviewPluginHandler::BindBodyText(RSqlStatement& sqlStmt,

    TMsvAttachmentId attachmentId)

{