/*
* 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 Store manager component
*
*/


#include <e32property.h>
#include "upnpavdevice.h"
#include "upnpavcontroller.h"
#include "upnpavdevicelist.h"
#include <utf.h>
#include "cmserviceobserver.h"
#include "cmsmfilemngr.h"
#include "cmsmtransferengine.h"
#include "cmstorelistitem.h"
#include "cmdmmain.h"
#include "cmmmmain.h"
#include "cmsmmain.h"
#include "msdebug.h"

// One file transfered
const TInt KCmOneFile = 1;
const TInt KCmSmClfRefreshInterval = 15000000;
const TInt KCmSmOneSecond = 1000000;

// ---------------------------------------------------------------------------
// CCmSmMain::NewL
// ---------------------------------------------------------------------------
// 
CCmSmMain* CCmSmMain::NewL( 
    MCmServiceObserver* aObserver, CMdESession& aSession,
    CCmDmMain* aDBManager, CCmMmMain* aMemManager )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::NewL() start"));
    CCmSmMain* self = CCmSmMain::NewLC( aObserver, aSession,
        aDBManager, aMemManager );
    CleanupStack::Pop( self );
    LOG(_L("[STORE MNGR]\t CCmSmMain::NewL() end")); 
    return self;         
    }

// ---------------------------------------------------------------------------
// CCmSmMain::NewLC
// ---------------------------------------------------------------------------
//  
CCmSmMain* CCmSmMain::NewLC(
    MCmServiceObserver* aObserver, CMdESession& aSession, 
    CCmDmMain* aDBManager, CCmMmMain* aMemManager )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::NewLC() start"));    
    CCmSmMain* self = new ( ELeave ) CCmSmMain( aObserver, aDBManager, 
        aMemManager );
    CleanupStack::PushL( self );
    self->ConstructL( aSession, aDBManager );
    LOG(_L("[STORE MNGR]\t CCmSmMain::NewLC() end")); 
    return self;  
    }    

// ---------------------------------------------------------------------------
// CCmSmMain::~CCmSmMain
// ---------------------------------------------------------------------------
//
CCmSmMain::~CCmSmMain()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::~CCmSmMain() start"));
    Cancel();
    delete iCmSmTransferEngine;
    delete iCmSmFileMngr;
    DeleteDevices();
    iItems.ResetAndDestroy();
    iItems.Close();
    iItemIds.Reset();
    iItemIds.Close();
    delete iPeriodic;            
    LOG(_L("[STORE MNGR]\t CCmSmMain::~CCmSmMain() end"));     
    }

// ---------------------------------------------------------------------------
// CCmSmMain::CCmSmMain
// ---------------------------------------------------------------------------
//    
CCmSmMain::CCmSmMain( MCmServiceObserver* aObserver, CCmDmMain* aDBManager,
    CCmMmMain* aMemManager  ) 
    : CActive( EPriorityStandard ), iObserver( aObserver ), 
        iMemManager( aMemManager ), iDbManager( aDBManager )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::CCmSmMain"));
    
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------------------------
// CCmSmMain::ConstructL
// ---------------------------------------------------------------------------
//
void CCmSmMain::ConstructL( CMdESession& aSession, CCmDmMain* aDBManager )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::ConstructL() start"));
    iService = ECmServiceNone;
    iCmSmTransferEngine = 
        CCmSmTransferEngine::NewL( this, aDBManager, iItems, iItemIds );
    iCmSmFileMngr = 
        CCmSmFileMngr::NewL( this, aSession, aDBManager, iItems );
    LOG(_L("[STORE MNGR]\t CCmSmMain::ConstructL() end"));
    iProgressInfo.iService = ECmServiceStore;
    }     

// ---------------------------------------------------------------------------
// CCmSmMain::StartStoreL
// ---------------------------------------------------------------------------
//    
void CCmSmMain::StartStoreL()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::StartStoreL()"));
    if( iService == ECmServiceAutomStoreListProcess )
        {
        iCmSmFileMngr->CancelOperation();
        }
    iCancelOnGoing = EFalse;
    iService = ECmServiceStore;
    iMemManager->SetObserver( *this );
    iDeviceIndex = KErrNone;
    iProgressInfo.iService = ECmServiceStore;
    iProgressInfo.iProcessedItems = KErrNone;
    iProgressInfo.iTotalItems = iCmSmFileMngr->StoreItemCount() + 
        iCmSmFileMngr->FillItemCount();
    SendProgressInfo( KErrNone );    
    ChangeState( ECmSmGetMediaServers );
    }

