/*
* Copyright (c) 2002-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: Provides initializing of landmark database
*
*
*/


#include <d32dbms.h>

#include <epos_poslmcategoryhandler.h>
#include <epos_cposlmglobalcategoryreader.h>
#include <epos_landmarkdatabasestructure.h>
#include <epos_poslmdatabaseutility.h>

#include "epos_lmdebug.h"
#include "EPos_PosLmServerCommon.h"
#include "EPos_CPosLmServer.h"
#include "EPos_CPosLmNameIndex.h"
#include "epos_cposlmindexmanager.h"
#include "epos_poslmserverutility.h"
#include "EPos_CPosLmInitializer.h"

const TInt KEstimatedNoOfGlobalCategories = 15;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmInitializer::CPosLmInitializer( 
    CPosLmServer& aServer,
    MPosLmServerOperationObserver* aObserver)
:   CPosLmServerOperation( aServer, aObserver )
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmInitializer::ConstructL( const TDesC& aUri )
    {
    BaseConstructL(aUri);

    iGlCatReader = CPosLmGlobalCategoryReader::NewL();
    iGlobalCategoryCount = iGlCatReader->Count();
    
    iPhase = EPhaseRecovering;
    CompleteSelf();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmInitializer* CPosLmInitializer::NewL(
    CPosLmServer& aServer,
    MPosLmServerOperationObserver* aObserver,
    const TDesC& aUri )
    {
    CPosLmInitializer* self = new( ELeave ) CPosLmInitializer( aServer, aObserver );
    CleanupStack::PushL( self );
    self->ConstructL( aUri );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmInitializer::~CPosLmInitializer()
    {
    delete iGlCatReader;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmInitializer::RunL()
    {
    if ( iStatusFlag == KPosLmOperationNotComplete )
        {
        NextStepL(); // perform one more step
        }

    if ( iStatusFlag == KPosLmOperationNotComplete )
        {
        CompleteSelf(); // continue executing
        }
    // else - stop executing, operation complete
    
    NotifyClients();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CPosLmInitializer::RunError( TInt aError )
    {
    if ( aError == KErrDiskFull &&
         ( iPhase == EPhaseCreatingLmFieldIndex || 
           iPhase == EPhaseCreatingLmCatIndex ) )
        {
        iPhase++;       // ignore these phases
        CompleteSelf(); // and continue
        return KErrNone;
        }
    else
        {
        return CPosLmServerOperation::RunError( aError );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmInitializer::NextStepL()
    {
    TReal32 phaseProgress = 0.0;
    switch ( iPhase )
        {
        case EPhaseRecovering:
            phaseProgress = RecoveryNextStepL();
            break;
        case EPhaseCreateCatsStart:
        case EPhaseCreatingCats:
            phaseProgress = CreateCategoriesNextStepL();
            break;
        case EPhaseUpdateCatsStart:
        case EPhaseUpdatingCats:
            phaseProgress = UpdateCategoriesNextStepL();
            break;
        case EPhaseCreatingLmFieldIndex:
            phaseProgress = CreateLmFieldIndexNextStepL();
            break;
        case EPhaseCreatingLmCatIndex:
            phaseProgress = CreateLmCatIndexNextStepL();
            break;
        case EPhaseCompacting:
            phaseProgress = CompactNextStepL();
            break;
        case EPhaseBuildingLmNameIndex:
            phaseProgress = BuildLmNameIndexNextStepL();
            break;
        default:
            break;
        }
    
    UpdateTotalProgress( phaseProgress );

    if ( phaseProgress >= KOperationDone )
        {
        LOG3("Initializer: phase %d, progress %5.2f ( db '%S')", 
            iPhase, iProgress, iDbUri );
        iPhase++;
        }
    
    if ( iPhase == EPhaseDone )
        {
        iProgress = KOperationDone;
        iStatusFlag = KErrNone;
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::CreateCategoriesNextStepL()
    {
    TReal32 progress = 0.0;
    

    switch ( iPhase )
        {
        case EPhaseCreateCatsStart:
            {
            TBool initNeeded( EFalse );
            User::LeaveIfError( iDb->IsInitializeNeededL( initNeeded ) );

            if ( initNeeded )
                {
                iCategoryCounter = 0;
                RemoveAllGlobalCategoriesL();
                }
            else
                {
                progress = KOperationDone;
                }

            iPhase = EPhaseCreatingCats;
            break;
            }
        case EPhaseCreatingCats:
            {
            if ( iCategoryCounter < iGlobalCategoryCount )
                {
                // Add global category to database
                CPosLandmarkCategory* category =
                    iGlCatReader->GlobalCategoryLC( iCategoryCounter );

                iDiskUtilities->DiskSpaceBelowCriticalLevelL(
                    iDiskUtilities->EstimatedDiskSizeOfLmOperation(
                    CPosLmDiskUtilities::EAddLmCategoryOp, *category ), iDbDrive );

                PosLmCategoryHandler::AddCategoryL( *iDb, *category );
                CleanupStack::PopAndDestroy( category );
                
                // Increase counter and calculate progress
                ++iCategoryCounter;
                progress = TReal32( iCategoryCounter ) / TReal32( iGlobalCategoryCount );
                }
            break;
            }
        default:
            break;
        }

    // Check whether the operation is done or not
    if ( iCategoryCounter >= iGlobalCategoryCount || iGlobalCategoryCount == 0 )
    {
    	progress = KOperationDone;
    	iDb->SetLanguageL( User::Language() );
    }

	if(progress == KOperationDone)
	{
		iDb->SetInitializeDoneL();
	}
    
    
    return progress;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::UpdateCategoriesNextStepL()
    {
    TReal32 progress = 0.0;
    switch ( iPhase )
        {
        case EPhaseUpdateCatsStart:
            {
            TBool langChangeNeeded( EFalse );
            iDb->IsLanguageChangeNeededL( langChangeNeeded );

            if ( langChangeNeeded )
                {
                iCategoryCounter = 0;
                if ( iGlobalCategoryCount == 0 )
                    {
                    // There are no global categories defined
                    // so remove them all from database
                    RemoveAllGlobalCategoriesL();
                    progress = KOperationDone;
                    }
                }
            else
                {
                progress = KOperationDone;
                }
            iPhase = EPhaseUpdatingCats;
            break;
            }
        case EPhaseUpdatingCats:
            {
            if ( iCategoryCounter < iGlobalCategoryCount )
                {
                // Update global category in database
                CPosLandmarkCategory* category = iGlCatReader->GlobalCategoryLC( iCategoryCounter );
            
                iDiskUtilities->DiskSpaceBelowCriticalLevelL(
                    iDiskUtilities->EstimatedDiskSizeOfLmOperation(
                    CPosLmDiskUtilities::EUpdateLmCategoryOp, *category ), iDbDrive );
            
                PosLmCategoryHandler::UpdateGlobalCategoryNameL( *iDb, *category );
                CleanupStack::PopAndDestroy( category );
            
                // Increase counter and calculate progress
                ++iCategoryCounter;
                progress = TReal32( iCategoryCounter ) / TReal32( iGlobalCategoryCount );
                }
            break;
            }
        default:    
            break;
        }
    
    // Check whether the operation is done or not
    if ( iCategoryCounter >= iGlobalCategoryCount || iGlobalCategoryCount == 0 )
        {
        progress = KOperationDone;
        }
    
    if ( progress == KOperationDone )
        {
        iDb->SetLanguageL( User::Language() );
        }

    return progress;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmInitializer::RemoveAllGlobalCategoriesL()
    {
    iDiskUtilities->DiskSpaceBelowCriticalLevelL(
        iDiskUtilities->EstimatedDiskSizeOfLmOperation(
        CPosLmDiskUtilities::ERemoveLmCategoryOp,
        TPosLmItemId()) * KEstimatedNoOfGlobalCategories, iDbDrive);
    
    PosLmCategoryHandler::RemoveAllGlobalCategoriesL( *iDb );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::CreateLmFieldIndexNextStepL()
    {
    if ( !iIncrementalStarted )
        {
        iDiskUtilities->DiskSpaceBelowCriticalLevelL(
            PosLmServerUtility::EstimatedDiskSizeOfIndex(
                PosLmServerUtility::ECreateFieldsLmIdIndex,
                PosLmServerUtility::GetTableRowCountL( *iDb, KPosLmLandmarkFieldTable ) ), 
            iDbDrive );

        RDbNamedDatabase database;
        iDb->GetDatabase( database );

        if ( !PosLmServerUtility::IndexExistsL( database, KPosLmLandmarkFieldTable, KPosLmFieldsLmIdIndex ) )
            {
            CDbKey* key = CDbKey::NewLC();
            key->AddL( TDbKeyCol( KPosLmLandmarkIdCol ) );
    
            iDbIncremental.CreateIndex( 
                database,
                KPosLmFieldsLmIdIndex,
                KPosLmLandmarkFieldTable,
                *key,
                iIncrementalStep );
            CleanupStack::PopAndDestroy( key );

            iIncrementalStartValue = iIncrementalStep;
            iIncrementalStarted = ETrue;
            iCompactRequired = ETrue;
            }
        else
            {
            return KOperationDone;
            }
        }

    return IncrementalStepL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::CreateLmCatIndexNextStepL()
    {
    if ( !iIncrementalStarted )
        {
        iDiskUtilities->DiskSpaceBelowCriticalLevelL(
            PosLmServerUtility::EstimatedDiskSizeOfIndex(
                PosLmServerUtility::ECreateCategoriesLmIdIndex,
                PosLmServerUtility::GetTableRowCountL( *iDb, KPosLmLandmarkCategoryTable ) ), 
            iDbDrive );

        RDbNamedDatabase database;
        iDb->GetDatabase( database );

        if ( !PosLmServerUtility::IndexExistsL( database, KPosLmLandmarkCategoryTable, KPosLmCategoryLmIdIndex ) )
            {
            CDbKey* key = CDbKey::NewLC();
            key->AddL( TDbKeyCol( KPosLmLandmarkIdCol ) );
    
            iDbIncremental.CreateIndex( 
                database,
                KPosLmCategoryLmIdIndex,
                KPosLmLandmarkCategoryTable,
                *key,
                iIncrementalStep );
            CleanupStack::PopAndDestroy( key );

            iIncrementalStartValue = iIncrementalStep;
            iIncrementalStarted = ETrue;
            iCompactRequired = ETrue;
            }
        else
            {
            return KOperationDone;
            }
        }

    return IncrementalStepL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::RecoveryNextStepL()
    {
    if ( !iIncrementalStarted )
        {
        RDbNamedDatabase database;
        iDb->GetDatabase( database );

        if ( database.IsDamaged() )
            {
            User::LeaveIfError( iDbIncremental.Recover( database, iIncrementalStep ) );
            iIncrementalStartValue = iIncrementalStep;
            iIncrementalStarted = ETrue;
            }
        else
            {
            return KOperationDone;
            }
        }

    return IncrementalStepL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::IncrementalStepL()
    {
    if ( iIncrementalStep > 0 )
        {
        User::LeaveIfError( iDbIncremental.Next( iIncrementalStep ) );
        }
    
    if ( iIncrementalStep == 0 )
        {
        iDbIncremental.Close();
        iIncrementalStarted = EFalse;
        iIncrementalStep = 0;
        return KOperationDone;
        }
    else
        {
        return  TReal32( iIncrementalStartValue - iIncrementalStep ) / 
                TReal32( iIncrementalStartValue );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::BuildLmNameIndexNextStepL()
    {
    TReal32 progress = 0;
    if ( iServer.IndexManager().Find( *iDbUri ) >= 0 )
        {
        CPosLmNameIndex& index = iServer.IndexManager().Index( *iDbUri );
        TInt status = index.Status(); 
        switch ( status )
            {
            case KErrNotReady:
                progress = index.Evaluate();
                break;
            case KErrNone:
                progress = KOperationDone;
                break;
            default:
                User::Leave( status );
            }
        return progress;
        }
    else
        {
        return KOperationDone;
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TReal32 CPosLmInitializer::CompactNextStepL()
    {
    if ( !iIncrementalStarted )
        {
        if ( iCompactRequired || iDb->IsCompactNeededL() )
            {
            RDbNamedDatabase database;
            iDb->GetDatabase( database );
    
            User::LeaveIfError( iDbIncremental.Compact( database, iIncrementalStep ) );
            iIncrementalStartValue = iIncrementalStep;
            iIncrementalStarted = ETrue;
            }
        else
            {
            return KOperationDone;
            }
        }

    return IncrementalStepL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmInitializer::UpdateTotalProgress( TReal32 aCurrentPhaseProgress )
    {
    iProgress = 
        ( TReal32( iPhase - 1 ) + aCurrentPhaseProgress ) / 
        TReal32 ( EPhaseDone - 1 ); // all phases "-" final phase
    }