/*

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

*

*/

#include <mediaservant.rsg>

#include <barsread.h>

#include <akntextsettingpage.h>

#include <StringLoader.h>

#include <akncheckboxsettingpage.h>

#include <e32math.h>

#include <utf.h>

#include "cmsqlpropertycontainer.h"

#include "mserv.hlp.hrh"

#include "cmfillrule.h"

#include "cmfillrulecontainer.h"

#include "cmmediaserverfull.h"

#include "msappui.h"

#include "mediaservantuid.h"

#include "msengine.h"

#include "msconstants.h"

#include "msfillruleeditlist.h"

#include "msfillruleeditview.h"

#include "msruleamountsetting.h"        // Amount

#include "msruleserverssetting.h"       // Servers

#include "msrulemultiselectionsetting.h"// Artist, genre, album, track

#include "msrulefilesizesetting.h"      // File size (min/max)

#include "mediaservant.hrh"

#include "msmetadatacollector.h"

#include "msdebug.h"

#include "msfillcontainer.h"

#include "msfillview.h"

// CONSTANTS

_LIT( KSpace, " ");

const TInt KDateBufferLength = 20;

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

// CMSFillRuleEditList::NewL()

// Two phase constructor.

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

//

CMSFillRuleEditList* CMSFillRuleEditList::NewL(

                CMSAppUi& aAppUi, CMSFillRuleEditView& aView )

    {

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

    CMSFillRuleEditList* self = CMSFillRuleEditList::NewLC( aAppUi, aView );        

    CleanupStack::Pop( self );

    return self;

    }

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

// CMSFillRuleEditList::NewLC()

// Two phase constructor.

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

//

CMSFillRuleEditList* CMSFillRuleEditList::NewLC(

                CMSAppUi& aAppUi, CMSFillRuleEditView& aView )

    {

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

    CMSFillRuleEditList* self = new ( ELeave ) CMSFillRuleEditList();

    CleanupStack::PushL( self );

    self->ConstructL( aAppUi, aView );

    return self;

    }

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

// CMSFillRuleEditList::CMSFillRuleEditList()

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

//

CMSFillRuleEditList::CMSFillRuleEditList()

    {

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

    iDummyText.Copy(_L(""));

    iMinFileSize = 0;

    iMaxFileSize = 0;

    iMinFileSizeSet = EMSAny;

    iMaxFileSizeSet = EMSAny;

    iFileSize = 0;

    iFileSizeEnum = 0;

    iTrackLengthEnum = 0;

    iNewList = EFalse;

    }

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

// CMSFillRuleEditList::~CMSFillRuleEditList()

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

//

CMSFillRuleEditList::~CMSFillRuleEditList()

    {

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

    delete iMetadataCollector;

    if ( iServers )

        {

        iServers->ResetAndDestroy();

        iServers->Close();

        delete iServers;

        }

    if ( iServerArray )

        {

        iServerArray->ResetAndDestroy();

        delete iServerArray;

        }

    iVisibleRules.Close();

    iArtistArray.Close();

    iAlbumArray.Close();

    iGenreArray.Close();

    iTrackArray.Close();

    iVideoTitleArray.Close();

    }

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

// CMSFillRuleEditList::ConstructL()

// Second phase constructor.

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

//

