/*

* Copyright (c) 2007-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 CWsfWlanInfoSortingBlackList

*

*/

//  EXTERNAL INCLUDES

#include <StringLoader.h>

#include <aknselectionlist.h>

#include <aknnotewrappers.h>

#include <utf.h>

//  CLASS HEADER

#include "wsfwlaninfosortingblacklist.h"

// INTERNAL INCLUDES

#include <wsfwlaninfosorting.rsg>

#include "wsfwlaninfoarray.h"

#include "wsfwlanssidselectiondlg2.h"

#include "wsflogger.h"

/**

* SSID array granularity

*/

static const TInt KIntSsidArrayGranularity = 3;

/**

* SSID blacklist table name in DB

*/

_LIT( KBlackListTableName,"WIZARD_BLACKLIST");

/**

* SSID column name in blacklist table

*/

_LIT( KBlackListTableIdColumnName,"WIZARD_BLACKLIST_SSID");  

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

// CWsfWlanInfoSortingBlackList::NewLC

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

//

CWsfWlanInfoSortingBlackList* CWsfWlanInfoSortingBlackList::NewLC( 

                                                  RDbNamedDatabase& aDatabase )

	{

	CWsfWlanInfoSortingBlackList* thisPtr = 

	                    new (ELeave) CWsfWlanInfoSortingBlackList( aDatabase );

	CleanupStack::PushL( thisPtr );

	thisPtr->ConstructL();

	return thisPtr;

	}

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

// CWsfWlanInfoSortingBlackList::NewL

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

//

CWsfWlanInfoSortingBlackList* CWsfWlanInfoSortingBlackList::NewL( 

                                                  RDbNamedDatabase& aDatabase )

	{

	CWsfWlanInfoSortingBlackList* thisPtr = NewLC( aDatabase );

	CleanupStack::Pop( thisPtr );

	return thisPtr;

	}

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

// CWsfWlanInfoSortingBlackList::CWsfWlanInfoSortingBlackList

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

//

CWsfWlanInfoSortingBlackList::CWsfWlanInfoSortingBlackList( 

                                                 RDbNamedDatabase& aDatabase ):

	iDefsDb( &aDatabase )

	{

	}

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

// CWsfWlanInfoSortingBlackList::~CWsfWlanInfoSortingBlackList

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

//

CWsfWlanInfoSortingBlackList::~CWsfWlanInfoSortingBlackList()

	{

	// free the blacklist entries...

	if ( iBlackListSsids )

		{

		iBlackListSsids->Reset();

		}

	delete iBlackListSsids;

	iBlackListSsidTable.Close();

	}

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

// CWsfWlanInfoSortingBlackList::ConstructL

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

//

void CWsfWlanInfoSortingBlackList::ConstructL()

	{

	CheckTableL();

	iBlackListSsids = new (ELeave) CDesC8ArrayFlat( KIntSsidArrayGranularity );

	}

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

// CWsfWlanInfoSortingBlackList::BlackListItemCount

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

//

TInt CWsfWlanInfoSortingBlackList::BlackListItemCount() const

    {

    return iBlackListSsids->Count();

    }

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

// CWsfWlanInfoSortingBlackList::Compare

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

//

TInt CWsfWlanInfoSortingBlackList::Compare( const TWsfWlanInfo& /*aInfoLeft*/, 

                                            const TWsfWlanInfo& /*aInfoRight*/ )

	{

	return 0;

	}

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

// CWsfWlanInfoSortingBlackList::SetupOnRuleMatch

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

//

TBool CWsfWlanInfoSortingBlackList::SetupOnRuleMatch( TWsfWlanInfo& aInfoLeft )

	{

	// look through the ssid array - and look for a match

	TInt rulePosition( 0 );

	if ( aInfoLeft.BlackListEntry() )

		{

		return ETrue;

		}

	if ( iBlackListSsids->FindIsq( aInfoLeft.iSsid, rulePosition ) == 0 )

		{

		// the rule matches....

		aInfoLeft.SetBlackListEntry( ETrue );

		return ETrue;

		}

	return EFalse;

	}

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

// CWsfWlanInfoSortingBlackList::MarkMatchedFilterL

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

//

void CWsfWlanInfoSortingBlackList::MarkMatchedFilterL( 

                                                   TWsfWlanInfo& aFilterEntry )

	{

	aFilterEntry.SetBlackListEntry( ETrue );

	}

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

// CWsfWlanInfoSortingBlackList::EditFilterDefsL

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

//

