/*

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

*

*/

#include <hash.h>

#include <xml/matchdata.h>

#include "cmsqlmainfactory.h"

#include "mcmsqlmain.h"

#include "cmsqlbaseitem.h"

#include "cmsqlgenericitem.h"

#include "cmsqlaudioitem.h"

#include "cmsqlimageitem.h"

#include "cmsqlvideoitem.h"

#include "cmsqlpropertyitem.h"

#include "cmsqlresolutionpropertyitem.h"

#include "cdssyncimplsql.h"

#include "cdssyncsqlao.h"

#include "msdebug.h"

// Constants

_LIT8( KXmlMimeType, "text/xml" );

_LIT8( KSymbian, "Symbian");

_LIT8( KSemicolon, ";");

_LIT8( KXmlCdsDefaultNamespace, 

       "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/");

_LIT8( KXmlCdsDcNamespace,"http://purl.org/dc/elements/1.1/");

_LIT8( KXmlCdsUpnpNamespace,"urn:schemas-upnp-org:metadata-1-0/upnp/");

_LIT8( KAlbum,      "album");

_LIT8( KArtist,     "artist");

_LIT8( KClass,      "class");

_LIT8( KDescription,"description");

_LIT8( KDate,       "date");

_LIT8( KGenre,      "genre");

_LIT8( KId,         "id");

_LIT8( KItem,       "item");

_LIT8( KRes,        "res");

_LIT8( KTitle,      "title");

_LIT8( KAlbumArtUri, "albumArtURI");

_LIT8( KBitrate,        "bitrate");

_LIT8( KDuration,       "duration");

_LIT8( KProtocolInfo,   "protocolInfo");

_LIT8( KResolution,     "resolution");

_LIT8( KSize,           "size");

_LIT8( KAudioItem,      "audioItem");

_LIT8( KImageItem,      "imageItem");

_LIT8( KVideoItem,      "videoItem");

_LIT8( KAudioBroadCastItem, "audioItem.audioBroadcast");

_LIT8( KVideoBroadCastItem, "videoItem.videoBroadcast");

_LIT8( KDlnaPn,         "DLNA.ORG_PN=" );

const TInt KAlbumIndex =        0;

const TInt KArtistIndex =       1;

const TInt KClassIndex =        2;

const TInt KGenreIndex =        3;

const TInt KResolutionIndex =   4;

const TInt KUpnpProfileIndex =  5;

const TCmMetadataField KMetadataTypes[] = 

    {

    ECmAlbum, ECmArtist, ECmUpnpClass, ECmGenre, ECmResolution, ECmProfileId

    };

const TInt KMetadataTypeCount = 6;

const TInt KParseChunkSize = 100 * KKilo; // 100 kB

const TInt KCdsSyncMaxBufLength = 512;

const TInt KCdsSyncPriority = CActive::EPriorityIdle; 

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

// CItemResource::NewLC()

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

CItemResource* CItemResource::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CItemResource::~CItemResource()

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

CItemResource::~CItemResource() // destruct - virtual, so no export

    {

    delete iDuration;

    delete iBitrate;

    delete iSize;    

    delete iResolution;    

    delete iProtocol;    

    delete iUri;    

    }

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

// CItemResource::CItemResource()

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

CItemResource::CItemResource()

    {

    }

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

// CItemResource::ConstructL()

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

void CItemResource::ConstructL()

    {

    }

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

// CCdsSyncImpl::NewL()

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

CCdsSyncImpl* CCdsSyncImpl::NewL()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::NewL"));

    CCdsSyncImpl* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCdsSyncImpl::NewLC()

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

CCdsSyncImpl* CCdsSyncImpl::NewLC()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::NewLC"));

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCdsSyncImpl::~CCdsSyncImpl()

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

CCdsSyncImpl::~CCdsSyncImpl() 

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::~CCdsSyncImpl"));

    if ( IsActive() )

        {

        Cancel();

        }

    // iCurrentContent is owned and needs to be deleted here before it is set

    // to NULL at CleanItemData-method.

    if ( iCurrentContent )

        {

        delete iCurrentContent;    

        }    

    CleanItemData();

    iState = ECdsSyncIdle;

    if ( iBackground )

        {

        delete iBackground;    

        }

    if ( iParser )

        {

        delete iParser;    

        }

    if ( iCurrentDocument )

        {

        delete iCurrentDocument;    

        }

    iItemsInDb.ResetAndDestroy();

    iItemsToAdd.ResetAndDestroy();

    for ( TInt i = 0; i < iNames.Count(); i++ )

        {

        iNames[ i ]->ResetAndDestroy();

        }

    iNames.ResetAndDestroy();

    iFs.Close();

    if ( iSqlAo )

        {

        delete iSqlAo;    

        }

    if ( iMetadataDb )

        {

        iMetadataDb->Close();    

        }    

    }

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

