/*

* Copyright (c) 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:  Fill rule and filled data processing

*

*/

#include <e32property.h>

#include "upnpdlnautility.h"

#include "cmsqlmainfactory.h"

#include "mcmsqlmain.h"

#include "cmdmmain.h"

#include "cmfillrule.h"

#include "cmfillrulecontainer.h"

#include "cmsqlpropertyitem.h"

#include "cmmediaserverfull.h"

#include "cmfilllistitem.h"

#include "cmfmmain.h"

#include "cmfmao.h"

#include "cmfmfillrulefilleddatamngr.h"

#include "msdebug.h"

// Constants

const TInt KCmFmIniDownloadDataAmount = 300; // 300 kBs

const TInt KCmFmIniDownloadTime = 1; // One second

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

// CCmFmFillRuleFilledDataMngr::NewL

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

//

CCmFmFillRuleFilledDataMngr* CCmFmFillRuleFilledDataMngr::NewL(

    MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr,

    RPointerArray<CCmFillListItem>& aItems )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewL() start"));    

    CCmFmFillRuleFilledDataMngr* self = CCmFmFillRuleFilledDataMngr::NewLC(

        aObserver, aDBMngr, aItems );

    CleanupStack::Pop( self );

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewL() end")); 

    return self;

    }

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

// CCmFmFillRuleFilledDataMngr::NewLC

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

//    

CCmFmFillRuleFilledDataMngr* CCmFmFillRuleFilledDataMngr::NewLC(

    MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr,

    RPointerArray<CCmFillListItem>& aItems )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewLC() start"));     

    CCmFmFillRuleFilledDataMngr* self = 

        new ( ELeave ) CCmFmFillRuleFilledDataMngr( aObserver, aDBMngr, 

                                                    aItems );

    CleanupStack::PushL( self );

    self->ConstructL();

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewLC() end"));     

    return self;  

    }    

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

// CCmFmFillRuleFilledDataMngr::~CCmFmFillRuleFilledDataMngr

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

//

CCmFmFillRuleFilledDataMngr::~CCmFmFillRuleFilledDataMngr()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

        ~CCmFmFillRuleFilledDataMngr() start"));

    Cancel();

    if ( iWrapper )

        {

        iWrapper->Close();    

        }    

    if ( iAo )

        {

        delete iAo;      

        }

    iObserver = NULL;

    iDBManager = NULL;

    if ( iContainer )

        {

        delete iContainer;    

        }

    iRuleArray.Reset();

    iRuleArray.Close();

    iUpdateItems.Reset();

    iUpdateItems.Close();        

    iPropertys.ResetAndDestroy();

    iFileIds.Close();

    iMetadataServersToBeDeleted.Close();

    iOldIds.Close();

    iFs.Close();

    iFilteredProfiles.Reset();

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

        ~CCmFmFillRuleFilledDataMngr() end"));

    }

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

// CCmFmFillRuleFilledDataMngr::CCmFmFillRuleFilledDataMngr

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

//            

CCmFmFillRuleFilledDataMngr::CCmFmFillRuleFilledDataMngr( 

    MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr,

    RPointerArray<CCmFillListItem>& aItems )

    :CActive( EPriorityStandard ), iObserver( aObserver ), 

    iDBManager( aDBMngr ), iItems(aItems)

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    CCmFmFillRuleFilledDataMngr()"));    

    CActiveScheduler::Add( this );

    iTransferInfo.iService = ECmServiceTransferInfoFill;

    }

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

// CCmFmFillRuleFilledDataMngr::ConstructL

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

//  

void CCmFmFillRuleFilledDataMngr::ConstructL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::ConstructL()"));   

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

    }

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

// CCmFmFillRuleFilledDataMngr::OperationCompletedL

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

// 