// ---------------------------------------------------------------------------
// CCmSmMain::CancelOperation
// ---------------------------------------------------------------------------
//
void CCmSmMain::CancelOperation()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::CancelOperation()"));    
    // If some files need to be removed or shrinked do it now
    iCancelOnGoing = ETrue;
    iItems.ResetAndDestroy();
    iItems.Close();
    iItemIds.Reset();
    iItemIds.Close();
    iCmSmFileMngr->CancelOperation();    
    iCmSmTransferEngine->CancelOperation();              
    iObserver->ServiceExecuted( iService, KErrCancel );
    // Service finished. Reset progress info.
    iProgressInfo.iService = ECmServiceNone;
    iService = ECmServiceNone;
    SendProgressInfo( KErrNone );    
    }

// ---------------------------------------------------------------------------
// CCmSmMain::PreProcessLists
// ---------------------------------------------------------------------------
//
void CCmSmMain::PreProcessLists()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::PreProcessLists"));
    
    iCancelOnGoing = EFalse;
    if( iService == ECmServiceAutomStoreListProcess )
        {
        iCmSmFileMngr->CancelOperation();
        iCmSmFileMngr->SetProcessingStatus( ECmSmProcessingFilesStarted );
        }    
    else
        {
        ChangeState( ECmSmStartFileProcessing );
        }
    
    iService = ECmServicePreProcessingStore;
    }

// ---------------------------------------------------------------------------
// CCmSmMain::GetColItemsL
// ---------------------------------------------------------------------------
//
void CCmSmMain::GetColItemsL( TCmMediaType aMedia, 
    CDesCArray& aArray )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::GetColItemsL"));
    
    iCancelOnGoing = EFalse;
    if( iService == ECmServiceAutomStoreListProcess )
        {
        iCmSmFileMngr->CancelOperation();
        }    
    iService = ECmServiceGetStoreFields;
    iCmSmFileMngr->ProcessAlbumList( aMedia, aArray );
    }

// ---------------------------------------------------------------------------
// CCmSmMain::GetColItemsL
// ---------------------------------------------------------------------------
//
void CCmSmMain::GetColItemsL( TCmMediaType /*aMedia*/, 
    CCmSqlPropertyContainer& /*aPropertys*/ )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::GetColItemsL"));
    
    iService = ECmServiceGetFillFields;
    ChangeState( ECmSmFinishing );
    }
    
// ---------------------------------------------------------------------------
// CCmSmMain::SetAvController
// ---------------------------------------------------------------------------
//    
void CCmSmMain::SetAvController( MUPnPAVController* aAVController )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::SetAvController"));
    
    iCmSmTransferEngine->SetAvController(aAVController);
    }

// ---------------------------------------------------------------------------
// CCmSmMain::FileProcessingStatus
// ---------------------------------------------------------------------------
//    
void CCmSmMain::FileProcessingStatus( TCmSmFileProcessingStatus aStatus )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::FileProcessingStatus()"));
    
    CancelMdETimer();
    switch(aStatus)
        {
        case ECmSmProcessingFilesStarted:
            {
            if( iService == ECmServicePreProcessingStore )
                {
                ChangeState( ECmSmStartFileProcessing );
                }
            break;
            }
        case ECmSmProcessingFilesReady:
            {
            break;
            }
        case ECmSmProcessingCanceled:
            {           
            break;
            }
        case ECmSmNoStoreRulesSelected:
            {
            if( iService == ECmServiceAutomStoreListProcess )
                {
                // Do not complete message
                }
            else
                {
                ChangeState( ECmSmFinishing );
                }                                        
            break;
            }
        case ECmSmPreProcessingReady:
            {
            if( iService == ECmServiceAutomStoreListProcess )
                {
                // Do not complete message
                }
            else
                {
                iObserver->ServiceExecuted( iService, KErrNone );
                }
            iService = ECmServiceNone;                    
            break;
            }
        case ECmSmRefreshError:
            {
            if( iService == ECmServiceAutomStoreListProcess )
                {
                // Do not complete message
                }
            else
                {
                iObserver->ServiceExecuted( iService, 
                    KErrGeneral );
                }
            iService = ECmServiceNone;                                
            break;
            }
        case ECmSmAlbumProcessingReady:
            {
            if( iService == ECmServiceAutomStoreListProcess )
                {
                // Do not complete message
                }
            else
                {
                iObserver->ServiceExecuted( iService, KErrNone );
                }
            iService = ECmServiceNone;                                  
            break;
            }
        case ECmSmContentChanged:
            {
            // If timer start up fails => wait next content change event
            TRAPD( err, StartMdETimerL() );
            if( err )
                {
                TRACE(Print(_L("[STORE MNGR]\t StartMdETimerL err = %d"), 
                    err ));
                }           
            break;
            }
        default:
            {
            break;
            }    
        }
    
    }
    
