/*

* 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:  CMSFillRuleController class implementation

*

*/

#include <StringLoader.h>

#include <mediaservant.rsg>

#include <utf.h>

#include "cmfillrulecontainer.h"

#include "cmfillrule.h"

#include "msfillrulecontroller.h"

#include "msconstants.h"

#include "mediaservant.hrh"

#include "msengine.h"

#include "msdebug.h"

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

// CMSFillRuleController::NewL

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

//

CMSFillRuleController* CMSFillRuleController::NewL( CMSEngine& aMSEngine )

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::NewL"));

    CMSFillRuleController* self = CMSFillRuleController::NewLC( aMSEngine );    

    CleanupStack::Pop(self);

    return self;

    }

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

// CMSFillRuleController::NewLC

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

//

CMSFillRuleController* CMSFillRuleController::NewLC( CMSEngine& aMSEngine )

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::NewLC"));

    CMSFillRuleController* self = new (ELeave) CMSFillRuleController(

                                                    aMSEngine );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CMSFillRuleController::ConstructL

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

//

void CMSFillRuleController::ConstructL()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::ConstructL"));

    if (iMSEngine)

        {

        InitializeRuleContainersL();

        }

    }

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

// CMSFillRuleController::CMSFillRuleController()

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

//

CMSFillRuleController::CMSFillRuleController( CMSEngine& aMSEngine )

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::CMSFillRuleController"));

    iMSEngine = &aMSEngine;

    }

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

// CMSFillRuleController::~CMSFillRuleController()

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

//

CMSFillRuleController::~CMSFillRuleController()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::~CMSFillRuleController"));

    iFillListArray.ResetAndDestroy();

    iFillListArray.Close();

    delete iRuleContainer;

    }

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

// CMSFillRuleController::FillListArray()

// Returns pointer to fill list array

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

//

RPointerArray<CMSFillList>* CMSFillRuleController::FillListArray()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::FillListArray"));

    return &iFillListArray;

    }

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

// CMSFillRuleController::InitializeRuleContainersL

// initializes rule containers

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

//

void CMSFillRuleController::InitializeRuleContainersL()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::\

    InitializeRuleContainersL"));

    TInt error( KErrNone );

    // Check if wizard has been executed

    TBool runWizard = iMSEngine->GetAppWizardState( error );

    if ( !runWizard  )

        {

        CreateFillRulesL();

        delete iRuleContainer;

        iRuleContainer = NULL;

        iRuleContainer = iMSEngine->FillRulesL();

        }

    else

        {

        // FILL RULES

        iRuleContainer = iMSEngine->FillRulesL();

        }

    // Creates pointer array to rules so we can change rule order at UI

    // Operations done trough pointer array affects original rules

    // in RuleContainer

    if ( iRuleContainer )

        {

        // Arrange rules by priority to pointer table

        TInt rulecount = iRuleContainer->FillRuleCount();

        for (TUint8 order = 0; order < rulecount; order++)

            {

            // search rule with desired priority

            for (TInt index = 0; index < rulecount; index++)

                {

                CCmFillRule* rule = iRuleContainer->FillRule(index);

                TUint8 priority = rule->Priority();

                if ( order == priority )

                    {

                    CMSFillList* list =

                        CMSFillList::NewL( *iMSEngine, *rule );

                    // add list to array

                    iFillListArray.AppendL( list );

                    // stop for loop

                    index = rulecount;

                    }

                }

            }

        }

    }

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

// CMSFillRuleController::CreateFillRulesL()

// FOR TEST

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

//

