/*

* 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:  Main class in the Fill manager component

*

*/

#include <e32property.h>

#include <e32std.h>

#include <f32file.h>

#include <badesca.h>

#include "upnpavdevice.h"

#include "upnpavcontroller.h"

#include "upnpavdevicelist.h"

#include "upnpitem.h"

#include "upnpcontainer.h"

#include <pathinfo.h>

#include <utf.h>

#include "cmserviceobserver.h"

#include "cmfmdownloadproxy.h"

#include "cmfmupnpmngr.h"

#include "cmfmfilldrivemngr.h"

#include "cmfmduplicatedetector.h"

#include "cmdriveinfo.h"

#include "cmfmfillrulefilleddatamngr.h"

#include "cmfmmpxnotifier.h"

#include "cmfmglxnotifier.h"

#include "cmfmcommon.h"

#include "cmdmmain.h"

#include "cmmmmain.h"

#include "cmfilllistitem.h"

#include "cmsqlpropertyitem.h"

#include "cmsqlpropertycontainer.h"

#include "cmfmmain.h"

#include "msdebug.h"

const TUint8 KExtensionLength = 4;

const TInt KCmFmOneFile = 1;

const TInt KCmFmLengthOfRoot = 3;

const TInt KCmFmOneSecond = 1000000;

const TInt KArrayGranularity = 10;

const TInt KExtraSpace = 5; // space reserved for backslashes etc. 

const TInt KDefaultCalculateSize = 100;

_LIT16( KCmKorp,               "<" );

_LIT16( KCmProk,               ">" );

_LIT16( KCmQuotation,          "\"" );

_LIT16( KCmDoubleBackSlash,    "\\" );

_LIT16( KCmSlash,              "/" );

_LIT16( KCmStar,               "*" );

_LIT16( KCmPipe,               "|" );

_LIT16( KCmColon,              ":");

_LIT16( KCmQuestionMark,       "?" );

_LIT16( KCmUnderScore,         "_" );

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

// CCmFmMain::NewL

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

//

CCmFmMain* CCmFmMain::NewL( MCmServiceObserver* aObserver,

    CMdESession& aSession, CCmDmMain* aDBManager, 

    CCmMmMain* aMemManager )

    {

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

    CCmFmMain* self = CCmFmMain::NewLC( aObserver, aSession,

        aDBManager, aMemManager );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CCmFmMain::NewLC

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

//

CCmFmMain* CCmFmMain::NewLC( MCmServiceObserver* aObserver,

    CMdESession& aSession, CCmDmMain* aDBManager, 

    CCmMmMain* aMemManager )

    {

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

    CCmFmMain* self = new ( ELeave ) CCmFmMain( aObserver, 

        aMemManager, aDBManager );

    CleanupStack::PushL( self );

    self->ConstructL( aSession, aDBManager );

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

    return self;

    }

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

// CCmFmMain::~CCmFmMain

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

//

CCmFmMain::~CCmFmMain()

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::~CCmFmMain() start"));

    if( IsActive() )

        {

        Cancel();

        }

    iFile.Close();        

    iFsSession.Close();

    delete iCmFmFillDriveMngr;

    delete iCmFmUpnpMngr;

    if( iDevices )

        {

        iDevices->ResetAndDestroy();

        delete iDevices;

        iDevices = NULL;

        }

    delete iCmFmFillRuleFilledDataMngr;

    delete iCmFmDownloadProxy;

    delete iCmFmDuplicateDetector;

    delete iCmFmGlxNotifier;

    delete iCmFmMpxNotifier;

    ResetDeleteQueue();

    ResetItems();

    iFullPath.Zero();

    iDrives.ResetAndDestroy();

    iDrives.Close();

    LOG(_L("[FILL MNGR]\t CCmFmMain::~CCmFmMain() end"));

    }

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

// CCmFmMain::CCmFmMain

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

//

CCmFmMain::CCmFmMain( MCmServiceObserver* aObserver,

    CCmMmMain* aMemManager, CCmDmMain* aDBManager )

    : CActive( EPriorityStandard ), iObserver( aObserver ), 

    iMemManager( aMemManager ), iDbManager( aDBManager )

    {

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

    CActiveScheduler::Add( this );

    iProgressInfo.iService = ECmServiceNone;

    iProgressInfo.iProcessedItems = 0;

    iProgressInfo.iItemsToTransferPerService = 0;

    iProgressInfo.iTotalItems = 0;

    iService = ECmServiceFill;

    }

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

// CCmFmMain::ConstructL

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

//

void CCmFmMain::ConstructL( CMdESession& aSession, CCmDmMain* aDBManager )

    {

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

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

    User::LeaveIfError( iFsSession.ShareProtected() );   

    iCmFmFillDriveMngr = CCmFmFillDriveMngr::NewL( iFsSession, iDrives );

    iCmFmUpnpMngr = CCmFmUpnpMngr::NewL( this );

    iCmFmFillRuleFilledDataMngr =

        CCmFmFillRuleFilledDataMngr::NewL( this, aDBManager, iItems );

    iCmFmDownloadProxy = CCmFmDownloadProxy::NewL( );

    iCmFmDuplicateDetector = CCmFmDuplicateDetector::NewL( *this, aSession );

    iCmFmGlxNotifier = CCmFmGlxNotifier::NewL( iFsSession );

    iCmFmMpxNotifier = CCmFmMpxNotifier::NewL( );

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

    }

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

