/*

* Copyright (c) 2002 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:  DM Idle SoftKey  Adapter

*

*/

#include "IdleSoftkeysWebTargetManager.h"

#include "UiSettingsUtil.h"

// symbian

// s60

#include <centralrepository.h>

// tarm

#include "IsAdapterLiterals.h"

#include "IsAdapterDefines.h"

#include "nsmldmuri.h"

#include "TARMCharConv.h"

#include "TPtrC8I.h"

#include "debug.h"

// #define ISADAPTER_USE_CAPTION_IN_WEBTARGET_NAME

CIdleSoftkeysWebTargetManager::CIdleSoftkeysWebTargetManager( MSmlDmCallback *& aCallBack,

        RFavouritesDb   & aFavDb ) : iCallBack( aCallBack ), iFavDb( aFavDb )        

        {

        	iUiSettingsNotInitialized = ETrue;	

        }

CIdleSoftkeysWebTargetManager::~CIdleSoftkeysWebTargetManager()

	{

	if(iUiSettingsNotInitialized == EFalse)

		{

		delete iUiSettings;

		}

	}

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

// CIdleSoftkeysWebTargetManager::ListWebTargetsL

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

TInt CIdleSoftkeysWebTargetManager::ListWebTargetsL( CBufFlat &aList )

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::ListWebTargetsL() >" );

    TInt i, num = 6, offset;

   	if(iUiSettingsNotInitialized)

   	{

   		iUiSettings = CUiSettingsUtil::NewL( );

   		iUiSettings->ReadBookmarksL();

   		iUiSettingsNotInitialized = EFalse;

   	}

	iUiSettings->GetWebTargetsCount( num ) ;

    HBufC8* dataH = HBufC8::NewLC( KRepositoryEntryMaxLength );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::ListWebTargetsL() HBufC8 dataH ALLOC %x", dataH);

    TPtr8 data( dataH->Des() );

    for(i=0, offset=0; i<num; i++)

        {

        TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf;

        TInt mappingIndex;

        TInt bmUid;

        //

        // List BM's with valid UID (>= 0)

        //

        // General names for the new bookmarks on the fly

        //

        User::LeaveIfError(iUiSettings->GetWebTargetAppUid( i, bmUid ));

        if( bmUid >= 0 )

            {

            mappingIndex = -1;

            numBuf.Num( bmUid );

            HBufC8* targetName = NULL;

            //

            // Case 1: There is already URI to LUID mapping, continue with that

            //

            if( (KErrNone == FindURIByLUIDL( data, numBuf, mappingIndex )) && (mappingIndex != -1) )

                {

                //

                // LUid was found in the database

                //

                targetName = GenerateNodeNameL( NSmlDmURI::LastURISeg(data) );

                CleanupStack::PushL(targetName);

                }

#ifdef ISADAPTER_USE_CAPTION_IN_WEBTARGET_NAME

            else

            //

            // Case 2: Bookmark caption is not used in mappings, use that webtarget name

            //

            if( NULL != (targetName = GenerateNodeNameL( i )) )

                {

                //

                // 

                //

                CleanupStack::PushL(targetName);

                UpdateLUIDDatabaseL( *targetName, numBuf, mappingIndex);

                }

#endif

            else

                {

                //

                // Generate unique name

                //

                targetName = GenerateNodeNameL( offset, KPrefixWebTargetURI() );

                CleanupStack::PushL(targetName);

                mappingIndex = -1;

                while( (KErrNone == FindLUIDByURIL( *targetName, data, mappingIndex )) &&

                       (mappingIndex != -1) )

                    {

                    offset ++;

                    mappingIndex = -1;

                    CleanupStack::PopAndDestroy( targetName );

                    targetName = GenerateNodeNameL( offset, KPrefixWebTargetURI() );

                    CleanupStack::PushL(targetName);

                    }

                // We have now unique webtarget node name and unique LUid

                //

                numBuf.Num( bmUid );

                mappingIndex = -1;

                UpdateLUIDDatabaseL( *targetName, numBuf, mappingIndex);

                }

            // Add webtarget node name to list

            //

            if( aList.Size() > 0 )

            {

                aList.InsertL( aList.Size(), KNSmlISSeparator() );

            }

            aList.InsertL( aList.Size(), NSmlDmURI::LastURISeg(*targetName) );

            CleanupStack::PopAndDestroy( targetName );

            }

        }

    CleanupStack::PopAndDestroy( dataH );

    RDEBUG( "CIdleSoftkeysWebTargetManager::ListWebTargetsL() <" );

    return KErrNone;

    }

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