void CCmFmFillRuleFilledDataMngr::OperationCompletedL( TInt aStatus )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    OperationCompletedL()"));

    iQueryFinished.HomeTime();

    TTimeIntervalMicroSeconds usecsFrom = 

        iQueryFinished.MicroSecondsFrom( iQueryStart );

    TRACE(Print(_L("[FILL MNGR]\t Query \

        took = %ld mseconds"), ( usecsFrom.Int64() / 1000 ) ));    

    if( KErrNone == aStatus )

        {

        switch( iProcessingState )

            {

            case ECmFmLoadingPropertys:

                {

                // Loading propertys ready

                CompleteRequest( EColumnDataReady );

                break;

                }

            case ECmFmLoadingMetadata:

                {

                // Loading file metadata ready ( for one fill list )

                iNewItemCount = iItems.Count() - iNewItemCount;              

                CompleteRequest( EQueryCompleted );

                break;

                }

            case ECmFmDeletingMetadata:

                {

                // Metadata deleted from defined media servers

                TRAPD( err, DeleteHashCodesL() );

                iMetadataServersToBeDeleted.Reset();

                iMetadataServersToBeDeleted.Close();

                iWrapper->DeleteUnusedPropertys( );

                if( !err )

                    {

                    CompleteRequest( EMetadataDeleted );

                    }

                else

                    {

                    TRACE(Print(_L("[FILL MNGR]\t \

                        OperationCompletedL err %d "), err ));                    

                    }                                    

                break;

                }

            case ECmFmLoadingProfileIds:

                {

                DefineAndSetDlnaProfileIdFiltersL();

                PreprocessListsL();

                break;

                }

            default:

                {

                LOG(_L("[FILL MNGR]\t OperationCompletedL processing \

                state not found"));

                break;

                }    

            }         

        }

    else

        {        

        TRACE(Print(_L("[FILL MNGR]\t OperationCompletedL aStatus = %d"), 

            aStatus ));        

        }         

    }

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

// CCmFmFillRuleFilledDataMngr::LoadProfileIdsL

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

//

void CCmFmFillRuleFilledDataMngr::LoadProfileIdsL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::LoadProfileIdsL()"));

    // Loads all dlna profile ids from database. Profile ids are used

    // to filter out unsupported media types

    iPropertys.ResetAndDestroy();

    iProcessingState = ECmFmLoadingProfileIds;

    CreateWrapperL();

    StartObserverL();

    iWrapper->GetPropertyValuesL( iPropertys, iAo->iStatus, 

        ECmProfileId, ECmAll );

    iQueryStart.HomeTime();

    iAo->RunL();    

    }

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

// CCmFmFillRuleFilledDataMngr::PreprocessListsL

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

// 

void CCmFmFillRuleFilledDataMngr::PreprocessListsL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::PreprocessListsL()"));

#ifdef _DEBUG

    TInt alloc;

    TInt cells = User::Heap().AllocSize( alloc );

    TInt size = User::Heap().Size();

    TRACE(Print(_L("[FILL MNGR]\t preprocess heap allocsize %d, \

    size %d, cells %d"), alloc, size, cells ));

#endif

    iProcessingState = ECmFmIdle;  

    ResetData();

    // Creates sqlite wrapper and starts preprocessing of all fill lists

    TRAP_IGNORE( CreateWrapperL() );

    iTransferInfo.iTotalItems = KErrNone;

    iTransferInfo.iProcessedItems = KErrNone;        

    CompleteRequest( EPreProcessingStarted );   

    }

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

// CCmFmFillRuleFilledDataMngr::PreProcessListL

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

// 

void CCmFmFillRuleFilledDataMngr::PreProcessListL( 

    const TDesC8& aFillListName )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::PreProcessListL()"));

    iProcessingState = ECmFmIdle;

    // Creates sqlite wrapper and starts preprocessing of 

    // one defined fill list 

    CreateWrapperL();

    ResetData();

    iContainer = CCmFillRuleContainer::NewL();     

    LoadRuleL( aFillListName );

    LoadAllFillItemsL();    

    CompleteRequest( ERandomizingStarted );

    }

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

// CCmFmFillRuleFilledDataMngr::GetColItemsL

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

//

void CCmFmFillRuleFilledDataMngr::GetColItemsL( TCmMetadataField aType, 

    TCmMediaType aMedia, CCmSqlPropertyContainer& aPropertys )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetColItemsL()"));

    iPropertyContainer = NULL;

    iPropertyContainer = &aPropertys;

    iPropertys.ResetAndDestroy(); 

    iProcessingState = ECmFmLoadingPropertys;

    CreateWrapperL();

    StartObserverL();

    // starts loading defined propertys from database

    iWrapper->GetPropertyValuesL(iPropertys, iAo->iStatus, aType, aMedia );

    iQueryStart.HomeTime();

    iAo->RunL();

    }

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

// CCmFmFillRuleFilledDataMngr::GetMetadataItemsL

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

//

void CCmFmFillRuleFilledDataMngr::GetMetadataItemsL(

                                    CCmSqlPropertyCollector& aPropertys )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    GetMetadataItemsL()"));

    iPropertyCollector = NULL;

    iPropertyCollector = &aPropertys;    

    iProcessingState = ECmFmLoadingPropertys;

    CreateWrapperL();

    StartObserverL();

    // starts loading property values. Selected artists, albums, genres and 

    // tracks are used as a filtering parameter ( e.g. if some artist is 

    // selected, only albums for that defined artist are loaded.

    iWrapper->GetFilteredPropertyValuesL( *iPropertyCollector, iAo->iStatus );

    iQueryStart.HomeTime();

    iAo->RunL();

    }

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

// CCmFmFillRuleFilledDataMngr::UpdatePriorities

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

//    

void CCmFmFillRuleFilledDataMngr::UpdatePriorities()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::UpdatePriorities()"));

    CompleteRequest( EUpdatePriorities );

    }

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

// CCmFmFillRuleFilledDataMngr::DoUpdatePrioritiesL

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

//

void CCmFmFillRuleFilledDataMngr::DoUpdatePrioritiesL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    DoUpdatePrioritiesL()"));

    // Updating first list item priorities    

#ifdef _DEBUG

    TInt alloc;

    TInt cells = User::Heap().AllocSize( alloc );

    TInt size = User::Heap().Size();

    TRACE(Print(_L("[FILL MNGR]\t DoUpdatePrioritiesL start heap \

    allocsize %d, size %d, cells %d"), alloc, size, cells ));    

#endif    

    CCmFillRuleContainer* container = LoadAllFillRulesL();

    CleanupStack::PushL( container );

    TInt err( UpdateListItemPriorities( container ) );

    TRACE(Print(_L("[FILL MNGR]\t UpdateListItemPriorities err = %d"), 

    err ));     

    CleanupStack::PopAndDestroy(container);

    CalculateAvgTransferTimeL();

    SendAvgTransferTime();

#ifdef _DEBUG    

    cells = User::Heap().AllocSize( alloc );

    size = User::Heap().Size();

    TRACE(Print(_L("[FILL MNGR]\t DoUpdatePrioritiesL end heap \

    allocsize %d, size %d, cells %d"), alloc, size, cells ));

#endif

    iObserver->FillRuleProcessingStatus( EDoUpdatePriorities );   

    }

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

// CCmFmFillRuleFilledDataMngr::DoUpdateReferenceIdsL

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

//

void CCmFmFillRuleFilledDataMngr::DoUpdateReferenceIdsL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    DoUpdateReferenceIdsL()")); 

#ifdef _DEBUG

    TInt alloc;

    TInt cells = User::Heap().AllocSize( alloc );

    TInt size = User::Heap().Size();

    TRACE(Print(_L("[FILL MNGR]\t DoUpdateReferenceIdsL start heap \

    allocsize %d, size %d, cells %d"), alloc, size, cells ));    

#endif

    LoadAllFillItemsL();

    LOG(_L("[FILL MNGR]\t Items loaded...")); 

    // Processing set referense ids into duplicate items

    LOG(_L("[FILL MNGR]\t Processing ref ids..."));

    DoProcessReferenceValuesL();   

    LOG(_L("[FILL MNGR]\t Ref ids processed..."));        

    UpdateFillItems();

    iItems.ResetAndDestroy();

    iItems.Close();

#ifdef _DEBUG    

    cells = User::Heap().AllocSize( alloc );

    size = User::Heap().Size();

    TRACE(Print(_L("[FILL MNGR]\t DoUpdateReferenceIdsL end heap \

    allocsize %d, size %d, cells %d"), alloc, size, cells ));

#endif     

    }

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

// CCmFmFillRuleFilledDataMngr::DeleteMetadataL

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

//

void CCmFmFillRuleFilledDataMngr::DeleteMetadataL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DeleteMetadataL()")); 

    iMetadataServersToBeDeleted.Reset();

    RPointerArray<CCmMediaServerFull> mediaServers;

    CleanupClosePushL( mediaServers );

    iDBManager->GetMediaServersL( mediaServers ); 

    TBool setSystemUpdateIDChange( EFalse );

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

        {

        // checks that server is either inactive or deleted

        if( mediaServers[i]->DbId() != 0 && 

            !( mediaServers[i]->FillUsage() ) )

            {

            TRACE(Print(_L("[FILL MNGR]\t DbId = %ld"), 

                mediaServers[i]->DbId() ));            

            mediaServers[i]->SetSystemUpdateID( KErrNotFound );

			setSystemUpdateIDChange = ETrue;

            }

        }

	if ( setSystemUpdateIDChange )

		{

		iDBManager->SetMediaServersL( mediaServers ); 	

		}

    mediaServers.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &mediaServers );

    iProcessingState = ECmFmDeletingMetadata;

    CreateWrapperL();

    StartObserverL();

    iWrapper->AsyncMetadataDelete( iMetadataServersToBeDeleted, 

        iAo->iStatus );

    iQueryStart.HomeTime();

    iAo->RunL();        

    }

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

// CCmFmFillRuleFilledDataMngr::SetMemoryCardQuota

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

// 

void CCmFmFillRuleFilledDataMngr::SetMemoryCardQuota( TInt64 aQuota )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    SetMemoryCardQuota()")); 

    if( iWrapper )

        {

        iWrapper->SetQuota( aQuota );

        }

    }

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

// CCmFmFillRuleFilledDataMngr::CancelOperation

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

//    

void CCmFmFillRuleFilledDataMngr::CancelOperation()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::CancelOperation()"));

    Cancel();    

    if( iWrapper )

        {

        iWrapper->CancelAsyncOperation();

        }

    DeleteWrapper(); 

    if( iAo )

        {

        if( iAo->IsActive() )

            {

            iAo->Cancel();

            } 

        delete iAo;

        iAo = NULL;      

        }

    LOG(_L("[FILL MNGR]\t iAo canceled..."));          

    iObserver->FillRuleProcessingStatus(EProcessingCanceled);           

    }

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

// CCmFmFillRuleFilledDataMngr::UpdateTransferHistoryData

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

//

void CCmFmFillRuleFilledDataMngr::UpdateTransferHistoryData( 

    TInt64 aInterval, TInt64 aDataAmount, 

    TUint8 aServerId )

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    UpdateTransferHistoryData()")); 

    iDBManager->UpdateDownloadHistory( (TUint)aServerId, aDataAmount,

        aInterval );

    }

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

// CCmFmFillRuleFilledDataMngr::GetFillItemsL

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

//

void CCmFmFillRuleFilledDataMngr::GetFillItemsL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetFillItemsL()")); 

    iItems.ResetAndDestroy();

    iItems.Close();

    iDBManager->PrepareQueryCmdL(EAllFillFilesStatusQuery);

    iDBManager->GetAllFillFilesL( iItems, 

        ECmToBeShrinked|ECmToBeFilled|ECmFilled|ECmLocalCopy );