// CCmFmMain::StartFillL

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

//

void CCmFmMain::StartFillL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::StartFillL()"));

    iDbManager->GetProgressInfo( iProgressInfo.iProcessedItems,

        iProgressInfo.iTotalItems );

    iProgressInfo.iItemsToTransferPerService =

        iDbManager->FillFileCount( ECmToBeShrinked|ECmToBeFilled );

    iService = ECmServiceFill;

    iProgressInfo.iService = ECmServiceFill;

    iTempIndex = 0;

    SendProgressInfo( KErrNone );

    LoadDrivesL();

    CompleteRequest( ECmFmMMCCheckStarted );

    }

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

// CCmFmMain::CancelOperation

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

//

void CCmFmMain::CancelOperation()

    {

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

    // Destroy all active objects

    iCmFmUpnpMngr->CancelOperation();

    iCmFmFillRuleFilledDataMngr->CancelOperation();

    iCmFmDownloadProxy->CancelOperation();

    LOG(_L("[FILL MNGR]\t Filling => Update items to database"));

    if( KErrNone < iItems.Count() )

        {

        iCmFmFillRuleFilledDataMngr->UpdateFillItems( ETrue );

        }

    if( KErrNone < iToBeDeleted.Count() )

        {

        iCmFmFillRuleFilledDataMngr->UpdateToBeDeleted( iToBeDeleted );

        }

    UpdateDrives();

    // File fetching was ongoing => have to notify gallery 

    // about deleted file    

    if( iFetchingFile && iIndex < iItems.Count() )

        {

        iFsSession.Delete( iFullPath );

        TRAP_IGNORE( iCmFmGlxNotifier->NotifyGalleryL( iFullPath ) );

        }

    // Update UI information

    TRAPD( err, iCmFmFillRuleFilledDataMngr->CalculateAvgTransferTimeL() );

    if( err )

        {

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

        }

    iCmFmFillRuleFilledDataMngr->SendAvgTransferTime();

    iCmFmFillRuleFilledDataMngr->ResetData();

    Cancel();

    iObserver->ServiceExecuted( iService, KErrCancel );

    if( iProgressInfo.iService != ECmServiceNone )

        {

        // Service finished. Reset progress info.

        iProgressInfo.iService = ECmServiceNone;

        SendProgressInfo( KErrNone );

        }

    }

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

// CCmFmMain::PreProcessListsL

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

//

void CCmFmMain::PreProcessListsL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::PreProcessListsL()"));

    if( KErrNone == iDbManager->FillFileCount(

        ECmToBeShrinked|ECmToBeFilled|ECmToBeRemoved|ECmFilled ) )

        {

        // Set used fill space to zero

        InitializeDriveQuotasL();

        }

    iService = ECmServicePreProcessingFill;

    TRAPD( err, iCmFmFillRuleFilledDataMngr->LoadProfileIdsL() );    

    if( err )

        {

        iObserver->ServiceExecuted( iService, KErrNone );

        }

    SetMmcQuotaL();

    }

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

// CCmFmMain::PreProcessListL

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

//

void CCmFmMain::PreProcessListL( const TDesC8& aFillListName )

    {

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

    if( KErrNone == iDbManager->FillFileCount(

        ECmToBeShrinked|ECmToBeFilled|ECmToBeRemoved|ECmFilled ) )

        {

        // Set used fill space to zero

        InitializeDriveQuotasL();

        }

    iService = ECmServicePreProcessingFilllist;

    TRAPD( err, 

           iCmFmFillRuleFilledDataMngr->PreProcessListL( aFillListName) );

    if( err )

        {

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

        iObserver->ServiceExecuted( iService, KErrNone );

        }

    SetMmcQuotaL();

    }

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

// CCmFmMain::GetColItemsL

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

//

void CCmFmMain::GetColItemsL( TCmMetadataField /*aType*/,

    TCmMediaType /*aMedia*/, CDesCArray& /*aArray*/ )

    {

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

    iService = ECmServiceGetFillFields;

    }

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

// CCmFmMain::GetMetadataItemsL

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

//

void CCmFmMain::GetMetadataItemsL(

                                CCmSqlPropertyCollector& aPropertys )

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::GetMetadataItemsL()"));

    iService = ECmServiceGetFillFields;

    iCmFmFillRuleFilledDataMngr->GetMetadataItemsL( aPropertys );

    }

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

// CCmFmMain::GetColItemsL

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

//

void CCmFmMain::GetColItemsL( TCmMetadataField aType,

    TCmMediaType aMedia, CCmSqlPropertyContainer& aPropertys )

    {

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

    iService = ECmServiceGetFillFields;

    iCmFmFillRuleFilledDataMngr->GetColItemsL( aType, aMedia, aPropertys );

    }

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

// CCmFmMain::SetAvController

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

