/*
* Copyright (c) 2005 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: Operation for resetting global categories.
*
*
*/


// INCLUDE FILES
#include    <EPos_LandmarksErrors.h>
#include    <epos_cposlmglobalcategoryreader.h>
#include    <epos_poslmcategoryhandler.h>
#include    <eposlmasyncops.rsg>
#include    <epos_cposlmlocaldbaccess.h>
#include    "EPos_CPosLmLocalResetGlobalCatOp.h"
#include    "epos_cposlmlocaldatabase.h"
#include    "EPos_CPosLmLocalCategoryManager.h"
#include    "EPos_LocalLandmarks.h"

// CONSTANTS
const TReal32 KReadGlCat =              0.2f;
const TReal32 KResetGlCat =             0.5f;
const TReal32 KCheckGlCatToBeRemoved =  0.1f;
const TReal32 KRemoveNotInResource =    0.2f;

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

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::CPosLmLocalResetGlobalCatOp
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPosLmLocalResetGlobalCatOp::CPosLmLocalResetGlobalCatOp(
    CPosLmLocalDatabase& aDb) :
    CPosLmLocalModifyOp(aDb),
    iState(EReadGlCat)
    {
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::ConstructL()
    {
    BaseConstructL();
    ReadInfoFromResourceFileL(R_POS_LM_LOCAL_RESET_GLOBAL_CATEGORIES_OP);
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPosLmLocalResetGlobalCatOp* CPosLmLocalResetGlobalCatOp::NewL(
    CPosLmLocalDatabase& aDb)
    {
    CPosLmLocalResetGlobalCatOp* self = new(ELeave) CPosLmLocalResetGlobalCatOp(
        aDb);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// Destructor
CPosLmLocalResetGlobalCatOp::~CPosLmLocalResetGlobalCatOp()
    {
    RollbackAndRegisterIfNeeded();
    iModifiedGlCats.Close();
    iToBeRemoved.Close();
    delete iGlCatReader;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::DoNextStepPreL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::DoNextStepPreL(
    TReal32& aProgress)
    {
    switch (iState)
        {
        case EReadGlCat:
            iGlCatReader = CPosLmGlobalCategoryReader::NewL();
            aProgress = KReadGlCat;
            break;
        case EResetGlCat:
            ResetCategoryPreL(aProgress);
            break;
        case ECheckGlCatToBeRemoved:
            // Find global categories to be removed (not in resource file)
            PosLmCategoryHandler::GetGlobalCategoriesL(*iDb->DatabaseAccess(),
                iModifiedGlCats, iToBeRemoved);
            iCurrent = 0; // Reset counter, so it can be reused
            aProgress = KReadGlCat + KResetGlCat + KCheckGlCatToBeRemoved;
            break;
        default: //ERemoveNotInResource
            RemoveCategoryNotInResourceL(aProgress);
            break;
        }
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::DoNextStepPostL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPosLmLocalResetGlobalCatOp::DoNextStepPostL(
    TReal32& /*aProgress*/)
    {
    switch (iState)
        {
        case EReadGlCat:
            iState = EResetGlCat;
            return ETrue;
        case EResetGlCat:
            if (iGlCatReader->Count() == 0 || iCurrent == iGlCatReader->Count())
                {
                // Done with reset, so step into next step.
                iState = ECheckGlCatToBeRemoved;
                }
            return ETrue;
        case ECheckGlCatToBeRemoved:
            iState = ERemoveNotInResource;
            return ETrue;
        default: //ERemoveNotInResource
            if (iToBeRemoved.Count() == 0 || iCurrent == iToBeRemoved.Count())
                {
                // Operation done
                iStatusFlag = KErrNone;

                User::LeaveIfError(
                    iDb->RegisterEvent(EPosLmEventCategoryUnknownChanges));

                return EFalse;
                }
            return ETrue;
        }
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::Step
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TReal32 CPosLmLocalResetGlobalCatOp::Step()
    {
    TReal32 step;

    switch (iState)
        {
        case EReadGlCat:
            step = KReadGlCat;
            break;
        case EResetGlCat:
            if (iGlCatReader->Count() > 0)
                {
                step = KResetGlCat/iGlCatReader->Count();
                }
            else
                {
                step = KResetGlCat;
                }
            break;
        case ECheckGlCatToBeRemoved:
            step = KCheckGlCatToBeRemoved;
            break;
        default: //ERemoveNotInResource
            if (iToBeRemoved.Count() > 0)
                {
                step = KCheckGlCatToBeRemoved/iToBeRemoved.Count();
                }
            else
                {
                step = KCheckGlCatToBeRemoved;
                }
            break;
        }

    return step;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::CheckResourceValue
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::CheckResourceValue(
    TInt /*aResourceId*/,
    TInt aNoOfSubOperations)
    {
    __ASSERT_ALWAYS(aNoOfSubOperations > 0, Panic(KPosLandmarksClientPanic,
        EPosInvalidValueSpecifiedInResourceFile));
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::HandleError
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::HandleError(
    TInt& aError)
    {
    iStatusFlag = aError;
    RollbackAndRegisterIfNeeded();
    iState = EError;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::ResetCategoryPreL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::ResetCategoryPreL(
    TReal32& aProgress)
    {
    for (TInt i = 0; i < iNoOfSubOperations &&
        iCurrent < iGlCatReader->Count(); i++)
        {
        ResetCategoryL(iCurrent++);
        }

    if (iGlCatReader->Count() != 0)
        {
        aProgress = KReadGlCat +
            (TReal32(iCurrent)/iGlCatReader->Count()) * KResetGlCat;
        }
    else
        {
        aProgress = KReadGlCat + KResetGlCat;
        }
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::RemoveCategoryNotInResourceL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::RemoveCategoryNotInResourceL(
    TReal32& aProgress)
    {
    // Remove global categories not in the resource file
    if (iToBeRemoved.Count() > 0)
        {
        PosLmCategoryHandler::RemoveCategoryL(*iDb->DatabaseAccess(),
            iToBeRemoved[iCurrent++]);
        }

    if (iToBeRemoved.Count() != 0)
        {
        aProgress = KResetGlCat + KResetGlCat + KCheckGlCatToBeRemoved +
            (TReal32(iCurrent)/iToBeRemoved.Count()) * KRemoveNotInResource;
        }
    else
        {
        aProgress = KReadGlCat + KResetGlCat + KCheckGlCatToBeRemoved +
            KRemoveNotInResource;
        }
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::ResetCategoryL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::ResetCategoryL(
    TInt aIndex)
    {
    CPosLandmarkCategory* glCategory =
        iGlCatReader->GlobalCategoryLC(aIndex);

    PosLmCategoryHandler::ResetGlobalCategoryL(*iDb->DatabaseAccess(),
        *glCategory);

    User::LeaveIfError(iModifiedGlCats.Append(glCategory->GlobalCategory()));

    CleanupStack::PopAndDestroy(glCategory);
    }

// -----------------------------------------------------------------------------
// CPosLmLocalResetGlobalCatOp::RollbackAndRegisterIfNeeded
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalResetGlobalCatOp::RollbackAndRegisterIfNeeded()
    {
    RollbackIfNeeded();

    // If progress is not made or an error has occured
    // previously, an event should not be registred
    if (Progress() > KReadGlCat && iState != EError)
        {
        iDb->RegisterEvent(EPosLmEventCategoryUnknownChanges);
        }

    // Reset flag: rollback and event generation should not be done twice.
    iStatusFlag = KErrNone;
    }

//  End of File