/*

* Copyright (c) 2008-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:    Implementation of CGlxtnVolumeDatabase

*

*/

/**

 * @internal reviewed 31/07/2007 by Simon Brooks

 */

#include "glxtnvolumedatabase.h"

#include <glxtracer.h>

#include <glxpanic.h>

#include <s32file.h>

#include "glxtnfileinfo.h"

#include "mglxtnvolumedatabaseobserver.h"

#include <glxlog.h>

_LIT(KGlxCreateTableIds, "CREATE TABLE Ids (MediaId UNSIGNED INTEGER NOT NULL, ThumbId UNSIGNED INTEGER NOT NULL)");

_LIT(KGlxCreateTableItems, "CREATE TABLE Items (Uri VARCHAR NOT NULL, ThumbId UNSIGNED INTEGER NOT NULL, FileSize INTEGER, ModTime TIME)");

_LIT(KGlxCreateTableThumbnails, "CREATE TABLE Thumbnails (ThumbId UNSIGNED INTEGER NOT NULL, Width INTEGER NOT NULL, Height INTEGER NOT NULL, Format INTEGER NOT NULL, ImageData LONG VARBINARY NOT NULL)");

_LIT(KGlxCreateIndexIds, "CREATE UNIQUE INDEX IdIndex ON Ids (MediaId)");

_LIT(KGlxCreateIndexItems, "CREATE UNIQUE INDEX ItemIndex ON Items (ThumbId ASC)");

_LIT(KGlxCreateIndexThumbnails, "CREATE UNIQUE INDEX ThumbnailIndex ON Thumbnails (ThumbId, Width, Height)");

_LIT(KGlxCreateIndexThumbIds, "CREATE UNIQUE INDEX ThumbIdIndex ON Ids (ThumbId)");

_LIT(KGlxTableIds, "Ids");

_LIT(KGlxTableItems, "Items");

_LIT(KGlxTableThumbnails, "Thumbnails");

_LIT(KGlxIndexItems, "ItemIndex");

_LIT(KGlxIndexThumbIds, "ThumbIdIndex");

const TInt KGlxColIdMediaId = 1;

const TInt KGlxColIdThumbId = 2;

const TInt KGlxColItemUri = 1;

const TInt KGlxColItemId = 2;

const TInt KGlxColItemFileSize = 3;

const TInt KGlxColItemModTime = 4;

const TInt KGlxColThumbnailId = 1;

const TInt KGlxColThumbnailWidth = 2;

const TInt KGlxColThumbnailHeight = 3;

const TInt KGlxColThumbnailFormat = 4;

const TInt KGlxColThumbnailData = 5;

_LIT(KGlxQueryThumbIdFromIds, "SELECT * FROM Ids WHERE MediaId = ");

_LIT(KGlxQueryThumbIdFromItems, "SELECT * FROM Items WHERE Uri = ");

_LIT(KGlxQueryThumbnail, "SELECT * FROM Thumbnails WHERE ThumbId = %d AND Width = %d AND Height = %d");

_LIT(KGlxQueryAvailable, "SELECT ThumbId, Width, Height FROM Thumbnails WHERE ThumbId = %d AND Width = %d AND Height = %d");

_LIT(KGlxQueryItems, "SELECT * FROM Items WHERE ThumbId = %d");

_LIT(KGlxDeleteId, "DELETE FROM Ids WHERE MediaId = %d");

_LIT(KGlxDeleteThumbnails, "DELETE FROM Thumbnails WHERE ThumbId = %d");

_LIT(KGlxDeleteItem, "DELETE FROM Items WHERE ThumbId = %d");

const TInt KGlxTIntMaxDigits = 11;

const TUint KGlxFirstThumbnailId = 1;

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

// NewL

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

//

CGlxtnVolumeDatabase* CGlxtnVolumeDatabase::NewLC(

        MGlxtnVolumeDatabaseObserver& aObserver, RFs& aFs, const TDesC& aPath)

    {

    TRACER("CGlxtnVolumeDatabase* CGlxtnVolumeDatabase::NewLC( MGlxtnVolumeDatabaseObserver& aObserver, RFs& aFs, const TDesC& aPath)");

    CGlxtnVolumeDatabase* self = 

                        new (ELeave) CGlxtnVolumeDatabase(aObserver, aFs);

    CleanupStack::PushL(self);

    self->ConstructL(aPath);

    return self;

    }

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

