/*

* 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:   

*

*/

#include <f32file.h>

#include "hnmdlocalizationelement.h"

#include "hnglobals.h"

#include "hnconvutils.h"

#include "hnutils.h"

const TText8 KSPChar = ' ';

const TText8 KNLChar = '\n';

const TInt KWholeFileReadLimit = 1024;

// ======== MEMBER FUNCTIONS ========

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

// 

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

//

TUint32 HBufC8Hash( HBufC8* const &  aBuf )

    {

    return DefaultHash::Des8(*aBuf);

    }

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

//

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

//

TBool HBufC8Ident( HBufC8* const & aL, HBufC8* const & aR )

    {

    return DefaultIdentity::Des8(*aL, *aR);

    }

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

// 

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

//

void CHnMdLocalizationElement::ConstructL( const TDesC& aNamespace, 

                                           const TDesC& aSource )

    {

    iNamespace.CreateL( aNamespace );

    iSource.CreateL( aSource );

    iSource.LowerCase();

    LocateLanguageFileL();

    }

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

// 

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

//

void CHnMdLocalizationElement::ConstructL( TXmlEngElement aElement )

    {

    ASSERT( aElement.HasAttributeL( KNameSpaceAttrName8 ) );

    SetNamespaceL( aElement.AttributeNodeL( KNameSpaceAttrName8 ) );

    SetSourceL( aElement.AttributeNodeL( KSourceAttrName8 ) );

    }

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

// 

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

//

void CHnMdLocalizationElement::SetNamespaceL( TXmlEngAttr aNamespace )

    {

    HBufC* namespac = HnConvUtils::Str8ToStrLC( aNamespace.Value() );

    iNamespace.Close();

    iNamespace.CreateL( *namespac );

    CleanupStack::PopAndDestroy( namespac );

    }

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

// 

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

//

void CHnMdLocalizationElement::SetSourceL( TXmlEngAttr aSource )

    {

    HBufC* source = HnConvUtils::Str8ToStrLC( aSource.Value() );

    iSource.Close();

    iSource.CreateL( *source );

    iSource.LowerCase();

    LocateLanguageFileL();

    CleanupStack::PopAndDestroy( source );

    }

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

// 

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

//

