/*

* 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:  Store file processing

*

*/

#include <e32property.h>

#include "cmdmmain.h"

#include "cmstorerule.h"

#include "cmstorelistitem.h"

#include "cmfilllistitem.h"

#include "cmsmfileprocessingobserver.h"

#include "cmsmcontentchangeobserver.h"

#include "cmsmvideoandimagemngr.h"

#include "cmsmclfmngr.h"

#include "cmsmiteminfo.h"

#include "cmsmmsinfo.h"

#include "cmsmfilemngr.h"

#include "msdebug.h"

// CONSTANTS

const TInt KCmSmIniStoreTransferSpeed = 200; // 200 kBs

const TInt KCmSmIniStoreTransferTime = 1; // One second

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

// CCmSmFileMngr::NewL

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

// 

CCmSmFileMngr* CCmSmFileMngr::NewL(

    MCmSmFileProcessingObserver* aObserver, CMdESession& aSession, 

    CCmDmMain* aDBMngr, RPointerArray<CCmStoreListItem>& aItems )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::NewL() start"));    

    CCmSmFileMngr* self = CCmSmFileMngr::NewLC(

        aObserver, aSession, aDBMngr, aItems );

    CleanupStack::Pop( self );

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::NewL() end")); 

    return self;

    }

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

// CCmSmFileMngr::NewLC

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

//     

CCmSmFileMngr* CCmSmFileMngr::NewLC( 

    MCmSmFileProcessingObserver* aObserver, CMdESession& aSession, 

    CCmDmMain* aDBMngr,

    RPointerArray<CCmStoreListItem>& aItems )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::NewLC() start"));     

    CCmSmFileMngr* self = new ( ELeave ) CCmSmFileMngr(

        aObserver, aDBMngr, aItems );

    CleanupStack::PushL( self );

    self->ConstructL( aSession );

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::NewLC() end"));     

    return self;  

    }    

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

// CCmSmFileMngr::~CCmSmFileMngr

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

// 

CCmSmFileMngr::~CCmSmFileMngr()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::\

        ~CCmSmFileMngr() start"));

    Cancel();    

    delete iVideoAndImageMngr;

    delete iClfMusicMngr;

    iRuleArray.ResetAndDestroy();

    iRuleArray.Close();

    iFilledItems.ResetAndDestroy();

    iFilledItems.Close();

    iStoredArray.ResetAndDestroy();

    iStoredArray.Close();

    iMsIds.ResetAndDestroy();

    iMsIds.Close();

    iMediaTypes.Reset();

    iMediaTypes.Close();

    delete iCcObserver;

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::\

        ~CCmSmFileMngr() end"));            

    }

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

// CCmSmFileMngr::CCmSmFileMngr

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

//            

CCmSmFileMngr::CCmSmFileMngr( 

    MCmSmFileProcessingObserver* aObserver, CCmDmMain* aDBMngr,

    RPointerArray<CCmStoreListItem>& aItems )

    :CActive( EPriorityStandard ),

    iObserver( aObserver ), iDBManager( aDBMngr ), iItems( aItems )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::CCmSmFileMngr()"));

    CActiveScheduler::Add( this );

    iTransferInfo.iTotalItems = KErrNone;

    iTransferInfo.iProcessedItems = KErrNone;    

    }

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

// CCmSmFileMngr::ConstructL

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

//  

void CCmSmFileMngr::ConstructL( CMdESession& aSession )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::ConstructL()"));

    iVideoAndImageMngr = 

        CCmSmVideoAndImageMngr::NewL( *this, *this, aSession, iItems );

    iClfMusicMngr = CCmSmClfMngr::NewL( *this, *this, iItems );

    iCcObserver = 

            CCmSmContentChangeObserver::NewL( aSession, *iObserver );        

    iProcessingStatus = ECmSmNone;

    }    

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

// CCmSmFileMngr::StartProcessing

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

// 

void CCmSmFileMngr::StartProcessing()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::StartProcessing()"));

    iTransferInfo.iTotalItems = KErrNone;

    iTransferInfo.iProcessedItems = KErrNone;

    if( !iCcObserver->IsStarted() )

        {

        TRAPD( err, iCcObserver->StartObserversL() );

        if( err )

            {

            TRACE(Print( _L("[STORE MNGR] StartObserversL err = %d"),

                err ) );

            }

        }    

    CompleteRequest( ECmSmPreProcessingStarted );

    }

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

// CCmSmFileMngr::ProcessAlbumList

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

// 

void CCmSmFileMngr::ProcessAlbumList( TCmMediaType /*aMedia*/, 

    CDesCArray& /*aArray*/ )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::ProcessAlbumList()"));

    }

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

// CCmSmFileMngr::StoreItemCount

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

//        

TInt CCmSmFileMngr::StoreItemCount()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::StoreItemCount()"));

    return iDBManager->StoreFileCount( 

        ECmToBeRemoved|ECmToBeShrinked|ECmKeepOnDevice );

    }

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

// CCmSmFileMngr::FillItemCount

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

//

