/*

* Copyright (c) 2009 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:   ?Description

*

*/

#include <xml/parser.h>

#include <stringpool.h>

#include <utf.h>

#include <e32cmn.h>

#include <bautils.h>

#include "iaupdatexmlparser.h"

#include "iaupdatexmlsubparser.h"

#include "iaupdatedebug.h"

// The text type to parse

_LIT8( KXmlType, "text/xml" );

EXPORT_C CIAUpdateXmlParser* CIAUpdateXmlParser::NewL( 

    CIAUpdateXmlSubParser* aSubParser )

    {

    CIAUpdateXmlParser* self =

        CIAUpdateXmlParser::NewLC( aSubParser );

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CIAUpdateXmlParser* CIAUpdateXmlParser::NewLC( 

    CIAUpdateXmlSubParser* aSubParser )

    {

    CIAUpdateXmlParser* self =

        new( ELeave ) CIAUpdateXmlParser( aSubParser );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;    

    }

EXPORT_C CIAUpdateXmlParser::CIAUpdateXmlParser( 

    CIAUpdateXmlSubParser* aSubParser )

: CBase(),

  iSubParser( aSubParser )

    {

    }

EXPORT_C void CIAUpdateXmlParser::ConstructL()

    {

    if ( !iSubParser )

        {

        User::Leave( KErrNotFound );

        }

    iParser = Xml::CParser::NewL( KXmlType, *iSubParser );

    }

EXPORT_C CIAUpdateXmlParser::~CIAUpdateXmlParser()

    {

    delete iParser;

    delete iSubParser;

    }

EXPORT_C void CIAUpdateXmlParser::ParseFileL( 

    const TDesC& aFilePath )    

    {

    HBufC8* data( ReadFileL( aFilePath ) );

    CleanupStack::PushL( data );

    ParseL( *data );

    CleanupStack::PopAndDestroy( data );

    }

EXPORT_C void CIAUpdateXmlParser::ParsePrivateFileL( 

    const TDesC& aFileName )

    {

    RFs fsSession;	

    User::LeaveIfError( fsSession.Connect() );

    CleanupClosePushL( fsSession );

    // This will set the correct drive and private path 

    // for the file server session.    

    SetPrivateDriveL( fsSession, aFileName );

	TFileName configFilePath;    

    User::LeaveIfError( fsSession.SessionPath( configFilePath ) );

    configFilePath.Append( aFileName );

    CleanupStack::PopAndDestroy( &fsSession );    

    ParseFileL( configFilePath );    

    }

EXPORT_C void CIAUpdateXmlParser::ParseL( const TDesC8& aData )

    {

    // Use parent class functions to handle the parsing

    Parser().ParseBeginL();

    Parser().ParseL( aData );

    Parser().ParseEndL();

    }

EXPORT_C void CIAUpdateXmlParser::ParseL( const TDesC& aData )

    {

    HBufC8* utf8( ConvertUnicodeToUtf8L( aData ) );

    CleanupStack::PushL( utf8 );

    ParseL( *utf8 );

    CleanupStack::PopAndDestroy( utf8 );

    }    

EXPORT_C CIAUpdateXmlSubParser& CIAUpdateXmlParser::SubParser()

    {

    return *iSubParser;

    }

Xml::CParser& CIAUpdateXmlParser::Parser()

    {

    return *iParser;

    }

HBufC8* CIAUpdateXmlParser::ReadFileL( const TDesC& aFilePath )

    {

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    RFile file;

    User::LeaveIfError( file.Open( fs,

                                   aFilePath,

                                   EFileRead ) );

    CleanupClosePushL( file );

    TInt size;

    User::LeaveIfError( file.Size( size ) );

    HBufC8* buffer = HBufC8::NewLC( size );

    TPtr8 ptr( buffer->Des() );

    User::LeaveIfError( file.Read( ptr, size ) );

    CleanupStack::Pop( buffer );

    CleanupStack::PopAndDestroy( &file );    

    CleanupStack::PopAndDestroy( &fs );

    return buffer;

    }    

HBufC8* CIAUpdateXmlParser::ConvertUnicodeToUtf8L( 

    const TDesC16& aUnicodeText )

    {

    const TInt KConvertBufferSize( 64 );

    // Place converted data here, 

    // initial size double the conversion buffer.

    HBufC8* convertedData = HBufC8::NewL( KConvertBufferSize * 2 );

    CleanupStack::PushL( convertedData );

    TPtr8 destination( convertedData->Des() );

    // Create a small output buffer

    TBuf8< KConvertBufferSize > outputBuffer;

    // Create a buffer for the unconverted text - initialised with the 

    // input text

    TPtrC16 remainderOfUnicodeText( aUnicodeText );

    for ( ;; ) // conversion loop

        {

        // Start conversion. When the output buffer is full, return the 

        // number of characters that were not converted

        const TInt returnValue(

            CnvUtfConverter::ConvertFromUnicodeToUtf8( 

                outputBuffer, 

                remainderOfUnicodeText ) );

        // check to see that the descriptor isn’t corrupt 

        // - leave if it is

        if ( returnValue == CnvUtfConverter::EErrorIllFormedInput )

            {            

            User::Leave( KErrCorrupt );

            }

        else if ( returnValue < 0 )

            {            

            // future-proof against "TError" expanding

            User::Leave( KErrGeneral );

            }

        // Do something here to store the contents of the output buffer.

        if ( destination.Length() + outputBuffer.Length() >= 

             destination.MaxLength() )

            {

            HBufC8* newBuffer = convertedData->ReAllocL(

                ( destination.MaxLength() + outputBuffer.Length() ) * 2 );

            CleanupStack::Pop( convertedData );

            convertedData = newBuffer;

            CleanupStack::PushL( convertedData );

            destination.Set( convertedData->Des() );

            }

        destination.Append( outputBuffer );

        outputBuffer.Zero();

        // Finish conversion if there are no unconverted characters 

        // in the remainder buffer

        if ( returnValue == 0 ) 

            {            

            break; 

            }

        // Remove the converted source text from the remainder buffer.

        // The remainder buffer is then fed back into loop

        remainderOfUnicodeText.Set( 

            remainderOfUnicodeText.Right( returnValue ) );

        }

    CleanupStack::Pop( convertedData );

    return convertedData;

    }

void CIAUpdateXmlParser::SetPrivateDriveL( 

    RFs& aFs,

    const TDesC& aFileName ) const

    {

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() begin: %S", 

                     &aFileName);

    // This will set the correct drive and private path 

    // for the file server session.    

    // First try to find the file from the private directory

    // of the drive where the process exists.

    RProcess process;

    // Set the session private path according to 

    // the process file name drive.

    TInt driveNum( 

        SetSessionPrivatePathL( aFs, process.FileName() ) );

    // Get the session path that was set above.

    IAUPDATE_TRACE_1("[IAUPDATE] Find file: %d", driveNum);

    TFileName sessionPath;

    User::LeaveIfError( aFs.SessionPath( sessionPath ) );

    IAUPDATE_TRACE_1("[IAUPDATE] Session path: %S", &sessionPath);

    // Use the file finder to check if the file actually exists 

    // in the given drive path. If it does not, the file finder 

    // will automatically check from other drives. So, here we 

    // should always find the file if any exists.

    TFindFile finder( aFs );

    User::LeaveIfError( finder.FindByDir( aFileName, sessionPath ) );

    // The drive may have changed if the file was not found from

    // the first suggested drive. So, be sure to have the correct

    // private path.

    driveNum = SetSessionPrivatePathL( aFs, finder.File() );

    // Use the drive info to check if the drive is ROM drive.

    // We prefer non ROM drives. But, accept ROM if nothing else is

    // available.

    IAUPDATE_TRACE_1("[IAUPDATE] Check ROM info: %d", driveNum);

    TDriveInfo info;

    User::LeaveIfError( aFs.Drive( info, driveNum ) );

    TBool isRomDrive( info.iDriveAtt & KDriveAttRom );

    if ( !isRomDrive )

        {

        // The current file is not in ROM drive so use that.

        IAUPDATE_TRACE("[IAUPDATE] First file search done. Non ROM found.");

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() end");

        return;

        }

    // Because previous finding was ROM file, try to find a non ROM file.

    IAUPDATE_TRACE("[IAUPDATE] Try to find non ROM file.");

    TInt findErrorCode( finder.Find() );

    if ( findErrorCode == KErrNotFound )

        {

        // Because no new file is found, use the current settings.

        IAUPDATE_TRACE("[IAUPDATE] Second search done. No file found.");

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() end");

        return;

        }

    User::LeaveIfError( findErrorCode );

    IAUPDATE_TRACE("[IAUPDATE] New file found. Use that.");

    // Update the session path for the correct file.

    SetSessionPrivatePathL( aFs, finder.File() );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() end");

    }

TInt CIAUpdateXmlParser::SetSessionPrivatePathL( 

    RFs& aFs,

    const TDesC& aPath ) const

    {

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateXmlParser::SetSessionPrivateL() begin: %S", 

                     &aPath);

    // Use the parser to get the drive information from the path.

    TParsePtrC parser( aPath );

    if ( !parser.DrivePresent() )

        {

        IAUPDATE_TRACE("[IAUPDATE] ERROR: Missing drive info.");

        User::Leave( KErrArgument );

        }

    // Drive check was passed above.

    // So, drive information is safe to use.

    const TDesC& drive( parser.Drive() );

    const TChar driveChar( drive[ 0 ] );

    TInt driveNum( EDriveA );

    User::LeaveIfError( 

        RFs::CharToDrive( driveChar, driveNum ) );

    IAUPDATE_TRACE_2("[IAUPDATE] Drive: %S, %d", &drive, driveNum );

    // Set the file drive to be file session private path drive.

    User::LeaveIfError( aFs.SetSessionToPrivate( driveNum ) );

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateXmlParser::SetSessionPrivateL() end: %d",

                     driveNum);

    return driveNum;

    }