// CCdsSyncImpl::CCdsSyncImpl()

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

CCdsSyncImpl::CCdsSyncImpl() : 

    CActive( EPriorityStandard ),

    iHashOrder( CCmSqlBaseItem::CompareByHash ),

    iNameOrder( CCmSqlPropertyItem::CompareItemsByName )

    {

    CActiveScheduler::Add( this );

    }

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

// CCdsSyncImpl::ConstructL() 

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

void CCdsSyncImpl::ConstructL() 

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::ConstructL"));

    CMatchData *matchData = CMatchData::NewL();

    CleanupStack::PushL( matchData );

    matchData->SetMimeTypeL( KXmlMimeType );

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

    matchData->SetVariantL( KSymbian );

    iParser  = CParser::NewL( *matchData, *this );

    CleanupStack::PopAndDestroy( matchData );

    iBackground = CIdle::NewL( KCdsSyncPriority );

    iMetadataDb = CCmSqlMainFactory::NewCmSqlMainL( iFs );

    }

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

// CCdsSyncImpl::ResetL()

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

void CCdsSyncImpl::ResetL() 

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::ResetL"));

    LOG(_L("[Cds Sync]\t cleaning objects.."));

    iBackground->Cancel();

    if( iSqlAo && iSqlAo->IsActive() && iMetadataDb )

        {

        iMetadataDb->CancelAsyncOperation();

        }

    delete iSqlAo; 

    iSqlAo = NULL;

    iItemsInDb.ResetAndDestroy();

    iItemsToAdd.ResetAndDestroy();

    for ( TInt i = 0; i < iNames.Count(); i++ )

        {

        iNames[ i ]->ResetAndDestroy();

        }

    iNames.ResetAndDestroy();

    CleanItemData();           

    }

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

// CCdsSyncImpl::InitL()

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

void CCdsSyncImpl::InitL( RPointerArray<HBufC8>& aSourceDataArray,

                                   const TInt& aDeviceId, 

                                   MCdsSyncObserver& aObserver,

                                   TInt aAddGranularity )

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::InitL"));

    iSearchIndex = 0;

    ResetL();

    LOG(_L("[Cds Sync]\t initializing variables.."));

    iObserver = &aObserver;

    iSourceDataArray = &aSourceDataArray;

    iSourceDataComplete = EFalse;

    iState = ECdsSyncInitializing;

    iUnchangedItemCount = 0;

    LOG(_L("[Cds Sync]\t creating ao.."));

    iSqlAo = CCdsSyncSqlAo::NewL( 

        *iMetadataDb, *this, iItemsToAdd, 

        iItemsInDb, aAddGranularity );

    LOG(_L("[Cds Sync]\t Requesting existing metadata.."));

    iMetadataDb->SetMsId( aDeviceId );

    iMetadataDb->GetItemsL( iItemsInDb, iSqlAo->iStatus );

    iSqlAo->iState = CCdsSyncSqlAo::ECdsSyncSqlAoInitializing;

    iSqlAo->Activate();

    LOG(_L("[Cds Sync]\t done."));

    }

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

// CCdsSyncImpl::RunL()

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