// ---------------------------------------------------------------------------
// CCmSmMain::TransferStatus
// ---------------------------------------------------------------------------
//    
void CCmSmMain::TransferStatus( TCmSmTransferStatus aStatus )    
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::TransferStatus()"));
    switch( aStatus )
        {
        case ECmSmTransferCompleted:
            {
            TTime storeFinished;
            storeFinished.HomeTime();
            TTimeIntervalMicroSeconds usecsFrom = 
                storeFinished.MicroSecondsFrom(iStoreStarted);
            TInt64 timeinsecs((TInt64)( usecsFrom.Int64() / KCmSmOneSecond ));
            TRACE(Print(_L("[STORE MNGR]\t Store took = %ld seconds"), 
                timeinsecs ));                        
                
            iCmSmFileMngr->UpdateTransferHistoryData( timeinsecs, 
                iCmSmTransferEngine->DataAmount(), (TUint8)iId );            
            ChangeState( ECmSmManageFiles );
            break;
            }
        case ECmSmAborted:
            {
            ChangeState( ECmSmStartCopying );            
            break;
            }
        case ECmSmTransferCanceled:
            {           
            break;
            }
        case ECmSmFileTransferred:
            {
            SendProgressInfo( KCmOneFile );
            break;
            }
        case ECmSmFileTransferFailed:
            {
            // File transferring failed => skip file
            SendProgressInfo( KCmOneFile );
            break;
            }
        case ECmSmWlanLost:
            {
            if( iDevices )
                {
                iDevices->ResetAndDestroy();
                delete iDevices;
                iDevices = NULL;                
                }
            iItemIds.Reset();
            iItemIds.Close();
            iCmSmFileMngr->ResetArrays();    
            iObserver->ServiceExecuted( iService, KErrGeneral );
            iProgressInfo.iService = ECmServiceNone;
            iService = ECmServiceNone;
            SendProgressInfo( KErrNone );
            break;
            }
        case ECmSmTransferContinued:
            {
            ChangeState( ECmSmContinueCopying ); 
            break;
            }
        default:
            {
            break;
            }                
        }
    }

#ifdef _DEBUG 
// ---------------------------------------------------------------------------
// CCmSmMain::LogServers
// ---------------------------------------------------------------------------
//
void CCmSmMain::LogServers()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::LogServers"));
    
    for( TInt i = 0; i < iDevices->Count(); i++ )
        {
        TBuf<KMaxName>temp;
        if((*iDevices)[i])
            {
            if( &(*iDevices)[i]->Uuid() )
                {
                if( (*iDevices)[i]->Uuid().Length() < KMaxName )
                    {
                    temp.Copy( (*iDevices)[i]->Uuid() );
                    TRACE(Print(_L("[STORE MNGR]\t FOUND DEVICE %d = %S"), 
                        i+1, &temp ));        
                    }
                temp.Zero();                
                }            
            }        
        }            
    }
#endif

// ---------------------------------------------------------------------------
// CCmSmMain::SendProgressInfo
// ---------------------------------------------------------------------------
//
void CCmSmMain::SendProgressInfo( TInt aProgress ) 
    {
    TRACE( Print( _L(
        "[STORE MNGR]\t CCmSmMain::SendProgressInfo( %d )"), 
        aProgress));
    
    iProgressInfo.iProcessedItems += aProgress;
    TRAPD( error, iCmSmFileMngr->GetStoreFileCountNoDuplicatesL( 
        iProgressInfo.iItemsToTransferPerService ) );
    if ( error ) 
        {
        TRACE( Print( _L( "[STORE MNGR]\t GetStoreFileCountNoDuplicatesL \
            failed with error %d"), error ) );
        }
    TCmProgressInfoPckg progressPckg( iProgressInfo );
    
    TRACE( Print( _L(
        "[STORE MNGR]\t processed: %d total %d"), 
        iProgressInfo.iProcessedItems, iProgressInfo.iTotalItems));
    
    TInt err = RProperty::Set( KCmPropertyCat, KCmProperty, progressPckg );
    
    TRACE( Print( _L("[STORE MNGR]\t RProperty::Set returned %d"), err));
    }

