/*

* 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:      Metadata Harvester server's metadata collector component

*

*/

// INCLUDE FILES

#include <upnpstring.h>

#include <upnpavcontrolpoint.h>

#include <upnperrors.h> // HTTP error codes

#include <hash.h>

#include "cmsearchresponsehash.h"

#include "mdhmetadatacollector.h"

#include "msdebug.h"

#include "mdhmediaservercontainer.h"

// CONSTANTS

const TInt KSearchTimeout = 120000000;

const TInt KMaxSearchRetries = 3;

const TInt KSearchCountLimit = 1;

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

// Two-phased constructor

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

CCmMdhMetadataCollector* CCmMdhMetadataCollector::NewL( 

        CCmMdhMediaserverContainer& aMediaserverContainer,

        CUpnpAVControlPoint& aControlPoint,

        TInt aSearchChunkSize, 

        TInt aAddGranularity )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::NewL"));

    CCmMdhMetadataCollector* self = new (ELeave) CCmMdhMetadataCollector ( 

        aMediaserverContainer, aControlPoint, 

        aSearchChunkSize, aAddGranularity );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

CCmMdhMetadataCollector::CCmMdhMetadataCollector( 

        CCmMdhMediaserverContainer& aMediaserverContainer,

        CUpnpAVControlPoint& aAvControlPoint,

        TInt aSearchChunkSize,

        TInt aAddGranularity ) :

    iMediaserverContainer( aMediaserverContainer ), 

    iAvControlPoint ( aAvControlPoint ),

    iSearchChunkSize( aSearchChunkSize ), 

    iAddGranularity( aAddGranularity )

    {

    iCdsSync = NULL;

    iXmlToParse = NULL;

    iUuid = NULL;

    iTimer = NULL;

    iSearchRetryCount = 0;

    iSessionId = 0;

    iTempStartIndex = -1;

    }

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

// 2nd phase constructor

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

void CCmMdhMetadataCollector::ConstructL()

    {

    iHashGenerator = CSHA1::NewL();

    }

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

// Destructor

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

CCmMdhMetadataCollector::~CCmMdhMetadataCollector()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::\

                             ~CCmMdhMetadataCollector"));

    delete iCdsSync;

    delete iXmlToParse;

    delete iTimer;

    iSourceDataArray.ResetAndDestroy();

    delete iHashGenerator;

    delete iUuid;

    iHashValues.ResetAndDestroy();  

    }

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

// Harvests a media server

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

void CCmMdhMetadataCollector::DoHarvestMediaserverL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::DoHarvestMediaserver"));

    // iUuid must be set before calling this method.

    if ( !iUuid ) 

        {

        User::Leave( KErrNotReady );

        }

