/*

* 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:  Implementation of setup Wizard

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <cmsappwizard.rsg>

#include "upnpavdevice.h"

#include "upnpavcontroller.h"

#include "upnpavcontrollerfactory.h"

#include <driveinfo.h>

#include <utf.h>

#include <aknnotewrappers.h>

#include "cmdriveinfo.h"

#include "cmmediaserverfull.h"

#include "cmstorerulecontainer.h"

#include "cmstorerule.h"

#include "cmfillrulecontainer.h"

#include "cmfillrule.h"

#include "cmsappwizard.h"

#include "msengine.h"

#include "cmsmultiselectionpopup.h"

#include "cmsselectionstorage.h"

#include "msconstants.h"

#include "msdebug.h"

#include "upnpavdevicelist.h"

// CONSTANTS

_LIT( KMSSetupWizardRscFile, "\\resource\\apps\\cmsappwizard.rsc" );

#ifdef _DEBUG

_LIT( KPanicedUnit, "MSAPPWIZARD" );

#endif // _DEBUG

const TInt KArrayGranularity = 3;

const TInt KFillListGranularity = 3;

const TInt KStoreListGranularity = 5;

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

// CMSAppWizard::CMSAppWizard

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

//

CMSAppWizard::CMSAppWizard( CMSEngine& aMSEngine )

    {

    iMSEngine = &aMSEngine;

    iMaxSteps = ELastStep;

    LOG(_L("[MSAppWizard]\t CMSAppWizard::CMSAppWizard"));

    }

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

// CMSAppWizard::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CMSAppWizard::ConstructL()

    {

    LOG(_L("[MSAppWizard]\t CMSAppWizard::ConstructL begin"));

    iCoeEnv = CEikonEnv::Static();

    iFileSession = iCoeEnv->FsSession();

    // Load resource file

    TFileName rscFileName( KMSSetupWizardRscFile );

    User::LeaveIfError( CompleteWithAppPath( rscFileName ) );

    // Get the exact filename of the resource file

    BaflUtils::NearestLanguageFile( iFileSession, rscFileName );

    // Check if the resource file exists or not

    if ( !BaflUtils::FileExists( iFileSession, rscFileName ) )

        {

        User::Leave( KErrNotFound );

        }

    TInt err(KErrNone);

    TRAP( err, iResFileOffset = iCoeEnv->AddResourceFileL( rscFileName ) );

    User::LeaveIfError( err );

    iSelections = CMSSelectionStorage::NewL( *iMSEngine,

                                             iMediaServers,

                                             iFileSession );

    iDeviceNameArray = new (ELeave) CDesCArrayFlat( KArrayGranularity );

    // original servers

    iOriginalServers = iMSEngine->GetMediaServersL();

    ClearServersSystemUpdateId();

    // Start searching servers

    TInt error = CreateAvControllerL();

    if ( !error && iAvController )

        {

        // Process devices that AVController has already discovered.

        FetchAlreadyDiscoveredDevicesL();

        }

#if _DEBUG

    RDebug::Printf("[MSAppWizard]\t CMSAppWizard::ConstructL: %s, %s\n",\

__DATE__,__TIME__);

#endif

    LOG( _L("[MSAppWizard]\t CMSAppWizard::ConstructL end") );

    }

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

// CMSAppWizard::NewL()

// Two-phased constructor.

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

//

EXPORT_C CMSAppWizard* CMSAppWizard::NewL( CMSEngine& aMSEngine )

    {

    LOG( _L("[MSAppWizard]\t CMSAppWizard::NewL begin") );

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

    CleanupStack::Pop( self );

    LOG( _L("[MSAppWizard]\t CMSAppWizard::NewL end") );

    return self;

    }

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

// CMSAppWizard::NewLC()

// Two-phased constructor.

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

//

EXPORT_C CMSAppWizard* CMSAppWizard::NewLC( CMSEngine& aMSEngine )

    {

    LOG( _L("[MSAppWizard]\t CMSAppWizard::NewLC begin") );

    CMSAppWizard* self = new ( ELeave) CMSAppWizard( aMSEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    LOG( _L("[MSAppWizard]\t CMSAppWizard::NewLC end") );

    return self;

    }    

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

// Destructor

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

//

CMSAppWizard::~CMSAppWizard()

    {

    LOG( _L("[MSAppWizard]\t CMSAppWizard::~CMSAppWizard begin") );

    // stop device search

    CancelDeviceSearch();

    // UnLoad resource file

    iCoeEnv->DeleteResourceFile( iResFileOffset );

    if ( iOriginalServers )

        {

        iOriginalServers->ResetAndDestroy();

        iOriginalServers->Close();

        delete iOriginalServers;

        }

    if ( iDeviceNameArray )

        {

        iDeviceNameArray->Reset();

        delete iDeviceNameArray;

        }

    iDriveIndexes.Close();

    iDriveArray.ResetAndDestroy();

    iDriveArray.Close();

    iStoreServers.Reset();

    iStoreServers.Close();

    iMediaServers.ResetAndDestroy();

    iMediaServers.Close();

    delete iSelections;

    if ( iAvController )

        {

        iAvController->RemoveDeviceObserver();

		iAvController->Release();

		iAvController = NULL;

        }

    CloseWaitDialog();

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    LOG( _L("[MSAppWizard]\t CMSAppWizard::~CMSAppWizard end") );

    }

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

// CMSAppWizard::StartL

// The main loop of setup wizard

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

//

EXPORT_C TInt CMSAppWizard::StartL()

    {

    LOG( _L("[MSAppWizard]\t CMSAppWizard::StartL begin") );

    TInt ret(KErrNone);

    do

        {

        switch ( iStep )

            {

            case EStep1:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_1, ELastStep );

                ret = ShowInfoStepL( iStep, head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep2:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_2, ELastStep );

                ret = ShowInfoStepL( iStep, head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep3:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_3, ELastStep );                

                CDesCArrayFlat* itemArray =

                                    CreateMultiselectionFillListItemsLC();

                CArrayFix<TInt>* resultArray =

                    new (ELeave) CArrayFixFlat<TInt>( KFillListGranularity );

                CleanupStack::PushL( resultArray );

                ret = ShowMultiselectionStepL( *itemArray,

                                               *resultArray,

                                               head->Des() );

                // keep selection safe

                iSelections->SetFillListSelections( *resultArray );                

                CleanupStack::Pop( resultArray );

                CleanupStack::PopAndDestroy( itemArray );                                                           

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep4:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_4, ELastStep );

                ret = ShowInfoStepL( iStep, head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep5:

                {

                CreateServerNameListL( iMediaServers );

                if ( iDeviceNameArray->Count() == 0 )

                    {

                    // no devices yet - show wait note                

                    ShowWaitNoteL();

                    // wait here for the first device before

                    // showing device selection

                    iWait.Start();                    

                    }

                if ( !iUserCancelledSearch )

                    {

                    HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_5, ELastStep );

                    CArrayFix<TInt>* selectedIndexes =

                       new (ELeave) CArrayFixFlat<TInt>( KArrayGranularity );

                    CleanupStack::PushL( selectedIndexes );                                                      

                    ret = ShowMultiselectionStepL( *iDeviceNameArray,

                                               *selectedIndexes,

                                               head->Des() );

                    iSelections->SetServersForFillRulesL( *selectedIndexes );

                    CleanupStack::PopAndDestroy( selectedIndexes );

                    CleanupStack::PopAndDestroy( head );                

                    }

                else

                    {

                    ret = KErrCancel;

                    }                                

                break;

                }

            case EStep6:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_6, ELastStep );

                ret = ShowInfoStepL( iStep, head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep7:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_7, ELastStep );

                //used CreateMultiselectionStoreListItemsLC before, modify then to 

                //make it the same with UI spec

                CDesCArrayFlat* itemArray =

                                    CreateMultiselectionUIStoreListStringLC();

                CArrayFix<TInt>* resultArray =

                   new (ELeave) CArrayFixFlat<TInt>( KStoreListGranularity );

                CleanupStack::PushL( resultArray );    

                ret = ShowMultiselectionStepL( *itemArray,

                                               *resultArray,

                                               head->Des() ); 

                // keep selection safe

                iSelections->SetStoreListSelections( *resultArray );                                                                

                CleanupStack::Pop( resultArray );

                CleanupStack::PopAndDestroy( itemArray );                

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep8:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_8, ELastStep );

                ret = ShowInfoStepL( iStep, head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep9:

                {                

                HBufC* head = StringLoader::LoadLC(

                                    R_MS_HEADING_STEP_9, ELastStep );

				// Clear previous store servers

    			iStoreServers.Reset();

        		// copy those media servers to store servers list, 

        		// where copy capability is active

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

					{

					if ( iMediaServers.operator[](index)->CopyCapability() )

						{

						    iMediaServers.operator[]( index ) );

						}

					}

                // append items to iDeviceNameArray

                CreateServerNameListL( iStoreServers );

                CArrayFix<TInt>* selectedIndexes =

                       new (ELeave) CArrayFixFlat<TInt>( KArrayGranularity );

                CleanupStack::PushL( selectedIndexes );                       

                if ( iDeviceNameArray->Count() )

                    {

                    ret = ShowMultiselectionStepL( *iDeviceNameArray,

                                               *selectedIndexes,

                                               head->Des() ); 

                    if ( ret > 0 && selectedIndexes->Count() == 0 )

                        {

                        ShowInfoNoteL( R_MS_NO_TARGET_DEVICES_SELECTED_INFO );

                        // clear store list selections

                        iSelections->ClearStoreListSelections();

                        }                                                

                    iSelections->SetServersForStoreRulesL( *selectedIndexes,

                                                           iStoreServers );

                    }

                else // no devices available - show info note

                    {

                    ret = ShowInfoStepL( iStep, head->Des() );

                    if ( ret > KErrNone )

                        {                        

                        // clear store list selections

                        iSelections->ClearStoreListSelections();

                        iSelections->SetServersForStoreRulesL(

                                                *selectedIndexes,

                                                iStoreServers );

                        }

                    }                    

                CleanupStack::PopAndDestroy( selectedIndexes );                                    

                CleanupStack::PopAndDestroy( head );                                                                                  

                break;

                }

            case EStep10:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_10, ELastStep );

                ret = ShowInfoStepL( iStep, head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep11:

                {

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_11, ELastStep );

                ret = ShowListStepL( R_MS_WIZARD_SELECTION_DIALOG_8,

                                     head->Des() );

                CleanupStack::PopAndDestroy( head );

                break;

                }

            case EStep12:

                {

                 // two parameters

                CArrayFix<TInt>* stepArray =

                                new ( ELeave ) CArrayFixFlat<TInt>(2);

                CleanupStack::PushL( stepArray );

                stepArray->AppendL( ELastStep );                                

                stepArray->AppendL( ELastStep );

                HBufC* head = StringLoader::LoadLC(

                                        R_MS_HEADING_STEP_12, *stepArray );                

                ret = ShowInfoStepL( iStep, head->Des() );                

                CleanupStack::PopAndDestroy( head );

                CleanupStack::PopAndDestroy( stepArray );

                break;

                }                

            case ELastStep:

                {                

                // stop device search

                CancelDeviceSearch();

                // set remove status and name to old servers

                CheckAndSetServerStateL();

                // clear ids again because there might be new unselected servers

                ClearServersSystemUpdateId();

                iMSEngine->SetMediaServersL( *iOriginalServers );

                // Set used drives

                iSelections->SetDriveInformationL();

                iSelections->StoreMSSettingsL();

                ret = ELastStep; // stop looping

                break;

                }

            case ECancelWizard:

            	{

                // stop device search

                CancelDeviceSearch();

            	// Wizard is cancelled, do not start information refreshing

            	ret = KErrNone;

            	break;

            	}

            default :

                {

                LOG( _L("[MSAppWizard]\t CMSAppWizard::StartL: default!") );

                __ASSERT_DEBUG( EFalse, User::Panic( KPanicedUnit, 0 ) );

                break;

                }

            }

        SetNextStep( ret );

        }

    while ( iStep != EWizardEnd );

    LOG(_L("[MSAppWizard]\t CMSAppWizard::StartL end"));

    return ret;

    }

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

// CMSAppWizard::DialogDismissedL

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

//

void CMSAppWizard::DialogDismissedL( TInt aButtonId )

    {

    LOG(_L("[MSAppWizard]\t CMSAppWizard::DialogDismissedL"));

    if( aButtonId != EAknSoftkeyDone )

        {

        LOG(_L("[MSAppWizard]\t CMSAppWizard::DialogDismissedL CANCEL"));

        if ( aButtonId == EAknSoftkeyCancel )

            {

            iUserCancelledSearch = ETrue;

            }

        }

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    }

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

// CMSAppWizard::ShowInfoNoteL

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

//

void CMSAppWizard::ShowInfoNoteL( TInt aBodyTextResource )

    {

    LOG(_L("[MSAppWizard]\t CMSAppWizard::ShowInfoNoteL"));

    CAknInformationNote* dlg = new(ELeave)CAknInformationNote( ETrue );

    CleanupStack::PushL( dlg );

    HBufC* noteText = StringLoader::LoadLC( aBodyTextResource );

    dlg->ExecuteLD( *noteText );

    CleanupStack::PopAndDestroy( noteText );

    CleanupStack::Pop( dlg );

    }

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

// CMSAppWizard::AddDeviceNameL

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

//

void CMSAppWizard::AddDeviceNameL( const CUpnpAVDevice& aDevice )

    {

    CUpnpAVDevice* device = const_cast<CUpnpAVDevice*> ( &aDevice );

    HBufC* devName = CnvUtfConverter::ConvertToUnicodeFromUtf8L(

	                                           device->FriendlyName() );

	CleanupStack::PushL( devName );

	TRACE(Print(_L("[MSAppWizard]\t device Name= %S"), devName ));

	iDeviceNameArray->AppendL( *devName );        

	CleanupStack::PopAndDestroy( devName );	

	}