// ---------------------------------------------------------------------------
// CCmSmMain::ManageFileL
// ---------------------------------------------------------------------------
//
void CCmSmMain::ManageFileL()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::ManageFileL"));
    
    if( KErrNone < iCmSmTransferEngine->FilesToBeRemoved().Count() )
        {
        iMemManager->DeleteFilesL( iCmSmTransferEngine->FilesToBeRemoved() );
        }
    else if ( KErrNone < iCmSmTransferEngine->FilesToBeShrinked().Count() )
        {
        TRAPD( err, iMemManager->ShrinkImagesL( 
            iCmSmTransferEngine->FilesToBeShrinked() ) );
        if( err )
            {
            ChangeState( ECmSmStartCopying );
            }
        }
    else if( iCancelOnGoing )
        {
        ChangeState( ECmSmFinishCanceling );      
        }
    else
        {
        // Store to next server...        
        ChangeState( ECmSmStartCopying );  
        }    
    }

// ---------------------------------------------------------------------------
// CCmSmMain::DeleteCompleteL
// ---------------------------------------------------------------------------
//
void CCmSmMain::DeleteCompleteL( TInt /*aErr*/ )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteCompleteL"));
    
    iCmSmTransferEngine->DeleteToBeRemoved();
    ManageFileL();
    }

// ---------------------------------------------------------------------------
// CCmSmMain::ShrinkCompleteL
// ---------------------------------------------------------------------------
//    
void CCmSmMain::ShrinkCompleteL( TInt /*aErr*/ )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::ShrinkCompleteL"));
    
    iCmSmTransferEngine->DeleteToBeShrinked();
    ManageFileL();    
    }

// ---------------------------------------------------------------------------
// CCmSmMain::ChangeState
// ---------------------------------------------------------------------------
// 
void CCmSmMain::ChangeState( 
    TCmSmMainSequencer aStatus )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::ChangeState"));
    
    __ASSERT_DEBUG(!IsActive(),\
        User::Panic( KCmSmManager, KErrInUse ));          
    SetActive();
    TRequestStatus* pStatus = &iStatus;
    User::RequestComplete( pStatus, aStatus );
    }
    
// ---------------------------------------------------------------------------
// CCmSmMain::StartMdETimerL
// ---------------------------------------------------------------------------
// 
void CCmSmMain::StartMdETimerL()
    {
    LOG( _L("[STORE MNGR] CCmSmMain::StartMdETimerL start"));
    
    if( iPeriodic )
        {
        iPeriodic->Cancel();
        }
    else
        {
        iPeriodic = CPeriodic::NewL( CActive::EPriorityIdle );
        }
    iPeriodic->Start( KCmSmClfRefreshInterval, KCmSmClfRefreshInterval,
            TCallBack( CheckItems, this ) );
    LOG( _L("[STORE MNGR] CCmSmMain::StartMdETimerL end"));                    
    }

// ---------------------------------------------------------------------------
// CCmSmMain::CancelMdETimer
// ---------------------------------------------------------------------------
//     
void CCmSmMain::CancelMdETimer()
    {
    LOG( _L("[STORE MNGR] CCmSmMain::CancelMdETimer start"));
    
    if( iPeriodic )
        {
        iPeriodic->Cancel();
        }
    LOG( _L("[STORE MNGR] CCmSmMain::CancelMdETimer end"));        
    } 
    
// -----------------------------------------------------------------------------
// CCmSmMain::CheckItems
// -----------------------------------------------------------------------------
//
TInt CCmSmMain::CheckItems( TAny* aPtr )
    {
    LOG( _L("[STORE MNGR] CCmSmMain::CheckItems"));
    
    return ( (CCmSmMain*)aPtr)->CheckItemsChanged();
    }
    
// -----------------------------------------------------------------------------
// CCmSmMain::CheckItemsChanged
// -----------------------------------------------------------------------------
//
TInt CCmSmMain::CheckItemsChanged( )
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::CheckItemsChanged"));
    
    TInt restart( 1 );
    if( iService == ECmServiceNone )
        {
        LOG( _L("[STORE MNGR] Starting autom. store list process..."));
        iService = ECmServiceAutomStoreListProcess;
        iCmSmFileMngr->StartProcessing();
        }
    else
        {
        LOG( _L("[STORE MNGR] Store manager busy wait another x mins..."));
        restart = 0;
        }                        
    return restart;
    }
        
// ---------------------------------------------------------------------------
// CCmSmMain::DeleteDevices
// ---------------------------------------------------------------------------
// 
void CCmSmMain::DeleteDevices()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteDevices"));
    
    if ( iDevices )
        {
        iDevices->ResetAndDestroy();
        delete iDevices;
        iDevices = NULL;
        }    
    }
    