#ifdef _DEBUG

    HBufC* uuid = UpnpString::ToUnicodeL( *iUuid );

    TRACE( Print(_L("[CmMdh Server]\t search request, uuid: %S, \

        searchIndex %d, chunk size %d"), 

        uuid, iSearchIndex, iSearchChunkSize ));

    delete uuid;

    uuid = NULL;

    iDebugTime.HomeTime();

#endif

    TInt err = iAvControlPoint.CdsSearchActionL( *iUuid,

                                      KRootContainerId,

                                      KSearchCriteria,

                                      KMdhSearchFilter,

                                      iSearchIndex,

                                      iSearchChunkSize,

                                      KSortCriteria );

    TRACE( Print( _L("[CmMdh Server]\t search request returned %d"), err));

    if ( err > 0 ) 

        {

        iSessionId = err;

        }

    LOG( _L("[CmMdh Server]\t creating CPeriodic \

        timer for search timeout..." ) );

    iTimer = CPeriodic::NewL(EPriorityHigh);

    iTimer->Start(KSearchTimeout, 0, TCallBack(TimeoutTimerCompletedL, this));

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::\

        DoHarvestMediaserver end"));

    }  

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

// Harvests a media server

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

void CCmMdhMetadataCollector::HarvestMediaserverL( TDesC8& aUuid )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::HarvestMediaserver"));

    iSearchIndex = 0;

    delete iUuid; iUuid = NULL;

    iUuid = aUuid.AllocL();

    iItemsToParse = 0;

#ifdef _DEBUG

    HBufC* uuid = UpnpString::ToUnicodeL( aUuid );

    TRACE( Print( _L("[CmMdh Server]\t starting \

            to harvest, uuid: %S"), uuid));

    delete uuid;

#endif

    if ( !iCdsSync )

        {

        iCdsSync = CCdsSync::NewL();

        }    

    iResultIncomplete = ETrue;

    iCanceled = EFalse;

    iSearchRetryCount = 0;

    iSourceDataArray.ResetAndDestroy();

    iHashValues.ResetAndDestroy();

    iMediaServerId = iMediaserverContainer.IdForMediaServerL( aUuid );

    iMediaserverContainer.HashValuesForMediaServerL( iMediaServerId, iHashValues );

    iCdsSync->InitL( iSourceDataArray,

                     iMediaServerId, 

                     *this,

                     iAddGranularity );

    DoHarvestMediaserverL();

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::\

        HarvestMediaserver end"));

    }

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

// Cancels harvest

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

void CCmMdhMetadataCollector::CancelHarvest()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::CancelHarvestL"));

    if( iCdsSync )

        {

        // cancel parsing and mde operations

        TRAP_IGNORE( iCdsSync->ResetL() ); 

        }

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer; iTimer = NULL;

        }

    // Remove old hash values

    TRAP_IGNORE(iMediaserverContainer.DeleteOldHashValuesL(

                                              iMediaServerId,

                                              iTempStartIndex ) );

    iTempStartIndex = -1;

    iSourceDataArray.ResetAndDestroy();

    iCanceled = ETrue;

    }

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

// Static timer callback function

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

TInt CCmMdhMetadataCollector::TimeoutTimerCompletedL(TAny* aInstance)

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::\

                             TimeoutTimerCompletedL"));

    return static_cast<CCmMdhMetadataCollector*>

        ( aInstance )->DoTimeoutTimerCompletedL();

    }

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

// Timer callback function

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

TInt CCmMdhMetadataCollector::DoTimeoutTimerCompletedL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::\

                             DoTimeoutTimerCompletedL"));

    delete iTimer; iTimer = NULL;

    iMediaserverContainer.HarvestCompleteL( KErrTimedOut );

    return KErrNone;

   }

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

// Observer callback for Content Directory Search function.

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