//

void CCmFmMain::SetAvController( MUPnPAVController* aAVController )

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::SetAvController()"));

    iAvController = aAVController;

    iCmFmUpnpMngr->SetAvController( aAVController );

    iCmFmDownloadProxy->CancelOperation( );

    ResetItemInfo();

    iDrives.ResetAndDestroy();

    }

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

// CCmFmMain::UpdatePriorities

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

//

void CCmFmMain::UpdatePriorities()

    {

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

    iCmFmFillRuleFilledDataMngr->UpdatePriorities();

    iService = ECmServiceUpdateFillLists;

    }

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

// CCmFmMain::UpdateRefIds

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

//

void CCmFmMain::UpdateRefIds()

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::UpdateRefIds()"));

    TRAPD( err, iCmFmFillRuleFilledDataMngr->DoUpdateReferenceIdsL() );

    if( err )

        {

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

        }    

    }

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

// CCmFmMain::DeleteMetadataL

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

//

void CCmFmMain::DeleteMetadataL()

    {

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

    iCmFmFillRuleFilledDataMngr->DeleteMetadataL();

    iService = ECmServiceDeleteMetadata;

    }

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

// CCmFmMain::SetMmcQuotaL

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

//

void CCmFmMain::SetMmcQuotaL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmMain::SetMmcQuotaL()"));

    LoadDrivesL();

    TInt64 quota( KErrNone );

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

        {

        if( quota < iDrives[i]->DriveQuota() )

            {

            quota = iDrives[i]->DriveQuota();

            }

        }

    iDrives.ResetAndDestroy();

    TRACE(Print(_L("[FILL MNGR]\t Max fill list size in bytes = %ld"),

        quota ));

    iCmFmFillRuleFilledDataMngr->SetMemoryCardQuota( quota );

    }

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

// CCmFmMain::FillRuleProcessingStatus

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

//

void CCmFmMain::FillRuleProcessingStatus( TCmFmFillRuleProcessing aStatus )

    {

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

        FillRuleProcessingStatus status = %d"), (TInt)aStatus ));

    switch( aStatus )

        {

        case EProcessingReady:

            {

            iObserver->ServiceExecuted( iService,

                KErrNone );

            break;

            }

        case ENoRulesSelected:    // fall through

        case ENoObjectsSelected:  // fall through

        case EColumnDataReady:    // fall through

        case EDoUpdatePriorities: // fall through

        case EMetadataDeleted:    

            {

            // Finish fill operation

            iObserver->ServiceExecuted( iService, KErrNone );

            break;

            }

        case EProcessingCanceled:

            {

            break;

            }

        case EProcessingFailed:

            {

            iObserver->ServiceExecuted( iService,

                KErrUnknown );

            break;

            }

        default:

            {

            LOG(_L("[FILL MNGR]\t Wrong status in Fill rule processing"));

            User::Invariant();

            break;

            }

        }

    }

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

// CCmFmMain::TransferStatus

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

//    

void CCmFmMain::TransferStatus( TCmFmTransferStatus aStatus, TInt aSessionId,

    TInt aInternalItemId, TInt aError, TInt64 aFSize )

    {

    TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::TransferStatus status = %d \

    error = %d"), (TInt)aStatus, (TInt)aError ));

    TInt err( KErrNone );    

    switch( aStatus )

        {

        case ECmFmFileFetchStarted: 

            {

            if( !aError )

                {

                TRACE(Print(_L("[FILL MNGR]\t File download started!"))); 

                iFetchingFile = ETrue;                

                }

            else if( KErrDisconnected == aError )

                {

                TransferStatus( ECmFmFileFetched, aSessionId, 0, 

                    aError, 0 );

                }

            else

                {

                ProceedWithNextItem( ECmFmCheckItem );                   

                }                

            break;

            }

        case ECmFmFileFetched:

            {

            iFetchingFile = EFalse; 

            iFile.Close();

            if( !aError )

                {

                TTime fetchFinished;                           

                fetchFinished.HomeTime();

                TTimeIntervalMicroSeconds usecsFrom =

                    fetchFinished.MicroSecondsFrom(iFileFetchStart);

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

                    took = %ld microseconds"), usecsFrom.Int64() ));

                // Update Fill quota

                TInt64 fillSpace( KErrNone );

                fillSpace = iDrives[iDriveIndex]->UsedDriveQuota() +

                    ( aFSize * KKilo );

                UpdateDriveQuota( iDriveNumber, fillSpace );

                TInt64 timeinsecs((TInt64)(usecsFrom.Int64()/KCmFmOneSecond));

                // Update transfer history information

                iCmFmFillRuleFilledDataMngr->UpdateTransferHistoryData(

                    timeinsecs, aFSize,

                    iItems[iIndex]->DevId() );

                // Update progress info

                SendProgressInfo( KCmFmOneFile );

                if( iItems[iIndex]->Status() == ECmToBeShrinked )

                    {

                    // Let's update file status

                    TRAP( err, SetStatusL( aInternalItemId ) );

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

                    CompleteRequest( ECmFmShrinkImage );

                    }

                else