void CMSFillRuleController::CreateFillRulesL()

    {

    CCmFillRuleContainer* fillRuleContainer = CCmFillRuleContainer::NewLC();

    // default list 1

    CCmFillRule* defaultList1 = CCmFillRule::NewLC();

    HBufC* temp = StringLoader::LoadLC( R_MS_DEFAULT_FILL_LIST_1 );

    HBufC8* listName = CnvUtfConverter::ConvertFromUnicodeToUtf8L( *temp );

    CleanupStack::PushL( listName );

    defaultList1->SetNameL( *listName );

    CleanupStack::PopAndDestroy( 2, temp );

    defaultList1->SetMediaType( ECmImage );

    defaultList1->SetMethod( ECmLatest );

    defaultList1->SetSelected( ECmUnSelected );

    defaultList1->SetPriority( 0 );

    defaultList1->SetTemplateId( EMSDefaultImageList );

    defaultList1->SetStatus( ECmToBeFilled );

    defaultList1->SetLimitType( EMbits );

    defaultList1->SetAmount( KDefaultListSize50 );

    fillRuleContainer->AddFillRuleL( defaultList1 );

    // default list 2

    CCmFillRule* defaultList2 = CCmFillRule::NewLC();

    temp = StringLoader::LoadLC( R_MS_DEFAULT_FILL_LIST_2 );

    listName = CnvUtfConverter::ConvertFromUnicodeToUtf8L( *temp );

    CleanupStack::PushL( listName );

    defaultList2->SetNameL( *listName );

    CleanupStack::PopAndDestroy( 2, temp );

    defaultList2->SetMediaType( ECmVideo );

    defaultList2->SetMethod( ECmLatest );

    defaultList2->SetSelected( ECmUnSelected );

    defaultList2->SetPriority( 1 );

    defaultList2->SetTemplateId( EMSDefaultVideoList );

    defaultList2->SetStatus( ECmToBeFilled );

    defaultList2->SetLimitType( EMbits );

    defaultList2->SetAmount( KDefaultListSize50 );

    fillRuleContainer->AddFillRuleL( defaultList2 );

    // default list 3

    CCmFillRule* defaultList3 = CCmFillRule::NewLC();

    temp = StringLoader::LoadLC( R_MS_DEFAULT_FILL_LIST_3 );

    listName = CnvUtfConverter::ConvertFromUnicodeToUtf8L( *temp );

    CleanupStack::PushL( listName );

    defaultList3->SetNameL( *listName );

    CleanupStack::PopAndDestroy( 2, temp );

    defaultList3->SetMediaType( ECmAudio );

    defaultList3->SetMethod( ECmLatest );

    defaultList3->SetSelected( ECmUnSelected );

    defaultList3->SetPriority( 2 );

    defaultList3->SetTemplateId( EMSDefaultMusicList );

    defaultList3->SetStatus( ECmToBeFilled );

    defaultList3->SetLimitType( EMbits );

    defaultList3->SetAmount( KDefaultListSize200 );

    fillRuleContainer->AddFillRuleL( defaultList3 );

    iMSEngine->SetFillRulesL( fillRuleContainer );

    CleanupStack::Pop( defaultList3 );

    CleanupStack::Pop( defaultList2 );

    CleanupStack::Pop( defaultList1 );

    CleanupStack::PopAndDestroy( fillRuleContainer );

    }

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

// CMSFillRuleController::DeleteRuleL()

// Deletes current rule

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

//

void CMSFillRuleController::DeleteRuleL( TInt aCurrentIndex )

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::DeleteRuleL"));

    // get priority of selected rule

    TInt currentPriority =

            iFillListArray[ aCurrentIndex ]->List()->Priority();

    // Rulecontainer must be scanned to find the index index of

    // rule container.

    // Priority can be used to compare because there can't be two rules

    // with same priority.

    for (TInt index = 0; index < iRuleContainer->FillRuleCount(); index++)

        {

        if (currentPriority == iRuleContainer->FillRule( index )->Priority())

            {

            iFillListArray[ aCurrentIndex ]->

                    List()->SetSelected( ECmDeleted );

            }

        }

    // recalculate priorities

    SetPriorities();

    // store rules to server

    iMSEngine->SetFillRulesL( iRuleContainer );

    // update pointer array

    UpdateArrayL();

    }

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

// CMSFillRuleController::AddRuleL()

// Adds new rule

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

//

void CMSFillRuleController::AddRuleL( CCmFillRule* aRule )

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::DeleteRuleL"));

    if ( aRule )

        {

        TInt priority = iFillListArray.Count();

        aRule->SetPriority( priority );

        iRuleContainer->AddFillRuleL( aRule );

        // store rules to server

        iMSEngine->SetFillRulesL( iRuleContainer );

        // update pointer array

        UpdateArrayL();

        }

    }

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

// CMSFillRuleController::SetPriorities()

// Sets priorities of rule array

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

//

void CMSFillRuleController::SetPriorities()

    {

    TInt priority = 0;

    for ( TInt index = 0; index < iFillListArray.Count(); index++ )

        {

        if ( iFillListArray[index]->List()->Selected() != ECmDeleted )

            {

            iFillListArray[index]->List()->SetPriority( priority );

            priority++; // next list priority

            }

        }

    }

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

// CMSFillRuleController::compare()

// For sort. Sort is based on rule priority

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

//

TInt CMSFillRuleController::compare ( const CMSFillList& rule1,

                                      const CMSFillList& rule2)

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::compare"));

    TInt result = 0;

    if ( rule1.Priority() < rule2.Priority() )

        {

        result = -1;

        }

    else if ( rule1.Priority() > rule2.Priority() )

        {

        result = 1;

        }

    return result;

    }

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

