/*

* Copyright (c) 2006 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 <eikenv.h>

#include <f32file.h>

#include <bautils.h>

#include <s32mem.h>

#include "ncdpurchasehistorydbimpl.h"

#include "ncdpurchasedownloadinfo.h"

#include "ncdpurchaseinstallinfo.h"

#include "ncdpurchasehistoryfilter.h"

#include "ncdnodefunctionids.h"

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "catalogsbigdes.h"

#include "catalogsconstants.h"

#include "catalogsutils.h"

#include "ncdutils.h"

#include "catalogsdebug.h"

// Create a purchases table.

// This column order is always used when inserting data or in queries.

// Column numbering is stored in CNcdPurchaseHistoryDb::PurchaseColumns.

_LIT( KSqlCreatePurchasesTable, "\

 CREATE TABLE purchases ( \

 purchase_id COUNTER,\

 event_id UNSIGNED INTEGER,\

 client_uid INTEGER,\

 namespace LONG VARCHAR,\

 entity_id LONG VARCHAR,\

 item_name LONG VARCHAR,\

 item_purpose UNSIGNED INTEGER,\

 catalog_name LONG VARCHAR,\

 download_info LONG VARBINARY,\

 purchase_option_id LONG VARCHAR,\

 purchase_option_name LONG VARCHAR,\

 purchase_option_price LONG VARCHAR,\

 final_price LONG VARCHAR,\

 payment_method_name LONG VARCHAR,\

 purchase_time BIGINT,\

 downloaded_files LONG VARBINARY,\

 file_install_infos LONG VARBINARY,\

 icon LONG VARBINARY,\

 downloadaccesspoint LONG VARCHAR,\

 description LONG VARCHAR,\

 version LONG VARCHAR,\

 server_uri LONG VARCHAR,\

 item_type INTEGER, \

 total_content_size INTEGER, \

 origin_node_id LONG VARCHAR, \

 last_operation_time BIGINT, \

 last_operation_error_code INTEGER, \

 has_icon INTEGER, \

 attributes LONG VARBINARY )" );

// Create a event counter table.

_LIT( KSqlCreateEventCounterTable,

    "CREATE TABLE event_counter_table ( event_counter UNSIGNED INTEGER )" );

// Event counter column number.

const TInt KEventCounterColumnNumber = 1;

// Select purchases.

_LIT( KSqlPurchasesStart,

     "SELECT purchase_id FROM purchases WHERE event_id >= " );

_LIT( KSqlPurchasesNamespace, " AND namespace = '" );

_LIT( KSqlPurchasesEntityId, " AND entity_id = '" );

_LIT( KSqlPurchasesClientUid, " AND ( client_uid = " );

_LIT( KSqlPurchasesOrClientUid, " OR client_uid = " );

_LIT( KSqlPurchasesEndClientUid, " )" );

_LIT( KSqlPurchasesEnd, "'" );

_LIT( KSqlPurchasesOrderNewestFirst, " ORDER BY event_id DESC" );

_LIT( KSqlPurchasesOrderOldestFirst, " ORDER BY event_id ASC" );

// Select purchase to be updated.

_LIT( KSqlPurchaseUpdateStart,

     "SELECT * FROM purchases WHERE client_uid = " );

_LIT( KSqlPurchasesUpdateNamespace, " AND namespace = '" );

_LIT( KSqlPurchasesUpdateEntityId, "' AND entity_id = '" );

_LIT( KSqlPurchasesUpdatePurchaseTime, "' AND purchase_time = " );

_LIT( KSqlPurchasesUpdateEnd, "" );

// Select purchase.

_LIT( KSqlPurchaseByPurchaseIdStart,

    "SELECT * FROM purchases WHERE purchase_id = " );

_LIT( KSqlPurchaseByPurchaseIdEnd, "" );

// Select all purchases.

_LIT( KSqlPurchasesAllNone, "SELECT * FROM purchases" );

// Delete specified purchase event.

_LIT( KSqlPurchasesDeleteStart,

    "DELETE FROM purchases WHERE purchase_id = " );

_LIT( KSqlPurchasesDeleteEnd,   "" );

// Select current event count.

_LIT( KSqlCurrentEventCount,

    "SELECT event_counter FROM event_counter_table" );

// Delete event count from event count table.

_LIT( KSqlEventCountDelete, "DELETE FROM event_counter_table" );

// "-2147483648"

const TInt KMaxLengthOfInt = 11;

// "-9223372036854775808"

const TInt KMaxLengthOfTint64 = 20;

static void AppendWithQuotesDuplicatedL(

    CCatalogsBigDes* aOutput,

    const TDesC& aInput )

    {

    _LIT( KQuote, "'" );

    if ( aOutput == NULL || &aInput == NULL )

        {

        return;

        }

    TPtrC in = aInput.Mid( 0 );

    while ( in.Length() > 0 )

        {

        TInt i = in.Locate( '\'' );

        if ( i == KErrNotFound )

            {

            // Quote not found, all done

            aOutput->AppendL( in );

            return;

            }

        aOutput->AppendL( in.Mid( 0, i + 1 ) );

        // Append extra quote

        aOutput->AppendL( KQuote );

        if ( i + 1 < in.Length() )

            {

            // Get end part of the input descriptor

            in.Set( in.Mid( i + 1 ) );

            }

        else

            {

            // End of the input descriptor reached

            return;

            }

        }

    }

static HBufC* ReadLongTextColumnL( RDbRowSet aView, TDbColNo aCol )

    {

    TInt length = aView.ColLength( aCol );

    if ( length == 0 )

        {

        return KNullDesC().Alloc();

        }

    RDbColReadStream readStream;

    readStream.OpenLC( aView, aCol );

    HBufC* result = HBufC::NewLC( length );

    TPtr resultPtr = result->Des();

    readStream.ReadL( resultPtr, length );

    readStream.Close();

    CleanupStack::Pop( result );

    CleanupStack::Pop(); //readStream

    return result;

    }

static void WriteLongTextColumnL(

    RDbRowSet aView,

    TDbColNo aCol,

    const TDesC& aValue )

    {

    RDbColWriteStream writeStream;

    writeStream.OpenLC( aView, aCol );

    if ( &aValue )

        {

        writeStream.WriteL( aValue );

        }

    else

        {

        writeStream.WriteL( KNullDesC );

        }

    writeStream.Close();

    CleanupStack::Pop( &writeStream );

    }

static HBufC8* ReadLongTextColumn8L( RDbRowSet aView, TDbColNo aCol )

    {

    TInt length = aView.ColLength( aCol );

    if ( length == 0 )

        {

        return KNullDesC8().Alloc();

        }

    RDbColReadStream readStream;

    readStream.OpenLC( aView, aCol );

    HBufC8* result = HBufC8::NewLC( length );

    TPtr8 resultPtr = result->Des();

    readStream.ReadL( resultPtr, length );

    readStream.Close();

    CleanupStack::Pop( result );

    CleanupStack::Pop(); //readStream

    return result;

    }

static void WriteLongTextColumn8L(

    RDbRowSet aView,

    TDbColNo aCol,

    const TDesC8& aValue )

    {

    RDbColWriteStream writeStream;

    writeStream.OpenLC( aView, aCol );

    if ( &aValue )

        {

        writeStream.WriteL( aValue );

        }

    else

        {

        writeStream.WriteL( KNullDesC8 );

        }

    writeStream.Close();

    CleanupStack::Pop( &writeStream );

    }

CNcdPurchaseHistoryDb* CNcdPurchaseHistoryDb::NewL(

    const TDesC& aDbFilename )

    {

    CNcdPurchaseHistoryDb* self = NewLC( aDbFilename );

    CleanupStack::Pop( self );

    return self;

    }

CNcdPurchaseHistoryDb* CNcdPurchaseHistoryDb::NewLC(

    const TDesC& aDbFilename )

    {

    CNcdPurchaseHistoryDb* self =

        new ( ELeave ) CNcdPurchaseHistoryDb();

    CleanupClosePushL( *self );

    self->ConstructL( aDbFilename );

    return self;    

    }

CNcdPurchaseHistoryDb::~CNcdPurchaseHistoryDb()

    {

    iDatabase.Close();

    delete iDbFilename;

    iFs.Close();

    }

void CNcdPurchaseHistoryDb::ReceiveMessage(

    MCatalogsBaseMessage* aMessage,

    TInt aFunctionNumber )

    {

    DLTRACEIN((""));

    DASSERT( aMessage );

    // Now, we can be sure that rest of the time iMessage exists.

    // This member variable is set for the CounterPartLost function.

    iMessage = aMessage;

    TInt trapError( KErrNone );

    switch( aFunctionNumber )

        {

        case NcdNodeFunctionIds::ENcdPurchaseHistorySavePurchase:

            DLTRACE(("Insert purchase event"));

            TRAP( trapError, SavePurchaseRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdPurchaseHistorySavePurchaseWithOldIcon:

            DLTRACE(("Insert purchase event with old icon"));

            TRAP( trapError, SavePurchaseRequestL( *aMessage, EFalse ) );

            break;

        case NcdNodeFunctionIds::ENcdPurchaseHistoryRemovePurchase:

            DLTRACE(("Remove purchase"));

            TRAP( trapError, RemovePurchaseRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdPurchaseHistoryGetPurchaseIds:

            DLTRACE(("Get purchase IDs"));

            TRAP( trapError, GetPurchaseIdsRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdPurchaseHistoryGetPurchase:

            DLTRACE(("Get purchase"));

            TRAP( trapError, GetPurchaseRequestL( *aMessage, ETrue ) );

            break;

        case NcdNodeFunctionIds::ENcdPurchaseHistoryGetPurchaseNoIcon:

            DLTRACE(("Get purchase"));

            TRAP( trapError, GetPurchaseRequestL( *aMessage, EFalse ) );

            break;

        case NcdNodeFunctionIds::ENcdPurchaseHistoryEventCount:

            DLTRACE(("Get purchase event count"));

            TRAP( trapError, EventCountRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdRelease:

            DLTRACE(("Release purchase history"));

            ReleaseRequest( *aMessage );

            break;

        default:

            break;

        }

    if ( trapError != KErrNone )

        {

        // Because something went wrong the complete has not been

        // yet called for the message.

        // So, inform the client about the error.

        DLTRACE(("ERROR, Complete and release %d", trapError));

        aMessage->CompleteAndRelease( trapError );

        }

    // Because the message should not be used after this, set it NULL.

    // So, CounterPartLost function will know that no messages are

    // waiting the response at the moment.

    iMessage = NULL;        

    DLTRACEOUT((""));

    }

void CNcdPurchaseHistoryDb::CounterPartLost(

    const MCatalogsSession& aSession )

    {

    // This function may be called whenever -- when the message is waiting

    // response or when the message does not exist.

    // iMessage may be NULL here, because in the end of the

    // ReceiveMessage it is set to NULL. The life time of the message

    // ends shortly after CompleteAndRelease is called.

    if ( iMessage != NULL )

        {

        iMessage->CounterPartLost( aSession );

        }    

    }

void CNcdPurchaseHistoryDb::ConstructL( const TDesC& aDbFilename )

    {

    if ( aDbFilename == KNullDesC )

        {

        User::Leave( KErrBadName );

        }

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

    // Set database name.

    iDbFilename = aDbFilename.AllocL();

    BaflUtils::EnsurePathExistsL( iFs, *iDbFilename );

    TInt err = iDatabase.Open( iFs, *iDbFilename );

    if ( err == KErrNotFound || err == KErrCorrupt )

        {

        // Delete existing database file. This should happen only if

        // database file is corrupted. Ignoring errors as database file

        // may not be present.

        BaflUtils::DeleteFile( iFs, *iDbFilename );

        // See if the database can be found from another drive

        TFindFile finder( iFs );

        CDir* dir = NULL;

        err = finder.FindWildByDir( *iDbFilename, KNullDesC, dir );

        if ( err == KErrNone )

            {

            // Move old database to correct folder and try to open it

            CleanupStack::PushL( dir );

            CFileMan* fileman = CFileMan::NewL( iFs );

            CleanupStack::PushL( fileman );

            User::LeaveIfError( fileman->Move( finder.File(),

                                               *iDbFilename,

                                               CFileMan::EOverWrite ) );

            CleanupStack::PopAndDestroy( fileman );

            CleanupStack::PopAndDestroy( dir );

            // NOTE: Error ignored. If folder contains files,

            // it will not be deleted.

            iFs.RmDir( finder.File() );

            err = iDatabase.Open( iFs, *iDbFilename );

            if ( err == KErrNotFound || err == KErrCorrupt )

                {

                BaflUtils::DeleteFile( iFs, *iDbFilename );

                // Trying to create the database

                User::LeaveIfError( iDatabase.Create( iFs, *iDbFilename ) );

                User::LeaveIfError(

                    iDatabase.Execute( KSqlCreatePurchasesTable ) );

                User::LeaveIfError(

                    iDatabase.Execute( KSqlCreateEventCounterTable ) );

                }

            else if ( err != KErrNone )

                {

                User::Leave( err );

                }

            }

        else

            {

            // Trying to create the database

            User::LeaveIfError( iDatabase.Create( iFs, *iDbFilename ) );

            User::LeaveIfError(

                iDatabase.Execute( KSqlCreatePurchasesTable ) );

            User::LeaveIfError(

                iDatabase.Execute( KSqlCreateEventCounterTable ) );

            }

        }

    else if ( err != KErrNone )

        {

        User::Leave( err );

        }

    if ( iDatabase.IsDamaged() )

        {

        // Database has been partly damaged. Try to recover it.

        iDatabase.Recover();

        }

    }

CNcdPurchaseHistoryDb::CNcdPurchaseHistoryDb()

    : CCatalogsCommunicable()

    {    

    }

void CNcdPurchaseHistoryDb::SavePurchaseL(

    CNcdPurchaseDetails& aPurchase, 

    TBool aSaveIcon )

    {

    DLTRACEIN((""));

    // Ensure that purchase history handling bugs in PCD! don't crash the client :)

    ValidatePurchaseDetailsL( aPurchase );

    CCatalogsBigDes* sqlStatement = CCatalogsBigDes::NewLC();

    sqlStatement->AppendL( KSqlPurchaseUpdateStart );

    TBuf<KMaxLengthOfInt> intBuf;

    intBuf.Num( aPurchase.ClientUid().iUid );

    sqlStatement->AppendL( intBuf );

    sqlStatement->AppendL( KSqlPurchasesUpdateNamespace );

    AppendWithQuotesDuplicatedL( sqlStatement, aPurchase.Namespace() );

    sqlStatement->AppendL( KSqlPurchasesUpdateEntityId );

    AppendWithQuotesDuplicatedL( sqlStatement, aPurchase.EntityId() );

    sqlStatement->AppendL( KSqlPurchasesUpdatePurchaseTime );

    TBuf<KMaxLengthOfTint64> bigIntBuf;

    bigIntBuf.Num( aPurchase.PurchaseTime().Int64() );

    sqlStatement->AppendL( bigIntBuf );

    sqlStatement->AppendL( KSqlPurchasesUpdateEnd );

    TUint newEventCount = EventCountL() + 1;

    RDbView view;

    CleanupClosePushL( view );

    HBufC* sqlStatementBuf = sqlStatement->DesLC();

    User::LeaveIfError(

        view.Prepare( iDatabase, TDbQuery( *sqlStatementBuf ) ) );

    CleanupStack::PopAndDestroy( sqlStatementBuf );

    User::LeaveIfError( view.EvaluateAll() );

    view.FirstL();

    if ( view.AtRow() )

        {

        UpdatePurchaseL( view, aPurchase, newEventCount, aSaveIcon );

        }

    else

        {

        view.Close();

        NewPurchaseL( aPurchase, newEventCount );

        }

    // Set new purchase count

    SetEventCountL( newEventCount );

    CleanupStack::PopAndDestroy( &view );

    CleanupStack::PopAndDestroy( sqlStatement );

    DLTRACEOUT((""));

    }

void CNcdPurchaseHistoryDb::RemovePurchaseL( TUint aPurchaseId )

    {

    if ( ! PurchaseExistsL( aPurchaseId ) )

        {

        // Purchase didn't exist in the database.

        User::Leave( KErrNotFound );

        }

    TInt maxLength = KSqlPurchasesDeleteStart().Length() + KMaxLengthOfInt

        + KSqlPurchasesDeleteEnd().Length();

    HBufC* sqlStatement = HBufC::NewLC( maxLength );

    TPtr statementPtr( sqlStatement->Des() );

    statementPtr.Copy( KSqlPurchasesDeleteStart );

    statementPtr.AppendNum( aPurchaseId );

    statementPtr.Append( KSqlPurchasesDeleteEnd );

    // Remove purchase from the database using event ID.

    User::LeaveIfError( iDatabase.Execute( *sqlStatement ) );

    // Remove all unnecessary data from the database.

    User::LeaveIfError( iDatabase.Compact() );

    CleanupStack::PopAndDestroy( sqlStatement );

    }

RArray<TUint> CNcdPurchaseHistoryDb::PurchaseIdsL(

    const CNcdPurchaseHistoryFilter& aFilter,

    const TSortingOrder aSortingOrder )

    {