TInt CCmSmFileMngr::FillItemCount()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::FillItemCount()"));

    return iDBManager->FillFileCount( ECmToBeShrinked|ECmToBeFilled );

    }

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

// CCmSmFileMngr::GetStoreFileCountNoDuplicatesL

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

//

void CCmSmFileMngr::GetStoreFileCountNoDuplicatesL( TInt& aCount )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::\

    GetStoreFileCountNoDuplicatesL()"));

    iDBManager->GetStoreFileCountNoDuplicatesL( aCount, 

        ECmToBeRemoved|ECmToBeShrinked|ECmKeepOnDevice );

    TRACE(Print( _L("[STORE MNGR] GetStoreFileCountNoDuplicatesL count = %d"),

        aCount ) );        

    TInt count = 0;

    TInt time = 0;

    iDBManager->GetTransferInfo( ECmServiceStore, count, time );

    iDBManager->UpdateTransferInfo( ECmServiceStore, aCount, 

        time );    

    }

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

// CCmSmFileMngr::UpdateTransferHistoryData

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

//

void CCmSmFileMngr::UpdateTransferHistoryData(

    TInt64 aInterval, TInt64 aDataAmount, 

    TUint8 aServerId )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::UpdateTransferHistoryData()"));

    iDBManager->UpdateUploadHistory( aServerId,

        aDataAmount, aInterval );

    }

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

// CCmSmFileMngr::CancelOperation

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

//    

void CCmSmFileMngr::CancelOperation()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::CancelOperation()"));

    Cancel();

    iVideoAndImageMngr->CancelOperation();

    iClfMusicMngr->CancelOperation();

    iObserver->FileProcessingStatus( ECmSmProcessingCanceled );

    }

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

// CCmSmFileMngr::ImagesAndVideosReady

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

// 

void CCmSmFileMngr::ImagesAndVideosReady( const TInt /*aStatus*/ )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::ImagesAndVideosReady()"));

    CompleteRequest( ECmSmMediaTypesSelected );

    }

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

// CCmSmFileMngr::MusicReady

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

// 

void CCmSmFileMngr::MusicReady( const TInt /*aStatus*/ )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::MusicReady()"));

    CompleteRequest( ECmSmMediaTypesSelected );

    }

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

// CCmSmFileMngr::LoadSelectedStoreRulesL

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

//        

void CCmSmFileMngr::LoadSelectedStoreRulesL()

    {

    LOG(_L("[FILL MNGR]\t CCmSmFileMngr::LoadSelectedStoreRulesL()"));

    RPointerArray<HBufC8> array;

    CleanupClosePushL( array );

    iDBManager->PrepareQueryCmdL( ESelectedStoreRuleQuery );    

    iDBManager->QuerySelectedStoreRuleNamesL( array, 1 );

    // Load selected store rules to array ( using names as a qyery 

    // parameter )

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

        {

        CCmStoreRule* storeRule = CCmStoreRule::NewLC();    

        iDBManager->PrepareQueryCmdL(EStoreRuleQuery);

        storeRule->SetNameL( *array[i] );        

        iDBManager->QueryStoreRuleL( storeRule );

        CleanupStack::Pop(storeRule);

        }

    array.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &array );

    }

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

// CCmSmFileMngr::ProcessStoreRules

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

//

void CCmSmFileMngr::ProcessStoreRules()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::ProcessStoreRules()"));    

    TPtrC8 mediaServer;        

    for( TInt i = iRuleArray.Count() - 1; i >= 0; i-- )

        {

        if( KErrNone == iRuleArray[i]->MediaServerCount() )    

            {

            // If no servers defined => DO NOT use rule at all

            // First delete the object

            delete iRuleArray[i];

            // Then delete the pointer

            iRuleArray.Remove(i);    

            LOG(_L("[STORE MNGR]\t Store rule doesn't have any \

                defined servers"));

            LOG(_L("[STORE MNGR]\t ******* ==> RULE SKIPPED \

                ******************"));      

            }

        else

            {

            // Do nothing

            }        

        }

    iRuleArray.Compress();                

    }

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

// CCmSmFileMngr::LoadFilledAndStoredL

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

//

void CCmSmFileMngr::LoadFilledAndStoredL()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::LoadFilledAndStoredL()"));    

    LoadMediaServerIdsL();

    LoadFilledL();    

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

        {

        LoadStoredL( *iMsIds[i]->iUuid );

        }

    CompleteRequest( ECmSmAllLoaded );            

    }

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

// CCmSmFileMngr::LoadFilledL

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

//

void CCmSmFileMngr::LoadFilledL()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::LoadFilledL()"));

    iFilledItems.ResetAndDestroy();

    iFilledItems.Close();

    iDBManager->PrepareQueryCmdL(EAllFillFilesStatusQuery);    

    iDBManager->GetAllFillFilesL( 

        iFilledItems,ECmFilled|ECmToBeRemoved|ECmLocalCopy );

    }

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

// CCmSmFileMngr::LoadStoredL

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

//

void CCmSmFileMngr::LoadStoredL( const TDesC8& aUDN )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::LoadStoredL()"));        

    // Load to spesific server filled items

    iDBManager->PrepareQueryCmdL( EMediaServerIdQuery );

    TInt64 id( iDBManager->QueryMediaServerId( aUDN ) );

    if( KErrNone < id )

        {

        RPointerArray<HBufC16> array;

        CleanupClosePushL( array );

        iDBManager->PrepareQueryCmdL(EStoredRowQuery);

        iDBManager->QueryStoredRowL( array, aUDN, KErrNotFound );

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

            {            

            CCmSmItemInfo* storedItemInfo = 

                CCmSmItemInfo::NewLC( *array[i], id );

            iStoredArray.Append( storedItemInfo );

            CleanupStack::Pop( storedItemInfo );

            }

        // Ownership didn't change, reset and destroy    

        array.ResetAndDestroy();

        CleanupStack::PopAndDestroy( &array );

        }

    else

        {

        LOG(_L("[STORE MNGR]\t No media server id found"));        

        }                        

    }

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