void CWsfWlanInfoSortingBlackList::EditFilterDefsL( 

                                                CWsfWlanInfoArray& aInfoArray )

	{

	LOG_ENTERFN( "CWsfWlanInfoSortingBlackList::EditFilterDefsL" );

	// ok - lets map aInfoArray contents and iBlackListSsids and build our selves 

	// a list of blacklist entries and current non sorted entries...

	// first loop through the aInfoArray and ...

	// make 16 bit copy of the ssid array...

	TInt arrayItemCount( iBlackListSsids->Count() + aInfoArray.Count() );

	if ( !arrayItemCount ) 

		{

		// there's nothing to edit 

		// just return before showing edit dialog

		return;

		}

	LOG_WRITE( "there are items to show" );

	CDesCArrayFlat *arrayOfItems = 

	                             new (ELeave) CDesCArrayFlat( arrayItemCount );

	CleanupStack::PushL( arrayOfItems );

	// go through the ssid's in aInfoArray and append them to the array

	TInt wlanArrayCount( aInfoArray.Count() );

	TWsfWlanInfo* wlanInfo( NULL );

	TWsfWlanInfo* connectedWlan( NULL );

	for ( TInt loopCounter( 0 ); loopCounter < wlanArrayCount; ++loopCounter )

		{

		wlanInfo = aInfoArray.At( loopCounter );

//      formerly (custfav or hidden -> does not appear in the list):

//		if ( wlanInfo->BrandId() || wlanInfo->Hidden() )

//      instead now (connected -> does not appear in the list):

		if ( wlanInfo->Connected() )

			{

			connectedWlan = wlanInfo;

			continue;

			}

		HBufC* ssid = wlanInfo->GetSsidAsUnicodeLC();

		arrayOfItems->AppendL( *ssid );

		CleanupStack::PopAndDestroy( ssid );

		}

	// simple alphabetical sort

	arrayOfItems->Sort();

	LOG_WRITE( "items added, list sorted" );

    // now insert the already selected items onto the top

	CArrayFix<TInt> *selectedItems = new (ELeave) CArrayFixFlat<TInt>( 

	                                                          arrayItemCount ); 

 	CleanupStack::PushL( selectedItems );	

    HBufC* connectedSsid( NULL );

    if ( connectedWlan )

        {

        connectedSsid = connectedWlan->GetSsidAsUnicodeLC();

        }

    TBool connectedBlacklisted( EFalse );

	TInt blackListLength( iBlackListSsids->Count() );

	TInt index( 0 );

	for ( TInt loopCounter( 0 ); loopCounter < blackListLength; ++loopCounter )

		{

    	HBufC* ssidUnicode = TWsfWlanInfo::GetSsidAsUnicodeLC(

    	                           iBlackListSsids->MdcaPoint( loopCounter ) );

		if ( !connectedWlan || ssidUnicode->Compare( *connectedSsid ) )

		    {

		    // only add the ssid to the list if it is not connected right now

    		arrayOfItems->InsertL( index, *ssidUnicode );

    		// these are already selected

    		selectedItems->AppendL( index );

    		++index;

		    }

		else if ( connectedWlan && !ssidUnicode->Compare( *connectedSsid ) )

	        {

	        connectedBlacklisted = ETrue;

	        }

		CleanupStack::PopAndDestroy( ssidUnicode );

		}

	if ( !arrayOfItems->Count() ) 

		{

		// there's nothing to edit

		// just return before showing edit dialog

    	if ( connectedWlan )

    	    {

    	    CleanupStack::PopAndDestroy( connectedSsid );

    	    }

    	CleanupStack::PopAndDestroy( selectedItems );	

    	CleanupStack::PopAndDestroy( arrayOfItems );

		return;

		}

	LOG_WRITE( "creating the dialog" );

 	CWsfWlanSsidSelectionDlg2* dlg = CWsfWlanSsidSelectionDlg2::NewL( 

 	                                           *arrayOfItems, *selectedItems );

 	dlg->PrepareLC( R_QTN_PREFERRED_FILTER_SELECTION_DIALOG2 );

    LOG_WRITE( "launching the dialog" );

 	if ( dlg->RunLD() )

 		{

 		LOG_WRITE( "dialog closed" );

		// go throught the list of selected items... and store them...

		iBlackListSsids->Reset();

		TInt selectedCount( selectedItems->Count() );

		for ( TInt loopCounter( 0 ); loopCounter < selectedCount; ++loopCounter )

			{

			TPtrC ssid = arrayOfItems->MdcaPoint( selectedItems->At( 

			                                                   loopCounter ) );

			HBufC8* ssidUtf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( 

			                                                            ssid );

            CleanupStack::PushL( ssidUtf8 );

			iBlackListSsids->AppendL( *ssidUtf8 );

			CleanupStack::PopAndDestroy( ssidUtf8 );

			}

	    if ( connectedBlacklisted )

	        {

			HBufC8* ssidUtf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( 

			                                                  *connectedSsid );

            CleanupStack::PushL( ssidUtf8 );

			iBlackListSsids->AppendL( *ssidUtf8 );

			CleanupStack::PopAndDestroy( ssidUtf8 );

	        }

		iBlackListSsids->Sort();	

		SaveDefsL();	

 		} 

	if ( connectedWlan )

	    {

	    CleanupStack::PopAndDestroy( connectedSsid );

	    }

 	CleanupStack::PopAndDestroy( selectedItems );	

	CleanupStack::PopAndDestroy( arrayOfItems );

	}

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