// CIdleSoftkeysWebTargetManager::CheckWebTargetsL

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

void CIdleSoftkeysWebTargetManager::CheckWebTargetsL()

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::CheckWebTargetsL() ><" );

    }

#ifdef ISADAPTER_USE_CAPTION_IN_WEBTARGET_NAME

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

// CIdleSoftkeysWebTargetManager::GenerateNodeNameL

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

HBufC8* CIdleSoftkeysWebTargetManager::GenerateNodeNameL(TInt aIndex)

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 1 >" );

    //

    // Get caption of the bookmark

    //

    TBuf<64> caption; 

    if(iUiSettingsNotInitialized)

   	{

   		iUiSettings = CUiSettingsUtil::NewL( );

   		iUiSettings->ReadBookmarksL();

   		iUiSettingsNotInitialized = EFalse;

   	}

    User::LeaveIfError( iUiSettings->GetWebTargetCaption( aIndex, caption ) );

    if( HasInvalidCharacters( caption ) )

        {

        return NULL;

        }

    //

    // Generate URI with caption

    // Reserve space

    //

    TInt length = caption.Length() + KPrefixWebTargetURI().Length();

    HBufC8* targetName = HBufC8::NewLC( length );

    TPtr8 ptr( targetName->Des() );

    //

    // Generate URI with caption

    // Append strings

    //

    ptr.Append( KPrefixWebTargetURI() );

    ptr.Append( caption );

    HBufC8* dataH = HBufC8::NewLC( KRepositoryEntryMaxLength );

    TPtr8 data( dataH->Des() );

    TInt index = -1;

    TBool okToAdd = (KErrNone != FindLUIDByURIL( ptr, data, index ));

    CleanupStack::PopAndDestroy( dataH );

    if( okToAdd )

        {

        RDEBUG8_2( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 1 < %S", &targetName );

        CleanupStack::Pop(targetName);

        return targetName;

        }

    else

        {

        RDEBUG( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 1 < NULL, WebTarget name was reserved!" );

        CleanupStack::PopAndDestroy(targetName);

        return NULL;

        }

    }

#endif

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

// CIdleSoftkeysWebTargetManager::GenerateNodeNameL

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

HBufC8* CIdleSoftkeysWebTargetManager::GenerateNodeNameL(TInt aIndex, const TDesC8 &aPrefix)

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 2 >" );

    TInt length = aPrefix.Length()

                    + KPrefixWebTargetNodeName().Length()

                    + MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64;

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 2 About to ALLOC %d bytes.", length );

    HBufC8* targetName = HBufC8::NewL( length );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 2 ALLOC HBufC8 targetName %x", targetName );

    TPtr8 ptr( targetName->Des() );

    ptr.Format(KFormatWebTargetNodeName, aIndex+1);

    ptr.Insert(0, aPrefix);

    RDEBUG8_2( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 2 < %S", &targetName );

    return targetName;

    }

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

// CIdleSoftkeysWebTargetManager::GenerateNodeNameL

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

HBufC8* CIdleSoftkeysWebTargetManager::GenerateNodeNameL(const TDesC8 &aText)

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 3 >" );

    TInt length = aText.Length();

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 3 About to ALLOC %d bytes.", length );

    HBufC8* targetName = HBufC8::NewL( length );

    RDEBUG_2("CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 3 ALLOC HBufC8 targetName %x", targetName );

    TPtr8 ptr( targetName->Des() );

    ptr.Copy( aText );

    RDEBUG8_2( "CIdleSoftkeysWebTargetManager::GenerateNodeNameL() 3 < %S", &targetName );

    return targetName;

    }

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

// CIdleSoftkeysWebTargetManager::RenameL

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