// CCmSmFileMngr::ResetFilledArray

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

//    

void CCmSmFileMngr::ResetFilledArray()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::ResetFilledArray()"));

    iFilledItems.ResetAndDestroy();

    iFilledItems.Close();

    }

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

// CCmSmFileMngr::SelectMediaTypes

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

//

void CCmSmFileMngr::SelectMediaTypes()

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::SelectMediaTypes()"));

    TCmMediaType mediaType;

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

        {

        for( TInt j = 0; j < iRuleArray[i]->DefCount(); j++ )

            {

            iRuleArray[i]->StoreRule( j, &mediaType );

            if( KErrNotFound == iMediaTypes.Find( mediaType ) )

                {

                iMediaTypes.Append( mediaType );

                }

            }

        }                                                   

    iRefreshIndex = 0;            

    CompleteRequest( ECmSmMediaTypesSelected );

    }

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

// CCmSmFileMngr::CheckIsFilledFileL

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

//

TBool CCmSmFileMngr::CheckIsFilledFileL( const TDesC& aPathAndFileName )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::CheckIsFilledFileL()"));

    TBool processed( EFalse );

    // Check if file is filled from some listed server

    for( TInt j = 0; j < iFilledItems.Count() && !processed; j++ )

        {

        if( KErrNotFound != aPathAndFileName.FindC( 

            iFilledItems[j]->Path() ) )

            {

            LOG(_L("[STORE MNGR]\t Filled file!!!"));

            LOG(_L("[STORE MNGR]\t File not stored!!!"));            

            processed = ETrue;

            // End loop

            j = iFilledItems.Count();

            }

        }

    return processed;    

    }

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

// CCmSmFileMngr::IsAlreadyStoreL

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

//

void CCmSmFileMngr::IsAlreadyStoreL( const TDesC& aPathAndFileName, 

    RArray<TInt>& aStoredIds, RArray<TInt>& aStoreIds )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::IsAlreadyStoreL()"));

    // Check if file is already stored to some of the defined servers

    for( TInt k = 0; k < iStoredArray.Count() ;k++ )

        {

        if(  KErrNone == iStoredArray[k]->iFile->

            Compare( aPathAndFileName ) )

                {

                for( TInt l = aStoreIds.Count() - 1; l >= 0; l-- )

                    {

                    if( aStoreIds[l] == iStoredArray[k]->iId )

                        {

                        aStoredIds.Append( aStoreIds[l] );

                        aStoreIds.Remove(l);

                        LOG(_L("[STORE MNGR]\t Stored file!!!"));

                        }

                    }

                aStoreIds.Compress();   

                }                        

        }     

    }

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

// CCmSmFileMngr::MediaTypesL

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

//    

void CCmSmFileMngr::MediaTypesL( RArray<TInt>& aIds, TCmMediaType aType )

    {

    LOG(_L("[STORE MNGR]\t CCmSmFileMngr::MediaTypesL()"));

    // Loop for store rules

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

        {

        TBool addServers = EFalse;

        TInt msCount(iRuleArray[i]->MediaServerCount());

        TInt defCount( iRuleArray[i]->DefCount() ); 

        TCmMediaType temptype;

        // In specific store rule, loop to check if the rule has relevant 

        // media type.

        for( TInt n = 0; n < defCount; n++ )

            {

            iRuleArray[i]->StoreRule(n, &temptype );

            if(  aType == temptype )

                {

                addServers = ETrue;            

                }

            }

        if( addServers )

            {

            // Loop for media servers

            for( TInt k = 0; k < msCount ; k++ )

                {

                const TPtrC8 ms = iRuleArray[i]->MediaServerL( k );

                // To find if Uuid of ms has been in iMsIds.

                for( TInt l = 0 ; l < iMsIds.Count(); l++ )

                    {

                    if( KErrNone == ms.Compare( *iMsIds[l]->iUuid ) )

                        {

                        // End loop    

                    	l = iMsIds.Count();  

                        }

                    }

                }

            }

        }    

    }

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

// CCmSmFileMngr::LoadMediaServerIdsL

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

//

void CCmSmFileMngr::LoadMediaServerIdsL()