// Constructor

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

//

CGlxtnVolumeDatabase::CGlxtnVolumeDatabase(

                                    MGlxtnVolumeDatabaseObserver& aObserver, 

                                    RFs& aFs)

    : CActive(EPriorityStandard), 

      iObserver(aObserver), iFs(aFs), iState(EStateIdle)

    {

    TRACER("CGlxtnVolumeDatabase::CGlxtnVolumeDatabase( MGlxtnVolumeDatabaseObserver& aObserver, RFs& aFs)");

    }

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

// ConstructL

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

//

void CGlxtnVolumeDatabase::ConstructL(const TDesC& aPath)

    {

    TRACER("void CGlxtnVolumeDatabase::ConstructL(const TDesC& aPath)");

    iDrive = aPath.Left(KMaxDriveName);

    TRAPD(error, OpenDbL(iFs, aPath));

    GLX_LOG_INFO1("CGlxtnVolumeDatabase::ConstructL OpenDbL TRAP error = %d", error);

    if ( KErrNone != error )

        {

        iDatabase.Close();

        delete iStore;

        iStore = NULL;

        CreateDbL(iFs, aPath);

        }

    CActiveScheduler::Add(this);

    }

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

// Destructor

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

//

CGlxtnVolumeDatabase::~CGlxtnVolumeDatabase() 

    {

    TRACER("CGlxtnVolumeDatabase::~CGlxtnVolumeDatabase()");

    Cancel();

    iView.Close();

    iTable.Close();

    iDbUpdater.Close();

    iDatabase.Close();

    delete iStore;

    }

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

// Drive

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

//

const TDesC& CGlxtnVolumeDatabase::Drive() const

    {

    TRACER("TDesC& CGlxtnVolumeDatabase::Drive()");

    return iDrive;

    }

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

// GetThumbnailIdL

// Look up thumbnail ID from Ids table

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

//

void CGlxtnVolumeDatabase::GetThumbnailIdL( const TGlxMediaId& aMediaId )

    {

    TRACER("void CGlxtnVolumeDatabase::GetThumbnailIdL( const TGlxMediaId& aMediaId )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("CGlxtnVolumeDatabase::GetThumbnailIdL() Media Id= %d",aMediaId.Value());

    HBufC* sql = HBufC::NewLC(

                    KGlxQueryThumbIdFromIds().Length() + KGlxTIntMaxDigits );

    *sql = KGlxQueryThumbIdFromIds;

    sql->Des().AppendNum( aMediaId.Value() );

    EvaluateQueryL( *sql );

    iState = EStateGettingIdFromMediaId;

    CleanupStack::PopAndDestroy(sql);

    }

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

// GetThumbnailIdL

// Look up thumbnail ID from Items table.  If not found, add new record.

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

//

void CGlxtnVolumeDatabase::GetThumbnailIdL(const CGlxtnFileInfo* aInfo)

    {

    TRACER("void CGlxtnVolumeDatabase::GetThumbnailIdL(const CGlxtnFileInfo* aInfo)");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    iInfo = aInfo;

    HBufC* uri = QuoteSqlStringLC(iInfo->FilePath());

    HBufC* sql = HBufC::NewLC(

                    KGlxQueryThumbIdFromItems().Length() + uri->Length());

    *sql = KGlxQueryThumbIdFromItems;

    sql->Des().Append(*uri);

    EvaluateQueryL( *sql );

    iState = EStateGettingIdFromFilename;

    CleanupStack::PopAndDestroy(sql);

    CleanupStack::PopAndDestroy(uri);

    }

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

// GetThumbnailIdL

// Retrieve the thumbnail id to be assigned to the next thumbnail that gets stored in the database. 

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

//

TGlxtnThumbnailId CGlxtnVolumeDatabase::GetThumbnailId()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxtnVolumeDatabase::GetThumbnailIdL()");

    TGlxtnThumbnailId thumbId( iNextThumbId );

    iNextThumbId++;

    GLX_LOG_INFO1("CGlxtnVolumeDatabase::InitializeThumbIdL iNextThumbId=%d", iNextThumbId);

    return thumbId;

    }

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

