/*

* Copyright (c) 2006-2006 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:  Stores element data and writes it to stream

*

*/

#include "cbsstorage.h"

#include "bsimportconstants.h"

#include "debugtrace.h"

#include <s32strm.h>

#include <utf.h>

#include <mbselement.h>

//#include "mbsimportlogger.h"

//#include "importlogwriter.h"

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

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

// CBSStorage::NewL

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

//

CBSStorage* CBSStorage::NewL()

    {

    CBSStorage* self = NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// CBSStorage::NewLC

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

//

CBSStorage* CBSStorage::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CBSStorage::ConstructL

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

//

void CBSStorage::ConstructL()

    {

    }

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

// CBSStorage::CBSStorage

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

//

CBSStorage::CBSStorage()

    {

    }

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

// CBSStorage::~CBSStorage

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

//

CBSStorage::~CBSStorage()

    {

    iElements.Close();

    delete iAppId;

    delete iStorageId;

    delete iLanguage;

    delete iFilename;

    }

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

// CBSStorage::AppendElement

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

//

void CBSStorage::AppendElementsL( MBSElement* aElement )

    {

    if( !aElement )

        {

		// Ignore empty

	    return;

        }

	TPtrC8 id = aElement->ElementId();

	// check if the id is unique

	TInt count = iElements.Count();

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

		{

		if( 0 == iElements[i]->ElementId().Compare( id ) )

			{

			// duplicate found

			User::Leave( KErrAlreadyExists );

			}

		}

	iElements.AppendL( aElement );

    }

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

// CBSStorage::ReplacesElementL

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

//

void CBSStorage::ReplaceElementL( MBSElement* aElement )

	{

    if( !aElement )

        {

		// Ignore empty

	    return;

        }

	TPtrC8 id = aElement->ElementId();

	// check if the id is unique

	TInt count = iElements.Count();

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

		{

		if( 0 == iElements[i]->ElementId().Compare( id ) )

			{

			// item found

			MBSElement* element = iElements[i];

			iElements.Remove( i );

			delete element;

			// put the new element

			iElements.AppendL( aElement );

			return;

			}

		}

	// the element was not found from this storage

	User::Leave( KErrNotFound );

	}

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

// CBSStorage::ElementCount

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

//

TInt CBSStorage::ElementCount()

    {

    return iElements.Count();

    }

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

// CBSStorage::ExternalizeL

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

//

void CBSStorage::ExternalizeL( RWriteStream& aWriteStream )

    {

    if( !VerifyHeader() || !VerifyDataL( iElements ) )

        {

        // Header not complete. Will not write to stream

        User::Leave( KErrCorrupt );

        }

    // Write header

    aWriteStream.WriteInt16L( iVersion );

    // Write elements 

    TInt count = iElements.Count();

    aWriteStream.WriteInt16L( count );

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

        {

        iElements[i]->ExternalizeL( aWriteStream );

        }

    }

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

// CBSStorage::SetVersion

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

//

void CBSStorage::SetVersion( TInt aVersion )

    {

    iVersion = aVersion;

    }

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

// CBSStorage::SetApplicationIdL

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

//

void CBSStorage::SetApplicationIdL( const TDesC& aAppId )

    {

    HBufC* tmp = aAppId.AllocL();

    delete iAppId;

    iAppId = tmp;

    }

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

// CBSStorage::SetStorageIdL

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

//

void CBSStorage::SetStorageIdL( const TDesC& aStorageId )

    {

    HBufC* tmp = aStorageId.AllocL();

    delete iStorageId;

    iStorageId = tmp;

    }

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

// CBSStorage::SetLanguageL

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

//

void CBSStorage::SetLanguageL( TLanguage aLanguage )

    {

    TBuf<KLangBufLength> buffer;

    buffer.AppendNum( aLanguage );

    HBufC* tmp = buffer.AllocL();

    delete iLanguage;

    iLanguage = tmp;

    }

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

// CBSStorage::VerifyHeader

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

//

TBool CBSStorage::VerifyHeader()

    {

    // not checking version as it is been consider not to use. - Pankaj - 31 may 07

    //return ( iAppId && iStorageId && iVersion > 0 && iLanguage );

    return ( iAppId && iStorageId && iLanguage );

    }

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

// CBSStorage::VerifyDataL

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

//

TBool CBSStorage::VerifyDataL( TArray<MBSElement*> aArray,

                                    TBool aIgnoreEmptyID /* = EFalse */ )

    {

    // Check that elements have unique ID's in their own namespace

    TInt count = aArray.Count();

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

        {

        // Verify inside list elements

        if( aArray[i]->ElementType() == EBSList )

            {

            TArray<MBSElement*> listArray = aArray[i]->GetStructureL();

            if( !VerifyDataL( listArray, ETrue ) )

                {

                return EFalse;

                }

            }

        if( aIgnoreEmptyID &&

            aArray[i]->ElementId().CompareC( KNullDesC8() ) == 0 )

            {

            // ignore empty id

            continue;

            }

        // Check that sibling elements have unique ID

        for( TInt j = i + 1; j < count; j++ )

            {

            if( aArray[i]->ElementId().CompareC( aArray[j]->ElementId() ) == 0 )

                {

                // convert elementID to 16-bit for event logger

                TPtrC8 id( aArray[i]->ElementId() );

                HBufC* conv = HBufC::NewLC( id.Length() );

                TPtr uniptr( conv->Des() );

                CnvUtfConverter::ConvertToUnicodeFromUtf8( uniptr, id );

                TRACE( T_LIT("ERROR: Found duplicate element ID (%S)!"), &uniptr );

                CleanupStack::PopAndDestroy();

                return EFalse;

                }

            }

        }

    // All elements ok

    return ETrue;

    }

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

// CBSStorage::VerifyDataL

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

//

TBool CBSStorage::VerifyDataL( RBSObjOwningPtrArray<MBSElement>& aArray,

                                    TBool aIgnoreEmptyID /* = EFalse */ )

    {

    return VerifyDataL( aArray.Array(), aIgnoreEmptyID );

    }

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

// CBSStorage::ProposeFileNameL

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

//

TPtrC CBSStorage::ProposeFileNameL()

    {

    if( !iFilename )

        {

        User::Leave( KErrNotReady );

        }

    return iFilename->Des();

    }

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

// CBSStorage::ProposeFileNameL

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

//

TPtrC CBSStorage::ProposedDirL()

    {

    if( !iFilename )

        {

        User::Leave( KErrNotReady );

        }

    return iDir;

    }

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

// CBSStorage::GetListOfFiles()

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

//

void CBSStorage::GetListOfFilesL( RArray<TPtrC>& aFileList )

    {

    CleanupClosePushL(aFileList);

    TInt count = iElements.Count();

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

        {

        AppendFilesL( iElements[i], aFileList );

        }

    CleanupStack::Pop(&aFileList);

    }

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

// CBSStorage::AppendFiles()

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

//

void CBSStorage::AppendFilesL( MBSElement* aElement, RArray<TPtrC>& aFileList )

    {

    if( !aElement )

        {

        // invalid element

        return;

        }

    TBSElementType type = aElement->ElementType();

    if( EBSList == type )

        {

        TArray<MBSElement*> list = aElement->GetStructureL();

        TInt count = list.Count();

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

            {

            AppendFilesL( list[i], aFileList );

            }

        }

    else if( EBSFile == type )

        {

        TPtrC ptr( aElement->TextDataL() );

        aFileList.Append( aElement->TextDataL() );

        }

    }

// End of file