TInt CIdleSoftkeysWebTargetManager::RenameL( const TDesC8& aURI, const TDesC8& /*aLUID*/,

                                   const TDesC8& aNewURI )

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::RenameL() >" );

    HBufC8* dataH = HBufC8::NewLC( KRepositoryEntryMaxLength );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::RenameL() HBufC8 dataH ALLOC %x", dataH);

    TPtr8 data( dataH->Des() );

    TInt index = -1;

    TInt retVal = KErrNone;

// OPTION 1: URI is already new one, find old according to LUID

#ifdef NOT_DEFINED

    // If we find some URI with that LUID ...

    if( ((KErrNone != FindLUIDByURIL( aURI, data, index ))) &&

         (KErrNone == FindURIByLUIDL( data, aLUID, index )) && (index != -1)  )

        {

        // ... we replace that URI with new one

        UpdateLUIDDatabaseL( aURI, aLUID, index );

        }

    else

        {

        retVal = KErrNotFound;

        }

// OPTION 2: New (complete) URI is found in the argument

#else

    TInt index2 = -1;

    if ( (KErrNone != FindLUIDByURIL( aNewURI, data, index )) &&

         (KErrNone == FindLUIDByURIL( aURI, data,  index2 )) 

         )

        {

        UpdateLUIDDatabaseL( aNewURI, data, index2 );

        }

    else

        {

        retVal = KErrNotFound;

        }

#endif

    CleanupStack::PopAndDestroy( dataH );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::RenameL() < %d", retVal );

    return retVal;

    }

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

// CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL

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

TInt CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL(const TDesC8& aURI, TInt &aIndex )

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL() >" );

	__UHEAP_MARK;

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TInt index = -1;

    TInt compareLen = KPrefixWebTargetNodeName().Length();

    TPtrC8 nodeName = NSmlDmURI::URISeg(aURI, 3);

    HBufC8* dataH = HBufC8::NewLC( KRepositoryEntryMaxLength );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL() HBufC8 dataH ALLOC %x", dataH);

    TPtr8 data( dataH->Des() );

    if( NSmlDmURI::NumOfURISegs( aURI ) >= 4 )

        {

        TInt bmIndex = -1;

        HBufC8* targetName = NULL;

        if( KErrNone == FindLUIDByURIL( NSmlDmURI::URISeg(aURI, 0, 4), data, bmIndex ) )

            {

            targetName = GenerateNodeNameL( NSmlDmURI::LastURISeg(aURI) );

            }

        else

            {

            status = CSmlDmAdapter::EError;

            }

        if( CSmlDmAdapter::EOk == status )

            {

            CleanupStack::PushL( targetName );

            TPtrC8 ptr( NSmlDmURI::LastURISeg(*targetName) );

            if( ptr == nodeName )

                {

                aIndex = index;

                }

            CleanupStack::PopAndDestroy( targetName );

            }

        }

    else

        {

        status = CSmlDmAdapter::EError;

        }

    CleanupStack::PopAndDestroy( dataH );

	__UHEAP_MARKEND;

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL() < %d", (TInt)status );

    return status;

    }

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

// CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL

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