// StoreThumbnailIdL

// Add record to Ids table

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

//

void CGlxtnVolumeDatabase::StoreThumbnailIdL( const TGlxMediaId& aMediaId,

                                        const TGlxtnThumbnailId& aThumbId )

    {

    TRACER("void CGlxtnVolumeDatabase::StoreThumbnailIdL( const TGlxMediaId& aMediaId, const TGlxtnThumbnailId& aThumbId )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("StoreThumbnailIdL():- Media Id = %d",aMediaId.Value());

    GLX_LOG_INFO1("StoreThumbnailIdL():- aThumbId = %d",aThumbId.Value());

    RDbTable table;

    CleanupClosePushL(table);

    User::LeaveIfError( table.Open(

                        iDatabase, KGlxTableIds, RDbRowSet::EInsertOnly ) );

    table.InsertL();

    table.SetColL( KGlxColIdMediaId, aMediaId.Value() );

    table.SetColL( KGlxColIdThumbId, aThumbId.Value() );

    table.PutL();

    GLX_LOG_INFO2("StoreThumbnailIdL():- Added media id [%d] and thumb id  [%d] to Ids table. ", aMediaId.Value(), aThumbId.Value());

    CleanupStack::PopAndDestroy(&table);

    iObserver.HandleThumbnailIdStoredL();

    }

void CGlxtnVolumeDatabase::StoreItemsL( const TGlxtnThumbnailId& aThumbId, const CGlxtnFileInfo* aInfo )

	{

    __ASSERT_ALWAYS(aInfo, Panic(EGlxPanicNullPointer));

    GLX_LOG_ENTRY_EXIT("void CGlxtnVolumeDatabase::StoreItemsL()");

    GLX_LOG_INFO1("StoreItemsL():- ThumbId Id = %d",aThumbId.Value());

    RDbTable table;

    CleanupClosePushL(table);

    User::LeaveIfError(table.Open(iDatabase, KGlxTableItems, RDbRowSet::EUpdatable));

    User::LeaveIfError(table.SetIndex(KGlxIndexItems));

    TGlxtnThumbnailId thumbId( aThumbId );

    HBufC* sql = HBufC::NewLC( KGlxQueryItems().Length() + KGlxTIntMaxDigits);

    sql->Des().Format( KGlxQueryItems, thumbId.Value());

    RDbView view;

    CleanupClosePushL(view);

    User::LeaveIfError(view.Prepare(

                       iDatabase, *sql, RDbRowSet::EReadOnly ) );

    view.EvaluateAll();

    if (view.IsEmptyL())

        {

        GLX_LOG_INFO("StoreItemsL() - Add a new record");

        table.InsertL();

        table.SetColL( KGlxColItemUri, aInfo->FilePath() );

        table.SetColL( KGlxColItemId, thumbId.Value() );

        table.SetColL( KGlxColItemFileSize, aInfo->iFileSize );

        table.SetColL( KGlxColItemModTime, aInfo->iFileTime );

        table.PutL();

        }

    CleanupStack::PopAndDestroy(&view);

    CleanupStack::PopAndDestroy(sql);

    CleanupStack::PopAndDestroy(&table);

    }

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

// GetThumbnailL

// Look up thumbnail from Thumbnails table

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

//

void CGlxtnVolumeDatabase::GetThumbnailL( const TGlxtnThumbnailId& aThumbId,

                                            const TSize& aSize )

    {

    TRACER("void CGlxtnVolumeDatabase::GetThumbnailL( const TGlxtnThumbnailId& aThumbId, const TSize& aSize )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("GetThumbnailL():- ThumbId Id = %d",aThumbId.Value());

    GLX_LOG_INFO2("GetThumbnailL Width=%d, Height=%d", aSize.iWidth, aSize.iHeight);

    HBufC* sql = HBufC::NewLC( KGlxQueryThumbnail().Length()

                                + 3 * KGlxTIntMaxDigits);

    sql->Des().Format( KGlxQueryThumbnail,

                        aThumbId.Value(), aSize.iWidth, aSize.iHeight );

    EvaluateQueryL( *sql );

    iState = EStateGettingThumbnail;

    CleanupStack::PopAndDestroy(sql);

    }

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

// CheckAvailableL

// Check if thumbnail is in Thumbnails table

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

//

void CGlxtnVolumeDatabase::CheckAvailableL( const TGlxtnThumbnailId& aThumbId,

                                            const TSize& aSize )

    {

    TRACER("void CGlxtnVolumeDatabase::CheckAvailableL( const TGlxtnThumbnailId& aThumbId, const TSize& aSize )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("CheckAvailableL():- ThumbId = %d", aThumbId.Value());

    HBufC* sql = HBufC::NewLC( KGlxQueryAvailable().Length()

                                + 3 * KGlxTIntMaxDigits);

    sql->Des().Format( KGlxQueryAvailable,

                        aThumbId.Value(), aSize.iWidth, aSize.iHeight );

    EvaluateQueryL( *sql );

    iState = EStateCheckingAvailability;

    CleanupStack::PopAndDestroy(sql);

    }

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

// StoreThumbnailL

// Add record to Thumbnails table

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

//

void CGlxtnVolumeDatabase::StoreThumbnailL( const TGlxtnThumbnailId& aThumbId,

                                           const TSize& aSize,

                                           TGlxImageDataFormat aFormat,

                                           const TDesC8& aData )

    {

    TRACER("void CGlxtnVolumeDatabase::StoreThumbnailL( const TGlxtnThumbnailId& aThumbId, const TSize& aSize, TGlxImageDataFormat aFormat, const TDesC8& aData )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("StoreThumbnailL():- aThumbId = %d",aThumbId.Value());

    GLX_LOG_INFO2("StoreThumbnailL Width=%d, Height=%d", aSize.iWidth, aSize.iHeight);

    RDbTable table;

    CleanupClosePushL(table);

    User::LeaveIfError( table.Open(

                iDatabase, KGlxTableThumbnails, RDbRowSet::EInsertOnly ) );

    table.InsertL();

    table.SetColL( KGlxColThumbnailId, aThumbId.Value() );

    table.SetColL( KGlxColThumbnailWidth, aSize.iWidth );

    table.SetColL( KGlxColThumbnailHeight, aSize.iHeight );

    table.SetColL( KGlxColThumbnailFormat, aFormat );

    table.SetColL( KGlxColThumbnailData, aData );

    table.PutL();

    CleanupStack::PopAndDestroy(&table);

    iObserver.HandleThumbnailStored();

    }

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

// DeleteFromIdsL

// Delete from IDs table

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

//

void CGlxtnVolumeDatabase::DeleteIdL( const TGlxMediaId& aMediaId )

    {

    TRACER("void CGlxtnVolumeDatabase::DeleteIdL( const TGlxMediaId& aMediaId )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("DeleteIdL():- Media Id = %d",aMediaId.Value());

    HBufC* sql = HBufC::NewLC( KGlxDeleteId().Length() + KGlxTIntMaxDigits);

    sql->Des().Format( KGlxDeleteId, aMediaId.Value() );

    UpdateDataL( *sql );

    iState = EStateDeletingId;

    CleanupStack::PopAndDestroy(sql);

    }

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

// DeleteThumbnailsL

// Delete Thumbnails from Thumbnail table

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

//

void CGlxtnVolumeDatabase::DeleteThumbnailsL(

                                        const TGlxtnThumbnailId& aThumbId )

    {

    TRACER("void CGlxtnVolumeDatabase::DeleteThumbnailsL( const TGlxtnThumbnailId& aThumbId )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("DeleteThumbnailsL():- aThumbId = %d",aThumbId.Value());

    HBufC* sql = HBufC::NewLC(KGlxDeleteThumbnails().Length() + 

                                 KGlxTIntMaxDigits);

    sql->Des().Format( KGlxDeleteThumbnails, aThumbId.Value() );

    UpdateDataL( *sql );

    iState = EStateDeletingThumbnails;

    CleanupStack::PopAndDestroy(sql);

    }

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

// DeleteItemL

// Delete Item from Items table

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

//

void CGlxtnVolumeDatabase::DeleteItemL( const TGlxtnThumbnailId& aThumbId )

    {

    TRACER("void CGlxtnVolumeDatabase::DeleteItemL( const TGlxtnThumbnailId& aThumbId )");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    GLX_LOG_INFO1("DeleteItemL():- aThumbId = %d",aThumbId.Value());

    HBufC* sql = HBufC::NewLC( KGlxDeleteItem().Length() + KGlxTIntMaxDigits);

    sql->Des().Format( KGlxDeleteItem, aThumbId.Value() );

    UpdateDataL( *sql );

    iState = EStateDeletingItem;

    CleanupStack::PopAndDestroy(sql);

    }

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

// CleanupDatabaseL

// Clean from database entries that do not have a corresponding media file

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

//

void CGlxtnVolumeDatabase::CleanupDatabaseL()

    {

    TRACER("void CGlxtnVolumeDatabase::CleanupDatabaseL()");

    if ( EStateIdle != iState )

        {

        User::Leave(KErrNotReady);

        }

    User::LeaveIfError( iTable.Open(

                        iDatabase, KGlxTableItems, RDbRowSet::EUpdatable ) );

    iTable.BeginningL();

    SetActive();

    TRequestStatus* ts = &iStatus;

    User::RequestComplete(ts, KErrNone);

    iState = EStateCleaning;

    }

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

// CleanupRowL

// Test entry in one row in Items table to see if file is available. If it is

// not, delete this row and start process of deleting corresponding entries 

// from Ids table and Thumbnails table

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

//

void CGlxtnVolumeDatabase::CleanupRowL()

    {

    TRACER("void CGlxtnVolumeDatabase::CleanupRowL()");

    // Get filename

    iTable.GetL();

    TPtrC filename = iTable.ColDes(KGlxColItemUri);

    // check if file exists

    TTime time(0);

    TInt err = iFs.Modified(filename, time);

    GLX_LOG_INFO1("void CGlxtnVolumeDatabase::CleanupRowL() New Time = %Ld",time.Int64());

    TTime modifiedTime(0);

    modifiedTime = iTable.ColTime(KGlxColItemModTime);

    GLX_LOG_INFO1("void CGlxtnVolumeDatabase::CleanupRowL() modifiedTime (from thumb Db) = %Ld",modifiedTime.Int64());

    if(err == KErrNone && (modifiedTime.Int64() == time.Int64()))

        {

        GLX_LOG_INFO("void CGlxtnVolumeDatabase::CleanupRowL() DBmodTime and FileModTime Same");

        //yes, file exists and not modified, so complete to go to next row

        SetActive();

        TRequestStatus* ts = &iStatus;

        User::RequestComplete(ts, KErrNone);

        iState = EStateCleaning;

        }

    else

        {

        GLX_LOG_INFO("void CGlxtnVolumeDatabase::CleanupRowL() DBmodTime and FileModTime NOT Same");

        TUint thumbId = iTable.ColUint( KGlxColItemId );

        if (err != KErrNone)

	        {

	        GLX_LOG_INFO1("void CGlxtnVolumeDatabase::CleanupRowL() DBmodTime and FileModTime NOT Same But err = %d", err);

	        // Problem accessing file, so delete database entries

	        // First delete row in Items table

	        // Delete the row (entry in Items)

	        iTable.DeleteL();

	        }

        else

	        {

	        // file modified, so update the modified time in items table

	        iTable.UpdateL();

	        iTable.SetColL(KGlxColItemModTime, time);

	        iTable.PutL();

	        }

        // Now delete from Thumbnails

        HBufC* sql = HBufC::NewLC(KGlxDeleteThumbnails().Length() + 

	                                     KGlxTIntMaxDigits);

        sql->Des().Format( KGlxDeleteThumbnails, thumbId );

        UpdateDataL( *sql );

        iState = EStateCleaningDeletingThumbnails;

        CleanupStack::PopAndDestroy(sql);