void CMSFillRuleEditList::ConstructL( CMSAppUi& aAppUi,

                                      CMSFillRuleEditView& aView )

    {

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

    iAppUi = &aAppUi;

    iView = &aView;

    // Set engine observer

    iAppUi->MSEngine()->SetObserver( this );

    // read template

    iRuleTemplate = iAppUi->ParameterAgent()->GetRuleTemplate();

    // Edit existing list

    if ( iRuleTemplate.templateType == EMSCmdEditRule )

        {

        // get selected item index from previous screen

        iSelectedList = iAppUi->ParameterAgent()->FillViewFocusIndex();

        // get selected list

        iRule =(*iAppUi->

               FillRuleController()->FillListArray())[iSelectedList]->List();

        // List media type

        iMediaType = iRule->MediaType();

        // set used template

        iRuleTemplate.selectedTemplate = iRule->TemplateId();

        ReadTemplateRulesL( iRuleTemplate.selectedTemplate );

        // Get values for rules

        GetRuleValuesL();

        }

    else

        {

        iNewList = ETrue;

        // New fill list will be last one - set focus index to it

        iSelectedList =

            iAppUi->FillRuleController()->FillListArray()->Count();

        iAppUi->ParameterAgent()->SetFillViewFocusIndex( iSelectedList );

        // Create new list

        iRule = CCmFillRule::NewL();

        // Read template rules and set default values

        ReadTemplateRulesL( iRuleTemplate.selectedTemplate );

        // Use template name as list name

        iListName.Copy( iRuleTemplate.templateName );

        HBufC8* temp = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

                                                            iListName );

        CleanupStack::PushL( temp );

        iRule->SetNameL( *temp );

        CleanupStack::PopAndDestroy( temp );

        // List type is determined by given menu command

        // MediaType is also set here

        SetListType( iRuleTemplate.templateType );

        iRule->SetTemplateId( iRuleTemplate.selectedTemplate );

        //Set rule selected by default

        iRule->SetSelected( ECmSelected );

        // Initialize fill rule status to ECmToBeFilled

        // If rule is image rule, status is re-set

        // according to used template

        iRule->SetStatus( ECmToBeFilled );

        InitializeValues();

        // save new list

        iAppUi->FillRuleController()->AddRuleL( iRule );

        // Get list

        iRule = (*iAppUi->FillRuleController()->

                                    FillListArray())[iSelectedList]->List();

        }

     // should filter the vedio array when construct first time, only selected item can be construct

     if( iRule->MediaType() == ECmVideo )

        {

        // reset track array

        iTrackArray.Reset();

        // append the select video title in track array

        TInt count = iVideoTitleArray.Count();

        if( count > 0 )

            {

            for( TInt i=0; i<count; i++ )

                {

                }

            }

        }

    // Creates metadata collector and starts data fetching

    iMetadataCollector = CMSMetadataCollector::NewL( *iAppUi,

                                                     iMediaType,

                                                     iGenreArray,

                                                     iArtistArray,

                                                     iAlbumArray,

                                                     iTrackArray);

    // get mediaservers and remove not activated

    GetServersAndCheckActivityL();

    CreateServerSettingListL();

    // Construct setting list

    ConstructListAndStartDataReadingL();

    iPreviousRuleIdentifier = 0;

    }

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

// CMSFillRuleEditList::StartDataReadingL

// starts reading data to multiselection lists from server

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

//

void CMSFillRuleEditList::ConstructListAndStartDataReadingL()

    {

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

    ConstructListAndStartDataReadingL"));

    switch ( iMediaType )

        {

        case ECmVideo:

            {

             // construct item list

            CAknSettingItemList::ConstructFromResourceL(

                                            R_MS_VIDEO_FILL_RULES );

            break;

            }

        case ECmImage:

            {

             // construct item list

            CAknSettingItemList::ConstructFromResourceL(

                                            R_MS_IMAGE_FILL_RULES );

            if ( iNewList )

                {

                SaveListValuesL();

                iAppUi->FillRuleController()->SaveRulesL();

                PreprocessListL();

                }

            else

                {

                CreateAndSetNaviPaneTextL();

                }

            break;

            }

        case ECmAudio:

            {

             // construct item list

            CAknSettingItemList::ConstructFromResourceL(

                                            R_MS_AUDIO_FILL_RULES );

            break;

            }

        default:

            {

            break;

            }

        }

    if ( iMediaType == ECmVideo || iMediaType == ECmAudio )

        {

        // Show 'reading data' text on navi pane

        HBufC* naviText = StringLoader::LoadLC(

                                            R_MS_WAIT_GETTING_DATA_TEXT );

        iView->SetNavigationPaneTextL( *naviText );

        CleanupStack::PopAndDestroy( naviText );

        }

    }

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

// CMSFillRuleEditList::SaveListValuesL

// Saves list values from visible setting items

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

//

void CMSFillRuleEditList::SaveListValuesL()

    {

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

    CAknSettingItemArray* itemArray = SettingItemArray();

    for ( TInt index  = 0; index < itemArray->Count(); index++ )

        {

        CAknSettingItem* item = itemArray->At( index );

        if ( !item->IsHidden() )

            {

            SaveValueL( item );

            }

        }

    }

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

// CMSFillRuleEditList::PreprocessListL

// starts list preprocess and shows info on navi pane

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

//

void CMSFillRuleEditList::PreprocessListL()

    {

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

    iAppUi->MSEngine()->PreProcessFillListL( iRule->Name() );

    HBufC* naviText = StringLoader::LoadLC( R_MS_PREPROCESSING_TEXT );

    iView->SetNavigationPaneTextL( *naviText );

    CleanupStack::PopAndDestroy( naviText );

    }

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

// CMSFillRuleEditList::SaveValueL

// Save values to rule container

// Only values from visible rules are stored

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

//