// ---------------------------------------------------------------------------
// CCmSmMain::RunL
// ---------------------------------------------------------------------------
//    
void CCmSmMain::RunL()
    {
    TRACE(Print(_L("[STORE MNGR]\t CCmSmMain::RunL status = %d"),
                iStatus.Int() ));
                
    switch( iStatus.Int() )
        {
        case ECmSmGetMediaServers:
            {
            DeleteDevices();            
            TRAPD( err, iCmSmTransferEngine->GetMediaServersL( iDevices ) );
            TRACE(Print(_L("[STORE MNGR]\t GetMediaServersL err = %d"), 
                err ));            
            if( err || 0 == iDevices->Count() )
                {
                iObserver->ServiceExecuted( iService, KErrNotFound );
                iService = ECmServiceNone;
                }
            else
                {
#ifdef _DEBUG            
                LogServers();
#endif        
                iDeviceIndex = 0;
                // Load store list into memory
                iCmSmFileMngr->LoadStoreFileListL();
                iCmSmTransferEngine->ResetFileArrays();    
                ChangeState( ECmSmStartCopying );                 
                }                           
            break;
            }
        case ECmSmStartFileProcessing:
            { 
            if( iService == ECmServicePreProcessingStore )
                {
                iCmSmFileMngr->StartProcessing();
                }
            break;
            }
        case ECmSmStartCopying:
            {
            LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteDevices \
                    start file copy"));

            iStoreStarted.HomeTime();    
            if( iDeviceIndex < iDevices->Count())
                {                    
                iCmSmFileMngr->GetItemsL( iItemIds, 
                    (*iDevices)[iDeviceIndex]->Uuid(), iId );
                if( KErrNone < iItemIds.Count() )
                    {
                    LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteDevices \
                    files to be copied"));
                    iCmSmTransferEngine->CopyFilesL( (TUint8)iId, 
                        (*iDevices)[iDeviceIndex] );
                    }
                else
                    {
                    // Jump to next device
                    LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteDevices \
                    undefined mediaserver - no items"));
                    ChangeState( ECmSmStartCopying );
                    }    
                iDeviceIndex++;
                }
            else
                {
                iCmSmFileMngr->DeleteItems(
                    iCmSmTransferEngine->ToBeDeleted() );
                iCmSmFileMngr->UpdateStoreFileListL();
                iDbManager->SetProgressInfo( iProgressInfo.iProcessedItems, 
                    iProgressInfo.iTotalItems );
                DeleteDevices();
                iItemIds.Reset();
                iItemIds.Close();
                iCmSmFileMngr->ResetArrays();    
                iObserver->ServiceExecuted( iService, KErrNone );
                iService = ECmServiceNone;
                }    
            break;
            }
        case ECmSmContinueCopying:
            {
            iCmSmTransferEngine->ContinueCopyFilesL();
            break;
            }
        case ECmSmFinishing:
            {
            LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteDevices no \
            rules selected"));
            iObserver->ServiceExecuted( iService, 
                KErrNone );
            iService = ECmServiceNone;                            
            break;
            }
        case ECmSmManageFiles:
            {
            ManageFileL();
            break;
            }
        case ECmSmFinishCanceling:
            {
            iCancelOnGoing = EFalse;
            // Before canceling update content of the db    
            if( KErrNone < iItems.Count() )
                {
                iCmSmFileMngr->DeleteItems( 
                    iCmSmTransferEngine->ToBeDeleted() );
                iCmSmFileMngr->UpdateStoreFileListL();        
                }            
            if( IsActive() )
                {
                Cancel();
                }           
            break;
            }
        default:
            {
            LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteDevices \
            no defined status"));
            break;
            }    
        }
    }
    
// ---------------------------------------------------------------------------
// CCmSmMain::Close
// ---------------------------------------------------------------------------
//      
void CCmSmMain::Close()
    {
    LOG(_L("[STORE MNGR]\t CCmSmMain::Close"));
    
    delete this;
    }

// ---------------------------------------------------------------------------
// CCmSmMain::DoCancel
// ---------------------------------------------------------------------------
//    
void CCmSmMain::DoCancel()
    {
    TRACE(Print(_L("[STORE MNGR]\t CCmSmMain::DoCancel()")));
    }

// ---------------------------------------------------------------------------
// CCmSmMain::RunError
// ---------------------------------------------------------------------------
//   
TInt CCmSmMain::RunError( TInt aError )
    {
    TRACE(Print(_L("[STORE MNGR]\t RunError aError = %d"), aError ));
    return aError;
    }
    
// End of file