void CCmMdhMetadataCollector::CdsSearchResponse( TInt aSessionId, 

                                                 TInt aErr, 

                                                 const TDesC8& aResult, 

                                                 TInt aReturned, 

                                                 TInt aMatches )

    { 

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::CdsSearchResponse")); 

    TRACE( Print( _L("[CmMdh Server]\t session %d err %d \

        returned:%d matches %d"), 

        aSessionId, aErr, aReturned, aMatches) );

    TRAPD( err, HandleSearchResponseL( aSessionId, 

                                       aErr,

                                       aResult, 

                                       aReturned, 

                                       aMatches ) );

    if ( err ) 

        {

        TRACE( Print( _L("[CmMdh Server]\t HandleSearchResponse leaved with \

                          error %d"), err ) );

        }

    }

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

// Handles search response.

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

void CCmMdhMetadataCollector::HandleSearchResponseL( TInt aSessionId, 

                                                     TInt aErr, 

                                                     const TDesC8& aResult, 

                                                     TInt aReturned, 

                                                     TInt aMatches )

    { 

    LOG(_L(

        "[CmMdh Server]\t CCmMdhMetadataCollector::HandleSearchResponseL") );

    if ( iSessionId != aSessionId ) 

        {

        LOG( _L("[CmMdh Server]\t session id mismatch, returning.."));

        return;

        }

    else 

        {

        iSessionId = 0;

        }

#ifdef _DEBUG

    TTime tempTime;

    tempTime.HomeTime();

    TRACE( Print( _L("[CmMdh Server]\t search request took %ld microsec"), 

        tempTime.MicroSecondsFrom( iDebugTime ).Int64() ));

#endif

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        iTimer = NULL;

        }

    if ( iXmlToParse )

        {

        LOG( _L("[CmMdh Server]\t deleting old xml buffer.."));

        delete iXmlToParse;

        iXmlToParse = NULL;

        }

    if ( iCanceled )

        {

        LOG(_L("[CmMdh Server]\t harvest canceled, returning..")); 

        return;

        }

    if ( aErr && aErr != EHttpOk )

        {

        if ( aErr == EActionFailed && 

             iSearchRetryCount++ < KMaxSearchRetries ) 

            // 501 = EActionFailed, retrying 

            {

            TRACE( Print( _L("[CmMdh Server]\t retrying search, retry #%d"), 

                    iSearchRetryCount ));

            DoHarvestMediaserverL();

            }

        else 

            {

            LOG(_L("[CmMdh Server]\t Unrecoverable response \

                error, aborting.. ")); 

            delete iTimer; iTimer = NULL;    

            iMediaserverContainer.HarvestCompleteL( aErr );

            }

        return;

        }

    // Check the hash value (or should it be checked in the cdssync side...?)

    iHashGenerator->Reset();

    iHashGenerator->Update( aResult );

    TPtrC8 hashValue = iHashGenerator->Final();

    TBool foundMatch( EFalse );

    for ( TInt index(0); index < iHashValues.Count() && !foundMatch; index++ )

        {

        CCmSearchResponseHash* hashInstance = iHashValues[index];

        if ( hashInstance->StartIndex() == iSearchIndex 

             && hashInstance->ItemCount() == aReturned 

             && hashInstance->Hash() == hashValue )

                {

                LOG( _L("[CmMdh Server]\t FOUND HASH MATCH!!"));

                foundMatch = ETrue;

                // Update last matching search chuck to cds sync component

                iCdsSync->SetSearchIndex( iSearchIndex + aReturned );

                }

        }

    if ( !foundMatch )

        {

        // Before updating hash values, remove all changed hash values

        iMediaserverContainer.DeleteOldHashValuesL( iMediaServerId, 

                                                  iSearchIndex );

        iMediaserverContainer.AddHashValueForResponseL( iMediaServerId,

                                                        iSearchIndex,

                                                        aReturned,

                                                        hashValue );

        // Save information about hash value in database in order to delete it

        iTempStartIndex = iSearchIndex;

        TRACE( Print( _L("[CmMdh Server]\t HASH= Index:%d\tCount:%d\tHash:%S"),

            iSearchIndex, aReturned, &hashValue ));    

        iSearchIndex += aReturned;

        iResultIncomplete = iSearchIndex < aMatches;

        iSearchRetryCount = 0;

        iItemsToParse = aReturned;        

        HBufC8* xmlToParse = aResult.AllocL();

        iSourceDataArray.Append( xmlToParse );

        TRACE( Print( _L("[CmMdh Server]\t source data array has %d items"), 

            iSourceDataArray.Count() ));

        iCdsSync->NotifySourceDataAddedL( !iResultIncomplete );

        if ( iResultIncomplete && iCdsSync->ChunkCount() < KSearchCountLimit )

            {

            DoHarvestMediaserverL();

            } 

        }

    else    // Found matching parsed search response

        {

        iSearchIndex += aReturned;

        iResultIncomplete = iSearchIndex < aMatches;

        iSearchRetryCount = 0;

        iItemsToParse = aReturned;

        // Send progress

        iMediaserverContainer.SendProgressInfo( aReturned );

        if ( iResultIncomplete && iCdsSync->ChunkCount() < KSearchCountLimit )

            {

            DoHarvestMediaserverL();

            }

        else

            {

            iMediaserverContainer.HarvestCompleteL( KErrNone );

            }             

        }

    }

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

// Sends progress data

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

void CCmMdhMetadataCollector::ProgressL( TInt aItemCount ) 

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::ProgressL")); 

    iMediaserverContainer.SendProgressInfo( aItemCount );

    }

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

// Cds Sync chunk completion callback function

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

void CCmMdhMetadataCollector::ChunkCompleteL() 

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::ChunkCompleteL")); 

    // to check if all of the items have been processed successfully

    // If it is not, the percentage need to be increased for those

    // items that are not processed successfully

    TInt processedItems = iCdsSync->ProcessedItemCount();

    if ( iItemsToParse > processedItems )

    	{

    	ProgressL( iItemsToParse - processedItems );

    	}

    if ( iResultIncomplete && iCdsSync->ChunkCount() < KSearchCountLimit )

        {

        DoHarvestMediaserverL();

        }

    }

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

// Cds Sync completion callback function

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

void CCmMdhMetadataCollector::SyncCompleteL() 

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::SyncCompleteL")); 

    if ( iCanceled )

        {

        LOG(_L("[CmMdh Server]\t harvest canceled, returning..")); 

        return;

        }

    iMediaserverContainer.HarvestCompleteL( KErrNone );

    }

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

// Cds Sync error callback function

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

#ifdef _DEBUG

void CCmMdhMetadataCollector::SyncErrorL( TInt aError ) 

#else // _DEBUG

void CCmMdhMetadataCollector::SyncErrorL( TInt /*aError*/ ) 

#endif // _DEBUG

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMetadataCollector::SyncErrorL")); 

    TRACE( Print( _L("[CmMdh Server]\t error is %d"), aError ));

    }