CHnMdLocalizationElement* CHnMdLocalizationElement::NewL(

        TXmlEngElement aElement )

    {

    CHnMdLocalizationElement* self = new( ELeave ) CHnMdLocalizationElement;

    CleanupStack::PushL( self );

    self->ConstructL( aElement );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CHnMdLocalizationElement* CHnMdLocalizationElement::NewL(const TDesC& aNamespace, 

                                                         const TDesC& aSource)

    {

    CHnMdLocalizationElement* self = new( ELeave ) CHnMdLocalizationElement;

    CleanupStack::PushL( self );

    self->ConstructL( aNamespace, aSource );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CHnMdLocalizationElement::CHnMdLocalizationElement():

    iResourceIDs( &HBufC8Hash, &HBufC8Ident )

    {

    }

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

// 

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

//

CHnMdLocalizationElement::~CHnMdLocalizationElement()

    {

    iNamespace.Close();

    iSource.Close();

    delete iSourcePath;

    THashMapIter<HBufC8*, TInt> iter( iResourceIDs );

    while ( HBufC8* const * ptr = iter.NextKey() )

        {       

        delete *ptr;

        }    

    iResourceIDs.Close();

    }

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

// 

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

//

const TDesC& CHnMdLocalizationElement::Namespace() const

    {

    return iNamespace;

    }

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

// 

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

//

const TDesC& CHnMdLocalizationElement::Source() const

    {

    return iSource;

    }

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

// 

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

//

HBufC* CHnMdLocalizationElement::SourcePath() const

    {

    return iSourcePath;

    }

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

// 

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

//

TBool CHnMdLocalizationElement::SourceExists() const

    {

    if ( iSourcePath )

    	{

        return iSourcePath->Compare(KNullDesC) != 0;

    	}

    else

    	{

    	return EFalse;

    	}

    }

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

// 

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

//

void CHnMdLocalizationElement::LocateLanguageFileL()

	{

	delete iSourcePath;

    iSourcePath = NULL;

    iSourcePath = HnUtils::LocateNearestLanguageFileLC( iSource );

    CleanupStack::Pop( iSourcePath );

	}

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

// 

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

//

const TInt& CHnMdLocalizationElement::FindResourceIdL( HBufC8* aResourceName )

    {

    if ( iState&EInitialized )

        {

        // check if we have it in cache

        TInt* result = iResourceIDs.Find(aResourceName);

        if (result)

            {

            return *result;

            }

        else if (iState&EWholeFileCached) // all should be in cache

            {

            User::Leave(KErrNotFound);

            }

        }

    if (!(iState&EInitialized) || iState&EUsedItemsCached )

        {

        // set initialized here, as we could have problem with file read

        // i.e. file is missing, but we dont want to go here next time

        iState |= EInitialized;

        HBufC8* rsgContent = ReadRsgContentLC( );

		if (rsgContent->Length() < KWholeFileReadLimit)

			{

			iState |= EWholeFileCached;

			ParseRsgContentL(*rsgContent);

			}

		else

			{

			iState |= EUsedItemsCached;

			ParseRsgContentL(*rsgContent, *aResourceName);

			}          

        //cleanup

        CleanupStack::PopAndDestroy(rsgContent);   

        }

    return iResourceIDs.FindL(aResourceName);

    }

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

// 

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

//

HBufC8* CHnMdLocalizationElement::ReadRsgContentLC( )

    {

    HBufC8* result(NULL);

    if ( iSourcePath->Compare( KNullDesC ) )

    	{

    	HBufC* fPath = iSourcePath->AllocLC();

		// change extension to rsg        

		TInt extPos = fPath->LocateReverse(KExtDelimiter);

		fPath->Des().Replace(extPos, fPath->Length() - extPos, KRsg);

		result = HnUtils::ReadFileLC(*fPath);

		CleanupStack::Pop(result);

		CleanupStack::PopAndDestroy(fPath);

		CleanupStack::PushL(result);

    	}

    else

    	{

        result = KNullDesC8().AllocLC();   

    	}

    return result;

    }

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

// 

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

//

void CHnMdLocalizationElement::ParseRsgContentL( const TDesC8& aContent )

    {

    TPtrC8 content(aContent);

    TInt posEoL(-1);

    // iterate over each line

    while ((posEoL = content.Locate(KNLChar)) > 0)

        {

        TPtrC8 line = content.Left( posEoL - 1 );        

        TInt firstSpace  = line.Locate(KSPChar);

        TInt lastSpace  = line.LocateReverse(KSPChar);

        // resource name

        TPtrC8 rname =  line.Mid(firstSpace, lastSpace - firstSpace);

        // resource id

        TPtrC8 rid =  line.Right( line.Length() - lastSpace - 1 );

        // trim resource name

        HBufC8* rnameTrimmed = rname.AllocLC();

        rnameTrimmed->Des().Trim();                

        // parse numer and insert to map

        TInt id(0);

        User::LeaveIfError( HnConvUtils::Str8ToInt(rid, id) );        

        User::LeaveIfError( iResourceIDs.Insert(rnameTrimmed->AllocL(), id) );        

        CleanupStack::PopAndDestroy(rnameTrimmed);

        // start search from next line

        content.Set(content.Mid( posEoL + 1 ));

        }    

    }

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

// 

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

//

void CHnMdLocalizationElement::ParseRsgContentL( const TDesC8& aContent, 

                                                 const TDesC8& aResourceName )

    {

    TPtrC8 content(aContent);

    HBufC8* resourceName = HBufC8::NewLC( aResourceName.Length() 

                                          + 2 /* extra spaces */  );

    // add extra space to make sure that we find the right one    

    resourceName->Des().Append(KSPChar);

    resourceName->Des().Append(aResourceName);

    resourceName->Des().Append(KSPChar);    

    TInt position = content.Find(*resourceName);

    User::LeaveIfError(position); // we can not find resource

    TPtrC8 contentAfterMid = content.Mid( position + 

                                          resourceName->Length());

    TInt posResId = contentAfterMid.Locate(KNLChar);

    User::LeaveIfError(posResId); // we can not find resource

    TPtrC8 rid = contentAfterMid.Left(posResId - 1);    

    HBufC8* ridTrimmed = rid.AllocLC();

    ridTrimmed->Des().Trim();

    // trim also resource name

    resourceName->Des().Trim();

    TInt id(0);

    User::LeaveIfError( HnConvUtils::Str8ToInt( *ridTrimmed, id) );      

    User::LeaveIfError( iResourceIDs.Insert( resourceName->AllocL(), id) );

    // clean up

    CleanupStack::PopAndDestroy(ridTrimmed);

    CleanupStack::PopAndDestroy(resourceName);        

    }