// CWsfWlanInfoSortingBlackList::ReadFilterDefsL

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

//

void CWsfWlanInfoSortingBlackList::ReadFilterDefsL()

	{

	RestoreDefsL();

	}

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

// CWsfWlanInfoSortingBlackList::SaveDefsL

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

//

void CWsfWlanInfoSortingBlackList::SaveDefsL()

	{	

    LOG_ENTERFN( "CWsfWlanInfoSortingBlackList::SaveDefsL" );

	// clear the db-table

	if ( iBlackListSsidTable.FirstL() != EFalse )

		{

		do 

			{

			iBlackListSsidTable.DeleteL();

			} 

		while ( iBlackListSsidTable.NextL() );

		}

	// and add the iBlackListSsids contents there....

	TInt ssidCount( iBlackListSsids->Count() );

	if ( ssidCount )

		{

		// there are items

    	CDbColSet* colSet = iBlackListSsidTable.ColSetL();

    	CleanupStack::PushL( colSet );	

    	TDbColNo ssidColumnNumber = colSet->ColNo( 

    	                                         KBlackListTableIdColumnName );

    	for ( TInt i( 0 ); i < ssidCount; ++i )

    		{

    		iBlackListSsidTable.InsertL();

    		iBlackListSsidTable.SetColL( ssidColumnNumber, 

    		                             iBlackListSsids->MdcaPoint( i ) );		

    		iBlackListSsidTable.PutL();

    		}

    	CleanupStack::PopAndDestroy( colSet );

		}

	}

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

// CWsfWlanInfoSortingBlackList::RestoreDefsL

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

//

void CWsfWlanInfoSortingBlackList::RestoreDefsL()

	{

	LOG_ENTERFN( "CWsfWlanInfoSortingBlackList::RestoreDefsL" );	

	iBlackListSsids->Reset();

	iBlackListSsidTable.Reset();

	// go through the table and fill the ssid array...

	if ( iBlackListSsidTable.FirstL() )

		{

    	CDbColSet* colSet = iBlackListSsidTable.ColSetL();

    	CleanupStack::PushL( colSet );	

    	TDbColNo ssidColumnNumber = colSet->ColNo( 

    	                                         KBlackListTableIdColumnName );

    	do

    		{

    		iBlackListSsidTable.GetL();

    		iBlackListSsids->AppendL( iBlackListSsidTable.ColDes8( 

    		                                              ssidColumnNumber ) );

    		} 

    	while ( iBlackListSsidTable.NextL() );

    	CleanupStack::PopAndDestroy( colSet );	

    	// sort the array...

    	iBlackListSsids->Sort();

		}

	}

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

// CWsfWlanInfoSortingBlackList::CheckTableL

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

//

void CWsfWlanInfoSortingBlackList::CheckTableL()

	{

	LOG_ENTERFN( "CWsfWlanInfoSortingBlackList::CheckTableL" );

	TInt tableStatus = iBlackListSsidTable.Open( *iDefsDb, 

	                                             KBlackListTableName );

	if ( tableStatus == KErrNotFound )

		{

		// the table does not exist... create it

		CDbColSet *ssidTableColumnSet = CDbColSet::NewLC();

		ssidTableColumnSet->AddL( TDbCol( KBlackListTableIdColumnName, 

		                                  EDbColText8 ) );

		iDefsDb->Begin();

		User::LeaveIfError( iDefsDb->CreateTable( KBlackListTableName, 

		                                          *ssidTableColumnSet ) );

		iDefsDb->Commit();

		CleanupStack::PopAndDestroy( ssidTableColumnSet );

		}

	if ( tableStatus != KErrNone )

		{

		User::LeaveIfError( iBlackListSsidTable.Open( *iDefsDb,  

		                                              KBlackListTableName ) );

		}

	}