/*

* Copyright (c) 2002-2005 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 XCFW Engine

*

*/

// INCLUDE FILES

#include    "xcfwengine.h"

#include    "gecoobjectfactorybase.h"

#include    "gecodefaultobject.h"

#include    "xcfwtree.h"

#include    "xcfwlocalizer.h"

#include    "xcfwpanic.h"

#include    "xcfwentityconverter.h"

#include    <gmxmlnode.h>

#include    <gmxmlelement.h>

#include    <gmxmlcomposer.h>

#include    <gmxmldocument.h>

#include    <gmxmlcharacterdata.h>

#include    <gmxmltext.h>

#include    <gmxmlcdatasection.h>

// CONSTANTS

// default XML declaration

_LIT( KXMLDeclaration, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>");

// default Doctype declaration

_LIT( KDocTypeDecl, "<!DOCTYPE xcfwml SYSTEM \"%S\">");

_LIT( KDocTypeDeclNoDTD, "<!DOCTYPE xcfwml>");

_LIT( KMmsDTD, "mms_smil.dtd"); //this is autogenerated by GMXML if no DTD decl.

_LIT( KXCFWAnd, "&" );

_LIT( KXCFWSemiC, ";" );

_LIT( KDTDExt, ".dtd" );

_LIT( KLocFormat, "%0*d\\");

const TInt KDTDExtLen = 4; // ".dtd"

const TInt KLocFormatLen = 7; // "%0*d\\" 

//Entity reference extra character count

const TInt KExtraChars = 2;

const TInt KMaxDTDLength = 160;

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

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

// CXCFWEngine::CXCFWEngine

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CXCFWEngine::CXCFWEngine(

    MXCFWEngineObserver* aObserver ):

    CActive( CActive::EPriorityStandard )

    {

    iObserver = aObserver;

    CActiveScheduler::Add( this );

    }

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

// CXCFWEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXCFWEngine::ConstructL()

    {

    //Create default object factory

    iDefaultFactory = CGECODefaultObjectFactory::NewL();

    iState = EStateIdle;

    }

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

// CXCFWEngine::NewL

// Two-phased constructor.

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

//

EXPORT_C CXCFWEngine* CXCFWEngine::NewL(

    MXCFWEngineObserver* aObserver )

    {

    __ASSERT_LEAVE( aObserver!=NULL, KErrArgument );

    CXCFWEngine* self = new( ELeave ) CXCFWEngine( aObserver ) ;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C CXCFWEngine::~CXCFWEngine()

    {

    if ( IsActive() )

        {

        Cancel();

        }

    // Reset object factory array (factories are not owned)

    iFactoryList.Reset();

    iFactoryList.Close();    

    // delete default object factory

    delete iDefaultFactory;

    // delete xml parser

    delete iParser;

    // delete XML composer

    delete iComposer;

    // delete XML document object

    delete iXMLDoc;

    // delete XML file name buffer

    delete iFile;

    // delete DTD file name buffer

    delete iDTD;

    // delete localizer instance

    delete iLocalizer;

    // delete node text buffer

    delete iNodeText;

    // Set non-owned pointers to NULL

    iCurrentXMLNode = NULL;

    if ( iTree )

        {

        iTree->SetLocked( EFalse );

        iTree = NULL;

        }

    iCurrentTreeNode = NULL;

    iObserver = NULL;

    //Close file system handle (just in case)

    iFileSystem.Close();

   }

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

// CXCFWEngine::RunL

// Engine conducts itself according to internal state.

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

//

void CXCFWEngine::RunL()

    {

    TRequestStatus *s = &iStatus;

    switch ( iState )

        {

        case EStateInitializingLoad:

            {

            //Instantiate parser and request parsing. If ParseFile returns

            //an error code, it is most probably a file that is not found

            //or it can't be currently accessed => leave.            

            //we'll get notification from parser through ParseFileCompleteL

            //when ready.

            iState = EStateLoadingFile;

            delete iParser;

	    iParser = NULL;

            iParser = CMDXMLParser::NewL( this );    

            User::LeaveIfError ( 

                iParser->ParseFile( iFileSystem, iFile->Des() ) );

            break;                

            }    

        case EStateInitializingSave:

            {

            if ( iLocalizer && iLocalizer->LastError() != KErrNone )

                {

                iObserver->HandleEngineErrorL ( KErrGeneral );

                Cancel();

                FreeResources();

                }

            else

                {

                iState = EStateConstructingDOM;

                SetActive();

                User::RequestComplete( s, KErrNone );                    

                }

            break;

            }

        case EStateParsing: //Constructing XCFWTree from DOM

            {

            if ( iCurrentXMLNode )

                {

                iTree->SetLocked( EFalse );

                DOM2TreeNextCycleL();

                iTree->SetLocked( ETrue );

                iState = EStateParsing;   

                SetActive();

                User::RequestComplete( s, KErrNone );

                }

            else

                {

                iState = EStateIdle;

                //free parsing resources

                iObserver->HandleEngineEventL( 

                    MXCFWEngineObserver::EEvtParsingComplete );

                FreeResources();

                }

            #ifdef __XCFW_MODULE_TEST

            iObserver->HandleEngineEventL( MXCFWEngineObserver::EEvtNull );                

            #endif

            break;

            }

        case EStateConstructingDOM: //Constructing DOM from XCFW Tree

            {

            if ( iCurrentTreeNode )

                {

                iTree->SetLocked( EFalse );

                Tree2DOMNextCycleL();

                iTree->SetLocked( ETrue );

                iState = EStateConstructingDOM;

                SetActive();

                User::RequestComplete( s, KErrNone );

                }

            else

                {

                iTree->SetLocked( EFalse );

                iState = EStateSavingFile;                    

                //delete possible previous instance of composer

                //and create new.

                delete iComposer;

                iConverter = NULL; //Deleted by composer

                iConverter = new ( ELeave ) CXCFWEntityConverter;

                iComposer = CMDXMLComposer::NewL( this );

                iComposer->SetEntityConverter( iConverter );

		// Ask composer to compose the file.

                // we'll get notification about the op through 

                // ComposeFileCompleteL

                User::LeaveIfError( 

                    iComposer->ComposeFile( 

                    iFileSystem, iFile->Des(), iXMLDoc, EUtf8 ) );

                }

            #ifdef __XCFW_MODULE_TEST

            iObserver->HandleEngineEventL( MXCFWEngineObserver::EEvtNull );                

            #endif

            break;                

            }

        case EStateIdle: //idle state, not doing anything

            {

            break;

            } 

        default:

            {

            break;

            }

        }

    }

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

// CXCFWEngine::RunError

// Notify observer about the error and free resources

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

//

TInt CXCFWEngine::RunError(

    TInt aError )

    {

    TInt ret = KErrNone;

    iStateByLastError = iState;

    FreeResources();            

    TRAP( ret, iObserver->HandleEngineErrorL( aError ) );    

    return ret;

    }

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

// CXCFWEngine::DoCancel

// Notify observer about operation cancellation and free resources.

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

//

void CXCFWEngine::DoCancel()

    {

    TInt state = iState;

    FreeResources();

    switch ( state )

        {

        case EStateInitializingLoad: //fallthrough

        case EStateParsing:

            {

            TInt err = 0;

            TRAP(err, iObserver->HandleEngineEventL( 

                MXCFWEngineObserver::EEvtParsingCanceled ) );

            break;   

            }

        case EStateInitializingSave: //fallthrough

        case EStateConstructingDOM:

            {

            TInt err = 0;

            TRAP(err, iObserver->HandleEngineEventL( 

                MXCFWEngineObserver::EEvtSavingCanceled ) );

            break;   

            }

        default:

            break;

        }

    }

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

// CXCFWEngine::CancelOperation

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

//

EXPORT_C void CXCFWEngine::CancelOperation()

    {

    Cancel();

    //in case engine was not active, need to free the resources here.

    FreeResources();

    }

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

// CXCFWEngine::LoadL

// Wrapper to support loading of XML without giving a DTD file name (i.e. when

// loading content that has no localized strings)

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

//

EXPORT_C void CXCFWEngine::LoadL(

    MXCFWTree& aTree, 

    const TDesC& aFile )

    {

    LoadL( aTree, aFile, KNullDesC );

    }

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

// CXCFWEngine::LoadL

// XML loading operation is started. Internal members are initialized and

// object is set active. 

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

//

EXPORT_C void CXCFWEngine::LoadL(

    MXCFWTree& aTree, 

    const TDesC& aFile, 

    const TDesC& aDTDFile )

    {

    // If we're active at the moment or iState is something else than Idle,

    // leave with KErrInUse.

    if ( IsActive() || iState != EStateIdle )

        {

        User::Leave( KErrInUse );        

        }

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

    //delete previous instances of parser and DTD name buffers

    delete iParser;     

    iParser = NULL;               

    delete iDTD;

    iDTD = NULL;

    iDTD = aDTDFile.AllocL();

    delete iFile;

    iFile = NULL;

    iFile = aFile.AllocL();

    //Set tree to use (not owned)

    iTree = &aTree;

    if ( iTree->Root () )

        {

        //if the tree has already a root, we'll load items under that root

        iCurrentTreeNode = iTree->Root();            

        }

    else

        {

        iCurrentTreeNode = NULL;            

        }

    iStateByLastError = EStateIdle;

    //Reset possible DTD name 

    iTree->SetDTDNameL( aDTDFile );

    iTree->SetLocked( ETrue );

    delete iParser;

    iParser = NULL;

    iParser = CMDXMLParser::NewL( this );    

    User::LeaveIfError ( 

        iParser->ParseFile( iFileSystem, iFile->Des() ) );

    iState = EStateLoadingFile;

    }

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

// CXCFWEngine::SaveL

// Wrapper to support saving of XML without giving a DTD file name (i.e. when

// saving content that has no localized strings)

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

//

EXPORT_C void CXCFWEngine::SaveL(

    MXCFWTree& aTree, 

    const TDesC& aFile )

    {

    SaveL( aTree, aFile, aTree.DTDName() );

    }

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

// CXCFWEngine::SaveL

// Save operation is initialized and started

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

//

EXPORT_C void CXCFWEngine::SaveL(

    MXCFWTree& aTree,

    const TDesC& aFile,

    const TDesC& aDTDFile )

    {

    if ( IsActive() || iState != EStateIdle )

        {

        User::Leave( KErrInUse );        

        }

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

    //create folder if not exist

    TChar bs = '\\';

    if ( aFile.Locate( bs ) != KErrNotFound )

        {

        TPtrC dir = aFile.Left( aFile.LocateReverse( bs ) + 1 );

        TInt ret = iFileSystem.MkDirAll( dir );

        if ( KErrAlreadyExists != ret && KErrNone != ret ) 

            {

            User::Leave( ret );                

            }

        }

    //Set tree pointer ( not owned )

    iTree = &aTree;

    if ( iTree->Root () )

        {

        //init current tree node to root if there's one

        iCurrentTreeNode = iTree->Root();            

        }

    else

        {

        // this tree can't be saved, has no data

        User::Leave( KErrArgument );

        }

    //delete previous instances of parser and filename buffers

    delete iComposer;     

    iComposer = NULL;               

    delete iFile;

    iFile = NULL;

    iFile = aFile.AllocL();

    delete iDTD;

    iDTD = NULL;

    iDTD = aDTDFile.AllocL();

    iStateByLastError = EStateIdle;

    // delete possible previous instance of XML Doc object

    // create new doc and initialize with XML decl + Doctype

    delete iXMLDoc;

    iXMLDoc = NULL;

    iXMLDoc = CMDXMLDocument::NewL();

    iXMLDoc->SetVersionTagL( KXMLDeclaration );

    // set doc type tag according to given DTD file name

    if ( aDTDFile.Compare ( KNullDesC) != 0 )

        {

        TBuf<KMaxDTDLength> buf;

        TInt bsloc = aDTDFile.LocateReverse( bs );

        // take just the file name, no preceding path chars

        // (the assumption is that loc files are stored

        // at relative path \locNN\dtdname.dtd related to

        // XML file location)

        if ( bsloc != KErrNotFound)

            {

            TPtrC dtdname = aDTDFile.Mid( bsloc + 1 );

            buf.Format( KDocTypeDecl, &dtdname);

            }

        else

            {

            buf.Format( KDocTypeDecl, &aDTDFile );

            }

        iXMLDoc->SetDocTypeTagL( buf );

        }

    else

        {

        iXMLDoc->SetDocTypeTagL( KDocTypeDeclNoDTD );

        }

    // notify observer that we're about to start saving

    iObserver->HandleEngineEventL( 

        MXCFWEngineObserver::EEvtSavingStarted );

    iState = EStateInitializingSave;

    PrepareEntityConverterAndSetActiveL();

    // lock tree to prevent changes during save