// CMSFillRuleController::ChangePriority()

// Change priorities of rules

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

//

void CMSFillRuleController::ChangePriority( TUint aTotalItem,

                                            TUint aCurrentItem,

                                            TInt aDirection )

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::ChangePriority"));

    TLinearOrder<CMSFillList> key(CMSFillRuleController::compare);

    // up

    if (aDirection == -1 && aCurrentItem)

        {

        // swap priotities of rules

        iFillListArray[aCurrentItem]->List()->SetPriority(aCurrentItem-1);

        iFillListArray[aCurrentItem-1]->List()->SetPriority(aCurrentItem);

        iFillListArray.Sort(key);

        }

    // down

    else if ( aDirection == 1 && aCurrentItem < aTotalItem - 1 )

        {

        // swap priotities of rules

        iFillListArray[aCurrentItem]->List()->SetPriority(aCurrentItem+1);

        iFillListArray[aCurrentItem+1]->List()->SetPriority(aCurrentItem);

        iFillListArray.Sort(key);

        }

    else

        {

        // Do nothing

        }

    }

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

// CMSFillRuleController::UpdateArrayL()

// Resets old fill rule array and reads new rules from server

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

//

void  CMSFillRuleController::UpdateArrayL()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::UpdateArrayL"));

    // FILL RULES

    delete iRuleContainer;

    iRuleContainer = NULL;

    iRuleContainer = iMSEngine->FillRulesL();

    // Creates pointer array to rules so we can change rule order at UI

    // Operations done trough pointer array affects original rules

    // in RuleContainer

    if ( iRuleContainer )

        {

        iFillListArray.ResetAndDestroy();

        // Arrange rules by priority to pointer table

        TInt rulecount = iRuleContainer->FillRuleCount();

        for (TUint8 order = 0; order < rulecount; order++)

            {

            // search rule with desired priority

            for (TInt index = 0; index < rulecount; index++)

                {

                CCmFillRule* rule = iRuleContainer->FillRule(index);

                TUint8 priority = rule->Priority();

                if ( order == priority )

                    {

                    // stop for loop

                    index = rulecount;

                    CMSFillList* list =

                            CMSFillList::NewLC( *iMSEngine, *rule );

                    // add rule to array

                    iFillListArray.AppendL( list );

                    CleanupStack::Pop( list );

                    }

                }

            }

        }

    }

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

// CMSFillRuleController::SaveRulesL()

// Sends fill rules to server

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

//

void  CMSFillRuleController::SaveRulesL()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::SaveRulesL"));

    iMSEngine->SetFillRulesL( iRuleContainer );

    }

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

// CMSFillRuleController::HasPriorityChangedL()

// Checks if list priorities has been changed

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

//

TBool CMSFillRuleController::HasPriorityChangedL()

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::\

    HasPriorityChangedL"));

    TBool status( EFalse );

    CCmFillRuleContainer* fillLists = iMSEngine->FillRulesL();

    CleanupStack::PushL( fillLists );

    TInt listCount = fillLists->FillRuleCount();

    TInt arrayCount = iFillListArray.Count();

    if ( listCount == arrayCount )

        {

        for ( TInt index = 0; index < listCount; index++ )

            {

            CCmFillRule* origList = fillLists->FillRule(index);

            TInt origPriority = origList->Priority();

            // lists are in priority order in iFillListArray

            CCmFillRule* modList = iFillListArray[ origPriority ]->List();

            // if list names are same we have the same lists

            if ( origList->Name().Compare( modList->Name() ) )

                {

                status = ETrue;

                index = listCount; // break loop

                }

            }

        }

    else

        {

        status = ETrue;

        }

    CleanupStack::PopAndDestroy( fillLists );

    return status;

    }

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

// CMSFillRuleController::HasSelectionsChanged()

// Checks if list activity has been changed

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

//

TBool CMSFillRuleController::HasSelectionsChanged( TCmFillRuleStatus aStatus )

    {

    LOG(_L("[MediaServant]\t CMSFillRuleController::\

    HasSelectionsChanged"));

    TBool status( EFalse );

    TInt listCount = iFillListArray.Count();

    for ( TInt index = 0; index < listCount; index++ )

        {

        if ( iFillListArray[ index ]->OriginalSelectionStatus() !=

             iFillListArray[ index ]->List()->Selected() &&

             iFillListArray[ index ]->OriginalSelectionStatus() != aStatus )

            {

            // activity changed

            status = ETrue;

            index = listCount;

            }

        }

    return status;

    }

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

// CMSFillRuleController::RestoreOriginalSelections()

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

//

void CMSFillRuleController::RestoreOriginalSelections()

    {