void CMSFillRuleEditList::SaveValueL( CAknSettingItem* aItem )

    {

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

    if ( !aItem->IsHidden() )

        {

        switch ( aItem->Identifier() )

            {

            case EMSListName:

                {

                // Name is always visible - set rule name

                HBufC8* listName =

                    CnvUtfConverter::ConvertFromUnicodeToUtf8L(

                       SettingItemArray()->At(EMSListName)->SettingTextL() );

                CleanupStack::PushL( listName );

                iRule->SetNameL( *listName );

                CleanupStack::PopAndDestroy( listName );

                break;

                }

            case EMSShrinkImages:

                {

                // Set shrinking status for images

                SetShrinkingStatus();

                break;

                }

            case EMSAmount:

                {

                // set amount of files

                iRule->SetAmount( iAmount );

                // set limit type

                iRule->SetLimitType( iLimitType );

                break;

                }

            case EMSStartingWith:

                {

                iRule->SetMethod(

                            static_cast<TCmFillMethod> (iStartWith) );

                break;

                }

            case EMSDateFrom:

                {

                DeleteRule( ECmDate, ECmGreater );

                TInt ruleIndex = iRule->AddRuleL( ECmDate,

                                                  ECmGreater );

                HBufC8* str = HBufC8::NewL( KDateBufferLength );

                CleanupStack::PushL( str );

                str->Des().AppendNum(iDateFrom.Int64());

                iRule->AddRuleParamL( ruleIndex, *str );

                CleanupStack::PopAndDestroy( str );

                break;

                }

            case EMSDateUntil:

                {

                DeleteRule( ECmDate, ECmSmaller );

                TInt ruleIndex = iRule->AddRuleL( ECmDate,

                                                  ECmSmaller );

                HBufC8* str = HBufC8::NewL( KDateBufferLength );

                CleanupStack::PushL( str );

                str->Des().AppendNum(iDateUntil.Int64());

                iRule->AddRuleParamL( ruleIndex, *str );

                CleanupStack::PopAndDestroy( str );

                break;

                }

            case EMSServers:

                {

                HandleServerSelectionL();

                break;

                }

            case EMSFreeText:

                {

                DeleteRule( ECmFreeText );

                if ( iFreeText.Size() )

                    {

                    TInt ruleIndex = iRule->AddRuleL( ECmFreeText,

                                                      ECmConsistOf );

                    HBufC8* str = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

                                                                 iFreeText );

                    CleanupStack::PushL( str );

                    iRule->AddRuleParamL( ruleIndex, *str );

                    CleanupStack::PopAndDestroy( str );

                    }

                break;

                }

            case EMSTitleName:

                {

                DeleteRule( ECmTitle );

                if ( iVideoTitleArray.Count() > 0 )

                    {

                    AddAdditionalRuleL( iVideoTitleArray,

                                        ECmTitle,

                                        ECmEquals );

                    }

                break;

                }

            case EMSMinFileSize:

                {

                DeleteRule( ECmFileSize, ECmGreater );

                if ( iMinFileSizeSet == EMSSetSize )

                    {

                    AddAdditionalRuleL( ECmFileSize,

                                        ECmGreater,

                                        iMinFileSize*KMega );

                    }

                break;

                }

            case EMSMaxFileSize:

                {

                DeleteRule( ECmFileSize, ECmSmaller );

                if ( iMaxFileSizeSet == EMSSetSize )

                    {

                    AddAdditionalRuleL( ECmFileSize,

                                        ECmSmaller,

                                        iMaxFileSize*KMega );

                    }

                break;

                }

             case EMSGenre:

                {

                DeleteRule( ECmGenre );

                if ( iGenreArray.Count() > 0 )

                    {

                    AddAdditionalRuleL( iGenreArray,

                                        ECmGenre,

                                        ECmEquals );

                    }

                break;

                }

             case EMSArtist:

                {

                DeleteRule( ECmArtist );

                if ( iArtistArray.Count() > 0 )

                    {

                    AddAdditionalRuleL( iArtistArray,

                                        ECmArtist,

                                        ECmEquals );

                    }

                break;

                }

             case EMSAlbum:

                {

                DeleteRule( ECmAlbum );

                if ( iAlbumArray.Count() > 0 )

                    {

                    AddAdditionalRuleL( iAlbumArray,

                                        ECmAlbum,

                                        ECmEquals );

                    }

                break;

                }

            case EMSTrack:

                {

                DeleteRule( ECmTitle );

                if ( iTrackArray.Count() > 0 )

                    {

                    AddAdditionalRuleL( iTrackArray,

                                        ECmTitle,

                                        ECmEquals );

                    }

                break;

                }

            case EMSTrackLength:

                {

                DeleteRule( ECmDuration );

                if ( iTrackLengthEnum )