void CCdsSyncImpl::RunL()

    {

    TRACE( Print( _L("[Cds Sync]\t CCdsSyncImpl::RunL,\

    iStatus %d iState %d"), iStatus.Int(), (TInt)iState ) );

    switch ( iState )

        {

        case ECdsSyncInitializing:

            {

            TInt namesCount = iNames.Count();

            TRACE( Print( 

                _L("[Cds Sync]\t iNames array size is %d out of %d"),

                namesCount, 

                KMetadataTypeCount ) );

            if ( namesCount == KMetadataTypeCount )

                {

                // all arrays ready, sort them

                iItemsInDb.Sort( iHashOrder );

                for ( TInt i = 0; i < KMetadataTypeCount; i++ )

                    {

                    iNames[ i ]->Sort( iNameOrder );

                    }

                iState = ECdsSyncReadyToParse;

                iSqlAo->iState = CCdsSyncSqlAo::ECdsSyncSqlAoIdle;

                NotifySourceDataAddedL();

                }

            else 

                {

                RPointerArray<CCmSqlPropertyItem>* nameArray =

                    new (ELeave) RPointerArray<CCmSqlPropertyItem>();

                iMetadataDb->GetPropertyValuesL( 

                    *nameArray,

                    iSqlAo->iStatus,

                    KMetadataTypes[namesCount]

                );

                iSqlAo->Activate();

                iNames.Append( nameArray );

                }

            break;

            }

        default: 

            {

            TRACE( Print( _L("[Cds Sync]\t RunL iState is \

            not ECdsSyncInitializing" ) ));

            break;

            }

        }

    }

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

// CCdsSyncImpl::DoCancel()

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

void CCdsSyncImpl::DoCancel()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::DoCancel"));

    }

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

// CCdsSyncImpl::NotifySourceDataAddedL()

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

void CCdsSyncImpl::NotifySourceDataAddedL( 

    TBool aSourceDataComplete ) 

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::NotifySourceDataAdded"));

    if ( aSourceDataComplete )

        {

        iSourceDataComplete = ETrue;

        }

    if ( iState == ECdsSyncReadyToParse ) 

        {

        if ( iSourceDataArray->Count() )

            {

            iCurrentDocument = ( *iSourceDataArray )[ 0 ];

            iSourceDataArray->Remove( 0 );

            iChunkIndex = 0;

            iParser->ParseBeginL();

            iBackground->Start( 

                TCallBack( CCdsSyncImpl::BackgroundParseL, this) );

            iState = ECdsSyncParsing;

            }

        else if ( iSourceDataComplete ) 

            {

            TRACE( Print( _L

            ("[Cds Sync]\t parsing complete, %d items to add"), 

                iItemsToAdd.Count() ));

            TRACE( Print( _L("[Cds Sync]\t and %d items to remove"), 

                iItemsInDb.Count() ));

            iState = ECdsSyncIdle;

            RemoveUnchangedItems( );

            iSqlAo->NotifyItemsAddedL( ETrue );

            }

        }

    }

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

// CCdsSyncImpl::ProgressL()

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

void CCdsSyncImpl::ProgressL( TInt aItemCount )

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::ProgressL"));

    iObserver->ProgressL( aItemCount );

    }

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

// CCdsSyncImpl::ChunkCount()

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

TInt CCdsSyncImpl::ChunkCount()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::ChunkCount"));

    TInt chunkCount = iSourceDataArray->Count();

    if ( iCurrentDocument )

        {

        chunkCount++;

        }

    return chunkCount;

    }

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

// Increment successfully processed number 

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

//

TInt CCdsSyncImpl::ProcessedItemCount()

	{

	return iProcessedItems;

	}

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

// Increment chuch number ( search index )

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

//

void CCdsSyncImpl::SetSearchIndex( const TInt aSearchIndex )

    {

    iSearchIndex = aSearchIndex;

    } 

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

// CCdsSyncImpl::ChunkCompleteL()

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

void CCdsSyncImpl::ChunkCompleteL()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::ChunkCompleteL"));

    iObserver->ChunkCompleteL();

    iProcessedItems = 0;

    }

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

// CCdsSyncImpl::OperationsCompleteL()

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

#ifdef _DEBUG

void CCdsSyncImpl::OperationsCompleteL( TInt aErrCode ) 

#else // _DEBUG

void CCdsSyncImpl::OperationsCompleteL( TInt /*aErrCode*/ ) 

#endif // _DEBUG

    {

    TRACE( Print( _L

    ("[Cds Sync]\t CCdsSyncImpl::OperationsCompleteL (err %d)"), 

        aErrCode ));

    if ( iState == ECdsSyncInitializing )

        {

        RunL();

        }

    else 

        {

        iObserver->SyncCompleteL();    

        iProcessedItems = 0;  

        }

    }

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

// CCdsSyncImpl::BackgroundParseL()

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

TInt CCdsSyncImpl::BackgroundParseL( TAny* aCdsSync )

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::BackgroundParseL"));

    return ((CCdsSyncImpl*)aCdsSync)->DoBackgroundParseL();

    }

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

// CCdsSyncImpl::DoBackgroundParseL()

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

TInt CCdsSyncImpl::DoBackgroundParseL()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncImpl::DoBackgroundParseL"));

    if ( iCurrentDocument ) 

        {

    #ifdef _DEBUG

        iHashTime = 0;

        TTime timeBefore;

        timeBefore.HomeTime();

    #endif

        TBool parseMore = 

            ( iCurrentDocument->Length() - iChunkIndex ) > KParseChunkSize;

        TPtrC8 parseChunk = 

            parseMore ?

            iCurrentDocument->Mid( iChunkIndex, KParseChunkSize ) :

            iCurrentDocument->Mid( iChunkIndex );

        iUnchangedItemCount = 0;

        // in case of leave that is caused by out of memory

        TRAPD( error, iParser->ParseL( parseChunk ) );

    	if ( error != KErrNone )

        	{