TInt CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL(const TDesC8& aURI, CFavouritesItem &aItem, TInt &aIndex )

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL() >" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TInt bmIndex = -1;

    TInt bmUid = -1;

    TInt compareLen = KPrefixWebTargetNodeName().Length();

    TPtrC8 nodeName = NSmlDmURI::URISeg(aURI, 3);

    HBufC8* dataH = HBufC8::NewLC( KRepositoryEntryMaxLength );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL() HBufC8 dataH ALLOC %x", dataH);

    TPtr8 data( dataH->Des() );

    if( NSmlDmURI::NumOfURISegs( aURI ) >= 4 )

        {

        TInt repIndex = -1;

        HBufC8* targetName = NULL;

        if( KErrNone == FindLUIDByURIL( NSmlDmURI::URISeg(aURI, 0, 4), data, repIndex ) )

            {

            targetName = GenerateNodeNameL( nodeName );

            CleanupStack::PushL( targetName );

            TPtrC8 ptr( NSmlDmURI::LastURISeg(*targetName) );

            User::LeaveIfError( ptr == nodeName ? KErrNone : KErrGeneral );

            CleanupStack::PopAndDestroy( targetName );

            TLex8 lex;

            lex.Assign(data);

            User::LeaveIfError( lex.Val( bmUid ) );

            TInt ret = KErrNone;

           	if(iUiSettingsNotInitialized)

   			{	

   				iUiSettings = CUiSettingsUtil::NewL( );

   				iUiSettings->ReadBookmarksL();

   				iUiSettingsNotInitialized = EFalse;

   			}

           	User::LeaveIfError(iUiSettings->GetWebTargetIndex(bmUid,bmIndex));

            if( -1 == bmIndex )

                {

                ret = KErrNotFound;

                }

            if( KErrNotFound == ret )

                {

                User::LeaveIfError(iUiSettings->GetWebTargetIndex(bmUid, bmIndex));                

                }

            else

                {

                User::LeaveIfError( ret );

                }

            }

        else

            {

            status = CSmlDmAdapter::EError;

            }

        if( CSmlDmAdapter::EOk == status )

            {

            if( KErrNone == iFavDb.Get( bmUid, aItem ) )

                {

                aIndex = bmIndex;

                }

            else

                {

                status = CSmlDmAdapter::EError;

                }

            }

        }

    else

        {

        status = CSmlDmAdapter::EError;

        }

    CleanupStack::PopAndDestroy( dataH );

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::GetTargetFromNodeNameL() < %d", (TInt)status );

    return status;

    }

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

// CIdleSoftkeysWebTargetManager::PrepareItemL

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

void CIdleSoftkeysWebTargetManager::PrepareItemL( const TDesC8& aURI, CFavouritesItem &aItem, TInt &aIndex )

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::PrepareItemL() >" );

	CheckWebTargetsL();

    TInt error = GetTargetFromNodeNameL( aURI, aItem, aIndex );

    if( KErrNone != error )

        {

        RDEBUG_2( "CIdleSoftkeysWebTargetManager::PrepareItemL TError %d", error );

        User::Leave( KErrNotFound );

        }

    RDEBUG( "CIdleSoftkeysWebTargetManager::PrepareItemL() <" );

    }

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

// CIdleSoftkeysWebTargetManager::ReleaseItemL

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

void CIdleSoftkeysWebTargetManager::ReleaseItemL( CFavouritesItem &aItem, TBool aUpdate/*=ETrue*/ )

    {

    if( aUpdate )

        {

        User::LeaveIfError( iFavDb.Update( aItem, aItem.Uid(), ETrue ) );

        }

    }

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

// CIdleSoftkeysWebTargetManager::SetCaptionL

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

void CIdleSoftkeysWebTargetManager::SetCaptionL( const TDesC8& aURI, const TDesC8& aCaption )

    {

    RDEBUG( "CIdleSoftkeysWebTargetManager::SetCaptionL() >" );

    TInt index;

    CFavouritesItem *favItem = CFavouritesItem::NewLC();

    RDEBUG_2( "CIdleSoftkeysWebTargetManager::SetCaptionL() CFavouritesItem ALLOC %x", favItem);

    HBufC* newCaption = CTARMCharConv::ConvertFromUtf8LC( aCaption );

    PrepareItemL( aURI, *favItem, index );

    favItem->SetNameL( *newCaption );

    if( favItem->Name().Compare( *newCaption ) != 0 )

        {

        User::Leave( KErrGeneral );

        }

    ReleaseItemL( *favItem );

    CleanupStack::PopAndDestroy( newCaption );

    CleanupStack::PopAndDestroy( favItem );

    RDEBUG( "CIdleSoftkeysWebTargetManager::SetCaptionL() <" );

    }

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

// CIdleSoftkeysWebTargetManager::FindWapApL

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

void CIdleSoftkeysWebTargetManager::FindWapApL( const TDesC8& aURI, TInt &aWapAp )

    {

    TPtrC8  apURI     = NSmlDmURI::RemoveDotSlash( aURI );

    TInt    numOfSegs = NSmlDmURI::NumOfURISegs( apURI );

    TPtrC8I seg1      = NSmlDmURI::URISeg( apURI, 0 );